From cbd3d9db35773993b6425aa15408cb275b0a7cab Mon Sep 17 00:00:00 2001 From: Even Solbraa <41290109+EvenSol@users.noreply.github.com> Date: Fri, 12 Dec 2025 11:39:32 +0100 Subject: [PATCH 1/7] update method --- src/neqsim/process/processTools.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/src/neqsim/process/processTools.py b/src/neqsim/process/processTools.py index 3e90fd16..dadb0f07 100644 --- a/src/neqsim/process/processTools.py +++ b/src/neqsim/process/processTools.py @@ -421,7 +421,8 @@ def _get_outlet(self, ref: Union[str, Any]) -> Any: return ref def add_stream(self, name: str, thermo_system: Any, - temperature: float = None, pressure: float = None) -> 'ProcessBuilder': + temperature: float = None, pressure: float = None, + flow_rate: float = None, flow_unit: str = 'kg/sec') -> 'ProcessBuilder': """ Add a stream to the process. @@ -430,14 +431,25 @@ def add_stream(self, name: str, thermo_system: Any, thermo_system: Fluid/thermodynamic system. temperature: Optional temperature in Kelvin. pressure: Optional pressure in bara. + flow_rate: Optional flow rate. If not specified, uses the flow rate + already set on the fluid. + flow_unit: Unit for flow rate (default 'kg/sec'). Common units include + 'kg/sec', 'kg/hr', 'MSm3/day', 'Sm3/day', 'mole/sec'. Returns: Self for method chaining. + + Example: + >>> process = (ProcessBuilder("Test") + ... .add_stream('inlet', feed, flow_rate=10.0, flow_unit='MSm3/day') + ... .run()) """ if temperature is not None: thermo_system.setTemperature(temperature) if pressure is not None: thermo_system.setPressure(pressure) + if flow_rate is not None: + thermo_system.setTotalFlowRate(flow_rate, flow_unit) s = jneqsim.process.equipment.stream.Stream(name, thermo_system) self.equipment[name] = s self.process.add(s) From dc52f849858efc0e3442f66a10da9d89dc082e28 Mon Sep 17 00:00:00 2001 From: Even Solbraa <41290109+EvenSol@users.noreply.github.com> Date: Fri, 12 Dec 2025 11:44:40 +0100 Subject: [PATCH 2/7] update --- examples/processBuilderConfig.py | 213 +++++++++++++++++++++++++++++ src/neqsim/process/processTools.py | 167 ++++++++++++++++++++++ 2 files changed, 380 insertions(+) create mode 100644 examples/processBuilderConfig.py diff --git a/examples/processBuilderConfig.py b/examples/processBuilderConfig.py new file mode 100644 index 00000000..2e4be95a --- /dev/null +++ b/examples/processBuilderConfig.py @@ -0,0 +1,213 @@ +""" +Example: Using ProcessBuilder with JSON/YAML Configuration + +This example demonstrates how to build process simulations from +configuration files, making it easy to separate process topology +from code and enable configuration-driven design. +""" + +from neqsim.thermo import fluid +from neqsim.process import ProcessBuilder + +# ============================================================================= +# Example 1: Using a Python dictionary configuration +# ============================================================================= + +# Create the fluid +feed = fluid('srk') +feed.addComponent('methane', 0.9) +feed.addComponent('ethane', 0.1) +feed.setTemperature(30.0, 'C') +feed.setPressure(50.0, 'bara') + +# Define process configuration as a dictionary +config = { + 'name': 'Compression Train', + 'equipment': [ + { + 'type': 'stream', + 'name': 'inlet', + 'fluid': 'feed', + 'flow_rate': 10.0, + 'flow_unit': 'MSm3/day' + }, + { + 'type': 'separator', + 'name': 'inlet_separator', + 'inlet': 'inlet' + }, + { + 'type': 'compressor', + 'name': 'stage1_compressor', + 'inlet': 'inlet_separator', + 'pressure': 100.0, + 'efficiency': 0.75 + }, + { + 'type': 'cooler', + 'name': 'intercooler', + 'inlet': 'stage1_compressor', + 'temperature': 303.15 # 30°C in Kelvin + }, + { + 'type': 'compressor', + 'name': 'stage2_compressor', + 'inlet': 'intercooler', + 'pressure': 200.0, + 'efficiency': 0.75 + } + ] +} + +# Build and run the process from config +process = ProcessBuilder.from_dict(config, fluids={'feed': feed}).run() + +# Access results +print("=== Compression Train Results ===") +print(f"Stage 1 outlet pressure: {process.get('stage1_compressor').getOutletStream().getPressure():.1f} bara") +print(f"Stage 1 power: {process.get('stage1_compressor').getPower()/1e3:.1f} kW") +print(f"Stage 2 outlet pressure: {process.get('stage2_compressor').getOutletStream().getPressure():.1f} bara") +print(f"Stage 2 power: {process.get('stage2_compressor').getPower()/1e3:.1f} kW") +print(f"Total power: {(process.get('stage1_compressor').getPower() + process.get('stage2_compressor').getPower())/1e3:.1f} kW") + + +# ============================================================================= +# Example 2: Loading from a JSON file +# ============================================================================= + +import json +import tempfile +import os + +# Create a temporary JSON config file +json_config = { + 'name': 'Simple Separator Process', + 'equipment': [ + {'type': 'stream', 'name': 'well_stream', 'fluid': 'reservoir_fluid'}, + {'type': 'heater', 'name': 'heater', 'inlet': 'well_stream', 'temperature': 350.0}, + {'type': 'separator', 'name': 'hp_separator', 'inlet': 'heater', 'three_phase': True}, + {'type': 'valve', 'name': 'lp_valve', 'inlet': 'hp_separator', 'pressure': 10.0} + ] +} + +# Create reservoir fluid +reservoir_fluid = fluid('srk') +reservoir_fluid.addComponent('methane', 0.7) +reservoir_fluid.addComponent('ethane', 0.1) +reservoir_fluid.addComponent('propane', 0.05) +reservoir_fluid.addComponent('n-butane', 0.05) +reservoir_fluid.addComponent('n-pentane', 0.05) +reservoir_fluid.addComponent('n-hexane', 0.05) +reservoir_fluid.setTemperature(80.0, 'C') +reservoir_fluid.setPressure(150.0, 'bara') +reservoir_fluid.setTotalFlowRate(5.0, 'MSm3/day') + +# Save config to temporary file +with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f: + json.dump(json_config, f, indent=2) + json_file = f.name + +try: + # Load and run from JSON file + process2 = ProcessBuilder.from_json(json_file, fluids={'reservoir_fluid': reservoir_fluid}).run() + + print("\n=== Separator Process Results (from JSON) ===") + print(f"HP Separator gas rate: {process2.get('hp_separator').getGasOutStream().getFlowRate('MSm3/day'):.2f} MSm3/day") + print(f"LP valve outlet pressure: {process2.get('lp_valve').getOutletStream().getPressure():.1f} bara") +finally: + os.unlink(json_file) # Clean up temp file + + +# ============================================================================= +# Example 3: Loading from a YAML file (requires pyyaml) +# ============================================================================= + +try: + import yaml + + yaml_config = """ +name: Gas Cooling Process +equipment: + - type: stream + name: hot_gas + fluid: gas + flow_rate: 50000 + flow_unit: kg/hr + - type: cooler + name: cooler1 + inlet: hot_gas + temperature: 300.0 + - type: separator + name: knockout_drum + inlet: cooler1 + - type: compressor + name: export_compressor + inlet: knockout_drum + pressure: 150.0 +""" + + # Create gas fluid + gas = fluid('srk') + gas.addComponent('methane', 0.85) + gas.addComponent('ethane', 0.10) + gas.addComponent('propane', 0.05) + gas.setTemperature(80.0, 'C') + gas.setPressure(70.0, 'bara') + + # Save to temp YAML file + with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f: + f.write(yaml_config) + yaml_file = f.name + + try: + process3 = ProcessBuilder.from_yaml(yaml_file, fluids={'gas': gas}).run() + + print("\n=== Gas Cooling Process Results (from YAML) ===") + print(f"Cooler outlet temperature: {process3.get('cooler1').getOutletStream().getTemperature() - 273.15:.1f} °C") + print(f"Export compressor power: {process3.get('export_compressor').getPower()/1e3:.1f} kW") + finally: + os.unlink(yaml_file) + +except ImportError: + print("\n(Skipping YAML example - install pyyaml: pip install pyyaml)") + + +# ============================================================================= +# Example 4: Dynamic configuration modification +# ============================================================================= + +print("\n=== Dynamic Configuration Example ===") + +# Base configuration that can be modified programmatically +base_config = { + 'name': 'Parameterized Compressor', + 'equipment': [ + {'type': 'stream', 'name': 'inlet', 'fluid': 'gas'}, + {'type': 'compressor', 'name': 'comp', 'inlet': 'inlet', 'pressure': None} + ] +} + +# Create gas +gas = fluid('srk') +gas.addComponent('methane', 1.0) +gas.setTemperature(25.0, 'C') +gas.setPressure(10.0, 'bara') +gas.setTotalFlowRate(1.0, 'MSm3/day') + +# Run with different outlet pressures +for outlet_pressure in [30, 50, 70]: + # Modify config + config_copy = base_config.copy() + config_copy['equipment'] = [eq.copy() for eq in base_config['equipment']] + config_copy['equipment'][1]['pressure'] = float(outlet_pressure) + + # Need fresh fluid for each run + gas_copy = fluid('srk') + gas_copy.addComponent('methane', 1.0) + gas_copy.setTemperature(25.0, 'C') + gas_copy.setPressure(10.0, 'bara') + gas_copy.setTotalFlowRate(1.0, 'MSm3/day') + + result = ProcessBuilder.from_dict(config_copy, fluids={'gas': gas_copy}).run() + power = result.get('comp').getPower() / 1e3 + print(f"Outlet pressure: {outlet_pressure} bara -> Power: {power:.1f} kW") diff --git a/src/neqsim/process/processTools.py b/src/neqsim/process/processTools.py index dadb0f07..35b91b5b 100644 --- a/src/neqsim/process/processTools.py +++ b/src/neqsim/process/processTools.py @@ -581,6 +581,173 @@ def add_pipe(self, name: str, inlet: str, length: float = 100.0, self.process.add(p) return self + def add_equipment(self, equipment_type: str, name: str, **kwargs) -> 'ProcessBuilder': + """ + Add equipment by type name. Useful for configuration-driven design. + + Args: + equipment_type: Type of equipment ('stream', 'compressor', 'separator', etc.) + name: Name of the equipment. + **kwargs: Equipment-specific parameters. + + Returns: + Self for method chaining. + + Example: + >>> builder.add_equipment('compressor', 'comp1', inlet='inlet', pressure=100.0) + """ + method_map = { + 'stream': self.add_stream, + 'separator': self.add_separator, + 'compressor': self.add_compressor, + 'pump': self.add_pump, + 'expander': self.add_expander, + 'valve': self.add_valve, + 'heater': self.add_heater, + 'cooler': self.add_cooler, + 'mixer': self.add_mixer, + 'splitter': self.add_splitter, + 'heat_exchanger': self.add_heat_exchanger, + 'pipe': self.add_pipe, + } + method = method_map.get(equipment_type.lower()) + if method is None: + raise ValueError(f"Unknown equipment type: {equipment_type}. " + f"Available: {list(method_map.keys())}") + return method(name, **kwargs) + + def add_from_config(self, equipment_list: List[Dict[str, Any]], + fluids: Dict[str, Any] = None) -> 'ProcessBuilder': + """ + Add multiple equipment items from a configuration list. + + Args: + equipment_list: List of equipment configurations. Each item should have + 'type', 'name', and equipment-specific parameters. + fluids: Dictionary mapping fluid names to fluid objects. Used for streams. + + Returns: + Self for method chaining. + + Example: + >>> config = [ + ... {'type': 'stream', 'name': 'inlet', 'fluid': 'feed'}, + ... {'type': 'compressor', 'name': 'comp1', 'inlet': 'inlet', 'pressure': 100.0} + ... ] + >>> builder.add_from_config(config, fluids={'feed': my_fluid}) + """ + fluids = fluids or {} + + for item in equipment_list: + item = item.copy() # Don't modify original + eq_type = item.pop('type') + name = item.pop('name') + + # Handle fluid reference for streams + if eq_type == 'stream' and 'fluid' in item: + fluid_name = item.pop('fluid') + if fluid_name in fluids: + item['thermo_system'] = fluids[fluid_name] + else: + raise ValueError(f"Fluid '{fluid_name}' not found in fluids dict") + + self.add_equipment(eq_type, name, **item) + + return self + + @classmethod + def from_dict(cls, config: Dict[str, Any], fluids: Dict[str, Any] = None) -> 'ProcessBuilder': + """ + Create a ProcessBuilder from a dictionary configuration. + + Args: + config: Dictionary with 'name' and 'equipment' keys. + fluids: Dictionary mapping fluid names to fluid objects. + + Returns: + ProcessBuilder instance (not yet run). + + Example: + >>> config = { + ... 'name': 'Compression Train', + ... 'equipment': [ + ... {'type': 'stream', 'name': 'inlet', 'fluid': 'feed'}, + ... {'type': 'separator', 'name': 'sep1', 'inlet': 'inlet'}, + ... {'type': 'compressor', 'name': 'comp1', 'inlet': 'sep1', 'pressure': 100.0} + ... ] + ... } + >>> process = ProcessBuilder.from_dict(config, fluids={'feed': my_fluid}).run() + """ + builder = cls(config.get('name', '')) + if 'equipment' in config: + builder.add_from_config(config['equipment'], fluids) + return builder + + @classmethod + def from_json(cls, json_path: str, fluids: Dict[str, Any] = None) -> 'ProcessBuilder': + """ + Create a ProcessBuilder from a JSON file. + + Args: + json_path: Path to JSON configuration file. + fluids: Dictionary mapping fluid names to fluid objects. + + Returns: + ProcessBuilder instance (not yet run). + + Example: + >>> # process_config.json: + >>> # { + >>> # "name": "Compression Train", + >>> # "equipment": [ + >>> # {"type": "stream", "name": "inlet", "fluid": "feed"}, + >>> # {"type": "compressor", "name": "comp1", "inlet": "inlet", "pressure": 100} + >>> # ] + >>> # } + >>> process = ProcessBuilder.from_json('process_config.json', + ... fluids={'feed': my_fluid}).run() + """ + with open(json_path, 'r') as f: + config = json.load(f) + return cls.from_dict(config, fluids) + + @classmethod + def from_yaml(cls, yaml_path: str, fluids: Dict[str, Any] = None) -> 'ProcessBuilder': + """ + Create a ProcessBuilder from a YAML file. + + Requires PyYAML to be installed (pip install pyyaml). + + Args: + yaml_path: Path to YAML configuration file. + fluids: Dictionary mapping fluid names to fluid objects. + + Returns: + ProcessBuilder instance (not yet run). + + Example: + >>> # process_config.yaml: + >>> # name: Compression Train + >>> # equipment: + >>> # - type: stream + >>> # name: inlet + >>> # fluid: feed + >>> # - type: compressor + >>> # name: comp1 + >>> # inlet: inlet + >>> # pressure: 100.0 + >>> process = ProcessBuilder.from_yaml('process_config.yaml', + ... fluids={'feed': my_fluid}).run() + """ + try: + import yaml + except ImportError: + raise ImportError("PyYAML is required for YAML support. Install with: pip install pyyaml") + + with open(yaml_path, 'r') as f: + config = yaml.safe_load(f) + return cls.from_dict(config, fluids) + def run(self) -> 'ProcessBuilder': """ Run the process simulation. From 45c5f98fe97c905a54d12290e81dd9a128410a15 Mon Sep 17 00:00:00 2001 From: Even Solbraa <41290109+EvenSol@users.noreply.github.com> Date: Fri, 12 Dec 2025 11:50:49 +0100 Subject: [PATCH 3/7] update --- README.md | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) diff --git a/README.md b/README.md index 5d28d553..c7cdf93a 100644 --- a/README.md +++ b/README.md @@ -12,6 +12,7 @@ NeqSim Python is part of the [NeqSim project](https://equinor.github.io/neqsimho NeqSim Python is distributed as a pip package. Please read the [Prerequisites](#prerequisites). End-users should install neqsim python with some additional packages by running + ``` pip install neqsim ``` @@ -95,7 +96,7 @@ print(f"Compressor power: {process.get('compressor').getPower()/1e6:.2f} MW") ### 4. Direct Java Access (Full control) -Explicit process management using jneqsim - for advanced features: +Explicit process management using jneqsim - for advanced features see [neqsim java API](https://github.com/equinor/neqsim): ```python from neqsim import jneqsim @@ -125,14 +126,14 @@ print(f"Compressor power: {comp.getPower()/1e6:.2f} MW") ### Choosing an Approach -| Use Case | Recommended Approach | -|----------|---------------------| -| Learning & prototyping | Python wrappers | -| Jupyter notebooks | Python wrappers | -| Production applications | ProcessContext | -| Multiple parallel processes | ProcessContext | -| Configuration-driven design | ProcessBuilder | -| Advanced Java features | Direct Java access | +| Use Case | Recommended Approach | +| --------------------------- | -------------------- | +| Learning & prototyping | Python wrappers | +| Jupyter notebooks | Python wrappers | +| Production applications | ProcessContext | +| Multiple parallel processes | ProcessContext | +| Configuration-driven design | ProcessBuilder | +| Advanced Java features | Direct Java access | See the [examples folder](https://github.com/equinor/neqsim-python/tree/master/examples) for more process simulation examples, including [processApproaches.py](https://github.com/equinor/neqsim-python/blob/master/examples/processApproaches.py) which demonstrates all four approaches. @@ -140,12 +141,10 @@ See the [examples folder](https://github.com/equinor/neqsim-python/tree/master/e Java version 8 or higher ([Java JDK](https://adoptium.net/)) needs to be installed. The Python package [JPype](https://github.com/jpype-project/jpype) is used to connect Python and Java. Read the [installation requirements for Jpype](https://jpype.readthedocs.io/en/latest/install.html). Be aware that mixing 64 bit Python with 32 bit Java and vice versa crashes on import of the jpype module. The needed Python packages are listed in the [NeqSim Python dependencies page](https://github.com/equinor/neqsim-python/network/dependencies). - ## Contributing Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct, and the process for submitting pull requests. - ## Discussion forum Questions related to neqsim can be posted in the [github discussion pages](https://github.com/equinor/neqsim/discussions). From 0d59c434d2ae7276411fbc6883cdb409afd09c84 Mon Sep 17 00:00:00 2001 From: Even Solbraa <41290109+EvenSol@users.noreply.github.com> Date: Fri, 12 Dec 2025 12:03:36 +0100 Subject: [PATCH 4/7] update --- src/neqsim/process/processTools.py | 203 ++++++++++++++++++++++++++++- 1 file changed, 202 insertions(+), 1 deletion(-) diff --git a/src/neqsim/process/processTools.py b/src/neqsim/process/processTools.py index 35b91b5b..e2f893da 100644 --- a/src/neqsim/process/processTools.py +++ b/src/neqsim/process/processTools.py @@ -406,8 +406,51 @@ def __init__(self, name: str = ""): self._name = name def _get_outlet(self, ref: Union[str, Any]) -> Any: - """Get outlet stream from equipment reference (name or object).""" + """ + Get outlet stream from equipment reference (name or object). + + Supports dot notation for selecting specific outlets from separators: + - 'separator.gas' or 'separator.vapor' - gas/vapor outlet + - 'separator.liquid' - liquid outlet (2-phase separator) + - 'separator.oil' - oil outlet (3-phase separator) + - 'separator.water' or 'separator.aqueous' - water outlet (3-phase separator) + + Examples: + >>> builder.add_compressor('comp', 'sep.gas', pressure=100) + >>> builder.add_pump('pump', 'sep.oil', pressure=50) + """ if isinstance(ref, str): + # Check for dot notation (e.g., 'separator.gas') + if '.' in ref: + parts = ref.split('.', 1) + equip_name = parts[0] + outlet_type = parts[1].lower() + + equip = self.equipment.get(equip_name) + if equip is None: + raise ValueError(f"Equipment '{equip_name}' not found") + + # Map outlet type to method + outlet_methods = { + 'gas': ['getGasOutStream', 'getOutletStream'], + 'vapor': ['getGasOutStream', 'getOutletStream'], + 'liquid': ['getLiquidOutStream', 'getOilOutStream'], + 'oil': ['getOilOutStream', 'getLiquidOutStream'], + 'water': ['getWaterOutStream', 'getAqueousOutStream'], + 'aqueous': ['getWaterOutStream', 'getAqueousOutStream'], + } + + if outlet_type not in outlet_methods: + raise ValueError(f"Unknown outlet type '{outlet_type}'. " + f"Valid types: {list(outlet_methods.keys())}") + + for method_name in outlet_methods[outlet_type]: + if hasattr(equip, method_name): + return getattr(equip, method_name)() + + raise ValueError(f"Equipment '{equip_name}' does not have a '{outlet_type}' outlet") + + # Standard lookup without dot notation equip = self.equipment.get(ref) if equip is None: raise ValueError(f"Equipment '{ref}' not found") @@ -773,6 +816,164 @@ def get(self, name: str) -> Any: def get_process(self) -> Any: """Get the underlying ProcessSystem object.""" return self.process + + def results_json(self) -> Dict[str, Any]: + """ + Get simulation results as a JSON-compatible dictionary. + + Returns: + Dictionary with all process results. + + Example: + >>> process = ProcessBuilder("Test").add_stream(...).run() + >>> results = process.results_json() + >>> print(json.dumps(results, indent=2)) + """ + json_report = str(self.process.getReport_json()) + return json.loads(json_report) + + def results_dataframe(self) -> pd.DataFrame: + """ + Get simulation results as a pandas DataFrame. + + Returns: + DataFrame with equipment results including temperatures, + pressures, flow rates, power, and duties. + + Example: + >>> process = ProcessBuilder("Test").add_stream(...).run() + >>> df = process.results_dataframe() + >>> print(df) + """ + rows = [] + for name, eq in self.equipment.items(): + row = {'Equipment': name} + + # Get outlet stream properties + out_stream = None + if hasattr(eq, 'getOutletStream'): + out_stream = eq.getOutletStream() + elif hasattr(eq, 'getOutStream'): + out_stream = eq.getOutStream() + elif hasattr(eq, 'getGasOutStream'): + out_stream = eq.getGasOutStream() + + if out_stream: + try: + row['T_out (°C)'] = round(out_stream.getTemperature() - 273.15, 2) + except: + pass + try: + row['P_out (bara)'] = round(out_stream.getPressure(), 2) + except: + pass + try: + row['Flow (kg/hr)'] = round(out_stream.getFlowRate('kg/hr'), 1) + except: + pass + + # Get power/duty + if hasattr(eq, 'getPower'): + try: + row['Power (kW)'] = round(eq.getPower() / 1e3, 2) + except: + pass + if hasattr(eq, 'getDuty'): + try: + row['Duty (kW)'] = round(eq.getDuty() / 1e3, 2) + except: + pass + + rows.append(row) + + return pd.DataFrame(rows) + + def print_results(self) -> 'ProcessBuilder': + """ + Print a formatted summary of simulation results. + + Returns: + Self for method chaining. + + Example: + >>> (ProcessBuilder("Test") + ... .add_stream('inlet', feed) + ... .add_compressor('comp1', 'inlet', pressure=100) + ... .run() + ... .print_results()) + """ + print(f"\n{'='*60}") + print(f"Process Results: {self._name}") + print(f"{'='*60}\n") + + for name, eq in self.equipment.items(): + print(f"📦 {name}") + + # Get outlet stream properties + out_stream = None + if hasattr(eq, 'getOutletStream'): + out_stream = eq.getOutletStream() + elif hasattr(eq, 'getOutStream'): + out_stream = eq.getOutStream() + elif hasattr(eq, 'getGasOutStream'): + out_stream = eq.getGasOutStream() + + if out_stream: + try: + print(f" Temperature: {out_stream.getTemperature() - 273.15:.1f} °C") + except: + pass + try: + print(f" Pressure: {out_stream.getPressure():.1f} bara") + except: + pass + try: + print(f" Flow rate: {out_stream.getFlowRate('kg/hr'):.0f} kg/hr") + except: + pass + + if hasattr(eq, 'getPower'): + try: + print(f" Power: {eq.getPower()/1e3:.2f} kW") + except: + pass + if hasattr(eq, 'getDuty'): + try: + print(f" Duty: {eq.getDuty()/1e3:.2f} kW") + except: + pass + print() + + return self + + def save_results(self, filename: str, format: str = 'json') -> 'ProcessBuilder': + """ + Save simulation results to a file. + + Args: + filename: Output file path. + format: Output format - 'json', 'csv', or 'excel'. + + Returns: + Self for method chaining. + + Example: + >>> process.run().save_results('results.json') + >>> process.save_results('results.csv', format='csv') + >>> process.save_results('results.xlsx', format='excel') + """ + if format == 'json': + with open(filename, 'w') as f: + json.dump(self.results_json(), f, indent=2) + elif format == 'csv': + self.results_dataframe().to_csv(filename, index=False) + elif format == 'excel': + self.results_dataframe().to_excel(filename, index=False) + else: + raise ValueError(f"Unknown format: {format}. Use 'json', 'csv', or 'excel'.") + + print(f"Results saved to {filename}") + return self def _add_to_process(equipment: Any, process: Any = None) -> None: From 52400b43ae1d7f33df8d445396dada8407a69336 Mon Sep 17 00:00:00 2001 From: Even Solbraa <41290109+EvenSol@users.noreply.github.com> Date: Fri, 12 Dec 2025 16:47:03 +0100 Subject: [PATCH 5/7] update precommit --- .github/workflows/generate-stubs.yml | 12 +- examples/beggsBrillPipeline.py | 8 +- examples/ejectorProcess.py | 14 +- examples/equationOfState.py | 36 +- examples/equipmentFactory.py | 15 +- examples/flareSystem.py | 6 +- examples/flashCalculations.py | 14 +- examples/fluidCreation.py | 32 +- examples/hydrateCalculations.py | 56 +- examples/mineralScalePrediction.py | 63 +- examples/phaseEquilibrium.py | 20 +- examples/physicalProperties.py | 2 +- examples/processApproaches.py | 18 +- examples/processBuilderConfig.py | 221 +- examples/processBuilderGUI.py | 429 ++ examples/pumpNPSH.py | 6 +- examples/pvtExperimentsAdvanced.py | 46 +- examples/safetyValve.py | 8 +- examples/transientSeparator.py | 22 +- examples/viscosityModels.py | 96 +- scripts/generate_stubs.py | 6 +- src/jneqsim-stubs/jneqsim-stubs/__init__.pyi | 3 +- .../jneqsim-stubs/api/__init__.pyi | 3 +- .../jneqsim-stubs/api/ioc/__init__.pyi | 13 +- .../jneqsim-stubs/blackoil/__init__.pyi | 63 +- .../jneqsim-stubs/blackoil/io/__init__.pyi | 34 +- .../chemicalreactions/__init__.pyi | 31 +- .../chemicalequilibrium/__init__.pyi | 108 +- .../chemicalreaction/__init__.pyi | 154 +- .../chemicalreactions/kinetics/__init__.pyi | 24 +- .../datapresentation/__init__.pyi | 24 +- .../filehandling/__init__.pyi | 23 +- .../datapresentation/jfreechart/__init__.pyi | 41 +- .../jneqsim-stubs/fluidmechanics/__init__.pyi | 5 +- .../fluidmechanics/flowleg/__init__.pyi | 63 +- .../flowleg/pipeleg/__init__.pyi | 9 +- .../fluidmechanics/flownode/__init__.pyi | 169 +- .../flownode/fluidboundary/__init__.pyi | 11 +- .../heatmasstransfercalc/__init__.pyi | 99 +- .../equilibriumfluidboundary/__init__.pyi | 17 +- .../finitevolumeboundary/__init__.pyi | 15 +- .../fluidboundarynode/__init__.pyi | 13 +- .../fluidboundarynonreactivenode/__init__.pyi | 9 +- .../fluidboundaryreactivenode/__init__.pyi | 9 +- .../fluidboundarysolver/__init__.pyi | 20 +- .../fluidboundaryreactivesolver/__init__.pyi | 9 +- .../fluidboundarysystem/__init__.pyi | 52 +- .../fluidboundarynonreactive/__init__.pyi | 18 +- .../fluidboundarysystemreactive/__init__.pyi | 18 +- .../nonequilibriumfluidboundary/__init__.pyi | 19 +- .../filmmodelboundary/__init__.pyi | 24 +- .../reactivefilmmodel/__init__.pyi | 27 +- .../enhancementfactor/__init__.pyi | 28 +- .../__init__.pyi | 125 +- .../interphaseonephase/__init__.pyi | 17 +- .../interphasepipeflow/__init__.pyi | 43 +- .../interphasetwophase/__init__.pyi | 25 +- .../interphasepipeflow/__init__.pyi | 149 +- .../interphasereactorflow/__init__.pyi | 71 +- .../stirredcell/__init__.pyi | 47 +- .../flownode/multiphasenode/__init__.pyi | 19 +- .../multiphasenode/waxnode/__init__.pyi | 32 +- .../flownode/onephasenode/__init__.pyi | 17 +- .../onephasepipeflownode/__init__.pyi | 21 +- .../flownode/twophasenode/__init__.pyi | 29 +- .../twophasepipeflownode/__init__.pyi | 85 +- .../twophasereactorflownode/__init__.pyi | 51 +- .../twophasestirredcellnode/__init__.pyi | 28 +- .../fluidmechanics/flowsolver/__init__.pyi | 13 +- .../onephaseflowsolver/__init__.pyi | 9 +- .../onephasepipeflowsolver/__init__.pyi | 34 +- .../twophaseflowsolver/__init__.pyi | 11 +- .../stirredcellsolver/__init__.pyi | 31 +- .../twophasepipeflowsolver/__init__.pyi | 39 +- .../fluidmechanics/flowsystem/__init__.pyi | 117 +- .../onephaseflowsystem/__init__.pyi | 9 +- .../pipeflowsystem/__init__.pyi | 9 +- .../twophaseflowsystem/__init__.pyi | 21 +- .../shipsystem/__init__.pyi | 45 +- .../stirredcellsystem/__init__.pyi | 13 +- .../twophasepipeflowsystem/__init__.pyi | 17 +- .../twophasereactorflowsystem/__init__.pyi | 13 +- .../geometrydefinitions/__init__.pyi | 82 +- .../internalgeometry/__init__.pyi | 11 +- .../internalgeometry/packings/__init__.pyi | 12 +- .../internalgeometry/wall/__init__.pyi | 5 +- .../geometrydefinitions/pipe/__init__.pyi | 7 +- .../geometrydefinitions/reactor/__init__.pyi | 14 +- .../stirredcell/__init__.pyi | 7 +- .../surrounding/__init__.pyi | 5 +- .../fluidmechanics/util/__init__.pyi | 13 +- .../fluidmechanicsvisualization/__init__.pyi | 11 +- .../flownodevisualization/__init__.pyi | 25 +- .../__init__.pyi | 13 +- .../__init__.pyi | 13 +- .../__init__.pyi | 13 +- .../flowsystemvisualization/__init__.pyi | 33 +- .../onephaseflowvisualization/__init__.pyi | 13 +- .../pipeflowvisualization/__init__.pyi | 13 +- .../twophaseflowvisualization/__init__.pyi | 13 +- .../__init__.pyi | 37 +- .../util/timeseries/__init__.pyi | 28 +- .../jneqsim-stubs/mathlib/__init__.pyi | 3 +- .../mathlib/generalmath/__init__.pyi | 12 +- .../mathlib/nonlinearsolver/__init__.pyi | 41 +- .../physicalproperties/__init__.pyi | 47 +- .../interfaceproperties/__init__.pyi | 111 +- .../solidadsorption/__init__.pyi | 13 +- .../surfacetension/__init__.pyi | 179 +- .../physicalproperties/methods/__init__.pyi | 37 +- .../__init__.pyi | 29 +- .../conductivity/__init__.pyi | 24 +- .../diffusivity/__init__.pyi | 36 +- .../viscosity/__init__.pyi | 84 +- .../gasphysicalproperties/__init__.pyi | 33 +- .../conductivity/__init__.pyi | 20 +- .../density/__init__.pyi | 16 +- .../diffusivity/__init__.pyi | 36 +- .../viscosity/__init__.pyi | 20 +- .../liquidphysicalproperties/__init__.pyi | 33 +- .../conductivity/__init__.pyi | 16 +- .../density/__init__.pyi | 42 +- .../diffusivity/__init__.pyi | 51 +- .../viscosity/__init__.pyi | 26 +- .../methods/methodinterface/__init__.pyi | 46 +- .../solidphysicalproperties/__init__.pyi | 33 +- .../conductivity/__init__.pyi | 16 +- .../density/__init__.pyi | 16 +- .../diffusivity/__init__.pyi | 28 +- .../viscosity/__init__.pyi | 16 +- .../mixingrule/__init__.pyi | 25 +- .../physicalproperties/system/__init__.pyi | 140 +- .../__init__.pyi | 9 +- .../system/gasphysicalproperties/__init__.pyi | 19 +- .../liquidphysicalproperties/__init__.pyi | 33 +- .../solidphysicalproperties/__init__.pyi | 5 +- .../physicalproperties/util/__init__.pyi | 7 +- .../util/parameterfitting/__init__.pyi | 7 +- .../__init__.pyi | 11 +- .../purecompinterfacetension/__init__.pyi | 21 +- .../purecompviscosity/__init__.pyi | 11 +- .../chungmethod/__init__.pyi | 21 +- .../linearliquidmodel/__init__.pyi | 21 +- .../jneqsim-stubs/process/__init__.pyi | 9 +- .../jneqsim-stubs/process/alarm/__init__.pyi | 238 +- .../process/conditionmonitor/__init__.pyi | 9 +- .../process/controllerdevice/__init__.pyi | 313 +- .../controllerdevice/structure/__init__.pyi | 23 +- .../process/costestimation/__init__.pyi | 20 +- .../costestimation/compressor/__init__.pyi | 10 +- .../costestimation/separator/__init__.pyi | 10 +- .../process/costestimation/valve/__init__.pyi | 10 +- .../process/equipment/__init__.pyi | 245 +- .../process/equipment/absorber/__init__.pyi | 128 +- .../process/equipment/adsorber/__init__.pyi | 19 +- .../process/equipment/battery/__init__.pyi | 5 +- .../process/equipment/blackoil/__init__.pyi | 13 +- .../process/equipment/compressor/__init__.pyi | 520 ++- .../equipment/diffpressure/__init__.pyi | 74 +- .../equipment/distillation/__init__.pyi | 127 +- .../process/equipment/ejector/__init__.pyi | 44 +- .../equipment/electrolyzer/__init__.pyi | 61 +- .../process/equipment/expander/__init__.pyi | 82 +- .../process/equipment/filter/__init__.pyi | 26 +- .../process/equipment/flare/__init__.pyi | 116 +- .../process/equipment/flare/dto/__init__.pyi | 46 +- .../equipment/heatexchanger/__init__.pyi | 403 +- .../process/equipment/manifold/__init__.pyi | 21 +- .../process/equipment/membrane/__init__.pyi | 27 +- .../process/equipment/mixer/__init__.pyi | 41 +- .../process/equipment/network/__init__.pyi | 91 +- .../process/equipment/pipeline/__init__.pyi | 567 ++- .../pipeline/twophasepipe/__init__.pyi | 514 ++- .../twophasepipe/closure/__init__.pyi | 76 +- .../twophasepipe/numerics/__init__.pyi | 190 +- .../equipment/powergeneration/__init__.pyi | 38 +- .../process/equipment/pump/__init__.pyi | 128 +- .../process/equipment/reactor/__init__.pyi | 196 +- .../process/equipment/reservoir/__init__.pyi | 526 ++- .../process/equipment/separator/__init__.pyi | 205 +- .../separator/sectiontype/__init__.pyi | 84 +- .../process/equipment/splitter/__init__.pyi | 72 +- .../process/equipment/stream/__init__.pyi | 315 +- .../process/equipment/subsea/__init__.pyi | 29 +- .../process/equipment/tank/__init__.pyi | 31 +- .../process/equipment/util/__init__.pyi | 582 ++- .../process/equipment/valve/__init__.pyi | 427 +- .../jneqsim-stubs/process/logic/__init__.pyi | 37 +- .../process/logic/action/__init__.pyi | 52 +- .../process/logic/condition/__init__.pyi | 66 +- .../process/logic/control/__init__.pyi | 24 +- .../process/logic/esd/__init__.pyi | 13 +- .../process/logic/hipps/__init__.pyi | 27 +- .../process/logic/shutdown/__init__.pyi | 13 +- .../process/logic/sis/__init__.pyi | 104 +- .../process/logic/startup/__init__.pyi | 21 +- .../process/logic/voting/__init__.pyi | 34 +- .../process/measurementdevice/__init__.pyi | 465 +- .../measurementdevice/online/__init__.pyi | 11 +- .../simpleflowregime/__init__.pyi | 112 +- .../process/mechanicaldesign/__init__.pyi | 157 +- .../mechanicaldesign/absorber/__init__.pyi | 14 +- .../mechanicaldesign/adsorber/__init__.pyi | 10 +- .../mechanicaldesign/compressor/__init__.pyi | 10 +- .../mechanicaldesign/data/__init__.pyi | 27 +- .../designstandards/__init__.pyi | 149 +- .../mechanicaldesign/ejector/__init__.pyi | 32 +- .../heatexchanger/__init__.pyi | 165 +- .../mechanicaldesign/pipeline/__init__.pyi | 51 +- .../mechanicaldesign/separator/__init__.pyi | 19 +- .../separator/sectiontype/__init__.pyi | 35 +- .../mechanicaldesign/valve/__init__.pyi | 457 +- .../process/processmodel/__init__.pyi | 588 ++- .../processmodel/processmodules/__init__.pyi | 184 +- .../jneqsim-stubs/process/safety/__init__.pyi | 172 +- .../process/safety/dto/__init__.pyi | 44 +- .../jneqsim-stubs/process/util/__init__.pyi | 3 +- .../process/util/example/__init__.pyi | 77 +- .../util/fielddevelopment/__init__.pyi | 725 ++- .../process/util/fire/__init__.pyi | 100 +- .../process/util/monitor/__init__.pyi | 172 +- .../process/util/optimization/__init__.pyi | 662 ++- .../process/util/report/__init__.pyi | 55 +- .../process/util/report/safety/__init__.pyi | 131 +- .../process/util/scenario/__init__.pyi | 105 +- .../jneqsim-stubs/pvtsimulation/__init__.pyi | 3 +- .../pvtsimulation/modeltuning/__init__.pyi | 13 +- .../reservoirproperties/__init__.pyi | 5 +- .../pvtsimulation/simulation/__init__.pyi | 174 +- .../pvtsimulation/util/__init__.pyi | 3 +- .../util/parameterfitting/__init__.pyi | 109 +- .../jneqsim-stubs/standards/__init__.pyi | 82 +- .../standards/gasquality/__init__.pyi | 144 +- .../standards/oilquality/__init__.pyi | 23 +- .../standards/salescontract/__init__.pyi | 76 +- .../jneqsim-stubs/statistics/__init__.pyi | 11 +- .../statistics/dataanalysis/__init__.pyi | 3 +- .../dataanalysis/datasmoothing/__init__.pyi | 14 +- .../experimentalequipmentdata/__init__.pyi | 9 +- .../wettedwallcolumndata/__init__.pyi | 9 +- .../experimentalsamplecreation/__init__.pyi | 11 +- .../readdatafromfile/__init__.pyi | 13 +- .../wettedwallcolumnreader/__init__.pyi | 17 +- .../samplecreator/__init__.pyi | 24 +- .../__init__.pyi | 13 +- .../montecarlosimulation/__init__.pyi | 16 +- .../statistics/parameterfitting/__init__.pyi | 122 +- .../nonlinearparameterfitting/__init__.pyi | 31 +- .../jneqsim-stubs/thermo/__init__.pyi | 49 +- .../thermo/atomelement/__init__.pyi | 31 +- .../thermo/characterization/__init__.pyi | 389 +- .../thermo/component/__init__.pyi | 4086 ++++++++++++++--- .../component/attractiveeosterm/__init__.pyi | 183 +- .../component/repulsiveeosterm/__init__.pyi | 5 +- .../thermo/mixingrule/__init__.pyi | 1472 +++++- .../jneqsim-stubs/thermo/phase/__init__.pyi | 3185 ++++++++++--- .../jneqsim-stubs/thermo/system/__init__.pyi | 1516 ++++-- .../thermo/util/Vega/__init__.pyi | 75 +- .../jneqsim-stubs/thermo/util/__init__.pyi | 3 +- .../thermo/util/benchmark/__init__.pyi | 17 +- .../thermo/util/constants/__init__.pyi | 5 +- .../thermo/util/empiric/__init__.pyi | 25 +- .../thermo/util/gerg/__init__.pyi | 368 +- .../thermo/util/humidair/__init__.pyi | 5 +- .../thermo/util/jni/__init__.pyi | 344 +- .../thermo/util/leachman/__init__.pyi | 81 +- .../thermo/util/readwrite/__init__.pyi | 52 +- .../util/referenceequations/__init__.pyi | 13 +- .../thermo/util/spanwagner/__init__.pyi | 9 +- .../thermo/util/steam/__init__.pyi | 5 +- .../thermodynamicoperations/__init__.pyi | 298 +- .../chemicalequilibrium/__init__.pyi | 17 +- .../flashops/__init__.pyi | 363 +- .../flashops/saturationops/__init__.pyi | 168 +- .../phaseenvelopeops/__init__.pyi | 11 +- .../multicomponentenvelopeops/__init__.pyi | 235 +- .../reactivecurves/__init__.pyi | 45 +- .../propertygenerator/__init__.pyi | 133 +- .../jneqsim-stubs/util/__init__.pyi | 32 +- .../jneqsim-stubs/util/database/__init__.pyi | 90 +- .../jneqsim-stubs/util/exception/__init__.pyi | 157 +- .../jneqsim-stubs/util/generator/__init__.pyi | 16 +- .../util/serialization/__init__.pyi | 13 +- .../jneqsim-stubs/util/unit/__init__.pyi | 109 +- .../jneqsim-stubs/util/util/__init__.pyi | 7 +- src/jneqsim-stubs/jpype-stubs/__init__.pyi | 10 +- src/neqsim/neqsimpython.py | 1 + src/neqsim/process/measurement.py | 2 +- src/neqsim/process/processTools.py | 709 +-- src/neqsim/thermo/thermoTools.py | 9 +- 290 files changed, 24851 insertions(+), 7438 deletions(-) create mode 100644 examples/processBuilderGUI.py diff --git a/.github/workflows/generate-stubs.yml b/.github/workflows/generate-stubs.yml index ced4210b..d3e6131d 100644 --- a/.github/workflows/generate-stubs.yml +++ b/.github/workflows/generate-stubs.yml @@ -14,30 +14,30 @@ on: 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: diff --git a/examples/beggsBrillPipeline.py b/examples/beggsBrillPipeline.py index ea527268..6e123fed 100644 --- a/examples/beggsBrillPipeline.py +++ b/examples/beggsBrillPipeline.py @@ -34,11 +34,15 @@ multiphase_fluid.setTotalFlowRate(100000.0, "kg/hr") # Create inlet stream -inlet_stream = jneqsim.process.equipment.stream.Stream("Pipeline Inlet", multiphase_fluid) +inlet_stream = jneqsim.process.equipment.stream.Stream( + "Pipeline Inlet", multiphase_fluid +) # Create Beggs and Brill pipeline # This pipeline goes uphill with significant elevation change -pipe = jneqsim.process.equipment.pipeline.PipeBeggsAndBrills("Multiphase Pipeline", inlet_stream) +pipe = jneqsim.process.equipment.pipeline.PipeBeggsAndBrills( + "Multiphase Pipeline", inlet_stream +) # Set pipeline geometry pipe.setLength(10000.0) # 10 km length diff --git a/examples/ejectorProcess.py b/examples/ejectorProcess.py index c21fdc9e..3a2575eb 100644 --- a/examples/ejectorProcess.py +++ b/examples/ejectorProcess.py @@ -3,7 +3,7 @@ Ejector Process Simulation Example This example demonstrates using an ejector (steam/gas jet) in NeqSim. -Ejectors are used in vacuum systems, refrigeration cycles, and +Ejectors are used in vacuum systems, refrigeration cycles, and for mixing/boosting low-pressure gas with a high-pressure motive stream. The ejector calculation uses a quasi one-dimensional formulation combining @@ -37,10 +37,14 @@ # Create streams motive_stream = jneqsim.process.equipment.stream.Stream("Motive Stream", motive_fluid) -suction_stream = jneqsim.process.equipment.stream.Stream("Suction Stream", suction_fluid) +suction_stream = jneqsim.process.equipment.stream.Stream( + "Suction Stream", suction_fluid +) # Create ejector -ejector = jneqsim.process.equipment.ejector.Ejector("Gas Ejector", motive_stream, suction_stream) +ejector = jneqsim.process.equipment.ejector.Ejector( + "Gas Ejector", motive_stream, suction_stream +) # Create process system and run process = jneqsim.process.processmodel.ProcessSystem() @@ -75,7 +79,9 @@ print(f" Flow rate: {outlet_flow:.0f} kg/hr") # Get entrainment ratio (mass of suction per mass of motive) -entrainment_ratio = suction_fluid.getFlowRate("kg/hr") / motive_fluid.getFlowRate("kg/hr") +entrainment_ratio = suction_fluid.getFlowRate("kg/hr") / motive_fluid.getFlowRate( + "kg/hr" +) print(f"\nEntrainment Ratio: {entrainment_ratio:.3f}") print(f"Compression Ratio: {outlet_pressure / suction_stream.getPressure('bara'):.2f}") print("=" * 60) diff --git a/examples/equationOfState.py b/examples/equationOfState.py index 5fa38ccb..f495ef9e 100644 --- a/examples/equationOfState.py +++ b/examples/equationOfState.py @@ -53,6 +53,7 @@ print("\n2. COMPARING EoS FOR NATURAL GAS") print("-" * 40) + # Define composition def create_natural_gas(eos_name): """Create a natural gas mixture with specified EoS.""" @@ -68,6 +69,7 @@ def create_natural_gas(eos_name): gas.setMixingRule("classic") return gas + # Conditions temp_c = 25.0 pressure_bara = 100.0 @@ -85,16 +87,16 @@ def create_natural_gas(eos_name): TPflash(gas) gas.initThermoProperties() gas.initPhysicalProperties() - + z = gas.getZ() rho = gas.getDensity("kg/m3") cp = gas.getCp("J/molK") - + if gas.hasPhaseType("gas"): sos = gas.getPhase("gas").getSoundSpeed() else: sos = gas.getPhase(0).getSoundSpeed() - + print(f"{eos:11} | {z:9.5f} | {rho:9.2f} | {cp:9.2f} | {sos:8.1f}") except Exception as e: print(f"{eos:11} | Error: {e}") @@ -106,6 +108,7 @@ def create_natural_gas(eos_name): print("-" * 40) print("CPA handles hydrogen bonding (association) in water and alcohols") + def create_wet_gas(eos_name): """Create a wet gas mixture with specified EoS.""" if eos_name == "cpa": @@ -114,13 +117,14 @@ def create_wet_gas(eos_name): else: gas = fluid(eos_name) gas.setMixingRule("classic") - + gas.addComponent("methane", 90.0, "mol%") gas.addComponent("ethane", 5.0, "mol%") gas.addComponent("water", 5.0, "mol%") gas.setMultiPhaseCheck(True) return gas + print(f"\nConditions: T = 25°C, P = 50 bara") print("Wet natural gas with 5 mol% water") print("\nEoS | # Phases | Gas Density | Water in Gas Phase") @@ -134,9 +138,9 @@ def create_wet_gas(eos_name): gas.setPressure(50.0, "bara") TPflash(gas) gas.initThermoProperties() - + n_phases = gas.getNumberOfPhases() - + if gas.hasPhaseType("gas"): gas_phase = gas.getPhase("gas") rho = gas_phase.getDensity("kg/m3") @@ -146,7 +150,7 @@ def create_wet_gas(eos_name): else: rho = gas.getPhase(0).getDensity("kg/m3") water_in_gas = 0.0 - + print(f"{eos:6} | {n_phases:8} | {rho:11.2f} | {water_in_gas:.6f}") except Exception as e: print(f"{eos:6} | Error: {e}") @@ -167,7 +171,7 @@ def create_wet_gas(eos_name): heptane.setPressure(1.01325, "bara") TPflash(heptane) heptane.initThermoProperties() - + rho = heptane.getDensity("kg/m3") print(f"{eos.upper()}: {rho:.1f} kg/m³") @@ -193,7 +197,7 @@ def create_wet_gas(eos_name): co2.setPressure(80.0, "bara") TPflash(co2) co2.initThermoProperties() - + rho = co2.getDensity("kg/m3") z = co2.getZ() print(f"{eos:13} | {rho:15.2f} | {z:.5f}") @@ -205,7 +209,8 @@ def create_wet_gas(eos_name): # ============================================================================= print("\n6. EOS-CG FOR CO2 AND COMBUSTION GASES") print("-" * 40) -print(""" +print( + """ EOS-CG (Equation of State for Combustion Gases) is based on GERG-2008 but optimized for CO2-rich mixtures and combustion product gases. @@ -217,7 +222,8 @@ def create_wet_gas(eos_name): - Blue/green hydrogen with CO2 Components: CO2, N2, O2, Ar, H2O, CO, H2, H2S, SO2, CH4 -""") +""" +) # Create a typical flue gas / CCS mixture print("Example: CO2-rich CCS mixture") @@ -239,7 +245,7 @@ def create_wet_gas(eos_name): ccs_gas.setPressure(100.0, "bara") TPflash(ccs_gas) ccs_gas.initThermoProperties() - + rho = ccs_gas.getDensity("kg/m3") z = ccs_gas.getZ() print(f"{eos:13} | {rho:15.2f} | {z:.5f}") @@ -254,7 +260,8 @@ def create_wet_gas(eos_name): # ============================================================================= print("\n7. GUIDELINES FOR EoS SELECTION") print("-" * 40) -print(""" +print( + """ Application | Recommended EoS -------------------------------------|---------------------- Natural gas properties | GERG-2008 (most accurate) @@ -279,5 +286,6 @@ def create_wet_gas(eos_name): Gas hydrates | CPA with hydrate model | Electrolyte solutions (brine) | Electrolyte-CPA -""") +""" +) print("=" * 70) diff --git a/examples/equipmentFactory.py b/examples/equipmentFactory.py index b0751a9a..709b2830 100644 --- a/examples/equipmentFactory.py +++ b/examples/equipmentFactory.py @@ -92,9 +92,18 @@ # List all available equipment types print("\n4. Available equipment types (partial list):") equipment_types = [ - "Stream", "Compressor", "Pump", "Separator", "HeatExchanger", - "ThrottlingValve", "Mixer", "Splitter", "Cooler", "Heater", - "Expander", "Pipeline" + "Stream", + "Compressor", + "Pump", + "Separator", + "HeatExchanger", + "ThrottlingValve", + "Mixer", + "Splitter", + "Cooler", + "Heater", + "Expander", + "Pipeline", ] for eq_type in equipment_types: print(f" - {eq_type}") diff --git a/examples/flareSystem.py b/examples/flareSystem.py index 85da3d29..e27ad89f 100644 --- a/examples/flareSystem.py +++ b/examples/flareSystem.py @@ -3,7 +3,7 @@ Flare System Simulation Example This example demonstrates using the Flare unit operation in NeqSim. -A flare is used to safely combust emergency relief gases, typically +A flare is used to safely combust emergency relief gases, typically from pressure safety valves (PSV) or blowdown systems. Features demonstrated: @@ -82,9 +82,9 @@ print(f" Mass utilization: {capacity_check.getMassUtilization() * 100:.1f}%") else: print(f"\n✓ Flare is within design capacity") - if not float('nan') == capacity_check.getHeatUtilization(): + if not float("nan") == capacity_check.getHeatUtilization(): print(f" Heat utilization: {capacity_check.getHeatUtilization() * 100:.1f}%") - if not float('nan') == capacity_check.getMassUtilization(): + if not float("nan") == capacity_check.getMassUtilization(): print(f" Mass utilization: {capacity_check.getMassUtilization() * 100:.1f}%") print("=" * 60) diff --git a/examples/flashCalculations.py b/examples/flashCalculations.py index 41f022ff..b3d1e468 100644 --- a/examples/flashCalculations.py +++ b/examples/flashCalculations.py @@ -76,14 +76,18 @@ if natural_gas.hasPhaseType("gas"): gas_phase = natural_gas.getPhase("gas") print(f" Gas phase:") - print(f" - Mole fraction: {natural_gas.getMoleFraction(natural_gas.getPhaseNumberOfPhase('gas')):.4f}") + print( + f" - Mole fraction: {natural_gas.getMoleFraction(natural_gas.getPhaseNumberOfPhase('gas')):.4f}" + ) print(f" - Density: {gas_phase.getDensity('kg/m3'):.2f} kg/m³") print(f" - Z-factor: {gas_phase.getZ():.4f}") if natural_gas.hasPhaseType("oil"): oil_phase = natural_gas.getPhase("oil") print(f" Liquid phase:") - print(f" - Mole fraction: {natural_gas.getMoleFraction(natural_gas.getPhaseNumberOfPhase('oil')):.4f}") + print( + f" - Mole fraction: {natural_gas.getMoleFraction(natural_gas.getPhaseNumberOfPhase('oil')):.4f}" + ) print(f" - Density: {oil_phase.getDensity('kg/m3'):.2f} kg/m³") # ============================================================================= @@ -182,7 +186,8 @@ print("\n" + "=" * 70) print("FLASH CALCULATION SUMMARY") print("=" * 70) -print(""" +print( + """ Flash Type | Given | Find | Application -----------|----------------|----------------|--------------------------- TPflash | T, P | Phases, comp. | General equilibrium @@ -191,5 +196,6 @@ TVflash | T, V | P, phases | Closed vessels VHflash | V, H | T, P, phases | Adiabatic closed systems VUflash | V, U | T, P, phases | Isolated systems -""") +""" +) print("=" * 70) diff --git a/examples/fluidCreation.py b/examples/fluidCreation.py index 3c41b14f..48742c05 100644 --- a/examples/fluidCreation.py +++ b/examples/fluidCreation.py @@ -35,7 +35,7 @@ gas = fluid("srk") # Soave-Redlich-Kwong EoS # Add components one by one -gas.addComponent("methane", 1.0) # Default: mole fraction +gas.addComponent("methane", 1.0) # Default: mole fraction gas.addComponent("ethane", 0.1) gas.addComponent("propane", 0.05) gas.setMixingRule("classic") @@ -92,10 +92,18 @@ # Define composition in a DataFrame composition_data = { - 'ComponentName': ['nitrogen', 'CO2', 'methane', 'ethane', 'propane', - 'i-butane', 'n-butane', 'i-pentane', 'n-pentane'], - 'MolarComposition[-]': [0.02, 0.01, 0.85, 0.05, 0.03, - 0.01, 0.015, 0.005, 0.01] + "ComponentName": [ + "nitrogen", + "CO2", + "methane", + "ethane", + "propane", + "i-butane", + "n-butane", + "i-pentane", + "n-pentane", + ], + "MolarComposition[-]": [0.02, 0.01, 0.85, 0.05, 0.03, 0.01, 0.015, 0.005, 0.01], } df = pd.DataFrame(composition_data) @@ -218,8 +226,12 @@ cloned.setTemperature(100.0, "C") cloned.setPressure(100.0, "bara") -print(f"Original fluid: T = {original.getTemperature('C'):.1f}°C, P = {original.getPressure('bara'):.1f} bara") -print(f"Cloned fluid: T = {cloned.getTemperature('C'):.1f}°C, P = {cloned.getPressure('bara'):.1f} bara") +print( + f"Original fluid: T = {original.getTemperature('C'):.1f}°C, P = {original.getPressure('bara'):.1f} bara" +) +print( + f"Cloned fluid: T = {cloned.getTemperature('C'):.1f}°C, P = {cloned.getPressure('bara'):.1f} bara" +) print("(Changes to clone don't affect original)") # ============================================================================= @@ -257,7 +269,8 @@ # ============================================================================= print("\n9. COMMONLY USED COMPONENTS") print("-" * 40) -print(""" +print( + """ Category | Component Names -------------------|------------------------------------------------ Light gases | nitrogen, oxygen, argon, helium, hydrogen, H2S @@ -272,7 +285,8 @@ Note: For components not in database, use addTBPfraction() or addPlusFraction() with MW and density. -""") +""" +) # ============================================================================= # 10. ELECTROLYTE FLUIDS diff --git a/examples/hydrateCalculations.py b/examples/hydrateCalculations.py index 40eafd26..886becca 100644 --- a/examples/hydrateCalculations.py +++ b/examples/hydrateCalculations.py @@ -28,19 +28,21 @@ # ============================================================================= print("\n1. INTRODUCTION TO GAS HYDRATES") print("-" * 40) -print(""" +print( + """ Gas hydrates form when water and light gases (C1, C2, C3, CO2, H2S) combine under high pressure and low temperature conditions. Hydrate Types: - Type I: Smaller molecules (methane, CO2, H2S) - Type II: Larger molecules (propane, i-butane, natural gas mixtures) - + Formation conditions: - Temperature: Typically < 25°C - Pressure: Typically > 10-20 bara - Presence of free water -""") +""" +) # ============================================================================= # 2. HYDRATE FORMATION TEMPERATURE @@ -72,10 +74,10 @@ try: gas.setPressure(p, "bara") gas.setTemperature(10.0, "C") # Initial guess - + # Calculate hydrate equilibrium temperature hydrate_T = hydrateequilibrium(gas) - + print(f"{p:15} | {hydrate_T:.1f}") except Exception as e: print(f"{p:15} | Error: {e}") @@ -94,11 +96,11 @@ for t_c in [0, 5, 10, 15, 20, 25]: gas.setTemperature(t_c, "C") gas.setPressure(50.0, "bara") # Initial pressure - + try: # This gives hydrate equilibrium hydrate_T = hydrateequilibrium(gas) - + # Since we set temperature, the result tells us the equilibrium T # For the hydrate curve, we need to iterate or use proper method status = "Hydrate possible" if t_c < hydrate_T else "No hydrate" @@ -111,14 +113,16 @@ # ============================================================================= print("\n4. SUBCOOLING - HYDRATE RISK ASSESSMENT") print("-" * 40) -print(""" +print( + """ Subcooling (ΔT) = Hydrate formation T - Operating T Interpretation: ΔT > 0: Operating BELOW hydrate T → HIGH RISK ΔT = 0: At hydrate equilibrium → BORDERLINE ΔT < 0: Operating ABOVE hydrate T → SAFE -""") +""" +) # Example calculation gas.setPressure(100.0, "bara") @@ -172,10 +176,10 @@ gas_meoh.setMultiPhaseCheck(True) gas_meoh.setPressure(100.0, "bara") gas_meoh.setTemperature(15.0, "C") - + hydrate_T_meoh = hydrateequilibrium(gas_meoh) depression = hydrate_T_no_inhibitor - hydrate_T_meoh - + print(f"{meoh_wt_pct:10} | {hydrate_T_meoh:.1f} | {depression:.1f}") except Exception as e: print(f"{meoh_wt_pct:10} | Error: {e}") @@ -204,10 +208,14 @@ gas_meg.setMultiPhaseCheck(True) gas_meg.setPressure(100.0, "bara") gas_meg.setTemperature(10.0, "C") - + hydrate_T_meg = hydrateequilibrium(gas_meg) - - note = "Baseline" if meg_wt_pct == 0 else f"ΔT = {hydrate_T_no_inhibitor - hydrate_T_meg:.1f}°C" + + note = ( + "Baseline" + if meg_wt_pct == 0 + else f"ΔT = {hydrate_T_no_inhibitor - hydrate_T_meg:.1f}°C" + ) print(f"{meg_wt_pct:9} | {hydrate_T_meg:.1f} | {note}") except Exception as e: print(f"{meg_wt_pct:9} | Error: {e}") @@ -217,7 +225,8 @@ # ============================================================================= print("\n7. INHIBITOR SELECTION GUIDELINES") print("-" * 40) -print(""" +print( + """ ┌─────────────────────────────────────────────────────────────────┐ │ Inhibitor Comparison │ ├────────────┬──────────────────────────────────────────────────┐ @@ -244,14 +253,16 @@ │ │ ✗ Cannot be regenerated │ │ │ → Best for: Drilling fluids, completion ops │ └────────────┴──────────────────────────────────────────────────┘ -""") +""" +) # ============================================================================= # 8. KINETIC HYDRATE INHIBITORS (KHI) # ============================================================================= print("\n8. KINETIC HYDRATE INHIBITORS (KHI)") print("-" * 40) -print(""" +print( + """ Unlike thermodynamic inhibitors (MEG, MeOH) that shift equilibrium, KHIs work by slowing hydrate formation kinetics. @@ -266,7 +277,8 @@ Note: NeqSim primarily calculates thermodynamic equilibrium. KHI effects require separate kinetic models. -""") +""" +) # ============================================================================= # 9. PRACTICAL EXAMPLE: PIPELINE HYDRATE ASSESSMENT @@ -274,14 +286,16 @@ print("\n9. PRACTICAL EXAMPLE: PIPELINE HYDRATE ASSESSMENT") print("-" * 40) -print(""" +print( + """ Scenario: Subsea pipeline from wellhead to platform - Wellhead: 150 bara, 80°C - Pipeline arrival: 80 bara, 5°C - Gas is water-saturated - + Question: Will hydrates form? How much MEG is needed? -""") +""" +) # Check hydrate risk pipeline_gas = fluid("cpa") diff --git a/examples/mineralScalePrediction.py b/examples/mineralScalePrediction.py index 37fb11bb..93344045 100644 --- a/examples/mineralScalePrediction.py +++ b/examples/mineralScalePrediction.py @@ -29,9 +29,10 @@ # ============================================================================= print("\n1. INTRODUCTION TO MINERAL SCALE") print("-" * 40) -print(""" +print( + """ Mineral scale forms when dissolved ions precipitate as solid deposits: - + Type | Formula | Common Causes ------------------|----------|-------------------------------- Calcium Carbonate | CaCO3 | Pressure drop (CO2 release) @@ -45,14 +46,16 @@ - Equipment damage - Increased operating costs - Production loss -""") +""" +) # ============================================================================= # 2. SATURATION INDEX CONCEPT # ============================================================================= print("\n2. SATURATION INDEX (SI)") print("-" * 40) -print(""" +print( + """ SI = log(IAP / Ksp) Where: @@ -63,7 +66,8 @@ SI > 0: Supersaturated → Scale WILL form SI = 0: At equilibrium → Borderline SI < 0: Undersaturated → Scale will NOT form -""") +""" +) # ============================================================================= # 3. CREATING FORMATION WATER @@ -82,7 +86,7 @@ formation_water.addComponent("Ca++", 0.02, "mol") formation_water.addComponent("Ba++", 0.0001, "mol") # 10 mg/L Ba formation_water.addComponent("SO4--", 0.001, "mol") # Low sulfate -formation_water.addComponent("HCO3-", 0.01, "mol") # Bicarbonate +formation_water.addComponent("HCO3-", 0.01, "mol") # Bicarbonate formation_water.setMixingRule("classic") print("Formation water composition (per kg water):") @@ -117,10 +121,12 @@ print(" SO4--: 0.028 mol (2.7 g/L) ← HIGH!") print(" HCO3-: 0.002 mol (122 mg/L)") -print(""" +print( + """ ⚠️ WARNING: Mixing formation water (high Ba++) with seawater (high SO4--) causes severe BaSO4 scale! -""") +""" +) # ============================================================================= # 5. SCALE POTENTIAL CALCULATION @@ -141,7 +147,7 @@ try: # Get ion composition analysis ion_analysis = ioncomposition(formation_water) - + if ion_analysis is not None: print("\nIon composition analysis:") # The ion analysis provides various metrics @@ -159,7 +165,8 @@ # ============================================================================= print("\n6. EFFECT OF PRESSURE DROP ON CaCO3 SCALE") print("-" * 40) -print(""" +print( + """ CaCO3 (calcite) precipitation is driven by CO2 loss: Ca++ + 2HCO3- ⇌ CaCO3↓ + H2O + CO2↑ @@ -174,7 +181,8 @@ - Wellhead chokes - First stage separator - ESPs (Electrical Submersible Pumps) -""") +""" +) print("\nPressure | Expected CaCO3 Scaling Tendency") print("---------|----------------------------------") @@ -188,7 +196,8 @@ # ============================================================================= print("\n7. BaSO4 SCALE FROM WATER MIXING") print("-" * 40) -print(""" +print( + """ Barite (BaSO4) is one of the hardest scales to remove: Ba++ (formation water) + SO4-- (seawater) → BaSO4↓ @@ -203,15 +212,21 @@ - Low-sulfate seawater injection - Scale inhibitor squeeze treatments - Careful mixing ratio control -""") +""" +) # Simulate mixing at different ratios print("\nMixing formation water with seawater:") print("Seawater% | Relative BaSO4 Precipitation Risk") print("----------|-----------------------------------") -risks = ["Very Low (no sulfate)", "High (max mixing)", "High", - "Moderate", "Low (Ba diluted)"] +risks = [ + "Very Low (no sulfate)", + "High (max mixing)", + "High", + "Moderate", + "Low (Ba diluted)", +] for pct, risk in zip([0, 10, 30, 50, 90], risks): print(f"{pct:9} | {risk}") @@ -220,7 +235,8 @@ # ============================================================================= print("\n8. SCALE INHIBITORS") print("-" * 40) -print(""" +print( + """ Scale inhibitors prevent crystal growth even when supersaturated: Type | Target Scales @@ -236,14 +252,16 @@ 3. Batch treatment (periodic) Typical dosages: 5-50 ppm based on water volume -""") +""" +) # ============================================================================= # 9. PRACTICAL SCALE ASSESSMENT WORKFLOW # ============================================================================= print("\n9. PRACTICAL SCALE ASSESSMENT WORKFLOW") print("-" * 40) -print(""" +print( + """ Step 1: Water Analysis └─ Measure: Na, K, Ca, Mg, Ba, Sr, Fe, Cl, SO4, HCO3, CO2 @@ -267,14 +285,16 @@ └─ Inhibitor selection and dosage └─ Operating condition optimization └─ Monitoring and intervention plan -""") +""" +) # ============================================================================= # 10. TEMPERATURE EFFECTS SUMMARY # ============================================================================= print("\n10. TEMPERATURE EFFECTS ON SCALE") print("-" * 40) -print(""" +print( + """ Scale Type | Solubility vs Temperature --------------|-------------------------------- CaCO3 | Decreases with increasing T @@ -293,6 +313,7 @@ | SiO2 | Increases significantly with T (Silica) | (Normal solubility) -""") +""" +) print("=" * 70) diff --git a/examples/phaseEquilibrium.py b/examples/phaseEquilibrium.py index f9210d57..7b0b05c4 100644 --- a/examples/phaseEquilibrium.py +++ b/examples/phaseEquilibrium.py @@ -107,7 +107,7 @@ cricondenbar_P = envelope.get("cricondenbarP")[0] cricondentherm_T = envelope.get("cricondenthermT")[0] - 273.15 cricondentherm_P = envelope.get("cricondenthermP")[0] - + print(f"\nPhase Envelope Properties:") print(f" Cricondenbar (max pressure):") print(f" P = {cricondenbar_P:.2f} bara at T = {cricondenbar_T:.1f}°C") @@ -120,13 +120,13 @@ try: temps = envelope.get("Tsat") pressures = envelope.get("Psat") - + if temps and pressures: print(f"\n Phase envelope points calculated: {len(temps)}") print("\n Selected points on the envelope:") print(" T [°C] | P [bara]") print(" ---------|----------") - + # Print every 5th point step = max(1, len(temps) // 8) for i in range(0, len(temps), step): @@ -141,13 +141,15 @@ # ============================================================================= print("\n4. RETROGRADE CONDENSATION") print("-" * 40) -print(""" +print( + """ Retrograde condensation is a unique phenomenon in gas condensate systems where REDUCING pressure causes MORE liquid to form (counterintuitive!). This occurs between the cricondentherm and critical point at pressures below the cricondenbar. It's important for gas condensate reservoirs. -""") +""" +) # Demonstrate retrograde behavior print("Demonstrating retrograde behavior with the rich gas:") @@ -170,7 +172,7 @@ test_gas.setTemperature(20.0, "C") test_gas.setPressure(p, "bara") TPflash(test_gas) - + n_phases = test_gas.getNumberOfPhases() if n_phases > 1 and test_gas.hasPhaseType("oil"): liq_frac = test_gas.getPhase("oil").getBeta() @@ -215,7 +217,8 @@ # ============================================================================= print("\n6. CRICONDENBAR & CRICONDENTHERM SIGNIFICANCE") print("-" * 40) -print(""" +print( + """ ┌─────────────────────────────────────────────────────────────────┐ │ PHASE ENVELOPE │ │ │ @@ -237,6 +240,7 @@ │ ● Above cricondentherm: Heating cannot cause condensation │ │ ● Critical point: Liquid and gas become indistinguishable │ └─────────────────────────────────────────────────────────────────┘ -""") +""" +) print("=" * 70) diff --git a/examples/physicalProperties.py b/examples/physicalProperties.py index d43369e8..7de39e52 100644 --- a/examples/physicalProperties.py +++ b/examples/physicalProperties.py @@ -249,7 +249,7 @@ TPflash(simple_gas) simple_gas.initThermoProperties() simple_gas.initPhysicalProperties() - + if simple_gas.hasPhaseType("gas"): gas = simple_gas.getPhase("gas") rho = gas.getDensity("kg/m3") diff --git a/examples/processApproaches.py b/examples/processApproaches.py index c8046994..5261a553 100644 --- a/examples/processApproaches.py +++ b/examples/processApproaches.py @@ -109,14 +109,14 @@ comp1 = ctx.compressor("1st stage", sep.getGasOutStream(), pres=60.0) cool = ctx.cooler("intercooler", comp1.getOutletStream(), temp=303.15) comp2 = ctx.compressor("2nd stage", cool.getOutletStream(), pres=120.0) - + # Run this specific process ctx.run() - + # Access equipment by name stage1 = ctx.get("1st stage") stage2 = ctx.get("2nd stage") - + print(f"\nResults (Approach 2):") print(f" Stage 1 power: {stage1.getPower()/1e6:.3f} MW") print(f" Stage 2 power: {stage2.getPower()/1e6:.3f} MW") @@ -147,13 +147,15 @@ feed_fluid3.setTotalFlowRate(5.0, "MSm3/day") # Build process with fluent API - all chained together -process = (ProcessBuilder("Compression Train") +process = ( + ProcessBuilder("Compression Train") .add_stream("inlet", feed_fluid3) .add_separator("HP separator", "inlet") .add_compressor("1st stage", "HP separator", pressure=60.0) .add_cooler("intercooler", "1st stage", temperature=303.15) .add_compressor("2nd stage", "intercooler", pressure=120.0) - .run()) + .run() +) # Access results comp1 = process.get("1st stage") @@ -213,7 +215,8 @@ print("\n" + "=" * 70) print("CHOOSING AN APPROACH") print("=" * 70) -print(""" +print( + """ | Use Case | Recommended Approach | |---------------------------------|-------------------------------| | Learning / tutorials | Wrappers (global process) | @@ -225,4 +228,5 @@ | Clean declarative style | ProcessBuilder | | Mixing wrapper convenience | Hybrid (process= parameter) | with explicit control | | -""") +""" +) diff --git a/examples/processBuilderConfig.py b/examples/processBuilderConfig.py index 2e4be95a..6909154c 100644 --- a/examples/processBuilderConfig.py +++ b/examples/processBuilderConfig.py @@ -1,8 +1,8 @@ """ Example: Using ProcessBuilder with JSON/YAML Configuration -This example demonstrates how to build process simulations from -configuration files, making it easy to separate process topology +This example demonstrates how to build process simulations from +configuration files, making it easy to separate process topology from code and enable configuration-driven design. """ @@ -14,61 +14,63 @@ # ============================================================================= # Create the fluid -feed = fluid('srk') -feed.addComponent('methane', 0.9) -feed.addComponent('ethane', 0.1) -feed.setTemperature(30.0, 'C') -feed.setPressure(50.0, 'bara') +feed = fluid("srk") +feed.addComponent("methane", 0.9) +feed.addComponent("ethane", 0.1) +feed.setTemperature(30.0, "C") +feed.setPressure(50.0, "bara") # Define process configuration as a dictionary config = { - 'name': 'Compression Train', - 'equipment': [ + "name": "Compression Train", + "equipment": [ { - 'type': 'stream', - 'name': 'inlet', - 'fluid': 'feed', - 'flow_rate': 10.0, - 'flow_unit': 'MSm3/day' + "type": "stream", + "name": "inlet", + "fluid": "feed", + "flow_rate": 10.0, + "flow_unit": "MSm3/day", }, + {"type": "separator", "name": "inlet_separator", "inlet": "inlet"}, { - 'type': 'separator', - 'name': 'inlet_separator', - 'inlet': 'inlet' + "type": "compressor", + "name": "stage1_compressor", + "inlet": "inlet_separator", + "pressure": 100.0, + "efficiency": 0.75, }, { - 'type': 'compressor', - 'name': 'stage1_compressor', - 'inlet': 'inlet_separator', - 'pressure': 100.0, - 'efficiency': 0.75 + "type": "cooler", + "name": "intercooler", + "inlet": "stage1_compressor", + "temperature": 303.15, # 30°C in Kelvin }, { - 'type': 'cooler', - 'name': 'intercooler', - 'inlet': 'stage1_compressor', - 'temperature': 303.15 # 30°C in Kelvin + "type": "compressor", + "name": "stage2_compressor", + "inlet": "intercooler", + "pressure": 200.0, + "efficiency": 0.75, }, - { - 'type': 'compressor', - 'name': 'stage2_compressor', - 'inlet': 'intercooler', - 'pressure': 200.0, - 'efficiency': 0.75 - } - ] + ], } # Build and run the process from config -process = ProcessBuilder.from_dict(config, fluids={'feed': feed}).run() +process = ProcessBuilder.from_dict(config, fluids={"feed": feed}).run() # Access results print("=== Compression Train Results ===") -print(f"Stage 1 outlet pressure: {process.get('stage1_compressor').getOutletStream().getPressure():.1f} bara") +print( + f"Stage 1 outlet pressure: {process.get('stage1_compressor').getOutletStream().getPressure():.1f} bara" +) print(f"Stage 1 power: {process.get('stage1_compressor').getPower()/1e3:.1f} kW") -print(f"Stage 2 outlet pressure: {process.get('stage2_compressor').getOutletStream().getPressure():.1f} bara") +print( + f"Stage 2 outlet pressure: {process.get('stage2_compressor').getOutletStream().getPressure():.1f} bara" +) print(f"Stage 2 power: {process.get('stage2_compressor').getPower()/1e3:.1f} kW") -print(f"Total power: {(process.get('stage1_compressor').getPower() + process.get('stage2_compressor').getPower())/1e3:.1f} kW") +print( + f"Total power: {(process.get('stage1_compressor').getPower() + process.get('stage2_compressor').getPower())/1e3:.1f} kW" +) # ============================================================================= @@ -81,39 +83,60 @@ # Create a temporary JSON config file json_config = { - 'name': 'Simple Separator Process', - 'equipment': [ - {'type': 'stream', 'name': 'well_stream', 'fluid': 'reservoir_fluid'}, - {'type': 'heater', 'name': 'heater', 'inlet': 'well_stream', 'temperature': 350.0}, - {'type': 'separator', 'name': 'hp_separator', 'inlet': 'heater', 'three_phase': True}, - {'type': 'valve', 'name': 'lp_valve', 'inlet': 'hp_separator', 'pressure': 10.0} - ] + "name": "Simple Separator Process", + "equipment": [ + {"type": "stream", "name": "well_stream", "fluid": "reservoir_fluid"}, + { + "type": "heater", + "name": "heater", + "inlet": "well_stream", + "temperature": 350.0, + }, + { + "type": "separator", + "name": "hp_separator", + "inlet": "heater", + "three_phase": True, + }, + { + "type": "valve", + "name": "lp_valve", + "inlet": "hp_separator", + "pressure": 10.0, + }, + ], } # Create reservoir fluid -reservoir_fluid = fluid('srk') -reservoir_fluid.addComponent('methane', 0.7) -reservoir_fluid.addComponent('ethane', 0.1) -reservoir_fluid.addComponent('propane', 0.05) -reservoir_fluid.addComponent('n-butane', 0.05) -reservoir_fluid.addComponent('n-pentane', 0.05) -reservoir_fluid.addComponent('n-hexane', 0.05) -reservoir_fluid.setTemperature(80.0, 'C') -reservoir_fluid.setPressure(150.0, 'bara') -reservoir_fluid.setTotalFlowRate(5.0, 'MSm3/day') +reservoir_fluid = fluid("srk") +reservoir_fluid.addComponent("methane", 0.7) +reservoir_fluid.addComponent("ethane", 0.1) +reservoir_fluid.addComponent("propane", 0.05) +reservoir_fluid.addComponent("n-butane", 0.05) +reservoir_fluid.addComponent("n-pentane", 0.05) +reservoir_fluid.addComponent("n-hexane", 0.05) +reservoir_fluid.setTemperature(80.0, "C") +reservoir_fluid.setPressure(150.0, "bara") +reservoir_fluid.setTotalFlowRate(5.0, "MSm3/day") # Save config to temporary file -with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f: +with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as f: json.dump(json_config, f, indent=2) json_file = f.name try: # Load and run from JSON file - process2 = ProcessBuilder.from_json(json_file, fluids={'reservoir_fluid': reservoir_fluid}).run() - + process2 = ProcessBuilder.from_json( + json_file, fluids={"reservoir_fluid": reservoir_fluid} + ).run() + print("\n=== Separator Process Results (from JSON) ===") - print(f"HP Separator gas rate: {process2.get('hp_separator').getGasOutStream().getFlowRate('MSm3/day'):.2f} MSm3/day") - print(f"LP valve outlet pressure: {process2.get('lp_valve').getOutletStream().getPressure():.1f} bara") + print( + f"HP Separator gas rate: {process2.get('hp_separator').getGasOutStream().getFlowRate('MSm3/day'):.2f} MSm3/day" + ) + print( + f"LP valve outlet pressure: {process2.get('lp_valve').getOutletStream().getPressure():.1f} bara" + ) finally: os.unlink(json_file) # Clean up temp file @@ -124,7 +147,7 @@ try: import yaml - + yaml_config = """ name: Gas Cooling Process equipment: @@ -145,29 +168,33 @@ inlet: knockout_drum pressure: 150.0 """ - + # Create gas fluid - gas = fluid('srk') - gas.addComponent('methane', 0.85) - gas.addComponent('ethane', 0.10) - gas.addComponent('propane', 0.05) - gas.setTemperature(80.0, 'C') - gas.setPressure(70.0, 'bara') - + gas = fluid("srk") + gas.addComponent("methane", 0.85) + gas.addComponent("ethane", 0.10) + gas.addComponent("propane", 0.05) + gas.setTemperature(80.0, "C") + gas.setPressure(70.0, "bara") + # Save to temp YAML file - with tempfile.NamedTemporaryFile(mode='w', suffix='.yaml', delete=False) as f: + with tempfile.NamedTemporaryFile(mode="w", suffix=".yaml", delete=False) as f: f.write(yaml_config) yaml_file = f.name - + try: - process3 = ProcessBuilder.from_yaml(yaml_file, fluids={'gas': gas}).run() - + process3 = ProcessBuilder.from_yaml(yaml_file, fluids={"gas": gas}).run() + print("\n=== Gas Cooling Process Results (from YAML) ===") - print(f"Cooler outlet temperature: {process3.get('cooler1').getOutletStream().getTemperature() - 273.15:.1f} °C") - print(f"Export compressor power: {process3.get('export_compressor').getPower()/1e3:.1f} kW") + print( + f"Cooler outlet temperature: {process3.get('cooler1').getOutletStream().getTemperature() - 273.15:.1f} °C" + ) + print( + f"Export compressor power: {process3.get('export_compressor').getPower()/1e3:.1f} kW" + ) finally: os.unlink(yaml_file) - + except ImportError: print("\n(Skipping YAML example - install pyyaml: pip install pyyaml)") @@ -180,34 +207,34 @@ # Base configuration that can be modified programmatically base_config = { - 'name': 'Parameterized Compressor', - 'equipment': [ - {'type': 'stream', 'name': 'inlet', 'fluid': 'gas'}, - {'type': 'compressor', 'name': 'comp', 'inlet': 'inlet', 'pressure': None} - ] + "name": "Parameterized Compressor", + "equipment": [ + {"type": "stream", "name": "inlet", "fluid": "gas"}, + {"type": "compressor", "name": "comp", "inlet": "inlet", "pressure": None}, + ], } # Create gas -gas = fluid('srk') -gas.addComponent('methane', 1.0) -gas.setTemperature(25.0, 'C') -gas.setPressure(10.0, 'bara') -gas.setTotalFlowRate(1.0, 'MSm3/day') +gas = fluid("srk") +gas.addComponent("methane", 1.0) +gas.setTemperature(25.0, "C") +gas.setPressure(10.0, "bara") +gas.setTotalFlowRate(1.0, "MSm3/day") # Run with different outlet pressures for outlet_pressure in [30, 50, 70]: # Modify config config_copy = base_config.copy() - config_copy['equipment'] = [eq.copy() for eq in base_config['equipment']] - config_copy['equipment'][1]['pressure'] = float(outlet_pressure) - + config_copy["equipment"] = [eq.copy() for eq in base_config["equipment"]] + config_copy["equipment"][1]["pressure"] = float(outlet_pressure) + # Need fresh fluid for each run - gas_copy = fluid('srk') - gas_copy.addComponent('methane', 1.0) - gas_copy.setTemperature(25.0, 'C') - gas_copy.setPressure(10.0, 'bara') - gas_copy.setTotalFlowRate(1.0, 'MSm3/day') - - result = ProcessBuilder.from_dict(config_copy, fluids={'gas': gas_copy}).run() - power = result.get('comp').getPower() / 1e3 + gas_copy = fluid("srk") + gas_copy.addComponent("methane", 1.0) + gas_copy.setTemperature(25.0, "C") + gas_copy.setPressure(10.0, "bara") + gas_copy.setTotalFlowRate(1.0, "MSm3/day") + + result = ProcessBuilder.from_dict(config_copy, fluids={"gas": gas_copy}).run() + power = result.get("comp").getPower() / 1e3 print(f"Outlet pressure: {outlet_pressure} bara -> Power: {power:.1f} kW") diff --git a/examples/processBuilderGUI.py b/examples/processBuilderGUI.py new file mode 100644 index 00000000..7486024e --- /dev/null +++ b/examples/processBuilderGUI.py @@ -0,0 +1,429 @@ +""" +NeqSim Process Builder GUI + +A simple graphical user interface for building and running process simulations. +Run with: streamlit run processBuilderGUI.py + +Requires: pip install streamlit pandas +""" + +import streamlit as st +import pandas as pd +from typing import Dict, Any, List + +# Must be first Streamlit command +st.set_page_config(page_title="NeqSim Process Builder", layout="wide") + +from neqsim.thermo import fluid +from neqsim.process import ProcessBuilder + +# ============================================================================= +# Session State Initialization +# ============================================================================= + +if 'fluids' not in st.session_state: + st.session_state.fluids = {} +if 'equipment_list' not in st.session_state: + st.session_state.equipment_list = [] +if 'process_result' not in st.session_state: + st.session_state.process_result = None +if 'results_data' not in st.session_state: + st.session_state.results_data = None + +# ============================================================================= +# Helper Functions +# ============================================================================= + +COMPONENT_OPTIONS = [ + 'methane', 'ethane', 'propane', 'i-butane', 'n-butane', + 'i-pentane', 'n-pentane', 'n-hexane', 'n-heptane', 'n-octane', + 'nitrogen', 'CO2', 'H2S', 'water', 'H2', 'oxygen' +] + +EOS_OPTIONS = ['srk', 'pr', 'cpa'] + +EQUIPMENT_TYPES = { + 'stream': {'inlet': False, 'has_fluid': True}, + 'separator': {'inlet': True, 'has_fluid': False}, + 'compressor': {'inlet': True, 'has_fluid': False}, + 'pump': {'inlet': True, 'has_fluid': False}, + 'expander': {'inlet': True, 'has_fluid': False}, + 'valve': {'inlet': True, 'has_fluid': False}, + 'heater': {'inlet': True, 'has_fluid': False}, + 'cooler': {'inlet': True, 'has_fluid': False}, + 'pipe': {'inlet': True, 'has_fluid': False}, +} + +FLOW_UNITS = ['kg/sec', 'kg/hr', 'MSm3/day', 'Sm3/day', 'mole/sec'] + +def get_available_inlets() -> List[str]: + """Get list of equipment names that can be used as inlets.""" + return [eq['name'] for eq in st.session_state.equipment_list] + +def create_fluid_from_config(config: Dict) -> Any: + """Create a NeqSim fluid from configuration.""" + f = fluid(config['eos']) + for comp, frac in config['components'].items(): + if frac > 0: + f.addComponent(comp, frac) + f.setTemperature(config['temperature'], 'C') + f.setPressure(config['pressure'], 'bara') + if config.get('flow_rate'): + f.setTotalFlowRate(config['flow_rate'], config.get('flow_unit', 'kg/sec')) + return f + +def run_process(): + """Build and run the process from current configuration.""" + if not st.session_state.equipment_list: + st.error("Add at least one piece of equipment before running") + return + + # Create fluids + fluids_dict = {} + for name, config in st.session_state.fluids.items(): + fluids_dict[name] = create_fluid_from_config(config) + + # Build equipment config + equipment_config = [] + for eq in st.session_state.equipment_list: + eq_config = {'type': eq['type'], 'name': eq['name']} + eq_config.update(eq.get('params', {})) + equipment_config.append(eq_config) + + config = { + 'name': 'GUI Process', + 'equipment': equipment_config + } + + try: + process = ProcessBuilder.from_dict(config, fluids=fluids_dict).run() + st.session_state.process_result = process + + # Collect results + results = [] + for eq in st.session_state.equipment_list: + name = eq['name'] + eq_obj = process.get(name) + if eq_obj: + result = {'Equipment': name, 'Type': eq['type']} + + # Try to get common properties + if hasattr(eq_obj, 'getOutletStream'): + out = eq_obj.getOutletStream() + result['Outlet T (°C)'] = f"{out.getTemperature() - 273.15:.1f}" + result['Outlet P (bara)'] = f"{out.getPressure():.1f}" + elif hasattr(eq_obj, 'getOutStream'): + out = eq_obj.getOutStream() + result['Outlet T (°C)'] = f"{out.getTemperature() - 273.15:.1f}" + result['Outlet P (bara)'] = f"{out.getPressure():.1f}" + elif hasattr(eq_obj, 'getGasOutStream'): + out = eq_obj.getGasOutStream() + result['Outlet T (°C)'] = f"{out.getTemperature() - 273.15:.1f}" + result['Outlet P (bara)'] = f"{out.getPressure():.1f}" + + if hasattr(eq_obj, 'getPower'): + power = eq_obj.getPower() + result['Power (kW)'] = f"{power/1e3:.1f}" + + if hasattr(eq_obj, 'getDuty'): + duty = eq_obj.getDuty() + result['Duty (kW)'] = f"{duty/1e3:.1f}" + + results.append(result) + + st.session_state.results_data = pd.DataFrame(results) + st.success("Process simulation completed!") + + except Exception as e: + st.error(f"Error running process: {str(e)}") + +# ============================================================================= +# Main UI +# ============================================================================= + +st.title("🔧 NeqSim Process Builder") +st.markdown("Build and simulate process systems with a visual interface") + +# Create tabs +tab1, tab2, tab3 = st.tabs(["📦 Define Fluids", "🏭 Build Process", "📊 Results"]) + +# ============================================================================= +# Tab 1: Define Fluids +# ============================================================================= + +with tab1: + st.header("Define Fluids") + + col1, col2 = st.columns([1, 2]) + + with col1: + st.subheader("Create New Fluid") + + fluid_name = st.text_input("Fluid Name", value="feed", key="new_fluid_name") + eos = st.selectbox("Equation of State", EOS_OPTIONS) + + st.markdown("**Composition (mole fractions)**") + components = {} + cols = st.columns(2) + for i, comp in enumerate(COMPONENT_OPTIONS[:10]): + with cols[i % 2]: + val = st.number_input(comp, min_value=0.0, max_value=1.0, + value=0.9 if comp == 'methane' else 0.1 if comp == 'ethane' else 0.0, + step=0.01, key=f"comp_{comp}") + if val > 0: + components[comp] = val + + st.markdown("**Conditions**") + temperature = st.number_input("Temperature (°C)", value=30.0) + pressure = st.number_input("Pressure (bara)", value=50.0, min_value=0.1) + + st.markdown("**Flow Rate (optional)**") + flow_rate = st.number_input("Flow Rate", value=10.0, min_value=0.0) + flow_unit = st.selectbox("Flow Unit", FLOW_UNITS, index=2) + + if st.button("➕ Add Fluid", type="primary"): + if fluid_name and components: + st.session_state.fluids[fluid_name] = { + 'eos': eos, + 'components': components, + 'temperature': temperature, + 'pressure': pressure, + 'flow_rate': flow_rate if flow_rate > 0 else None, + 'flow_unit': flow_unit + } + st.success(f"Fluid '{fluid_name}' added!") + st.rerun() + + with col2: + st.subheader("Defined Fluids") + if st.session_state.fluids: + for name, config in st.session_state.fluids.items(): + with st.expander(f"📦 {name}", expanded=True): + st.write(f"**EOS:** {config['eos']}") + st.write(f"**T:** {config['temperature']} °C | **P:** {config['pressure']} bara") + if config.get('flow_rate'): + st.write(f"**Flow:** {config['flow_rate']} {config['flow_unit']}") + st.write("**Composition:**", config['components']) + if st.button(f"🗑️ Remove", key=f"del_fluid_{name}"): + del st.session_state.fluids[name] + st.rerun() + else: + st.info("No fluids defined yet. Create one using the form on the left.") + +# ============================================================================= +# Tab 2: Build Process +# ============================================================================= + +with tab2: + st.header("Build Process") + + col1, col2 = st.columns([1, 2]) + + with col1: + st.subheader("Add Equipment") + + eq_type = st.selectbox("Equipment Type", list(EQUIPMENT_TYPES.keys())) + eq_name = st.text_input("Equipment Name", value=f"{eq_type}_1") + + params = {} + + # Equipment-specific parameters + if EQUIPMENT_TYPES[eq_type]['has_fluid']: + if st.session_state.fluids: + params['fluid'] = st.selectbox("Select Fluid", list(st.session_state.fluids.keys())) + else: + st.warning("Define a fluid first in the 'Define Fluids' tab") + + if EQUIPMENT_TYPES[eq_type]['inlet']: + inlets = get_available_inlets() + if inlets: + params['inlet'] = st.selectbox("Inlet From", inlets) + else: + st.warning("Add a stream first") + + if eq_type == 'compressor': + params['pressure'] = st.number_input("Outlet Pressure (bara)", value=100.0, min_value=0.1) + params['efficiency'] = st.slider("Isentropic Efficiency", 0.5, 1.0, 0.75) + + elif eq_type == 'pump': + params['pressure'] = st.number_input("Outlet Pressure (bara)", value=100.0, min_value=0.1) + params['efficiency'] = st.slider("Efficiency", 0.5, 1.0, 0.75) + + elif eq_type == 'expander': + params['pressure'] = st.number_input("Outlet Pressure (bara)", value=10.0, min_value=0.1) + + elif eq_type == 'valve': + params['pressure'] = st.number_input("Outlet Pressure (bara)", value=10.0, min_value=0.1) + + elif eq_type == 'heater': + params['temperature'] = st.number_input("Outlet Temperature (K)", value=350.0) + + elif eq_type == 'cooler': + params['temperature'] = st.number_input("Outlet Temperature (K)", value=300.0) + + elif eq_type == 'separator': + params['three_phase'] = st.checkbox("Three-phase separator") + + elif eq_type == 'pipe': + params['length'] = st.number_input("Length (m)", value=100.0) + params['diameter'] = st.number_input("Diameter (m)", value=0.1) + + # Add button + can_add = True + if EQUIPMENT_TYPES[eq_type]['inlet'] and not get_available_inlets(): + can_add = False + if EQUIPMENT_TYPES[eq_type]['has_fluid'] and not st.session_state.fluids: + can_add = False + + if st.button("➕ Add Equipment", type="primary", disabled=not can_add): + st.session_state.equipment_list.append({ + 'type': eq_type, + 'name': eq_name, + 'params': params + }) + st.success(f"Added {eq_type} '{eq_name}'") + st.rerun() + + with col2: + st.subheader("Process Equipment") + + if st.session_state.equipment_list: + for i, eq in enumerate(st.session_state.equipment_list): + with st.expander(f"{'🔵' if eq['type'] == 'stream' else '⚙️'} {eq['name']} ({eq['type']})", expanded=True): + for key, value in eq['params'].items(): + st.write(f"**{key}:** {value}") + + col_a, col_b = st.columns(2) + with col_a: + if st.button("⬆️ Move Up", key=f"up_{i}", disabled=i==0): + st.session_state.equipment_list[i], st.session_state.equipment_list[i-1] = \ + st.session_state.equipment_list[i-1], st.session_state.equipment_list[i] + st.rerun() + with col_b: + if st.button("🗑️ Remove", key=f"del_{i}"): + st.session_state.equipment_list.pop(i) + st.rerun() + + st.divider() + + col_run, col_clear = st.columns(2) + with col_run: + if st.button("▶️ Run Simulation", type="primary", use_container_width=True): + run_process() + with col_clear: + if st.button("🗑️ Clear All", use_container_width=True): + st.session_state.equipment_list = [] + st.session_state.process_result = None + st.session_state.results_data = None + st.rerun() + else: + st.info("No equipment added yet. Use the form on the left to add equipment.") + +# ============================================================================= +# Tab 3: Results +# ============================================================================= + +with tab3: + st.header("Simulation Results") + + if st.session_state.results_data is not None: + st.dataframe(st.session_state.results_data, use_container_width=True) + + # Show detailed results for each equipment + st.subheader("Detailed Equipment Results") + + if st.session_state.process_result: + for eq in st.session_state.equipment_list: + eq_obj = st.session_state.process_result.get(eq['name']) + if eq_obj: + with st.expander(f"📋 {eq['name']} Details"): + # Get outlet stream properties + out_stream = None + if hasattr(eq_obj, 'getOutletStream'): + out_stream = eq_obj.getOutletStream() + elif hasattr(eq_obj, 'getOutStream'): + out_stream = eq_obj.getOutStream() + elif hasattr(eq_obj, 'getGasOutStream'): + out_stream = eq_obj.getGasOutStream() + + if out_stream: + col1, col2, col3 = st.columns(3) + with col1: + st.metric("Temperature", f"{out_stream.getTemperature() - 273.15:.1f} °C") + with col2: + st.metric("Pressure", f"{out_stream.getPressure():.1f} bara") + with col3: + try: + st.metric("Flow Rate", f"{out_stream.getFlowRate('kg/hr'):.0f} kg/hr") + except: + pass + + if hasattr(eq_obj, 'getPower'): + st.metric("Power", f"{eq_obj.getPower()/1e3:.2f} kW") + if hasattr(eq_obj, 'getDuty'): + st.metric("Duty", f"{eq_obj.getDuty()/1e3:.2f} kW") + + # Export config button + st.subheader("Export Configuration") + + equipment_config = [] + for eq in st.session_state.equipment_list: + eq_config = {'type': eq['type'], 'name': eq['name']} + eq_config.update(eq.get('params', {})) + equipment_config.append(eq_config) + + config = { + 'name': 'Exported Process', + 'equipment': equipment_config + } + + import json + json_str = json.dumps(config, indent=2) + st.download_button( + label="📥 Download JSON Config", + data=json_str, + file_name="process_config.json", + mime="application/json" + ) + + st.code(json_str, language="json") + else: + st.info("Run a simulation to see results here.") + +# ============================================================================= +# Sidebar +# ============================================================================= + +with st.sidebar: + st.header("ℹ️ About") + st.markdown(""" + **NeqSim Process Builder GUI** + + A visual tool for building and simulating + process systems using NeqSim. + + **Workflow:** + 1. Define fluids with compositions + 2. Add process equipment + 3. Run simulation + 4. View and export results + + **Supported Equipment:** + - Streams + - Separators (2/3 phase) + - Compressors + - Pumps + - Expanders + - Valves + - Heaters/Coolers + - Pipes + """) + + st.divider() + + if st.button("🔄 Reset All"): + st.session_state.fluids = {} + st.session_state.equipment_list = [] + st.session_state.process_result = None + st.session_state.results_data = None + st.rerun() diff --git a/examples/pumpNPSH.py b/examples/pumpNPSH.py index 5e7b970e..dbcacf21 100644 --- a/examples/pumpNPSH.py +++ b/examples/pumpNPSH.py @@ -57,7 +57,9 @@ print("\nPump Specifications:") print(f" Suction pressure: {inlet_stream.getPressure('bara'):.1f} bara") print(f" Discharge pressure: {outlet_stream.getPressure('bara'):.1f} bara") -print(f" Differential: {outlet_stream.getPressure('bara') - inlet_stream.getPressure('bara'):.1f} bar") +print( + f" Differential: {outlet_stream.getPressure('bara') - inlet_stream.getPressure('bara'):.1f} bar" +) print("\nFlow Conditions:") print(f" Volume flow: {inlet_stream.getFlowRate('m3/hr'):.0f} m³/hr") @@ -82,7 +84,7 @@ npsha = pump.getNPSHAvailable() if npsha > 0: print(f" NPSHa (available): {npsha:.2f} m") - + # Check for cavitation if pump.isCavitating(): print(f" ⚠️ WARNING: CAVITATION RISK!") diff --git a/examples/pvtExperimentsAdvanced.py b/examples/pvtExperimentsAdvanced.py index a8656313..14230663 100644 --- a/examples/pvtExperimentsAdvanced.py +++ b/examples/pvtExperimentsAdvanced.py @@ -111,20 +111,22 @@ oil.setPressure(p, "bara") TPflash(oil) oil.initThermoProperties() - + v_total = oil.getVolume("m3") rel_vol = v_total / v_sat - + # Get phase properties if oil.hasPhaseType("oil"): rho_oil = oil.getPhase("oil").getDensity("kg/m3") else: rho_oil = oil.getDensity("kg/m3") - + if oil.hasPhaseType("gas"): rho_gas = oil.getPhase("gas").getDensity("kg/m3") z_gas = oil.getPhase("gas").getZ() - print(f"{p:8.1f} | {rel_vol:7.4f} | {rho_oil:8.1f} | {rho_gas:8.2f} | {z_gas:.4f}") + print( + f"{p:8.1f} | {rel_vol:7.4f} | {rho_oil:8.1f} | {rho_gas:8.2f} | {z_gas:.4f}" + ) else: print(f"{p:8.1f} | {rel_vol:7.4f} | {rho_oil:8.1f} | (single) | -") @@ -168,16 +170,16 @@ diff_oil.setPressure(p, "bara") TPflash(diff_oil) diff_oil.initThermoProperties() - + if diff_oil.hasPhaseType("gas") and diff_oil.hasPhaseType("oil"): v_oil = diff_oil.getPhase("oil").getVolume("m3") v_gas = diff_oil.getPhase("gas").getVolume("m3") - + # Simple GOR calculation (approximate) n_gas = diff_oil.getPhase("gas").getNumberOfMolesInPhase() n_oil = diff_oil.getPhase("oil").getNumberOfMolesInPhase() gor = (n_gas / n_oil) * 100 if n_oil > 0 else 0 - + print(f"{p:8.1f} | {v_oil:.2e} | {v_gas:.2e} | {gor:.1f}") else: v_total = diff_oil.getVolume("m3") @@ -204,9 +206,9 @@ # Separator conditions sep_stages = [ - (50.0, 40.0), # Stage 1: 50 bara, 40°C - (10.0, 30.0), # Stage 2: 10 bara, 30°C - (1.0, 20.0), # Stock tank: 1 bara, 20°C + (50.0, 40.0), # Stage 1: 50 bara, 40°C + (10.0, 30.0), # Stage 2: 10 bara, 30°C + (1.0, 20.0), # Stock tank: 1 bara, 20°C ] print("\nStage | P [bara] | T [°C] | Gas Fraction | Oil Density") @@ -217,14 +219,18 @@ sep_oil.setPressure(p, "bara") TPflash(sep_oil) sep_oil.initThermoProperties() - + if sep_oil.hasPhaseType("gas"): gas_frac = sep_oil.getPhase("gas").getBeta() - oil_rho = sep_oil.getPhase("oil").getDensity("kg/m3") if sep_oil.hasPhaseType("oil") else 0 + oil_rho = ( + sep_oil.getPhase("oil").getDensity("kg/m3") + if sep_oil.hasPhaseType("oil") + else 0 + ) else: gas_frac = 0 oil_rho = sep_oil.getDensity("kg/m3") - + stage_name = f"Stage {i+1}" if i < 2 else "Tank" print(f"{stage_name:5} | {p:8.1f} | {t:6.1f} | {gas_frac:12.4f} | {oil_rho:.1f}") @@ -268,14 +274,14 @@ swell_oil.addComponent("n-decane", 40.0 * scale, "mol%") swell_oil.setMixingRule("classic") swell_oil.setMultiPhaseCheck(True) - + swell_oil.setTemperature(80.0, "C") psat_swell = bubblepoint(swell_oil) swell_oil.setPressure(psat_swell, "bara") TPflash(swell_oil) swell_oil.initThermoProperties() v_swell = swell_oil.getVolume("m3") - + swelling_factor = v_swell / v_ref print(f"{co2_pct:9} | {swelling_factor:8.4f} | {psat_swell:8.1f}") @@ -302,7 +308,7 @@ TPflash(visc_oil) visc_oil.initThermoProperties() visc_oil.initPhysicalProperties("viscosity") - + mu = visc_oil.getViscosity("cP") print(f"{t:6} | {p:8} | {mu:.4f}") @@ -311,15 +317,17 @@ # ============================================================================= print("\n8. PVT EXPERIMENTS SUMMARY") print("-" * 40) -print(""" +print( + """ Experiment | Purpose --------------------|---------------------------------------------- CME | Oil compressibility, relative volume, GOR -Differential | Gas liberation, reservoir depletion behavior +Differential | Gas liberation, reservoir depletion behavior Liberation | Separator Test | Optimize surface separation, stock tank oil Swelling Test | EOR potential with gas injection (CO2, HC gas) Viscosity Study | Flow assurance, production optimization -""") +""" +) print("=" * 70) diff --git a/examples/safetyValve.py b/examples/safetyValve.py index de296cce..55b10f2e 100644 --- a/examples/safetyValve.py +++ b/examples/safetyValve.py @@ -49,7 +49,9 @@ psv.setBlowdown(7.0) # Blowdown percentage # Create PSV relief stream -psv_relief = jneqsim.process.equipment.stream.Stream("PSV Relief", psv.getOutletStream()) +psv_relief = jneqsim.process.equipment.stream.Stream( + "PSV Relief", psv.getOutletStream() +) # Create flare header (mixer to collect relief streams) flare_header = jneqsim.process.equipment.mixer.Mixer("Flare Header") @@ -89,7 +91,9 @@ print("\nNormal Operating Conditions (50 bara):") print(f" Separator pressure: {separator.getPressure():.1f} bara") -print(f" PSV status: {'CLOSED' if psv.getPercentValveOpening() < 0.1 else 'OPEN'}") +print( + f" PSV status: {'CLOSED' if psv.getPercentValveOpening() < 0.1 else 'OPEN'}" +) print(f" PSV opening: {psv.getPercentValveOpening():.1f}%") # Simulate overpressure by increasing separator pressure diff --git a/examples/transientSeparator.py b/examples/transientSeparator.py index be2aa61a..8748f268 100644 --- a/examples/transientSeparator.py +++ b/examples/transientSeparator.py @@ -2,7 +2,7 @@ """ Transient Separator Simulation Example -This example demonstrates transient (dynamic) simulation of a +This example demonstrates transient (dynamic) simulation of a separator in NeqSim. Transient simulation tracks how equipment responds over time to changing conditions. @@ -92,30 +92,32 @@ feed_fluid.setTotalFlowRate(60000.0, "kg/hr") # 20% increase feed_stream.setFluid(feed_fluid) print(f">>> Feed rate increased to 60,000 kg/hr at t={time:.0f}s <<<") - + # At t=90s, decrease feed rate back to original if time == 90.0: feed_fluid.setTotalFlowRate(50000.0, "kg/hr") # Back to original feed_stream.setFluid(feed_fluid) print(f">>> Feed rate decreased to 50,000 kg/hr at t={time:.0f}s <<<") - + # Run feed stream feed_stream.run() - + # Run separator transient step run_id = uuid.uuid4() separator.runTransient(time_step, jneqsim.util.util.UUIDJVM.randomUUID()) - + # Run outlet streams gas_outlet.run() liquid_outlet.run() - + # Print results every 10 seconds if time % 10.0 == 0: - print(f"{time:8.0f} | {separator.getPressure():15.2f} | " - f"{gas_outlet.getFlowRate('kg/hr'):16.0f} | " - f"{liquid_outlet.getFlowRate('kg/hr'):18.0f}") - + print( + f"{time:8.0f} | {separator.getPressure():15.2f} | " + f"{gas_outlet.getFlowRate('kg/hr'):16.0f} | " + f"{liquid_outlet.getFlowRate('kg/hr'):18.0f}" + ) + time += time_step print("-" * 70) diff --git a/examples/viscosityModels.py b/examples/viscosityModels.py index 5ed94c56..dcd95493 100644 --- a/examples/viscosityModels.py +++ b/examples/viscosityModels.py @@ -30,7 +30,8 @@ # ============================================================================= print("\n1. AVAILABLE VISCOSITY MODELS") print("-" * 40) -print(""" +print( + """ Model | Keyword | Best For -------------------|--------------------|--------------------------------- LBC | "LBC" | General oil, reservoir fluids @@ -41,7 +42,8 @@ The LBC model is based on corresponding states principle using critical properties. Friction Theory links viscosity to EoS pressure terms, providing thermodynamic consistency. -""") +""" +) # ============================================================================= # 2. BASIC VISCOSITY CALCULATION @@ -87,11 +89,12 @@ # ============================================================================= print("\n3. LBC MODEL (LOHRENZ-BRAY-CLARK)") print("-" * 40) -print(""" +print( + """ The LBC model calculates viscosity as: - + η = η* + η_dense / ξ_m - + Where: η* = Low-pressure gas viscosity contribution η_dense = Dense-fluid contribution (function of reduced density) @@ -100,7 +103,7 @@ Dense-fluid contribution uses a polynomial: (η_dense * ξ_m + 10^-4)^0.25 = a0 + a1*ρr + a2*ρr² + a3*ρr³ + a4*ρr⁴ - + Default LBC parameters (a0 to a4): a0 = 0.10230 a1 = 0.023364 @@ -109,7 +112,8 @@ a4 = 0.0093324 These parameters can be tuned to match laboratory viscosity data. -""") +""" +) # ============================================================================= # 4. TUNING LBC MODEL PARAMETERS @@ -135,36 +139,37 @@ tuning_oil.getPhase("oil").getPhysicalProperties().setViscosityModel("LBC") tuning_oil.initPhysicalProperties() default_visc = tuning_oil.getPhase("oil").getViscosity("cP") - + print(f"\nDefault LBC viscosity: {default_visc:.4f} cP") - + # Suppose lab measurement is 2.5 cP - we need to tune lab_viscosity = 2.5 print(f"Laboratory measurement: {lab_viscosity:.4f} cP") - + # Method 1: Set all five parameters at once # Increasing coefficients generally increases viscosity # Default: [0.10230, 0.023364, 0.058533, -0.040758, 0.0093324] tuned_params = [0.15, 0.04, 0.08, -0.03, 0.015] # Increased values - + tuning_oil.getPhase("oil").getPhysicalProperties().setLbcParameters(tuned_params) tuning_oil.initPhysicalProperties() tuned_visc_1 = tuning_oil.getPhase("oil").getViscosity("cP") - + print(f"\nTuned viscosity (all params): {tuned_visc_1:.4f} cP") - + # Method 2: Adjust individual parameter # Parameter indices: a0=0, a1=1, a2=2, a3=3, a4=4 # a0 (index 0) has most influence at low density # a4 (index 4) has most influence at high density - + tuning_oil.getPhase("oil").getPhysicalProperties().setLbcParameter(2, 0.10) tuning_oil.initPhysicalProperties() tuned_visc_2 = tuning_oil.getPhase("oil").getViscosity("cP") - + print(f"Further adjusted (a2=0.10): {tuned_visc_2:.4f} cP") -print(""" +print( + """ LBC Tuning Guidelines: ---------------------- • a0 (index 0): Baseline offset - increase for higher overall viscosity @@ -172,18 +177,20 @@ • a2 (index 2): Quadratic term - significant for liquid viscosity • a3 (index 3): Cubic term - fine-tuning at high density • a4 (index 4): Quartic term - extreme density behavior -""") +""" +) # ============================================================================= # 5. FRICTION THEORY MODEL # ============================================================================= print("\n5. FRICTION THEORY MODEL") print("-" * 40) -print(""" +print( + """ Friction Theory (f-theory) links viscosity to EoS pressure terms: η = η0 + ηf - + Where: η0 = Dilute gas viscosity (Chung correlation) ηf = Friction contribution from EoS @@ -195,7 +202,8 @@ ✓ Consistent with phase equilibrium calculations ✓ Better extrapolation behavior ✓ Works well for wide T/P ranges -""") +""" +) # ============================================================================= # 6. TUNING FRICTION THEORY - TBP CORRECTION FACTOR @@ -222,47 +230,49 @@ # Set friction theory model ft_oil.getPhase("oil").getPhysicalProperties().setViscosityModel("friction theory") ft_oil.initPhysicalProperties() - + # Get default viscosity default_ft_visc = ft_oil.getPhase("oil").getViscosity("cP") print(f"\nDefault Friction Theory viscosity: {default_ft_visc:.4f} cP") - + # Apply TBP viscosity correction factor # Factor > 1.0 increases viscosity # Factor < 1.0 decreases viscosity visc_model = ft_oil.getPhase("oil").getPhysicalProperties().getViscosityModel() - + # Access the FrictionTheoryViscosityMethod directly print("\nApplying TBP correction factors:") print("\nCorrection Factor | Viscosity [cP]") print("------------------|----------------") - + for correction in [0.8, 1.0, 1.2, 1.5, 2.0]: try: # Set the TBP correction factor visc_model.setTBPviscosityCorrection(correction) ft_oil.initPhysicalProperties() - + corrected_visc = ft_oil.getPhase("oil").getViscosity("cP") print(f"{correction:17.1f} | {corrected_visc:.4f}") except Exception as e: print(f"{correction:17.1f} | Error: {e}") - + # Reset to default visc_model.setTBPviscosityCorrection(1.0) -print(""" +print( + """ Friction Theory Tuning Guidelines: ---------------------------------- • TBP Correction Factor: - Default = 1.0 (no correction) - > 1.0: Increases viscosity for heavy fractions - < 1.0: Decreases viscosity - + • Use when TBP fractions give incorrect viscosity predictions • Tune to match laboratory viscosity at one T/P condition • Model will extrapolate to other conditions -""") +""" +) # ============================================================================= # 7. ADVANCED: TUNING WITH EXPERIMENTAL DATA @@ -284,7 +294,8 @@ for pt in exp_data: print(f"{pt['T_C']:6} | {pt['P_bara']:8} | {pt['visc_cP']:.2f}") -print(""" +print( + """ Tuning Workflow: ---------------- 1. Create fluid with accurate composition @@ -299,7 +310,8 @@ For automatic optimization, use NeqSim's parameter fitting capabilities with the ViscosityFunction class in PVT simulation. -""") +""" +) # ============================================================================= # 8. MODEL COMPARISON AT DIFFERENT CONDITIONS @@ -332,18 +344,20 @@ comp_oil.setPressure(p_bara, "bara") TPflash(comp_oil) comp_oil.initThermoProperties() - + if comp_oil.hasPhaseType("oil"): # LBC comp_oil.getPhase("oil").getPhysicalProperties().setViscosityModel("LBC") comp_oil.initPhysicalProperties() lbc_visc = comp_oil.getPhase("oil").getViscosity("cP") - + # Friction Theory - comp_oil.getPhase("oil").getPhysicalProperties().setViscosityModel("friction theory") + comp_oil.getPhase("oil").getPhysicalProperties().setViscosityModel( + "friction theory" + ) comp_oil.initPhysicalProperties() ft_visc = comp_oil.getPhase("oil").getViscosity("cP") - + ratio = lbc_visc / ft_visc if ft_visc > 0 else 0 print(f"{t_c:6} | {p_bara:8} | {lbc_visc:9.4f} | {ft_visc:13.4f} | {ratio:.3f}") @@ -352,7 +366,8 @@ # ============================================================================= print("\n9. HEAVY OIL CONSIDERATIONS") print("-" * 40) -print(""" +print( + """ For heavy oils (API < 20°, viscosity > 100 cP), consider: 1. Use PFCT-Heavy-Oil model: @@ -365,14 +380,16 @@ 4. Temperature sensitivity is critical - ensure accurate measurements 5. Consider using Pedersen corresponding states for very heavy systems -""") +""" +) # ============================================================================= # 10. SUMMARY # ============================================================================= print("\n10. SUMMARY: MODEL SELECTION GUIDELINES") print("-" * 40) -print(""" +print( + """ ┌────────────────────┬──────────────────────────────────────────┐ │ Oil Type │ Recommended Model & Notes │ ├────────────────────┼──────────────────────────────────────────┤ @@ -388,6 +405,7 @@ │ Extra-heavy │ Specialized correlations │ │ (API < 10°) │ May require custom viscosity data │ └────────────────────┴──────────────────────────────────────────┘ -""") +""" +) print("=" * 70) diff --git a/scripts/generate_stubs.py b/scripts/generate_stubs.py index 566a9996..d1e4534c 100644 --- a/scripts/generate_stubs.py +++ b/scripts/generate_stubs.py @@ -34,9 +34,7 @@ def rename_package_in_stubs(stubs_dir: Path, old_name: str, new_name: str): # Replace import statements and type references # Match 'neqsim.' but not 'jneqsim.' (negative lookbehind) - new_content = re.sub( - rf"(?= (3, 8): from typing import Protocol else: @@ -21,7 +21,6 @@ import jneqsim.thermodynamicoperations import jneqsim.util import typing - class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("neqsim")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/api/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/api/__init__.pyi index 9a813888..a4f6baec 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/api/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/api/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,7 +8,6 @@ else: import jneqsim.api.ioc import typing - class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.api")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/api/ioc/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/api/ioc/__init__.pyi index eb216820..c3b82f33 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/api/ioc/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/api/ioc/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,16 +9,19 @@ 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/blackoil/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/blackoil/__init__.pyi index dc3079a4..a730a346 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/blackoil/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/blackoil/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,15 +11,20 @@ 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': ... + 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' = ... + pvt: "BlackOilPVTTable" = ... + blackOilSystem: "SystemBlackOil" = ... rho_o_sc: float = ... rho_g_sc: float = ... rho_w_sc: float = ... @@ -27,8 +32,21 @@ class BlackOilConverter: 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': ... + 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 = ... @@ -51,7 +69,9 @@ class BlackOilFlashResult: def __init__(self): ... class BlackOilPVTTable: - def __init__(self, list: java.util.List['BlackOilPVTTable.Record'], double: float): ... + 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: ... @@ -62,6 +82,7 @@ class BlackOilPVTTable: 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 = ... @@ -72,11 +93,28 @@ class BlackOilPVTTable: 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): ... + 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 __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: ... @@ -101,7 +139,6 @@ class SystemBlackOil: 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/blackoil/io/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/blackoil/io/__init__.pyi index 7cca1deb..3dfef276 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/blackoil/io/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/blackoil/io/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,14 +13,15 @@ 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': ... + def fromFile( + path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath] + ) -> "EclipseBlackOilImporter.Result": ... @staticmethod - def fromReader(reader: java.io.Reader) -> 'EclipseBlackOilImporter.Result': ... + def fromReader(reader: java.io.Reader) -> "EclipseBlackOilImporter.Result": ... + class Result: pvt: jneqsim.blackoil.BlackOilPVTTable = ... system: jneqsim.blackoil.SystemBlackOil = ... @@ -30,20 +31,25 @@ class EclipseBlackOilImporter: 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "EclipseBlackOilImporter.Units": ... @staticmethod - def values() -> typing.MutableSequence['EclipseBlackOilImporter.Units']: ... - + def values() -> typing.MutableSequence["EclipseBlackOilImporter.Units"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.blackoil.io")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/__init__.pyi index 15fbc77a..44cbcee9 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,22 +14,26 @@ import jneqsim.thermo.phase import jneqsim.thermo.system import typing - - -class ChemicalReactionOperations(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.Cloneable): +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 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 getReactionList( + self, + ) -> jneqsim.chemicalreactions.chemicalreaction.ChemicalReactionList: ... def hasReactions(self) -> bool: ... - def reacHeat(self, int: int, string: typing.Union[java.lang.String, str]) -> float: ... + def reacHeat( + self, int: int, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def setComponents(self) -> None: ... @typing.overload @@ -39,20 +43,25 @@ class ChemicalReactionOperations(jneqsim.thermo.ThermodynamicConstantsInterface, def setReactiveComponents(self) -> None: ... @typing.overload def setReactiveComponents(self, int: int) -> None: ... - def setSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> 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 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__ + 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 index cbcae533..f13de768 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalequilibrium/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalequilibrium/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,54 +16,128 @@ 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]): ... + 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]): ... + 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 __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: ... + 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 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 __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 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): ... +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 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): +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: ... - + 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] + 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 index a0aa6923..3e249b4b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalreaction/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/chemicalreaction/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,14 +16,31 @@ 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: ... +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: ... @@ -34,51 +51,124 @@ class ChemicalReaction(jneqsim.util.NamedBaseClass, jneqsim.thermo.Thermodynamic @typing.overload def getRateFactor(self) -> float: ... @typing.overload - def getRateFactor(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + 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 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 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: ... + 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: ... + 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 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 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]]: ... + 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]: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/kinetics/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/kinetics/__init__.pyi index 4582d9a0..d92d0dcf 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/kinetics/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/chemicalreactions/kinetics/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,17 +10,27 @@ import jneqsim.chemicalreactions import jneqsim.thermo.phase import typing - - class Kinetics(java.io.Serializable): - def __init__(self, chemicalReactionOperations: jneqsim.chemicalreactions.ChemicalReactionOperations): ... + 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 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/datapresentation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/__init__.pyi index b0c27dc0..9049d753 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/datapresentation/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,8 +11,6 @@ import jneqsim.datapresentation.filehandling import jneqsim.datapresentation.jfreechart import typing - - class DataHandling: def __init__(self): ... def getItemCount(self, int: int) -> int: ... @@ -22,17 +20,31 @@ class DataHandling: 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: ... + 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/datapresentation/filehandling/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/filehandling/__init__.pyi index 1a332122..0870b3b0 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/datapresentation/filehandling/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/filehandling/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,18 +10,27 @@ 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: ... + 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: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/datapresentation/jfreechart/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/jfreechart/__init__.pyi index 41806bf3..bffb7cec 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/datapresentation/jfreechart/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/datapresentation/jfreechart/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,27 +13,52 @@ 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]): ... + 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]): ... + 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 __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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/__init__.pyi index e8ed463d..ba2a8adf 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,12 +13,9 @@ 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/__init__.pyi index fb4311a1..f15c1e44 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,46 +13,73 @@ 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 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 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 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: ... + 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: ... + 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 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 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/pipeleg/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/pipeleg/__init__.pyi index 68ab91bf..e536bd22 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/pipeleg/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowleg/pipeleg/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,15 +9,14 @@ 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/__init__.pyi index 98340f26..442c8d18 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -20,8 +20,6 @@ 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: ... @@ -38,19 +36,31 @@ class FlowNodeInterface(java.lang.Cloneable): 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 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 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 getNextNode(self) -> "FlowNodeInterface": ... + def getOperations( + self, + ) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... def getPhaseFraction(self, int: int) -> float: ... def getPrandtlNumber(self, int: int) -> float: ... @typing.overload @@ -82,15 +92,24 @@ class FlowNodeInterface(java.lang.Cloneable): def init(self) -> None: ... def initBulkSystem(self) -> None: ... def initFlowCalc(self) -> None: ... - def setBulkSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> 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 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 setGeometryDefinitionInterface( + self, + geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface, + ) -> None: ... def setInterphaseModelType(self, int: int) -> None: ... - def setInterphaseSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> 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 @@ -100,19 +119,27 @@ class FlowNodeInterface(java.lang.Cloneable): @typing.overload def setVelocityIn(self, int: int, double: float) -> None: ... @typing.overload - def setVelocityIn(self, int: int, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + 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: ... + 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: ... + 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 setVelocityOut( + self, doubleCloneable: jneqsim.util.util.DoubleCloneable + ) -> None: ... def setVerticalPositionOfNode(self, double: float) -> None: ... @typing.overload def setWallFrictionFactor(self, int: int, double: float) -> None: ... @@ -120,12 +147,28 @@ class FlowNodeInterface(java.lang.Cloneable): 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: ... + 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: ... + 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] = ... @@ -143,16 +186,28 @@ class FlowNode(FlowNodeInterface, jneqsim.thermo.ThermodynamicConstantsInterface @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 __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]]: ... + 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 @@ -163,19 +218,31 @@ class FlowNode(FlowNodeInterface, jneqsim.thermo.ThermodynamicConstantsInterface 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 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 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 getOperations( + self, + ) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... def getPhaseFraction(self, int: int) -> float: ... def getPrandtlNumber(self, int: int) -> float: ... @typing.overload @@ -206,17 +273,29 @@ class FlowNode(FlowNodeInterface, jneqsim.thermo.ThermodynamicConstantsInterface def increaseMolarRate(self, double: float) -> None: ... def init(self) -> None: ... def initBulkSystem(self) -> None: ... - def setBulkSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> 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 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 setGeometryDefinitionInterface( + self, + geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface, + ) -> None: ... def setInterphaseModelType(self, int: int) -> None: ... - def setInterphaseSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> 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 setOperations( + self, + thermodynamicOperations: jneqsim.thermodynamicoperations.ThermodynamicOperations, + ) -> None: ... def setPhaseFraction(self, int: int, double: float) -> None: ... @typing.overload def setVelocity(self, double: float) -> None: ... @@ -225,19 +304,27 @@ class FlowNode(FlowNodeInterface, jneqsim.thermo.ThermodynamicConstantsInterface @typing.overload def setVelocityIn(self, double: float) -> None: ... @typing.overload - def setVelocityIn(self, doubleCloneable: jneqsim.util.util.DoubleCloneable) -> None: ... + 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: ... + 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: ... + 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 setVelocityOut( + self, int: int, doubleCloneable: jneqsim.util.util.DoubleCloneable + ) -> None: ... def setVerticalPositionOfNode(self, double: float) -> None: ... @typing.overload def setWallFrictionFactor(self, double: float) -> None: ... @@ -245,8 +332,12 @@ class FlowNode(FlowNodeInterface, jneqsim.thermo.ThermodynamicConstantsInterface 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/__init__.pyi index a14f83ec..87d6582e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,9 +9,12 @@ 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__ + 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 index d5d830ea..7ede9ccd 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/heatmasstransfercalc/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -17,27 +17,37 @@ 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 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 getBinaryMassTransferCoefficient( + self, int: int, int2: int, int3: int + ) -> float: ... def getBulkSystem(self) -> jneqsim.thermo.system.SystemInterface: ... - def getBulkSystemOpertions(self) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... + 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 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 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 setInterphaseSystem( + self, systemInterface: jneqsim.thermo.system.SystemInterface + ) -> None: ... def setMassTransferCalc(self, boolean: bool) -> None: ... def solve(self) -> None: ... @typing.overload @@ -52,7 +62,12 @@ class FluidBoundaryInterface(java.lang.Cloneable): 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: ... + 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] = ... @@ -60,28 +75,46 @@ class FluidBoundary(FluidBoundaryInterface, java.io.Serializable): heatTransferCalc: bool = ... thermodynamicCorrections: typing.MutableSequence[bool] = ... finiteFluxCorrection: typing.MutableSequence[bool] = ... - binaryMassTransferCoefficient: typing.MutableSequence[typing.MutableSequence[typing.MutableSequence[float]]] = ... + 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): ... + 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 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 getBinaryMassTransferCoefficient( + self, int: int, int2: int, int3: int + ) -> float: ... def getBulkSystem(self) -> jneqsim.thermo.system.SystemInterface: ... - def getBulkSystemOpertions(self) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... + 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 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 getInterphaseOpertions( + self, + ) -> jneqsim.thermodynamicoperations.ThermodynamicOperations: ... def getInterphaseSystem(self) -> jneqsim.thermo.system.SystemInterface: ... - def getMassTransferCoefficientMatrix(self) -> typing.MutableSequence[Jama.Matrix]: ... + def getMassTransferCoefficientMatrix( + self, + ) -> typing.MutableSequence[Jama.Matrix]: ... def heatTransSolve(self) -> None: ... def init(self) -> None: ... def initHeatTransferCalc(self) -> None: ... @@ -89,10 +122,14 @@ class FluidBoundary(FluidBoundaryInterface, java.io.Serializable): def initMassTransferCalc(self) -> None: ... def isHeatTransferCalc(self) -> bool: ... def massTransSolve(self) -> None: ... - def setBulkSystem(self, systemInterface: jneqsim.thermo.system.SystemInterface) -> 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 setInterphaseSystem( + self, systemInterface: jneqsim.thermo.system.SystemInterface + ) -> None: ... def setMassTransferCalc(self, boolean: bool) -> None: ... def setSolverType(self, int: int) -> None: ... @typing.overload @@ -107,14 +144,24 @@ class FluidBoundary(FluidBoundaryInterface, java.io.Serializable): 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: ... - + 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__ + 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 index 9d218f41..6a1dd224 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,19 +12,22 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc import jneqsim.thermo.system import typing - - -class EquilibriumFluidBoundary(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundary): +class EquilibriumFluidBoundary( + jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundary +): @typing.overload - def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + 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 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")``. 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 index c4b2b51b..93c977e3 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,10 +10,15 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finite 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__ + 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 index 13e342b7..fb7db6ac 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,8 +10,6 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finite import jneqsim.thermo.system import typing - - class FluidBoundaryNodeInterface: def getBulkSystem(self) -> jneqsim.thermo.system.SystemInterface: ... @@ -22,11 +20,14 @@ class FluidBoundaryNode(FluidBoundaryNodeInterface): 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__ + 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 index 0352e096..1877686c 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,15 +9,14 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finite import jneqsim.thermo.system import typing - - -class FluidBoundaryNodeNonReactive(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.FluidBoundaryNode): +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")``. 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 index 595bb4dd..9fa0f45b 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,15 +9,14 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finite import jneqsim.thermo.system import typing - - -class FluidBoundaryNodeReactive(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarynode.FluidBoundaryNode): +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")``. 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 index aee2c3cf..0a9ddf4e 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,8 +9,6 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finite import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem import typing - - class FluidBoundarySolverInterface: def getMolarFlux(self, int: int) -> float: ... def solve(self) -> None: ... @@ -19,9 +17,16 @@ class FluidBoundarySolver(FluidBoundarySolverInterface): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, fluidBoundarySystemInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysystem.FluidBoundarySystemInterface): ... + 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 __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: ... @@ -29,10 +34,11 @@ class FluidBoundarySolver(FluidBoundarySolverInterface): 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__ + 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 index eb963873..efccbf8b 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,12 +8,11 @@ else: import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver import typing - - -class FluidBoundaryReactiveSolver(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finitevolumeboundary.fluidboundarysolver.FluidBoundarySolver): +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")``. 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 index 6ca7b29d..0bfc1bab 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,14 +11,23 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.finite 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 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 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: ... @@ -29,23 +38,40 @@ 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 __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 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__ + 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 index eea1a2f0..1eb55f19 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,17 +11,21 @@ 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): +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 __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: ... - + 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")``. 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 index 2daa6377..56604d41 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,17 +11,21 @@ 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): +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 __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: ... - + 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")``. 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 index 6f80cd92..37e20a75 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,19 +11,21 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequ import jneqsim.thermo.system import typing - - -class NonEquilibriumFluidBoundary(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundary): +class NonEquilibriumFluidBoundary( + jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundary +): molFractionDifference: typing.MutableSequence[typing.MutableSequence[float]] = ... @typing.overload - def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + 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 clone(self) -> "NonEquilibriumFluidBoundary": ... def heatTransSolve(self) -> None: ... def init(self) -> None: ... def initHeatTransferCalc(self) -> None: ... @@ -37,9 +39,10 @@ class NonEquilibriumFluidBoundary(jneqsim.fluidmechanics.flownode.fluidboundary. 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__ + 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 index 3bf40546..90fbb94c 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,11 +14,14 @@ import jneqsim.thermo import jneqsim.thermo.system import typing - - -class KrishnaStandartFilmModel(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.NonEquilibriumFluidBoundary, jneqsim.thermo.ThermodynamicConstantsInterface): +class KrishnaStandartFilmModel( + jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.NonEquilibriumFluidBoundary, + jneqsim.thermo.ThermodynamicConstantsInterface, +): @typing.overload - def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + def __init__( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ): ... @typing.overload def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... def calcBinaryMassTransferCoefficients(self, int: int) -> float: ... @@ -29,18 +32,21 @@ class KrishnaStandartFilmModel(jneqsim.fluidmechanics.flownode.fluidboundary.hea def calcRedCorrectionMatrix(self, int: int) -> None: ... def calcRedPhiMatrix(self, int: int) -> None: ... def calcTotalMassTransferCoefficientMatrix(self, int: int) -> None: ... - def clone(self) -> 'KrishnaStandartFilmModel': ... + 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 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__ + 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 index 18c88ea7..0605442c 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,12 +11,14 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequ import jneqsim.thermo.system import typing - - -class ReactiveFluidBoundary(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.KrishnaStandartFilmModel): +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): ... + def __init__( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ): ... @typing.overload def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... def calcFluxes(self) -> typing.MutableSequence[float]: ... @@ -24,7 +26,7 @@ class ReactiveFluidBoundary(jneqsim.fluidmechanics.flownode.fluidboundary.heatma def calcHeatTransferCoefficients(self, int: int) -> None: ... def calcHeatTransferCorrection(self, int: int) -> None: ... def calcMolFractionDifference(self) -> None: ... - def clone(self) -> 'ReactiveFluidBoundary': ... + def clone(self) -> "ReactiveFluidBoundary": ... def heatTransSolve(self) -> None: ... def init(self) -> None: ... def initHeatTransferCalc(self) -> None: ... @@ -38,18 +40,23 @@ class ReactiveFluidBoundary(jneqsim.fluidmechanics.flownode.fluidboundary.heatma def solve(self) -> None: ... def updateMassTrans(self) -> None: ... -class ReactiveKrishnaStandartFilmModel(jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.KrishnaStandartFilmModel): +class ReactiveKrishnaStandartFilmModel( + jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.nonequilibriumfluidboundary.filmmodelboundary.KrishnaStandartFilmModel +): @typing.overload - def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + 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__ + 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 index 774d694d..62fe4493 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,8 +9,6 @@ import jpype import jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc import typing - - class EnhancementFactorInterface: def calcEnhancementVec(self, int: int) -> None: ... def getEnhancementVec(self, int: int) -> float: ... @@ -20,7 +18,10 @@ class EnhancementFactor(EnhancementFactorInterface): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface): ... + def __init__( + self, + fluidBoundaryInterface: jneqsim.fluidmechanics.flownode.fluidboundary.heatmasstransfercalc.FluidBoundaryInterface, + ): ... @typing.overload def calcEnhancementVec(self, int: int) -> None: ... @typing.overload @@ -34,24 +35,33 @@ class EnhancementFactor(EnhancementFactorInterface): @typing.overload def getHattaNumber(self) -> typing.MutableSequence[float]: ... @typing.overload - def setEnhancementVec(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> None: ... + 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 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): ... + 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 __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")``. 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 index bc6265e2..5f984b14 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/fluidboundary/interphasetransportcoefficient/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,45 +10,120 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoeffici 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: ... + 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: ... + def calcWallFrictionFactor( + self, + int: int, + flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface, + ) -> float: ... @typing.overload - def calcWallFrictionFactor(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallFrictionFactor( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ) -> float: ... @typing.overload - def calcWallHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + 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: ... + 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: ... + 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: ... + def calcWallFrictionFactor( + self, + int: int, + flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface, + ) -> float: ... @typing.overload - def calcWallFrictionFactor(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallFrictionFactor( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ) -> float: ... @typing.overload - def calcWallHeatTransferCoefficient(self, int: int, double: float, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + 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: ... - + 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__ + 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 index e7791a37..af6ae6f4 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,17 +10,20 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoeffici import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase.interphasepipeflow import typing - - -class InterphaseOnePhase(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.InterphaseTransportCoefficientBaseClass): +class InterphaseOnePhase( + jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.InterphaseTransportCoefficientBaseClass +): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... - + 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__ + 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 index 12d08770..b2e4d19c 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,23 +9,44 @@ import jneqsim.fluidmechanics.flownode import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase import typing - - -class InterphasePipeFlow(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase.InterphaseOnePhase): +class InterphasePipeFlow( + jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphaseonephase.InterphaseOnePhase +): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + def __init__( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ): ... @typing.overload - def calcWallFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallFrictionFactor( + self, + int: int, + flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface, + ) -> float: ... @typing.overload - def calcWallFrictionFactor(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallFrictionFactor( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ) -> float: ... @typing.overload - def calcWallHeatTransferCoefficient(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + 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: ... - + 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")``. 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 index 6871db55..bd4f5228 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,19 +12,26 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoeffici import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.stirredcell import typing - - -class InterphaseTwoPhase(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.InterphaseTransportCoefficientBaseClass): +class InterphaseTwoPhase( + jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.InterphaseTransportCoefficientBaseClass +): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... - + 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__ + 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 index 5ed7bf75..a69abc44 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,56 +10,135 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoeffici import jneqsim.thermo import typing - - -class InterphaseTwoPhasePipeFlow(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.InterphaseTwoPhase): +class InterphaseTwoPhasePipeFlow( + jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.InterphaseTwoPhase +): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + def __init__( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ): ... -class InterphaseDropletFlow(InterphaseTwoPhasePipeFlow, jneqsim.thermo.ThermodynamicConstantsInterface): +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: ... + 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): +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: ... + 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): ... - + 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")``. 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 index b3baf11f..dff0cc40 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,32 +10,71 @@ import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoeffici import jneqsim.thermo import typing - - -class InterphaseReactorFlow(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.InterphaseTwoPhase): +class InterphaseReactorFlow( + jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.InterphaseTwoPhase +): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface): ... + def __init__( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ): ... -class InterphasePackedBed(InterphaseReactorFlow, jneqsim.thermo.ThermodynamicConstantsInterface): +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: ... + 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: ... + def calcWallFrictionFactor( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ) -> float: ... @typing.overload - def calcWallFrictionFactor(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + def calcWallFrictionFactor( + self, + int: int, + flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface, + ) -> float: ... @typing.overload - def calcWallHeatTransferCoefficient(self, int: int, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> float: ... + 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: ... - + 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")``. 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 index de38a3cc..01193480 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,21 +9,46 @@ import jneqsim.fluidmechanics.flownode import jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasepipeflow import typing - - -class InterphaseStirredCellFlow(jneqsim.fluidmechanics.flownode.fluidboundary.interphasetransportcoefficient.interphasetwophase.interphasepipeflow.InterphaseStratifiedFlow): +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: ... + 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: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/__init__.pyi index ddb10290..60cc5d1a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,28 +13,33 @@ 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 __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 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 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")``. 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 index 184b718e..6c3e876a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/waxnode/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/multiphasenode/waxnode/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,22 +14,36 @@ import jneqsim.fluidmechanics.geometrydefinitions import jneqsim.thermo.system import typing - - -class WaxDepositionFlowNode(jneqsim.fluidmechanics.flownode.multiphasenode.MultiPhaseFlowNode): +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): ... + 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 __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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/__init__.pyi index bb517645..5fbf5ef4 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,25 +11,28 @@ 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 __init__( + self, + systemInterface: jneqsim.thermo.system.SystemInterface, + geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface, + ): ... def calcReynoldsNumber(self) -> float: ... - def clone(self) -> 'onePhaseFlowNode': ... + 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__ + 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 index 7b538aa9..62fa2226 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/onephasepipeflownode/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/onephasenode/onephasepipeflownode/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,18 +12,23 @@ import jneqsim.fluidmechanics.geometrydefinitions import jneqsim.thermo.system import typing - - -class onePhasePipeFlowNode(jneqsim.fluidmechanics.flownode.onephasenode.onePhaseFlowNode): +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 __init__( + self, + systemInterface: jneqsim.thermo.system.SystemInterface, + geometryDefinitionInterface: jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinitionInterface, + ): ... def calcReynoldsNumber(self) -> float: ... - def clone(self) -> 'onePhasePipeFlowNode': ... + def clone(self) -> "onePhasePipeFlowNode": ... @staticmethod - def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/__init__.pyi index a13a5c10..cfcba43a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,35 +14,44 @@ 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 __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 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: ... + 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__ + 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 index 422b426e..fdf8d13b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasepipeflownode/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasepipeflownode/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,74 +13,117 @@ 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): ... + 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 __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 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: ... + 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): ... + 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 __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 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 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): ... + 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 __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 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: ... + 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 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): ... + 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 __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 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: ... - + 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")``. 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 index 5178367d..626c0c3b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasereactorflownode/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasereactorflownode/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,44 +13,67 @@ import jneqsim.fluidmechanics.geometrydefinitions import jneqsim.thermo.system import typing - - -class TwoPhasePackedBedFlowNode(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowNode): +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): ... + 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 __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 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: ... + 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): +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): ... + 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 __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 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: ... - + 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")``. 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 index 742b80a5..11e8fedd 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasestirredcellnode/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flownode/twophasenode/twophasestirredcellnode/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,20 +13,27 @@ 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): ... + 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 __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 clone(self) -> "StirredCellNode": ... def getDt(self) -> float: ... def getNextNode(self) -> jneqsim.fluidmechanics.flownode.FlowNodeInterface: ... def getStirrerDiameter(self) -> typing.MutableSequence[float]: ... @@ -34,12 +41,16 @@ class StirredCellNode(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowN def init(self) -> None: ... def initFlowCalc(self) -> None: ... @staticmethod - def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + 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: ... + def setStirrerDiameter( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... @typing.overload def setStirrerSpeed(self, double: float) -> None: ... @typing.overload @@ -49,7 +60,6 @@ class StirredCellNode(jneqsim.fluidmechanics.flownode.twophasenode.TwoPhaseFlowN @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/__init__.pyi index 191f0f95..f77b2875 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,8 +10,6 @@ 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: ... @@ -29,11 +27,14 @@ class FlowSolver(FlowSolverInterface, java.io.Serializable): 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__ + 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 index 4c753bbf..c9a60408 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,14 +9,13 @@ 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__ + 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 index 4eb13069..90dd00a2 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/onephasepipeflowsolver/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/onephaseflowsolver/onephasepipeflowsolver/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,21 +10,34 @@ import jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.pipeflowsystem import jneqsim.thermo import typing - - -class OnePhasePipeFlowSolver(jneqsim.fluidmechanics.flowsolver.onephaseflowsolver.OnePhaseFlowSolver): +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): + 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 __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: ... @@ -38,7 +51,6 @@ class OnePhaseFixedStaggeredGrid(OnePhasePipeFlowSolver, jneqsim.thermo.Thermody 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/__init__.pyi index c076e8ef..5ff04415 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,9 +9,12 @@ 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__ + 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 index 65f532c1..11632de8 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/stirredcellsolver/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/stirredcellsolver/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,17 +10,33 @@ import jneqsim.fluidmechanics.flowsystem import jneqsim.thermo import typing - - -class StirredCellSolver(jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.twophasepipeflowsolver.TwoPhasePipeFlowSolver, jneqsim.thermo.ThermodynamicConstantsInterface): +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): ... + 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 __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 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: ... @@ -32,7 +48,6 @@ class StirredCellSolver(jneqsim.fluidmechanics.flowsolver.twophaseflowsolver.two 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")``. 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 index 234cc0dc..05a426ae 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/twophasepipeflowsolver/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsolver/twophaseflowsolver/twophasepipeflowsolver/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,24 +10,42 @@ import jneqsim.fluidmechanics.flowsystem import jneqsim.thermo import typing - - -class TwoPhasePipeFlowSolver(jneqsim.fluidmechanics.flowsolver.onephaseflowsolver.OnePhaseFlowSolver): +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': ... + def __init__( + self, + flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, + double: float, + int: int, + ): ... + def clone(self) -> "TwoPhasePipeFlowSolver": ... -class TwoPhaseFixedStaggeredGridSolver(TwoPhasePipeFlowSolver, jneqsim.thermo.ThermodynamicConstantsInterface): +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): ... + 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 __init__( + self, + flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, + double: float, + int: int, + boolean: bool, + ): ... def calcFluxes(self) -> None: ... - def clone(self) -> 'TwoPhaseFixedStaggeredGridSolver': ... + def clone(self) -> "TwoPhaseFixedStaggeredGridSolver": ... def initComposition(self, int: int, int2: int) -> None: ... def initFinalResults(self, int: int) -> None: ... def initMatrix(self) -> None: ... @@ -45,7 +63,6 @@ class TwoPhaseFixedStaggeredGridSolver(TwoPhasePipeFlowSolver, jneqsim.thermo.Th 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/__init__.pyi index a5c09187..e7b4da67 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -19,17 +19,23 @@ 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 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 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: ... @@ -49,15 +55,37 @@ class FlowSystemInterface: 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 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 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: ... @@ -79,12 +107,20 @@ class FlowSystem(FlowSystemInterface, java.io.Serializable): 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 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 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: ... @@ -106,26 +142,51 @@ class FlowSystem(FlowSystemInterface, java.io.Serializable): 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 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 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__ + 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 index c9fb0710..cf27e7f5 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,8 +11,6 @@ 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 @@ -20,9 +18,10 @@ class OnePhaseFlowSystem(jneqsim.fluidmechanics.flowsystem.FlowSystem): @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__ + 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 index 4f0c9b28..1a108226 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/pipeflowsystem/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/onephaseflowsystem/pipeflowsystem/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,9 +9,9 @@ import java.util import jneqsim.fluidmechanics.flowsystem.onephaseflowsystem import typing - - -class PipeFlowSystem(jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.OnePhaseFlowSystem): +class PipeFlowSystem( + jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.OnePhaseFlowSystem +): def __init__(self): ... def createSystem(self) -> None: ... def init(self) -> None: ... @@ -24,7 +24,6 @@ class PipeFlowSystem(jneqsim.fluidmechanics.flowsystem.onephaseflowsystem.OnePha @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/__init__.pyi index ae05f3e1..04722872 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,8 +14,6 @@ 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 @@ -23,12 +21,19 @@ class TwoPhaseFlowSystem(jneqsim.fluidmechanics.flowsystem.FlowSystem): @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__ + 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 index 6c0e45d6..cbc0a5ca 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/shipsystem/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/shipsystem/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,8 +13,6 @@ import jneqsim.standards.gasquality import jneqsim.thermo.system import typing - - class LNGship(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowSystem): totalTankVolume: float = ... numberOffTimeSteps: int = ... @@ -23,20 +21,31 @@ class LNGship(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowS volume: typing.MutableSequence[float] = ... tankTemperature: typing.MutableSequence[float] = ... endVolume: float = ... - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: 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 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 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 @@ -44,9 +53,18 @@ class LNGship(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowS @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: ... + 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 @@ -55,8 +73,11 @@ class LNGship(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowS 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: ... - + 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")``. 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 index 007411f6..e5dd1285 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/stirredcellsystem/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/stirredcellsystem/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,14 +11,16 @@ import jpype import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem import typing - - -class StirredCellSystem(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowSystem): +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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def solveSteadyState(self, int: int) -> None: ... @typing.overload @@ -28,7 +30,6 @@ class StirredCellSystem(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.Two @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")``. 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 index 91fa6b0b..80cd22bc 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasepipeflowsystem/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasepipeflowsystem/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,14 +11,16 @@ import jpype import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem import typing - - -class TwoPhasePipeFlowSystem(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowSystem): +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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def solveSteadyState(self, int: int) -> None: ... @typing.overload @@ -31,8 +33,9 @@ class TwoPhasePipeFlowSystem(jneqsim.fluidmechanics.flowsystem.twophaseflowsyste class TwoPhasePipeFlowSystemReac(TwoPhasePipeFlowSystem): def __init__(self): ... @staticmethod - def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... - + 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")``. 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 index f523ccba..3bdd4f0c 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasereactorflowsystem/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/flowsystem/twophaseflowsystem/twophasereactorflowsystem/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,14 +11,16 @@ import jpype import jneqsim.fluidmechanics.flowsystem.twophaseflowsystem import typing - - -class TwoPhaseReactorFlowSystem(jneqsim.fluidmechanics.flowsystem.twophaseflowsystem.TwoPhaseFlowSystem): +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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def solveSteadyState(self, int: int) -> None: ... @typing.overload @@ -28,7 +30,6 @@ class TwoPhaseReactorFlowSystem(jneqsim.fluidmechanics.flowsystem.twophaseflowsy @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/__init__.pyi index 8d08de57..c1869877 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,24 +16,30 @@ import jneqsim.fluidmechanics.geometrydefinitions.surrounding import jneqsim.thermo import typing - - class GeometryDefinitionInterface(java.lang.Cloneable): - def clone(self) -> 'GeometryDefinitionInterface': ... + def clone(self) -> "GeometryDefinitionInterface": ... def getArea(self) -> float: ... def getCircumference(self) -> float: ... def getDiameter(self) -> float: ... - def getGeometry(self) -> 'GeometryDefinitionInterface': ... + 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 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 getSurroundingEnvironment( + self, + ) -> ( + jneqsim.fluidmechanics.geometrydefinitions.surrounding.SurroundingEnvironment + ): ... def getWallHeatTransferCoefficient(self) -> float: ... def init(self) -> None: ... def setDiameter(self, double: float) -> None: ... @@ -43,11 +49,21 @@ class GeometryDefinitionInterface(java.lang.Cloneable): @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 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): +class GeometryDefinition( + GeometryDefinitionInterface, jneqsim.thermo.ThermodynamicConstantsInterface +): diameter: float = ... radius: float = ... innerSurfaceRoughness: float = ... @@ -71,14 +87,24 @@ class GeometryDefinition(GeometryDefinitionInterface, jneqsim.thermo.Thermodynam def getInnerSurfaceRoughness(self) -> float: ... def getInnerWallTemperature(self) -> float: ... def getNodeLength(self) -> float: ... - def getPacking(self) -> jneqsim.fluidmechanics.geometrydefinitions.internalgeometry.packings.PackingInterface: ... + 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 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: ... @@ -88,19 +114,35 @@ class GeometryDefinition(GeometryDefinitionInterface, jneqsim.thermo.Thermodynam @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 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__ + 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__ + 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 index 7463f8c9..1d34ea88 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,9 +9,12 @@ 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__ + 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 index ec83b712..167b916a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/packings/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/packings/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,8 +9,6 @@ import java.lang import jneqsim.util import typing - - class PackingInterface: def getSize(self) -> float: ... def getSurfaceAreaPrVolume(self) -> float: ... @@ -21,7 +19,12 @@ 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 __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: ... @@ -43,7 +46,6 @@ class RachigRingPacking(Packing): @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")``. 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 index b19934d6..332ce244 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/wall/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/internalgeometry/wall/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,8 +8,6 @@ else: import java.lang import typing - - class MaterialLayer: def __init__(self, string: typing.Union[java.lang.String, str], double: float): ... def getConductivity(self) -> float: ... @@ -41,7 +39,6 @@ class Wall(WallInterface): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/pipe/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/pipe/__init__.pyi index e8af144e..61519bbe 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/pipe/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/pipe/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,8 +8,6 @@ else: import jneqsim.fluidmechanics.geometrydefinitions import typing - - class PipeData(jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinition): @typing.overload def __init__(self): ... @@ -17,8 +15,7 @@ class PipeData(jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinition): def __init__(self, double: float): ... @typing.overload def __init__(self, double: float, double2: float): ... - def clone(self) -> 'PipeData': ... - + def clone(self) -> "PipeData": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions.pipe")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/reactor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/reactor/__init__.pyi index 765c65d4..415d1201 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/reactor/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/reactor/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,8 +9,6 @@ import java.lang import jneqsim.fluidmechanics.geometrydefinitions import typing - - class ReactorData(jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinition): @typing.overload def __init__(self): ... @@ -20,14 +18,18 @@ class ReactorData(jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinition) def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, int: int): ... - def clone(self) -> 'ReactorData': ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/stirredcell/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/stirredcell/__init__.pyi index 4d6bd40b..d92aa426 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/stirredcell/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/stirredcell/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,8 +8,6 @@ else: import jneqsim.fluidmechanics.geometrydefinitions import typing - - class StirredCell(jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinition): @typing.overload def __init__(self): ... @@ -17,8 +15,7 @@ class StirredCell(jneqsim.fluidmechanics.geometrydefinitions.GeometryDefinition) def __init__(self, double: float): ... @typing.overload def __init__(self, double: float, double2: float): ... - def clone(self) -> 'StirredCell': ... - + def clone(self) -> "StirredCell": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.fluidmechanics.geometrydefinitions.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 index 89200bd0..c0ceee52 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/surrounding/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/geometrydefinitions/surrounding/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,8 +8,6 @@ else: import java.lang import typing - - class SurroundingEnvironment: def getHeatTransferCoefficient(self) -> float: ... def getTemperature(self) -> float: ... @@ -29,7 +27,6 @@ class PipeSurroundingEnvironment(SurroundingEnvironmentBaseClass): @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/__init__.pyi index 537592a0..8bf7d7f0 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,8 +10,6 @@ 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] = ... @@ -22,14 +20,17 @@ class FrictionFactorCalculator: @staticmethod def calcHaalandFrictionFactor(double: float, double2: float) -> float: ... @staticmethod - def calcPressureDropPerLength(double: float, double2: float, double3: float, double4: float) -> float: ... + 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__ + 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 index 4ab16300..2bda0082 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,9 +9,12 @@ import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualiza 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__ + 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 index 4eb052b8..595c5378 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flownodevisualization/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,8 +10,6 @@ import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualiza import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.twophaseflownodevisualization import typing - - class FlowNodeVisualizationInterface: def getBulkComposition(self, int: int, int2: int) -> float: ... def getDistanceToCenterOfNode(self) -> float: ... @@ -28,7 +26,9 @@ class FlowNodeVisualizationInterface: 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: ... + def setData( + self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface + ) -> None: ... class FlowNodeVisualization(FlowNodeVisualizationInterface): temperature: typing.MutableSequence[float] = ... @@ -40,7 +40,9 @@ class FlowNodeVisualization(FlowNodeVisualizationInterface): wallContactLength: typing.MutableSequence[float] = ... bulkComposition: typing.MutableSequence[typing.MutableSequence[float]] = ... interfaceComposition: typing.MutableSequence[typing.MutableSequence[float]] = ... - effectiveMassTransferCoefficient: 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 = ... @@ -62,13 +64,18 @@ class FlowNodeVisualization(FlowNodeVisualizationInterface): 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: ... - + 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__ + 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 index 529b2ea9..30a87a4a 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,14 +9,15 @@ import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualiza import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization.onephasepipeflownodevisualization import typing - - -class OnePhaseFlowNodeVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.FlowNodeVisualization): +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__ + 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 index 22e3a21e..943e8ab4 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,12 +9,13 @@ import jneqsim.fluidmechanics.flownode import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization import typing - - -class OnePhasePipeFlowNodeVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization.OnePhaseFlowNodeVisualization): +class OnePhasePipeFlowNodeVisualization( + jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.onephaseflownodevisualization.OnePhaseFlowNodeVisualization +): def __init__(self): ... - def setData(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> None: ... - + 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")``. 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 index 89734b0d..8ffb9cf2 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,12 +9,13 @@ import jneqsim.fluidmechanics.flownode import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization import typing - - -class TwoPhaseFlowNodeVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.FlowNodeVisualization): +class TwoPhaseFlowNodeVisualization( + jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flownodevisualization.FlowNodeVisualization +): def __init__(self): ... - def setData(self, flowNodeInterface: jneqsim.fluidmechanics.flownode.FlowNodeInterface) -> None: ... - + 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")``. 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 index 5fcd20b8..44d0d17b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/fluidmechanicsvisualization/flowsystemvisualization/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,14 +11,18 @@ import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisuali 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: ... + def setNextData( + self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface + ) -> None: ... @typing.overload - def setNextData(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, double: float) -> None: ... + def setNextData( + self, + flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, + double: float, + ) -> None: ... def setPoints(self) -> None: ... class FlowSystemVisualization(FlowSystemVisualizationInterface): @@ -28,16 +32,25 @@ class FlowSystemVisualization(FlowSystemVisualizationInterface): 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: ... + def setNextData( + self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface + ) -> None: ... @typing.overload - def setNextData(self, flowSystemInterface: jneqsim.fluidmechanics.flowsystem.FlowSystemInterface, double: float) -> None: ... + 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__ + 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 index e8afd882..0c62933b 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,17 +9,18 @@ import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisuali import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization.pipeflowvisualization import typing - - -class OnePhaseFlowVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.FlowSystemVisualization): +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__ + 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 index 620aa4af..4d82997b 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,10 +9,12 @@ 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]]] = ... +class PipeFlowVisualization( + jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.onephaseflowvisualization.OnePhaseFlowVisualization +): + bulkComposition: typing.MutableSequence[ + typing.MutableSequence[typing.MutableSequence[float]] + ] = ... @typing.overload def __init__(self): ... @typing.overload @@ -21,7 +23,6 @@ class PipeFlowVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualizat 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")``. 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 index 5af529e1..9a2e025a 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,17 +9,18 @@ import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisuali import jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.twophaseflowvisualization.twophasepipeflowvisualization import typing - - -class TwoPhaseFlowVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvisualization.flowsystemvisualization.FlowSystemVisualization): +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__ + 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 index 73b872c6..bdafa337 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,16 +9,30 @@ 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]]]] = ... +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 @@ -26,7 +40,6 @@ class TwoPhasePipeFlowVisualization(jneqsim.fluidmechanics.util.fluidmechanicsvi 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/timeseries/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/timeseries/__init__.pyi index d8f5f76d..702449cb 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/timeseries/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/fluidmechanics/util/timeseries/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,23 +11,33 @@ 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]: ... + 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/mathlib/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/mathlib/__init__.pyi index 1268c6e8..8d4339cf 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/mathlib/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/mathlib/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,7 +9,6 @@ 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/mathlib/generalmath/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/mathlib/generalmath/__init__.pyi index cf8aaf86..08ece27e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/mathlib/generalmath/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/mathlib/generalmath/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,12 +8,14 @@ else: 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]: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/mathlib/nonlinearsolver/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/mathlib/nonlinearsolver/__init__.pyi index dbd97c1d..a5b9d6ce 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/mathlib/nonlinearsolver/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/mathlib/nonlinearsolver/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,16 +13,18 @@ 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 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: ... @@ -30,9 +32,22 @@ class NewtonRhapson(java.io.Serializable): 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: ... + 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: ... + 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): ... @@ -41,7 +56,12 @@ 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 __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: ... @@ -49,14 +69,15 @@ class SysNewtonRhapson(java.io.Serializable): def getNpCrit(self) -> int: ... def init(self) -> None: ... @staticmethod - def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/__init__.pyi index 833ca43a..d68c019e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -15,37 +15,48 @@ 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'] = ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "PhysicalPropertyType": ... @staticmethod - def values() -> typing.MutableSequence['PhysicalPropertyType']: ... - + 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__ + interfaceproperties: ( + jneqsim.physicalproperties.interfaceproperties.__module_protocol__ + ) methods: jneqsim.physicalproperties.methods.__module_protocol__ mixingrule: jneqsim.physicalproperties.mixingrule.__module_protocol__ system: jneqsim.physicalproperties.system.__module_protocol__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/__init__.pyi index 31339608..a107db12 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,32 +13,59 @@ 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 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: ... + 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: ... + 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: ... + 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 @@ -46,34 +73,66 @@ class InterfaceProperties(InterphasePropertiesInterface, java.io.Serializable): @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 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: ... + 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: ... + 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: ... - + 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__ + 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 index 9a0dc8d8..67ca8613 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/solidadsorption/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/solidadsorption/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,14 +10,14 @@ 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 getSurfaceExcess( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def setSolidMaterial(self, string: typing.Union[java.lang.String, str]) -> None: ... class PotentialTheoryAdsorption(AdsorptionInterface): @@ -29,11 +29,12 @@ class PotentialTheoryAdsorption(AdsorptionInterface): @typing.overload def getSurfaceExcess(self, int: int) -> float: ... @typing.overload - def getSurfaceExcess(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/surfacetension/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/surfacetension/__init__.pyi index d9d0043f..736bc897 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/surfacetension/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/interfaceproperties/surfacetension/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,50 +11,169 @@ 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): ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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 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: ... + 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 __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: ... + 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): +class SurfaceTension( + jneqsim.physicalproperties.interfaceproperties.InterfaceProperties, + SurfaceTensionInterface, +): @typing.overload def __init__(self): ... @typing.overload @@ -78,9 +197,16 @@ class GTSurfaceTension(SurfaceTension): 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: ... + 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: ... + def solveWithRefcomp( + systemInterface: jneqsim.thermo.system.SystemInterface, + int: int, + int2: int, + int3: int, + ) -> float: ... class GTSurfaceTensionSimple(SurfaceTension): @typing.overload @@ -89,13 +215,23 @@ class GTSurfaceTensionSimple(SurfaceTension): 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 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: ... + def setDmudn2( + self, + doubleArray: typing.Union[ + typing.List[typing.MutableSequence[typing.MutableSequence[float]]], + jpype.JArray, + ], + ) -> None: ... class LGTSurfaceTension(SurfaceTension): @typing.overload @@ -116,7 +252,6 @@ class ParachorSurfaceTension(SurfaceTension): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/__init__.pyi index 68b6c72c..3d1c04d7 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -15,26 +15,37 @@ 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 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 __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__ + 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 index 535a6cfe..308ecca1 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,17 +12,26 @@ import jneqsim.physicalproperties.methods.commonphasephysicalproperties.viscosit 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 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__ + 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 index 5bbc5bd6..83cf819b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/conductivity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/conductivity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,25 +11,31 @@ 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 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 __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 __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")``. 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 index 68d90647..f1181a7c 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/diffusivity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/diffusivity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,22 +10,34 @@ 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]]: ... +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 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: ... + 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: ... - + 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")``. 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 index 247793e7..bd562d68 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/viscosity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/commonphasephysicalproperties/viscosity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,25 +12,34 @@ import jneqsim.physicalproperties.system import jneqsim.thermo import typing - - -class Viscosity(jneqsim.physicalproperties.methods.commonphasephysicalproperties.CommonPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface): +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 __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcPureComponentViscosity(self) -> None: ... - def clone(self) -> 'Viscosity': ... + 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 __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcViscosity(self) -> float: ... -class FrictionTheoryViscosityMethod(Viscosity, jneqsim.thermo.ThermodynamicConstantsInterface): +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 __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: ... @@ -38,56 +47,87 @@ class FrictionTheoryViscosityMethod(Viscosity, jneqsim.thermo.ThermodynamicConst 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 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 __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcViscosity(self) -> float: ... class KTAViscosityMethodMod(Viscosity): - def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcViscosity(self) -> float: ... class LBCViscosityMethod(Viscosity): - def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcViscosity(self) -> float: ... - def clone(self) -> 'LBCViscosityMethod': ... + 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: ... + def setDenseContributionParameters( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... class MethaneViscosityMethod(Viscosity): - def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcViscosity(self) -> float: ... class MuznyModViscosityMethod(Viscosity): - def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcViscosity(self) -> float: ... class MuznyViscosityMethod(Viscosity): - def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcViscosity(self) -> float: ... class PFCTViscosityMethod(Viscosity): - def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + 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 __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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/__init__.pyi index 3d5a53ad..85ae476b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,21 +13,32 @@ import jneqsim.physicalproperties.methods.gasphysicalproperties.viscosity import jneqsim.physicalproperties.system import typing - - -class GasPhysicalPropertyMethod(jneqsim.physicalproperties.methods.PhysicalPropertyMethod): +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: ... - + 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__ + 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 index 1dceae9a..8d4b5eae 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/conductivity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/conductivity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,19 +10,23 @@ 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 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 __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")``. 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 index 4aba4d2e..b474b4ef 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/density/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/density/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,13 +10,15 @@ 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): ... +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': ... - + def clone(self) -> "Density": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.gasphysicalproperties.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 index ab001405..1496a528 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/diffusivity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/diffusivity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,22 +10,34 @@ 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]]: ... +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 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: ... + 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: ... - + 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")``. 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 index 3f8a06f9..9d58e45d 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/viscosity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/gasphysicalproperties/viscosity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,23 +10,27 @@ 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 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi index a6846849..79d7a46b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,18 +13,29 @@ 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 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__ + 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 index 62fc06f7..1ed87d7e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/conductivity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/conductivity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,15 +10,17 @@ import jneqsim.physicalproperties.methods.methodinterface import jneqsim.physicalproperties.system import typing - - -class Conductivity(jneqsim.physicalproperties.methods.liquidphysicalproperties.LiquidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ConductivityInterface): +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 __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcConductivity(self) -> float: ... def calcPureComponentConductivity(self) -> None: ... - def clone(self) -> 'Conductivity': ... - + def clone(self) -> "Conductivity": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.liquidphysicalproperties.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 index bd085daf..4a111f97 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/density/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/density/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,25 +10,37 @@ 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): ... +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 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 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': ... - + def clone(self) -> "Water": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.liquidphysicalproperties.density")``. 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 index 2abd9ce2..56f01d37 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/diffusivity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/diffusivity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,26 +9,45 @@ 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]]: ... +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 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")``. 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 index 20b5c21b..f8fed742 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/viscosity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/liquidphysicalproperties/viscosity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,26 +10,32 @@ import jneqsim.physicalproperties.methods.methodinterface import jneqsim.physicalproperties.system import typing - - -class Viscosity(jneqsim.physicalproperties.methods.liquidphysicalproperties.LiquidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface): +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 __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcPureComponentViscosity(self) -> None: ... def calcViscosity(self) -> float: ... - def clone(self) -> 'Viscosity': ... + 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 __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcViscosity(self) -> float: ... class Water(Viscosity): - def __init__(self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties): ... + def __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcViscosity(self) -> float: ... - def clone(self) -> 'Water': ... - + def clone(self) -> "Water": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.liquidphysicalproperties.viscosity")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/methodinterface/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/methodinterface/__init__.pyi index 6e22bfa4..acafabf5 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/methodinterface/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/methodinterface/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,31 +9,45 @@ import jneqsim.physicalproperties.methods import jneqsim.thermo import typing - - -class ConductivityInterface(jneqsim.thermo.ThermodynamicConstantsInterface, jneqsim.physicalproperties.methods.PhysicalPropertyMethodInterface): +class ConductivityInterface( + jneqsim.thermo.ThermodynamicConstantsInterface, + jneqsim.physicalproperties.methods.PhysicalPropertyMethodInterface, +): def calcConductivity(self) -> float: ... - def clone(self) -> 'ConductivityInterface': ... + def clone(self) -> "ConductivityInterface": ... -class DensityInterface(jneqsim.thermo.ThermodynamicConstantsInterface, jneqsim.physicalproperties.methods.PhysicalPropertyMethodInterface): +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 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 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: ... + def getMaxwellStefanBinaryDiffusionCoefficient( + self, int: int, int2: int + ) -> float: ... -class ViscosityInterface(jneqsim.physicalproperties.methods.PhysicalPropertyMethodInterface): +class ViscosityInterface( + jneqsim.physicalproperties.methods.PhysicalPropertyMethodInterface +): def calcViscosity(self) -> float: ... - def clone(self) -> 'ViscosityInterface': ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/__init__.pyi index 2b1af6e3..1f74c105 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,18 +13,29 @@ 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 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__ + 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 index c825dc55..d6c01b3e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/conductivity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/conductivity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,13 +10,15 @@ 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): ... +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': ... - + def clone(self) -> "Conductivity": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.solidphysicalproperties.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 index b040be27..55362c1e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/density/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/density/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,13 +10,15 @@ 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): ... +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': ... - + def clone(self) -> "Density": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.physicalproperties.methods.solidphysicalproperties.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 index 4a643c08..9355bd17 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/diffusivity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/diffusivity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,18 +10,26 @@ 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]]: ... +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 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: ... - + 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")``. 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 index 05e66fcd..8a8bb111 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/viscosity/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/methods/solidphysicalproperties/viscosity/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,18 +10,20 @@ import jneqsim.physicalproperties.methods.solidphysicalproperties import jneqsim.physicalproperties.system import typing - - -class Viscosity(jneqsim.physicalproperties.methods.solidphysicalproperties.SolidPhysicalPropertyMethod, jneqsim.physicalproperties.methods.methodinterface.ViscosityInterface): +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 __init__( + self, physicalProperties: jneqsim.physicalproperties.system.PhysicalProperties + ): ... def calcPureComponentViscosity(self) -> None: ... def calcViscosity(self) -> float: ... - def clone(self) -> 'Viscosity': ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/mixingrule/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/mixingrule/__init__.pyi index 47abd115..ff0e2338 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/mixingrule/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/mixingrule/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,26 +10,31 @@ import jneqsim.thermo import jneqsim.thermo.phase import typing - - class PhysicalPropertyMixingRuleInterface(java.lang.Cloneable): - def clone(self) -> 'PhysicalPropertyMixingRuleInterface': ... + def clone(self) -> "PhysicalPropertyMixingRuleInterface": ... def getViscosityGij(self, int: int, int2: int) -> float: ... - def initMixingRules(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... + 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): +class PhysicalPropertyMixingRule( + PhysicalPropertyMixingRuleInterface, jneqsim.thermo.ThermodynamicConstantsInterface +): Gij: typing.MutableSequence[typing.MutableSequence[float]] = ... def __init__(self): ... - def clone(self) -> 'PhysicalPropertyMixingRule': ... + 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 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] + 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 index 714df8bc..ed72dd6d 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -18,13 +18,21 @@ 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 = ... +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 = ... @@ -32,85 +40,133 @@ class PhysicalProperties(java.lang.Cloneable, jneqsim.thermo.ThermodynamicConsta @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 __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 clone(self) -> "PhysicalProperties": ... def getConductivity(self) -> float: ... - def getConductivityModel(self) -> jneqsim.physicalproperties.methods.methodinterface.ConductivityInterface: ... + 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: ... + 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 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 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 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: ... + 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 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 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 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 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: ... + 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: ... + 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'] = ... +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': ... + def byName( + string: typing.Union[java.lang.String, str] + ) -> "PhysicalPropertyModel": ... @staticmethod - def byValue(int: int) -> 'PhysicalPropertyModel': ... + def byValue(int: int) -> "PhysicalPropertyModel": ... def getValue(self) -> int: ... - _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + _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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "PhysicalPropertyModel": ... @staticmethod - def values() -> typing.MutableSequence['PhysicalPropertyModel']: ... - + 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__ + 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 index 2eef4c1f..a2439e48 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/commonphasephysicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/commonphasephysicalproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,11 +9,10 @@ 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): ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/gasphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/gasphysicalproperties/__init__.pyi index 06ed955d..150b05aa 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/gasphysicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/gasphysicalproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,18 +9,21 @@ 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': ... + 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): ... + 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): ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/liquidphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/liquidphysicalproperties/__init__.pyi index 01620630..05babcd3 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/liquidphysicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/liquidphysicalproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,28 +9,37 @@ 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': ... + 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': ... + 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): ... + 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): ... + 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): ... + 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): ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/solidphysicalproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/solidphysicalproperties/__init__.pyi index 15663403..bc024b28 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/solidphysicalproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/system/solidphysicalproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,12 +9,9 @@ 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/__init__.pyi index b370d2ff..cba76fa1 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,8 +8,9 @@ else: 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__ + 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 index 8472550e..d1c65431 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,8 +8,9 @@ else: 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__ + 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 index 02780107..f105ed84 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/physicalproperties/util/parameterfitting/purecomponentparameterfitting/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,9 +9,12 @@ import jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfi 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__ + 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 index 83490b4a..c9722906 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,21 +10,26 @@ import jpype import jneqsim.statistics.parameterfitting.nonlinearparameterfitting import typing - - -class ParachorFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +class ParachorFunction( + jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction +): def __init__(self): ... - def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + 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: ... + 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: ... - + 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")``. 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 index cb694af1..ffe9f92a 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,9 +9,12 @@ import jneqsim.physicalproperties.util.parameterfitting.purecomponentparameterfi 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__ + 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 index 353c3046..79f98106 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,21 +10,26 @@ import jpype import jneqsim.statistics.parameterfitting.nonlinearparameterfitting import typing - - -class ChungFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +class ChungFunction( + jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction +): def __init__(self): ... - def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + 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: ... + 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: ... - + 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")``. 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 index abde4dda..5fad580c 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,21 +10,26 @@ 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... -class ViscosityFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +class ViscosityFunction( + jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction +): def __init__(self): ... - def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/__init__.pyi index ca2b2795..1d4142cb 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -22,9 +22,9 @@ import jneqsim.process.util import jneqsim.util import typing - - -class SimulationInterface(jneqsim.util.NamedInterface, java.lang.Runnable, java.io.Serializable): +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: ... @@ -61,7 +61,6 @@ class SimulationBaseClass(jneqsim.util.NamedBaseClass, SimulationInterface): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/alarm/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/alarm/__init__.pyi index 6bf354d9..8d335522 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/alarm/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/alarm/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,121 +13,184 @@ 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': ... + 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': ... + 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': ... + 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 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: ... + def handle(self, alarmEvent: "AlarmEvent") -> bool: ... class AlarmConfig(java.io.Serializable): @staticmethod - def builder() -> 'AlarmConfig.Builder': ... + 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 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: ... + 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': ... + 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']: ... + 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']: ... + 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']: ... + 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': ... + 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': ... + 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 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 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) # +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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "AlarmEventType": ... @staticmethod - def values() -> typing.MutableSequence['AlarmEventType']: ... + 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': ... +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) # + _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: ... + 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': ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "AlarmLevel.Direction": ... @staticmethod - def values() -> typing.MutableSequence['AlarmLevel.Direction']: ... + 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: ... + def displayAlarmHistory(processAlarmManager: "ProcessAlarmManager") -> None: ... @typing.overload @staticmethod - def displayAlarmHistory(processAlarmManager: 'ProcessAlarmManager', int: int) -> None: ... + def displayAlarmHistory( + processAlarmManager: "ProcessAlarmManager", int: int + ) -> None: ... @staticmethod - def displayAlarmStatistics(processAlarmManager: 'ProcessAlarmManager') -> None: ... + def displayAlarmStatistics(processAlarmManager: "ProcessAlarmManager") -> None: ... @staticmethod - def displayAlarmStatus(processAlarmManager: 'ProcessAlarmManager', string: typing.Union[java.lang.String, str]) -> None: ... + def displayAlarmStatus( + processAlarmManager: "ProcessAlarmManager", + string: typing.Union[java.lang.String, str], + ) -> None: ... @staticmethod def formatAlarmEvent(alarmEvent: AlarmEvent) -> java.lang.String: ... @staticmethod @@ -137,18 +200,36 @@ class AlarmReporter: 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 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': ... + 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 __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: ... @@ -158,19 +239,42 @@ class AlarmStatusSnapshot(java.io.Serializable): 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 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/conditionmonitor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/conditionmonitor/__init__.pyi index e2024f0f..c63c3909 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/conditionmonitor/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/conditionmonitor/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,8 +10,6 @@ import java.lang import jneqsim.process.processmodel import typing - - class ConditionMonitor(java.io.Serializable, java.lang.Runnable): @typing.overload def __init__(self): ... @@ -20,7 +18,9 @@ class ConditionMonitor(java.io.Serializable, java.lang.Runnable): @typing.overload def conditionAnalysis(self) -> None: ... @typing.overload - def conditionAnalysis(self, string: typing.Union[java.lang.String, str]) -> None: ... + 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: ... @@ -29,7 +29,6 @@ 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/__init__.pyi index da900342..0caaa203 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,10 +13,10 @@ 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: ... + def addGainSchedulePoint( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... @typing.overload def autoTune(self, double: float, double2: float) -> None: ... @typing.overload @@ -26,20 +26,28 @@ class ControllerDeviceInterface(java.io.Serializable): @typing.overload def autoTuneFromEventLog(self, boolean: bool) -> bool: ... @typing.overload - def autoTuneStepResponse(self, double: float, double2: float, double3: float) -> None: ... + 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 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 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 getMeasuredValue( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getResponse(self) -> float: ... def getSettlingTime(self) -> float: ... - def getStepResponseTuningMethod(self) -> 'ControllerDeviceInterface.StepResponseTuningMethod': ... + def getStepResponseTuningMethod( + self, + ) -> "ControllerDeviceInterface.StepResponseTuningMethod": ... def getUnit(self) -> java.lang.String: ... def hashCode(self) -> int: ... def isActive(self) -> bool: ... @@ -47,36 +55,69 @@ class ControllerDeviceInterface(java.io.Serializable): def resetEventLog(self) -> None: ... def resetPerformanceMetrics(self) -> None: ... @typing.overload - def runTransient(self, double: float, double2: float, uUID: java.util.UUID) -> None: ... + 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: ... + 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 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 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "ControllerDeviceInterface.StepResponseTuningMethod": ... @staticmethod - def values() -> typing.MutableSequence['ControllerDeviceInterface.StepResponseTuningMethod']: ... + 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 __init__( + self, + double: float, + double2: float, + double3: float, + double4: float, + double5: float, + ): ... def getError(self) -> float: ... def getMeasuredValue(self) -> float: ... def getResponse(self) -> float: ... @@ -88,7 +129,9 @@ class ControllerDeviceBaseClass(jneqsim.util.NamedBaseClass, ControllerDeviceInt 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: ... + def addGainSchedulePoint( + self, double: float, double2: float, double3: float, double4: float + ) -> None: ... @typing.overload def autoTune(self, double: float, double2: float) -> None: ... @typing.overload @@ -98,9 +141,13 @@ class ControllerDeviceBaseClass(jneqsim.util.NamedBaseClass, ControllerDeviceInt @typing.overload def autoTuneFromEventLog(self, boolean: bool) -> bool: ... @typing.overload - def autoTuneStepResponse(self, double: float, double2: float, double3: float) -> None: ... + 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 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: ... @@ -108,10 +155,14 @@ class ControllerDeviceBaseClass(jneqsim.util.NamedBaseClass, ControllerDeviceInt @typing.overload def getMeasuredValue(self) -> float: ... @typing.overload - def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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 getStepResponseTuningMethod( + self, + ) -> ControllerDeviceInterface.StepResponseTuningMethod: ... def getTd(self) -> float: ... def getTi(self) -> float: ... def getUnit(self) -> java.lang.String: ... @@ -122,21 +173,33 @@ class ControllerDeviceBaseClass(jneqsim.util.NamedBaseClass, ControllerDeviceInt @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 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: ... + 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 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 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 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): @@ -144,20 +207,32 @@ class ModelPredictiveController(jneqsim.util.NamedBaseClass, ControllerDeviceInt def __init__(self): ... @typing.overload def __init__(self, string: typing.Union[java.lang.String, str]): ... - def addQualityConstraint(self, qualityConstraint: 'ModelPredictiveController.QualityConstraint') -> None: ... + 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': ... + 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': ... + 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 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 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: ... @@ -171,20 +246,28 @@ class ModelPredictiveController(jneqsim.util.NamedBaseClass, ControllerDeviceInt def getControlWeight(self) -> float: ... def getControllerSetPoint(self) -> float: ... def getLastAppliedControl(self) -> float: ... - def getLastMovingHorizonEstimate(self) -> 'ModelPredictiveController.MovingHorizonEstimate': ... + 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 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 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: ... @@ -195,27 +278,39 @@ class ModelPredictiveController(jneqsim.util.NamedBaseClass, ControllerDeviceInt @typing.overload def ingestPlantSample(self, double: float, double2: float) -> None: ... @typing.overload - def ingestPlantSample(self, double: float, double2: float, double3: float) -> None: ... + 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 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: ... + 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 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: ... + 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: ... + 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: ... @@ -232,17 +327,38 @@ class ModelPredictiveController(jneqsim.util.NamedBaseClass, ControllerDeviceInt @typing.overload def setProcessModel(self, double: float, double2: float) -> None: ... @typing.overload - def setProcessModel(self, double: float, double2: float, double3: float) -> None: ... + 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 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: ... + 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 builder() -> "ModelPredictiveController.AutoTuneConfiguration.Builder": ... def getClosedLoopTimeConstantRatio(self) -> float: ... def getControlWeightFactor(self) -> float: ... def getMaximumHorizon(self) -> int: ... @@ -252,18 +368,40 @@ class ModelPredictiveController(jneqsim.util.NamedBaseClass, ControllerDeviceInt 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': ... + 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: ... @@ -277,26 +415,51 @@ class ModelPredictiveController(jneqsim.util.NamedBaseClass, ControllerDeviceInt 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': ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/structure/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/structure/__init__.pyi index f4fe6803..cd3ab2c3 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/structure/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/controllerdevice/structure/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,8 +10,6 @@ import jneqsim.process.controllerdevice import jneqsim.process.measurementdevice import typing - - class ControlStructureInterface(java.io.Serializable): def getOutput(self) -> float: ... def isActive(self) -> bool: ... @@ -19,14 +17,22 @@ class ControlStructureInterface(java.io.Serializable): def setActive(self, boolean: bool) -> None: ... class CascadeControllerStructure(ControlStructureInterface): - def __init__(self, controllerDeviceInterface: jneqsim.process.controllerdevice.ControllerDeviceInterface, controllerDeviceInterface2: jneqsim.process.controllerdevice.ControllerDeviceInterface): ... + 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 __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: ... @@ -34,14 +40,17 @@ class FeedForwardControllerStructure(ControlStructureInterface): def setFeedForwardGain(self, double: float) -> None: ... class RatioControllerStructure(ControlStructureInterface): - def __init__(self, controllerDeviceInterface: jneqsim.process.controllerdevice.ControllerDeviceInterface, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface): ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/__init__.pyi index 7b03c873..8cea3da4 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,13 +12,18 @@ 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): ... + def __init__( + self, + systemMechanicalDesign: jneqsim.process.mechanicaldesign.SystemMechanicalDesign, + ): ... @typing.overload - def __init__(self, systemMechanicalDesign: jneqsim.process.mechanicaldesign.SystemMechanicalDesign, double: float): ... + 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: ... @@ -29,12 +34,13 @@ class UnitCostEstimateBaseClass(java.io.Serializable): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, mechanicalDesign: jneqsim.process.mechanicaldesign.MechanicalDesign): ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/compressor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/compressor/__init__.pyi index 919a5424..21e016c9 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/compressor/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/compressor/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,13 +9,13 @@ 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/separator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/separator/__init__.pyi index 35af7c89..8050d4ec 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/separator/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/separator/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,13 +9,13 @@ 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/valve/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/valve/__init__.pyi index e3d93149..9a376f35 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/valve/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/costestimation/valve/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,13 +9,13 @@ 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/__init__.pyi index 94d553a0..6cf11f37 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -43,75 +43,96 @@ 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'] = ... +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) # + _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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "EquipmentEnum": ... @staticmethod - def values() -> typing.MutableSequence['EquipmentEnum']: ... + 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: ... + 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': ... + 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': ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... @@ -119,10 +140,16 @@ class ProcessEquipmentInterface(jneqsim.process.SimulationInterface): 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: ... + 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: ... + 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: ... @@ -130,14 +157,18 @@ class ProcessEquipmentInterface(jneqsim.process.SimulationInterface): 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 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 getResultTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... def getSpecification(self) -> java.lang.String: ... @typing.overload def getTemperature(self) -> float: ... @@ -147,9 +178,16 @@ class ProcessEquipmentInterface(jneqsim.process.SimulationInterface): 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 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: ... @@ -157,7 +195,9 @@ class ProcessEquipmentInterface(jneqsim.process.SimulationInterface): @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + def toJson( + self, reportConfig: jneqsim.process.util.report.ReportConfig + ) -> java.lang.String: ... class TwoPortInterface: def getInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... @@ -169,13 +209,19 @@ class TwoPortInterface: 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 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 setOutletStream( + self, streamInterface: jneqsim.process.equipment.stream.StreamInterface + ) -> None: ... def setOutletTemperature(self, double: float) -> None: ... -class ProcessEquipmentBaseClass(jneqsim.process.SimulationBaseClass, ProcessEquipmentInterface): +class ProcessEquipmentBaseClass( + jneqsim.process.SimulationBaseClass, ProcessEquipmentInterface +): hasController: bool = ... report: typing.MutableSequence[typing.MutableSequence[java.lang.String]] = ... properties: java.util.HashMap = ... @@ -186,26 +232,38 @@ class ProcessEquipmentBaseClass(jneqsim.process.SimulationBaseClass, ProcessEqui 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 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: ... + 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 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 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 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 getResultTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... def getSpecification(self) -> java.lang.String: ... @typing.overload def getTemperature(self) -> float: ... @@ -219,18 +277,30 @@ class ProcessEquipmentBaseClass(jneqsim.process.SimulationBaseClass, ProcessEqui @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: ... + 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: ... + 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 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: ... @@ -240,13 +310,19 @@ class ProcessEquipmentBaseClass(jneqsim.process.SimulationBaseClass, ProcessEqui @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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 __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: ... @@ -258,16 +334,21 @@ class TwoPortEquipment(ProcessEquipmentBaseClass, TwoPortInterface): 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 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/absorber/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/absorber/__init__.pyi index 4bf26175..bcef58d7 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/absorber/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/absorber/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,8 +13,6 @@ 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: ... @@ -24,22 +22,34 @@ class SimpleAbsorber(jneqsim.process.equipment.separator.Separator, AbsorberInte @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 __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 getInStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getInTemperature(self, int: int) -> float: ... - def getMechanicalDesign(self) -> jneqsim.process.mechanicaldesign.absorber.AbsorberMechanicalDesign: ... + 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 getOutStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getOutTemperature(self, int: int) -> float: ... - def getSolventInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getSolventInStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getStageEfficiency(self) -> float: ... def getWettingRate(self) -> float: ... @typing.overload @@ -58,12 +68,20 @@ class SimpleAbsorber(jneqsim.process.equipment.separator.Separator, AbsorberInte 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 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 calcNTU( + self, double: float, double2: float, double3: float, double4: float + ) -> float: ... def calcNumberOfTheoreticalStages(self) -> float: ... def calcY0(self) -> float: ... def displayResult(self) -> None: ... @@ -74,67 +92,109 @@ class SimpleTEGAbsorber(SimpleAbsorber): 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: ... + 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: ... + def getLiquidOutStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... @typing.overload - def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + 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 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: ... + 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 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 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 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 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: ... + 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: ... + def getLiquidOutStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... @typing.overload - def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + 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 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: ... + 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 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/adsorber/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/adsorber/__init__.pyi index b63e2a2d..30bbb58a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/adsorber/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/adsorber/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,13 +12,15 @@ 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 __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: ... @@ -26,11 +28,15 @@ class SimpleAdsorber(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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 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 getOutStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getOutTemperature(self, int: int) -> float: ... def getStageEfficiency(self) -> float: ... @typing.overload @@ -47,7 +53,6 @@ class SimpleAdsorber(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/battery/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/battery/__init__.pyi index 11d61d4c..2e63cf24 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/battery/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/battery/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,8 +10,6 @@ import java.util import jneqsim.process.equipment import typing - - class BatteryStorage(jneqsim.process.equipment.ProcessEquipmentBaseClass): @typing.overload def __init__(self): ... @@ -31,7 +29,6 @@ class BatteryStorage(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/blackoil/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/blackoil/__init__.pyi index 7fb003db..6f4bb176 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/blackoil/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/blackoil/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,10 +9,14 @@ 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 __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: ... @@ -21,7 +25,6 @@ class BlackOilSeparator: 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/compressor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/compressor/__init__.pyi index 763b06df..5d74b44d 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/compressor/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/compressor/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,8 +16,6 @@ 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: ... @@ -36,17 +34,37 @@ class BoundaryCurveInterface(java.io.Serializable): 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: ... + 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': ... + 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 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: ... @@ -56,23 +74,54 @@ class CompressorChartInterface(java.lang.Cloneable): 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 getStoneWallCurve(self) -> "StoneWallCurve": ... def getStoneWallFlowAtSpeed(self, double: float) -> float: ... def getStoneWallHeadAtSpeed(self, double: float) -> float: ... - def getSurgeCurve(self) -> 'SafeSplineSurgeCurve': ... + 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 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 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: ... @@ -83,13 +132,15 @@ class CompressorChartReader: 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 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 setCurvesToCompressor(self, compressor: "Compressor") -> None: ... def setHeadUnit(self, string: typing.Union[java.lang.String, str]) -> None: ... class CompressorCurve(java.io.Serializable): @@ -101,13 +152,29 @@ class CompressorCurve(java.io.Serializable): @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 __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): +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: ... @@ -122,7 +189,9 @@ class CompressorInterface(jneqsim.process.equipment.ProcessEquipmentInterface, j def hashCode(self) -> int: ... def isStoneWall(self) -> bool: ... def isSurge(self) -> bool: ... - def setCompressorChartType(self, string: typing.Union[java.lang.String, str]) -> None: ... + 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: ... @@ -130,11 +199,17 @@ class CompressorInterface(jneqsim.process.equipment.ProcessEquipmentInterface, j 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 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: ... + def setFluid( + self, arrayList: java.util.ArrayList[jneqsim.thermo.system.SystemInterface] + ) -> None: ... class BoundaryCurve(BoundaryCurveInterface): def equals(self, object: typing.Any) -> bool: ... @@ -146,7 +221,12 @@ class BoundaryCurve(BoundaryCurveInterface): 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: ... + 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 = ... @@ -163,11 +243,17 @@ class Compressor(jneqsim.process.equipment.TwoPortEquipment, CompressorInterface @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 __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 findOutPressure( + self, double: float, double2: float, double3: float + ) -> float: ... def generateCompressorCurves(self) -> None: ... def getActualCompressionRatio(self) -> float: ... def getAntiSurge(self) -> AntiSurge: ... @@ -178,15 +264,21 @@ class Compressor(jneqsim.process.equipment.TwoPortEquipment, CompressorInterface def getDistanceToStoneWall(self) -> float: ... def getDistanceToSurge(self) -> float: ... def getEnergy(self) -> float: ... - def getEntropyProduction(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 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 getMechanicalDesign( + self, + ) -> jneqsim.process.mechanicaldesign.compressor.CompressorMechanicalDesign: ... def getMinimumSpeed(self) -> float: ... def getNumberOfCompressorCalcSteps(self) -> int: ... def getOutTemperature(self) -> float: ... @@ -197,7 +289,9 @@ class Compressor(jneqsim.process.equipment.TwoPortEquipment, CompressorInterface @typing.overload def getPolytropicHead(self) -> float: ... @typing.overload - def getPolytropicHead(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getPolytropicHead( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getPolytropicHeadMeter(self) -> float: ... def getPolytropicMethod(self) -> java.lang.String: ... @typing.overload @@ -205,8 +299,12 @@ class Compressor(jneqsim.process.equipment.TwoPortEquipment, CompressorInterface @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 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: ... @@ -243,9 +341,15 @@ class Compressor(jneqsim.process.equipment.TwoPortEquipment, CompressorInterface 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 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: ... @@ -257,16 +361,24 @@ class Compressor(jneqsim.process.equipment.TwoPortEquipment, CompressorInterface @typing.overload def setOutletPressure(self, double: float) -> None: ... @typing.overload - def setOutletPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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 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 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: ... @@ -280,17 +392,36 @@ class Compressor(jneqsim.process.equipment.TwoPortEquipment, CompressorInterface @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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 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: ... @@ -305,10 +436,10 @@ class CompressorChart(CompressorChartInterface, java.io.Serializable): 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 getStoneWallCurve(self) -> "StoneWallCurve": ... def getStoneWallFlowAtSpeed(self, double: float) -> float: ... def getStoneWallHeadAtSpeed(self, double: float) -> float: ... - def getSurgeCurve(self) -> 'SafeSplineSurgeCurve': ... + def getSurgeCurve(self) -> "SafeSplineSurgeCurve": ... def getSurgeFlowAtSpeed(self, double: float) -> float: ... def getSurgeHeadAtSpeed(self, double: float) -> float: ... def hashCode(self) -> int: ... @@ -316,32 +447,89 @@ class CompressorChart(CompressorChartInterface, java.io.Serializable): 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 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 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): +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: ... + 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: ... + 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 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: ... @@ -355,23 +543,56 @@ class CompressorChartAlternativeMapLookup(CompressorChart, CompressorChartInterf 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 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 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 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 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: ... @@ -380,7 +601,11 @@ 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 __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: ... @@ -389,12 +614,18 @@ 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 __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): +class CompressorChartAlternativeMapLookupExtrapolate( + CompressorChartAlternativeMapLookup +): def __init__(self): ... def getClosestRefSpeeds(self, double: float) -> java.util.ArrayList[float]: ... def getPolytropicEfficiency(self, double: float, double2: float) -> float: ... @@ -404,7 +635,11 @@ 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]): ... + 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 @@ -414,13 +649,22 @@ class SafeSplineStoneWallCurve(StoneWallCurve): 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: ... + 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]): ... + 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 @@ -430,23 +674,57 @@ class SafeSplineSurgeCurve(SurgeCurve): 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: ... + 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 __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 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 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: ... @@ -454,26 +732,72 @@ class CompressorChartKhader2015(CompressorChartAlternativeMapLookupExtrapolate): 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 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: ... + 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]): ... + 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]): ... - + 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")``. @@ -483,8 +807,12 @@ class __module_protocol__(Protocol): BoundaryCurveInterface: typing.Type[BoundaryCurveInterface] Compressor: typing.Type[Compressor] CompressorChart: typing.Type[CompressorChart] - CompressorChartAlternativeMapLookup: typing.Type[CompressorChartAlternativeMapLookup] - CompressorChartAlternativeMapLookupExtrapolate: typing.Type[CompressorChartAlternativeMapLookupExtrapolate] + CompressorChartAlternativeMapLookup: typing.Type[ + CompressorChartAlternativeMapLookup + ] + CompressorChartAlternativeMapLookupExtrapolate: typing.Type[ + CompressorChartAlternativeMapLookupExtrapolate + ] CompressorChartGenerator: typing.Type[CompressorChartGenerator] CompressorChartInterface: typing.Type[CompressorChartInterface] CompressorChartKhader2015: typing.Type[CompressorChartKhader2015] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/diffpressure/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/diffpressure/__init__.pyi index 535ace92..b02783fc 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/diffpressure/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/diffpressure/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,18 +11,37 @@ 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': ... + 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': ... + 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': ... + 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]: ... @@ -33,18 +52,46 @@ 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 __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: ... + 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: ... + 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: ... + 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: ... + def calculatePressureDrop( + double: float, double2: float, double3: float, double4: float, double5: float + ) -> float: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -53,8 +100,9 @@ class Orifice(jneqsim.process.equipment.TwoPortEquipment): 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/distillation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/distillation/__init__.pyi index 445a56e9..98861204 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/distillation/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/distillation/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,10 +14,8 @@ import jneqsim.process.equipment.stream import jneqsim.process.util.report import typing - - class DistillationColumnMatrixSolver: - def __init__(self, distillationColumn: 'DistillationColumn'): ... + def __init__(self, distillationColumn: "DistillationColumn"): ... def solve(self, uUID: java.util.UUID) -> None: ... class DistillationInterface(jneqsim.process.equipment.ProcessEquipmentInterface): @@ -26,26 +24,52 @@ class DistillationInterface(jneqsim.process.equipment.ProcessEquipmentInterface) def setNumberOfTrays(self, int: int) -> None: ... class TrayInterface(jneqsim.process.equipment.ProcessEquipmentInterface): - def addStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + 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): ... +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: ... + 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 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 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 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: ... @@ -54,7 +78,9 @@ class DistillationColumn(jneqsim.process.equipment.ProcessEquipmentBaseClass, Di def getLastMassResidual(self) -> float: ... def getLastSolveTimeSeconds(self) -> float: ... def getLastTemperatureResidual(self) -> float: ... - def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidOutStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... @typing.overload def getMassBalance(self) -> float: ... @typing.overload @@ -62,17 +88,19 @@ class DistillationColumn(jneqsim.process.equipment.ProcessEquipmentBaseClass, Di def getMassBalanceError(self) -> float: ... def getMassBalanceTolerance(self) -> float: ... def getNumerOfTrays(self) -> int: ... - def getReboiler(self) -> 'Reboiler': ... + 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 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 main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... def massBalanceCheck(self) -> bool: ... @typing.overload def run(self) -> None: ... @@ -91,7 +119,7 @@ class DistillationColumn(jneqsim.process.equipment.ProcessEquipmentBaseClass, Di 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 setSolverType(self, solverType: "DistillationColumn.SolverType") -> None: ... def setTemperatureTolerance(self, double: float) -> None: ... def setTopCondenserDuty(self, double: float) -> None: ... def setTopPressure(self, double: float) -> None: ... @@ -99,21 +127,29 @@ class DistillationColumn(jneqsim.process.equipment.ProcessEquipmentBaseClass, Di @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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "DistillationColumn.SolverType": ... @staticmethod - def values() -> typing.MutableSequence['DistillationColumn.SolverType']: ... + def values() -> typing.MutableSequence["DistillationColumn.SolverType"]: ... class SimpleTray(jneqsim.process.equipment.mixer.Mixer, TrayInterface): def __init__(self, string: typing.Union[java.lang.String, str]): ... @@ -122,13 +158,19 @@ class SimpleTray(jneqsim.process.equipment.mixer.Mixer, TrayInterface): 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: ... + 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 getVaporFlowRate( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def guessTemperature(self) -> float: ... def init(self) -> None: ... def massBalance(self) -> float: ... @@ -148,9 +190,15 @@ class Condenser(SimpleTray): @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 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 @@ -158,7 +206,9 @@ class Condenser(SimpleTray): @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 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): @@ -178,7 +228,9 @@ 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: ... + def getLiquidOutStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... @typing.overload def getTemperature(self, string: typing.Union[java.lang.String, str]) -> float: ... @typing.overload @@ -191,7 +243,6 @@ class VLSolidTray(SimpleTray): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/ejector/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/ejector/__init__.pyi index 46b04dff..f6687d48 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/ejector/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/ejector/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,17 +12,24 @@ 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 __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 getMechanicalDesign( + self, + ) -> jneqsim.process.mechanicaldesign.ejector.EjectorMechanicalDesign: ... def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... def initMechanicalDesign(self) -> None: ... @typing.overload @@ -40,9 +47,29 @@ class Ejector(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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): ... + 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 empty() -> "EjectorDesignResult": ... def getBodyVolume(self) -> float: ... def getConnectedPipingVolume(self) -> float: ... def getDiffuserOutletArea(self) -> float: ... @@ -67,7 +94,6 @@ class EjectorDesignResult: 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/electrolyzer/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/electrolyzer/__init__.pyi index e3b36e50..4060e9c8 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/electrolyzer/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/electrolyzer/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,15 +11,21 @@ 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: ... + 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 @@ -30,32 +36,53 @@ class CO2Electrolyzer(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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 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 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: ... + 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: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/expander/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/expander/__init__.pyi index 4f3c1c3f..25f3c9cf 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/expander/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/expander/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,9 +14,10 @@ import jneqsim.process.equipment.stream import jneqsim.process.util.report import typing - - -class ExpanderInterface(jneqsim.process.equipment.ProcessEquipmentInterface, jneqsim.process.equipment.TwoPortInterface): +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: ... @@ -25,7 +26,11 @@ class Expander(jneqsim.process.equipment.compressor.Compressor, ExpanderInterfac @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 __init__( + self, + string: typing.Union[java.lang.String, str], + streamInterface: jneqsim.process.equipment.stream.StreamInterface, + ): ... @typing.overload def run(self) -> None: ... @typing.overload @@ -35,18 +40,28 @@ 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 __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 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 __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: ... @@ -54,8 +69,12 @@ class TurboExpanderCompressor(Expander): 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 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: ... @@ -69,10 +88,14 @@ class TurboExpanderCompressor(Expander): 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 getExpanderFeedStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getExpanderIsentropicEfficiency(self) -> float: ... def getExpanderOutPressure(self) -> float: ... - def getExpanderOutletStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getExpanderOutletStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getExpanderSpeed(self) -> float: ... def getGearRatio(self) -> float: ... def getHeadFromQN(self, double: float) -> float: ... @@ -88,11 +111,15 @@ class TurboExpanderCompressor(Expander): @typing.overload def getPowerCompressor(self) -> float: ... @typing.overload - def getPowerCompressor(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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 getPowerExpander( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getQNratiocompressor(self) -> float: ... def getQNratioexpander(self) -> float: ... def getQn(self) -> float: ... @@ -117,7 +144,9 @@ class TurboExpanderCompressor(Expander): 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 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: ... @@ -129,19 +158,32 @@ class TurboExpanderCompressor(Expander): 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 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/filter/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/filter/__init__.pyi index 9d8d0b0d..f4e4cac2 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/filter/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/filter/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,26 +11,36 @@ 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 __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 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: ... + 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): ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/__init__.pyi index 6e2849ab..de5d4d6e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,41 +13,63 @@ 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): ... + 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': ... + def evaluateCapacity(self) -> "Flare.CapacityCheckResult": ... @typing.overload - def evaluateCapacity(self, double: float, double2: float, double3: float) -> 'Flare.CapacityCheckResult': ... + 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: ... + 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 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: ... @@ -59,14 +81,23 @@ class Flare(jneqsim.process.equipment.TwoPortEquipment): 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 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 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: ... @@ -96,39 +127,54 @@ class FlareStack(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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 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 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 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 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "FlareStack.RadiationModel": ... @staticmethod - def values() -> typing.MutableSequence['FlareStack.RadiationModel']: ... - + def values() -> typing.MutableSequence["FlareStack.RadiationModel"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.flare")``. 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 index 78d20c59..931d5f89 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/dto/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/flare/dto/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,10 +10,20 @@ 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 __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: ... @@ -26,7 +36,15 @@ class FlareCapacityDTO(java.io.Serializable): 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 __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: ... @@ -35,7 +53,22 @@ class FlareDispersionSurrogateDTO(java.io.Serializable): 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 __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: ... @@ -50,7 +83,6 @@ class FlarePerformanceDTO(java.io.Serializable): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi index 42423d91..4dc4ba16 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/heatexchanger/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -15,31 +15,43 @@ 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 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 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: ... +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 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 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 getOutStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getOutTemperature(self, int: int) -> float: ... def getThermalEffectiveness(self) -> float: ... def getUAvalue(self) -> float: ... @@ -47,14 +59,25 @@ class MultiStreamHeatExchangerInterface(jneqsim.process.equipment.ProcessEquipme @typing.overload def runConditionAnalysis(self) -> None: ... @typing.overload - def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + 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: ... + 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 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: ... @@ -64,10 +87,16 @@ class MultiStreamHeatExchangerInterface(jneqsim.process.equipment.ProcessEquipme @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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 __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 @@ -91,26 +120,38 @@ class UtilityStreamSpecification(java.io.Serializable): @typing.overload def setApproachTemperature(self, double: float) -> None: ... @typing.overload - def setApproachTemperature(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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: ... + 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: ... + 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: ... + 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 __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: ... @@ -119,12 +160,20 @@ class Heater(jneqsim.process.equipment.TwoPortEquipment, HeaterInterface): @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: ... + 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 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: ... @@ -143,39 +192,67 @@ class Heater(jneqsim.process.equipment.TwoPortEquipment, HeaterInterface): @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 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 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 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 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: ... + 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 __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: ... + def toJson( + self, reportConfig: jneqsim.process.util.report.ReportConfig + ) -> java.lang.String: ... class HeatExchanger(Heater, HeatExchangerInterface): guessOutTemperature: float = ... @@ -184,10 +261,21 @@ class HeatExchanger(Heater, HeatExchangerInterface): @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 __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: ... @@ -195,24 +283,34 @@ class HeatExchanger(Heater, HeatExchangerInterface): 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 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 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: ... + 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 getOutStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getOutTemperature(self, int: int) -> float: ... def getThermalEffectiveness(self) -> float: ... def getUAvalue(self) -> float: ... @@ -224,26 +322,45 @@ class HeatExchanger(Heater, HeatExchangerInterface): @typing.overload def runConditionAnalysis(self) -> None: ... @typing.overload - def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + 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: ... + 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 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: ... + def setOutStream( + self, + int: int, + streamInterface: jneqsim.process.equipment.stream.StreamInterface, + ) -> None: ... @typing.overload - def setOutStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + 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 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: ... @@ -251,14 +368,22 @@ class HeatExchanger(Heater, HeatExchangerInterface): @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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 __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: ... @@ -268,14 +393,18 @@ class MultiStreamHeatExchanger(Heater, MultiStreamHeatExchangerInterface): def getDuty(self) -> float: ... @typing.overload def getDuty(self, int: int) -> float: ... - def getEntropyProduction(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 getInStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getInTemperature(self, int: int) -> float: ... @typing.overload def getMassBalance(self) -> float: ... @@ -284,7 +413,9 @@ class MultiStreamHeatExchanger(Heater, MultiStreamHeatExchangerInterface): @typing.overload def getOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... @typing.overload - def getOutStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getOutStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getOutTemperature(self, int: int) -> float: ... def getTemperatureApproach(self) -> float: ... def getThermalEffectiveness(self) -> float: ... @@ -297,19 +428,32 @@ class MultiStreamHeatExchanger(Heater, MultiStreamHeatExchangerInterface): @typing.overload def runConditionAnalysis(self) -> None: ... @typing.overload - def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + 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: ... + 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 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: ... + 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: ... @@ -320,18 +464,35 @@ class MultiStreamHeatExchanger(Heater, MultiStreamHeatExchangerInterface): @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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 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 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 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: ... @@ -343,12 +504,16 @@ class MultiStreamHeatExchanger2(Heater, MultiStreamHeatExchangerInterface): @typing.overload def getInStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... @typing.overload - def getInStream(self, int: int) -> jneqsim.process.equipment.stream.StreamInterface: ... + 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 getOutStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getOutTemperature(self, int: int) -> float: ... def getTemperatureApproach(self) -> float: ... def getThermalEffectiveness(self) -> float: ... @@ -361,16 +526,27 @@ class MultiStreamHeatExchanger2(Heater, MultiStreamHeatExchangerInterface): @typing.overload def run(self, uUID: java.util.UUID) -> None: ... @typing.overload - def runConditionAnalysis(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface) -> None: ... + 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: ... + 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 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: ... @@ -380,21 +556,29 @@ class MultiStreamHeatExchanger2(Heater, MultiStreamHeatExchangerInterface): @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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 __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: ... + def setOutTemperature( + self, double: float, string: typing.Union[java.lang.String, str] + ) -> None: ... @typing.overload def setOutTemperature(self, double: float) -> None: ... @@ -402,30 +586,52 @@ 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: ... + 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: ... + 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 __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 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: ... @@ -433,17 +639,30 @@ 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: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/manifold/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/manifold/__init__.pyi index b88090b4..259d7709 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/manifold/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/manifold/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,29 +13,34 @@ 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: ... + 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: ... + 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: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/membrane/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/membrane/__init__.pyi index 346a1535..5c323dd0 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/membrane/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/membrane/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,20 +11,24 @@ 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 __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 getRetentateStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def needRecalculation(self) -> bool: ... @typing.overload def run(self) -> None: ... @@ -35,11 +39,16 @@ class MembraneSeparator(jneqsim.process.equipment.ProcessEquipmentBaseClass): @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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/mixer/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/mixer/__init__.pyi index 1b4efe85..bcef2d26 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/mixer/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/mixer/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,25 +13,33 @@ 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 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: ... + 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 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: ... + def getEntropyProduction( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getMassBalance(self) -> float: ... @typing.overload @@ -41,7 +49,9 @@ class Mixer(jneqsim.process.equipment.ProcessEquipmentBaseClass, MixerInterface) 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 getStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... def guessTemperature(self) -> float: ... def hashCode(self) -> int: ... @@ -52,7 +62,11 @@ class Mixer(jneqsim.process.equipment.ProcessEquipmentBaseClass, MixerInterface) 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: ... + def replaceStream( + self, + int: int, + streamInterface: jneqsim.process.equipment.stream.StreamInterface, + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -64,7 +78,9 @@ class Mixer(jneqsim.process.equipment.ProcessEquipmentBaseClass, MixerInterface) @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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]): ... @@ -78,7 +94,9 @@ class StaticMixer(Mixer): @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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]): ... @@ -96,7 +114,6 @@ class StaticPhaseMixer(StaticMixer): @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/network/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/network/__init__.pyi index c0c9d598..b45aff42 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/network/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/network/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,28 +16,66 @@ 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': ... + 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': ... + 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': ... + 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': ... + 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 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: ... + 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 @@ -46,29 +84,40 @@ class WellFlowlineNetwork(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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 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: ... + 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: ... + 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 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: ... + def setChoke( + self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve + ) -> None: ... + class ManifoldNode: - def getBranches(self) -> java.util.List['WellFlowlineNetwork.Branch']: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/__init__.pyi index 0600173d..e23d06d7 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -20,51 +20,87 @@ 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']: ... + 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]): ... + 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 __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 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): +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 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: ... + 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 __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: ... + 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 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]: ... @@ -79,24 +115,53 @@ class Pipeline(jneqsim.process.equipment.TwoPortEquipment, PipeLineInterface): 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 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: ... + 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 __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: ... @@ -108,29 +173,41 @@ class AdiabaticPipe(Pipeline): 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: ... + 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 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: ... + 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 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 __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: ... @@ -152,27 +229,41 @@ class AdiabaticTwoPhasePipe(Pipeline): @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 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: ... + 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 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): ... + 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 __init__( + self, streamInterface: jneqsim.process.equipment.stream.StreamInterface + ): ... def createSystem(self) -> None: ... @typing.overload def run(self) -> None: ... @@ -183,25 +274,40 @@ 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 __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 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 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 estimateHeatTransferCoefficent( + self, systemInterface: jneqsim.thermo.system.SystemInterface + ) -> float: ... def getAngle(self) -> float: ... - def getCalculationMode(self) -> 'PipeBeggsAndBrills.CalculationMode': ... + 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 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]: ... @@ -222,7 +328,7 @@ class PipeBeggsAndBrills(Pipeline): 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 getSegmentFlowRegime(self, int: int) -> "PipeBeggsAndBrills.FlowRegime": ... def getSegmentGasSuperficialVelocity(self, int: int) -> float: ... def getSegmentLength(self, int: int) -> float: ... def getSegmentLiquidDensity(self, int: int) -> float: ... @@ -251,8 +357,12 @@ class PipeBeggsAndBrills(Pipeline): @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 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: ... @@ -265,59 +375,89 @@ class PipeBeggsAndBrills(Pipeline): @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: ... + 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 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) # + 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: ... + 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': ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "PipeBeggsAndBrills.FlowRegime": ... @staticmethod - def values() -> typing.MutableSequence['PipeBeggsAndBrills.FlowRegime']: ... + 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 __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 setInitialFlowPattern( + self, string: typing.Union[java.lang.String, str] + ) -> None: ... def setOutPressure(self, double: float) -> None: ... def setOutTemperature(self, double: float) -> None: ... @@ -325,22 +465,30 @@ 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 __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 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 setCorrelationType( + self, correlationType: "TubingPerformance.CorrelationType" + ) -> None: ... def setDiameter(self, double: float) -> None: ... def setFormationThermalConductivity(self, double: float) -> None: ... def setGeothermalGradient(self, double: float) -> None: ... @@ -351,59 +499,87 @@ class TubingPerformance(Pipeline): 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 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) # + + 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: ... + 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': ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "TubingPerformance.TemperatureModel": ... @staticmethod - def values() -> typing.MutableSequence['TubingPerformance.TemperatureModel']: ... + 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 __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 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 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 getLiquidInventory( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getLiquidVelocityProfile(self) -> typing.MutableSequence[float]: ... def getMaxSimulationTime(self) -> float: ... def getMaxSlugLengthAtOutlet(self) -> float: ... @@ -418,14 +594,18 @@ class TwoFluidPipe(Pipeline): def getRoughness(self) -> float: ... def getSimulationTime(self) -> float: ... def getSlugStatisticsSummary(self) -> java.lang.String: ... - def getSlugTracker(self) -> jneqsim.process.equipment.pipeline.twophasepipe.SlugTracker: ... + 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 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: ... @@ -449,68 +629,102 @@ class TwoFluidPipe(Pipeline): 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 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 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 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 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 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) # + 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: ... + 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': ... + 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 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) # + _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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "TwoFluidPipe.InsulationType": ... @staticmethod - def values() -> typing.MutableSequence['TwoFluidPipe.InsulationType']: ... + 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 __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: ... @@ -521,12 +735,18 @@ 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 __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 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]: ... @@ -548,7 +768,9 @@ class WaterHammerPipe(Pipeline): @typing.overload def getPressureProfile(self) -> typing.MutableSequence[float]: ... @typing.overload - def getPressureProfile(self, string: typing.Union[java.lang.String, str]) -> typing.MutableSequence[float]: ... + 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]: ... @@ -568,53 +790,76 @@ class WaterHammerPipe(Pipeline): @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 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 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 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "WaterHammerPipe.BoundaryType": ... @staticmethod - def values() -> typing.MutableSequence['WaterHammerPipe.BoundaryType']: ... + 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 __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: ... + 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")``. 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 index 3b90303b..643b737a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pipeline/twophasepipe/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -18,16 +18,47 @@ 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: ... + 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 = ... @@ -37,6 +68,7 @@ class DriftFluxModel(java.io.Serializable): voidFraction: float = ... liquidHoldup: float = ... def __init__(self): ... + class EnergyEquationResult(java.io.Serializable): newTemperature: float = ... jouleThomsonDeltaT: float = ... @@ -51,42 +83,79 @@ 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 __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 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) # + 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: ... + 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': ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "EntrainmentDeposition.EntrainmentModel": ... @staticmethod - def values() -> typing.MutableSequence['EntrainmentDeposition.EntrainmentModel']: ... + def values() -> ( + typing.MutableSequence["EntrainmentDeposition.EntrainmentModel"] + ): ... + class EntrainmentResult(java.io.Serializable): entrainmentRate: float = ... depositionRate: float = ... @@ -100,7 +169,16 @@ class EntrainmentDeposition(java.io.Serializable): 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 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: ... @@ -110,45 +188,83 @@ class FlashTable(java.io.Serializable): 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 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 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 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 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "FlowRegimeDetector.DetectionMethod": ... @staticmethod - def values() -> typing.MutableSequence['FlowRegimeDetector.DetectionMethod']: ... + 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 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 getOverflowingZones( + self, + ) -> java.util.List["LiquidAccumulationTracker.AccumulationZone"]: ... def getTotalAccumulatedVolume(self) -> float: ... - def identifyAccumulationZones(self, pipeSectionArray: typing.Union[typing.List['PipeSection'], jpype.JArray]) -> None: ... + 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: ... + def updateAccumulation( + self, + pipeSectionArray: typing.Union[typing.List["PipeSection"], jpype.JArray], + double: float, + ) -> None: ... + class AccumulationZone(java.io.Serializable): startPosition: float = ... endPosition: float = ... @@ -162,6 +278,7 @@ class LiquidAccumulationTracker(java.io.Serializable): timeSinceSlug: float = ... sectionIndices: java.util.List = ... def __init__(self): ... + class SlugCharacteristics(java.io.Serializable): frontPosition: float = ... tailPosition: float = ... @@ -177,8 +294,10 @@ 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 __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]: ... @@ -186,7 +305,7 @@ class PipeSection(java.lang.Cloneable, java.io.Serializable): def getEffectiveLiquidHoldup(self) -> float: ... def getEffectiveMixtureDensity(self) -> float: ... def getElevation(self) -> float: ... - def getFlowRegime(self) -> 'PipeSection.FlowRegime': ... + def getFlowRegime(self) -> "PipeSection.FlowRegime": ... def getFrictionPressureGradient(self) -> float: ... def getGasDensity(self) -> float: ... def getGasEnthalpy(self) -> float: ... @@ -224,9 +343,14 @@ class PipeSection(java.lang.Cloneable, java.io.Serializable): 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 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 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: ... @@ -255,49 +379,66 @@ class PipeSection(java.lang.Cloneable, java.io.Serializable): 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "PipeSection.FlowRegime": ... @staticmethod - def values() -> typing.MutableSequence['PipeSection.FlowRegime']: ... + 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 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 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 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 = ... @@ -325,10 +466,16 @@ class ThermodynamicCoupling(java.io.Serializable): 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 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: ... @@ -338,10 +485,18 @@ class ThermodynamicCoupling(java.io.Serializable): 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 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: ... + 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 = ... @@ -368,15 +523,28 @@ class ThermodynamicCoupling(java.io.Serializable): class ThreeFluidConservationEquations(java.io.Serializable): def __init__(self): ... - def calcRHS(self, threeFluidSection: 'ThreeFluidSection', double: float, threeFluidSection2: 'ThreeFluidSection', threeFluidSection3: 'ThreeFluidSection') -> 'ThreeFluidConservationEquations.ThreeFluidRHS': ... + 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 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 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 = ... @@ -392,13 +560,20 @@ class ThreeFluidConservationEquations(java.io.Serializable): oilWaterInterfacialShear: float = ... def __init__(self): ... -class TransientPipe(jneqsim.process.equipment.TwoPortEquipment, jneqsim.process.equipment.pipeline.PipeLineInterface): +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 __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: ... @@ -417,7 +592,9 @@ class TransientPipe(jneqsim.process.equipment.TwoPortEquipment, jneqsim.process. def getOverallHeatTransferCoeff(self) -> float: ... def getPipe(self) -> jneqsim.fluidmechanics.flowsystem.FlowSystemInterface: ... def getPipeElasticity(self) -> float: ... - def getPressureHistory(self) -> typing.MutableSequence[typing.MutableSequence[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]: ... @@ -441,52 +618,84 @@ class TransientPipe(jneqsim.process.equipment.TwoPortEquipment, jneqsim.process. 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 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 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 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 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 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 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "TransientPipe.BoundaryCondition": ... @staticmethod - def values() -> typing.MutableSequence['TransientPipe.BoundaryCondition']: ... + def values() -> typing.MutableSequence["TransientPipe.BoundaryCondition"]: ... class TwoFluidConservationEquations(java.io.Serializable): NUM_EQUATIONS: typing.ClassVar[int] = ... @@ -499,18 +708,60 @@ class TwoFluidConservationEquations(java.io.Serializable): 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 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 getFluxCalculator( + self, + ) -> ( + jneqsim.process.equipment.pipeline.twophasepipe.numerics.AUSMPlusFluxCalculator + ): ... def getHeatTransferCoefficient(self) -> float: ... - def getInterfacialFriction(self) -> jneqsim.process.equipment.pipeline.twophasepipe.closure.InterfacialFriction: ... + 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 getReconstructor( + self, + ) -> ( + jneqsim.process.equipment.pipeline.twophasepipe.numerics.MUSCLReconstructor + ): ... def getSurfaceTemperature(self) -> float: ... - def getWallFriction(self) -> jneqsim.process.equipment.pipeline.twophasepipe.closure.WallFriction: ... + def getWallFriction( + self, + ) -> jneqsim.process.equipment.pipeline.twophasepipe.closure.WallFriction: ... def isEnableWaterOilSlip(self) -> bool: ... def isHeatTransferEnabled(self) -> bool: ... def isIncludeEnergyEquation(self) -> bool: ... @@ -527,13 +778,15 @@ class TwoFluidSection(PipeSection): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, double: float, double2: float, double3: float, double4: float): ... + 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 clone(self) -> "TwoFluidSection": ... def extractPrimitiveVariables(self) -> None: ... @staticmethod - def fromPipeSection(pipeSection: PipeSection) -> 'TwoFluidSection': ... + def fromPipeSection(pipeSection: PipeSection) -> "TwoFluidSection": ... def getEnergyPerLength(self) -> float: ... def getEnergySource(self) -> float: ... def getGasHydraulicDiameter(self) -> float: ... @@ -595,7 +848,9 @@ class TwoFluidSection(PipeSection): 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 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: ... @@ -616,8 +871,10 @@ class ThreeFluidSection(TwoFluidSection, java.lang.Cloneable, java.io.Serializab @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 __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: ... @@ -675,7 +932,6 @@ class ThreeFluidSection(TwoFluidSection, java.lang.Cloneable, java.io.Serializab 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")``. @@ -693,4 +949,6 @@ class __module_protocol__(Protocol): 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__ + 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 index 2c162846..b1da4a66 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,17 +9,28 @@ 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: ... + 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 = ... @@ -35,8 +46,33 @@ class GeometryCalculator(java.io.Serializable): 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': ... + 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 = ... @@ -46,11 +82,28 @@ class InterfacialFriction(java.io.Serializable): 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 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 = ... @@ -60,7 +113,6 @@ class WallFriction(java.io.Serializable): 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")``. 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 index 079f096a..7a83432c 100644 --- 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 @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,30 +10,52 @@ 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 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 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 = ... @@ -44,10 +66,19 @@ class AUSMPlusFluxCalculator(java.io.Serializable): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float): ... + 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' = ... + gasFlux: "AUSMPlusFluxCalculator.PhaseFlux" = ... + liquidFlux: "AUSMPlusFluxCalculator.PhaseFlux" = ... interfaceMach: float = ... def __init__(self): ... @@ -55,83 +86,150 @@ class MUSCLReconstructor(java.io.Serializable): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, slopeLimiter: 'MUSCLReconstructor.SlopeLimiter'): ... + 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 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 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "MUSCLReconstructor.SlopeLimiter": ... @staticmethod - def values() -> typing.MutableSequence['MUSCLReconstructor.SlopeLimiter']: ... + 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 __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 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 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 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) # + 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: ... + 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': ... + 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]]: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/powergeneration/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/powergeneration/__init__.pyi index d7545e9d..bed3627d 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/powergeneration/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/powergeneration/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,15 +14,18 @@ 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 __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: ... @@ -32,7 +35,9 @@ class FuelCell(jneqsim.process.equipment.TwoPortEquipment): @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: ... + def setOxidantStream( + self, streamInterface: jneqsim.process.equipment.stream.StreamInterface + ) -> None: ... class GasTurbine(jneqsim.process.equipment.TwoPortEquipment): thermoSystem: jneqsim.thermo.system.SystemInterface = ... @@ -45,16 +50,24 @@ class GasTurbine(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 __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 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: ... + def setInletStream( + self, streamInterface: jneqsim.process.equipment.stream.StreamInterface + ) -> None: ... class SolarPanel(jneqsim.process.equipment.ProcessEquipmentBaseClass): @typing.overload @@ -62,7 +75,13 @@ class SolarPanel(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], double: float, double2: float, double3: float): ... + 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: ... @@ -91,7 +110,6 @@ class WindTurbine(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pump/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pump/__init__.pyi index 50ae033f..c1d3287b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pump/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/pump/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,10 +16,14 @@ 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 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: ... @@ -31,10 +35,30 @@ class PumpChartInterface(java.lang.Cloneable): 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 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 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: ... @@ -47,9 +71,18 @@ class PumpCurve(java.io.Serializable): @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]): ... + 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): +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: ... @@ -68,14 +101,20 @@ class Pump(jneqsim.process.equipment.TwoPortEquipment, PumpInterface): @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 __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 getEntropyProduction( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getIsentropicEfficiency(self) -> float: ... def getMinimumFlow(self) -> float: ... def getMolarFlow(self) -> float: ... @@ -105,21 +144,33 @@ class Pump(jneqsim.process.equipment.TwoPortEquipment, PumpInterface): @typing.overload def setOutletPressure(self, double: float) -> None: ... @typing.overload - def setOutletPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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 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: ... + 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 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: ... @@ -136,17 +187,42 @@ class PumpChart(PumpChartInterface, java.io.Serializable): def hasNPSHCurve(self) -> bool: ... def isUsePumpChart(self) -> bool: ... @staticmethod - def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + 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 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 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): +class PumpChartAlternativeMapLookupExtrapolate( + jneqsim.process.equipment.compressor.CompressorChartAlternativeMapLookupExtrapolate, + PumpChartInterface, +): def __init__(self): ... def getBestEfficiencyFlowRate(self) -> float: ... def getEfficiency(self, double: float, double2: float) -> float: ... @@ -156,16 +232,22 @@ class PumpChartAlternativeMapLookupExtrapolate(jneqsim.process.equipment.compres 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 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] + 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 index 65ea127c..fa2a74c6 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reactor/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reactor/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,8 +13,6 @@ 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: ... @@ -33,60 +31,137 @@ class FurnaceBurner(jneqsim.process.equipment.ProcessEquipmentBaseClass): @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 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 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "FurnaceBurner.BurnerDesign": ... @staticmethod - def values() -> typing.MutableSequence['FurnaceBurner.BurnerDesign']: ... + 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): ... + 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: ... + 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 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 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 getEnergyMode(self) -> "GibbsReactor.EnergyMode": ... def getEnthalpyOfReactions(self) -> float: ... def getFinalConvergenceError(self) -> float: ... - def getFugacityCoefficient(self, object: typing.Any) -> typing.MutableSequence[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 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 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: ... @@ -96,7 +171,9 @@ class GibbsReactor(jneqsim.process.equipment.TwoPortEquipment): 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 getObjectiveMinimizationVectorLabels( + self, + ) -> java.util.List[java.lang.String]: ... def getOutletMole(self) -> java.util.List[float]: ... def getOutletMoles(self) -> java.util.List[float]: ... @typing.overload @@ -107,7 +184,11 @@ class GibbsReactor(jneqsim.process.equipment.TwoPortEquipment): 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 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 @@ -117,13 +198,15 @@ class GibbsReactor(jneqsim.process.equipment.TwoPortEquipment): @typing.overload def setComponentAsInert(self, int: int) -> None: ... @typing.overload - def setComponentAsInert(self, string: typing.Union[java.lang.String, str]) -> None: ... + 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 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: ... @@ -133,21 +216,51 @@ class GibbsReactor(jneqsim.process.equipment.TwoPortEquipment): @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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "GibbsReactor.EnergyMode": ... @staticmethod - def values() -> typing.MutableSequence['GibbsReactor.EnergyMode']: ... + 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 __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: ... @@ -165,13 +278,16 @@ 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): ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reservoir/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reservoir/__init__.pyi index dceea0d3..6f738af8 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reservoir/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/reservoir/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,24 +16,34 @@ 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): ... + 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): ... + 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 __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: ... @@ -41,49 +51,77 @@ class ReservoirTPsim(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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: ... + 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 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: ... + 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 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 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 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': ... + 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 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 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: ... + 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -92,84 +130,173 @@ class SimpleReservoir(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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: ... + 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 __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 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 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 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: ... + 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: ... + 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 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) # + 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: ... + 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': ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "TubingPerformance.TemperatureModel": ... @staticmethod - def values() -> typing.MutableSequence['TubingPerformance.TemperatureModel']: ... + def values() -> ( + typing.MutableSequence["TubingPerformance.TemperatureModel"] + ): ... class Well(jneqsim.util.NamedBaseClass): def __init__(self, string: typing.Union[java.lang.String, str]): ... @@ -178,22 +305,34 @@ class Well(jneqsim.util.NamedBaseClass): 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: ... + 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 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 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: ... + def loadIPRFromFile( + self, path: typing.Union[java.nio.file.Path, jpype.protocol.SupportsPath] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -202,119 +341,222 @@ class WellFlow(jneqsim.process.equipment.TwoPortEquipment): 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: ... + 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 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "WellFlow.InflowPerformanceModel": ... @staticmethod - def values() -> typing.MutableSequence['WellFlow.InflowPerformanceModel']: ... + 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): ... + 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 __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 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 getReservoirPressure( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getTubingVLP(self) -> TubingPerformance: ... - def getVLPSolverMode(self) -> 'WellSystem.VLPSolverMode': ... + def getVLPSolverMode(self) -> "WellSystem.VLPSolverMode": ... def getWellFlowIPR(self) -> WellFlow: ... - def getWellheadPressure(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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 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 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 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "WellSystem.IPRModel": ... @staticmethod - def values() -> typing.MutableSequence['WellSystem.IPRModel']: ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "WellSystem.VLPSolverMode": ... @staticmethod - def values() -> typing.MutableSequence['WellSystem.VLPSolverMode']: ... - + def values() -> typing.MutableSequence["WellSystem.VLPSolverMode"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.reservoir")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/__init__.pyi index 50d51e48..d77fda61 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -18,8 +18,6 @@ import jneqsim.process.util.report import jneqsim.thermo.system import typing - - class SeparatorInterface(jneqsim.process.SimulationInterface): @typing.overload def getHeatInput(self) -> float: ... @@ -30,25 +28,47 @@ class SeparatorInterface(jneqsim.process.SimulationInterface): @typing.overload def setHeatInput(self, double: float) -> None: ... @typing.overload - def setHeatInput(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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): +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 __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 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 @@ -57,11 +77,15 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn 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: ... + 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 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: ... @@ -84,25 +108,39 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn def getLiquid(self) -> jneqsim.process.equipment.stream.StreamInterface: ... def getLiquidCarryoverFraction(self) -> float: ... def getLiquidLevel(self) -> float: ... - def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + 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 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 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 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: ... @@ -124,19 +162,34 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn @typing.overload def setDuty(self, double: float) -> None: ... @typing.overload - def setDuty(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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 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: ... + 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 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: ... @@ -147,37 +200,59 @@ class Separator(jneqsim.process.equipment.ProcessEquipmentBaseClass, SeparatorIn @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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: ... + 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 __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: ... + 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: ... + 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 __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: ... @@ -185,37 +260,59 @@ class Hydrocyclone(Separator): 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 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 __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: ... + 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: ... + 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 __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: ... + 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 getExergyChange( + self, string: typing.Union[java.lang.String, str], double: float + ) -> float: ... def getGasOutletFlowFraction(self) -> float: ... @typing.overload def getMassBalance(self) -> float: ... @@ -237,9 +334,18 @@ class ThreePhaseSeparator(Separator): 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 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 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: ... @@ -248,14 +354,19 @@ class ThreePhaseSeparator(Separator): @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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): ... - + 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")``. 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 index b43c0620..78bbdec1 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/sectiontype/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/separator/sectiontype/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,15 +11,20 @@ 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 __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 getMechanicalDesign( + self, + ) -> jneqsim.process.mechanicaldesign.separator.sectiontype.SepDesignSection: ... def getMinimumLiquidSealHeight(self) -> float: ... def getOuterDiameter(self) -> float: ... def getPressureDrop(self) -> float: ... @@ -29,37 +34,80 @@ class SeparatorSection(jneqsim.util.NamedBaseClass): 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: ... + 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 __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: ... + 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 __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: ... + 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 __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: ... + 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 __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 __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: ... + 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 __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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/splitter/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/splitter/__init__.pyi index 1bb50d07..aaf7ff59 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/splitter/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/splitter/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,13 +13,15 @@ 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 __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 @@ -27,32 +29,53 @@ class ComponentSplitter(jneqsim.process.equipment.ProcessEquipmentBaseClass): @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: ... + 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: ... + 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: ... + 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 getSplitStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def hashCode(self) -> int: ... - def setInletStream(self, streamInterface: jneqsim.process.equipment.stream.StreamInterface) -> None: ... + 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 __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: ... @@ -63,7 +86,9 @@ class Splitter(jneqsim.process.equipment.ProcessEquipmentBaseClass, SplitterInte 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 getSplitStream( + self, int: int + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def needRecalculation(self) -> bool: ... @typing.overload def run(self) -> None: ... @@ -73,15 +98,24 @@ class Splitter(jneqsim.process.equipment.ProcessEquipmentBaseClass, SplitterInte 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/stream/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/stream/__init__.pyi index 7a439e77..75619111 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/stream/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/stream/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -15,14 +15,12 @@ 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 clone(self) -> "EnergyStream": ... def equals(self, object: typing.Any) -> bool: ... def getDuty(self) -> float: ... def getName(self) -> java.lang.String: ... @@ -35,121 +33,239 @@ class StreamInterface(jneqsim.process.equipment.ProcessEquipmentInterface): 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: ... + def TVP( + self, double: float, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload - def clone(self) -> 'StreamInterface': ... + def clone(self) -> "StreamInterface": ... @typing.overload - def clone(self, string: typing.Union[java.lang.String, str]) -> 'StreamInterface': ... + 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 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 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: ... + 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 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 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: ... + 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: ... + 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 __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: ... + 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 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 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): +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 __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: ... + def TVP( + self, double: float, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload - def clone(self) -> 'Stream': ... + def clone(self) -> "Stream": ... @typing.overload - def clone(self, string: typing.Union[java.lang.String, str]) -> 'Stream': ... + 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 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 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: ... + 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 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]]: ... + def reportResults( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -160,36 +276,60 @@ class Stream(jneqsim.process.equipment.ProcessEquipmentBaseClass, StreamInterfac 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 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 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: ... + 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: ... + 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): ... + def __init__( + self, + string: typing.Union[java.lang.String, str], + systemInterface: jneqsim.thermo.system.SystemInterface, + ): ... @typing.overload - def clone(self) -> 'EquilibriumStream': ... + def clone(self) -> "EquilibriumStream": ... @typing.overload - def clone(self, string: typing.Union[java.lang.String, str]) -> 'EquilibriumStream': ... + def clone( + self, string: typing.Union[java.lang.String, str] + ) -> "EquilibriumStream": ... @typing.overload def run(self) -> None: ... @typing.overload @@ -199,13 +339,23 @@ 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): ... + 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 __init__( + self, + string: typing.Union[java.lang.String, str], + systemInterface: jneqsim.thermo.system.SystemInterface, + ): ... @typing.overload - def clone(self) -> 'IronIonSaturationStream': ... + def clone(self) -> "IronIonSaturationStream": ... @typing.overload - def clone(self, string: typing.Union[java.lang.String, str]) -> 'IronIonSaturationStream': ... + def clone( + self, string: typing.Union[java.lang.String, str] + ) -> "IronIonSaturationStream": ... def displayResult(self) -> None: ... @typing.overload def run(self) -> None: ... @@ -216,13 +366,21 @@ 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): ... + 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 __init__( + self, + string: typing.Union[java.lang.String, str], + systemInterface: jneqsim.thermo.system.SystemInterface, + ): ... @typing.overload - def clone(self) -> 'NeqStream': ... + def clone(self) -> "NeqStream": ... @typing.overload - def clone(self, string: typing.Union[java.lang.String, str]) -> 'NeqStream': ... + def clone(self, string: typing.Union[java.lang.String, str]) -> "NeqStream": ... @typing.overload def run(self) -> None: ... @typing.overload @@ -232,20 +390,29 @@ 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): ... + 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 __init__( + self, + string: typing.Union[java.lang.String, str], + systemInterface: jneqsim.thermo.system.SystemInterface, + ): ... @typing.overload - def clone(self) -> 'ScalePotentialCheckStream': ... + def clone(self) -> "ScalePotentialCheckStream": ... @typing.overload - def clone(self, string: typing.Union[java.lang.String, str]) -> 'ScalePotentialCheckStream': ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/subsea/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/subsea/__init__.pyi index ecc2f48a..4397f58f 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/subsea/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/subsea/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,13 +14,17 @@ 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 __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 getPipeline( + self, + ) -> jneqsim.process.equipment.pipeline.AdiabaticTwoPhasePipe: ... def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... @typing.overload def run(self) -> None: ... @@ -31,16 +35,23 @@ class SimpleFlowLine(jneqsim.process.equipment.TwoPortEquipment): 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: ... + 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: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/tank/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/tank/__init__.pyi index 306cfcc2..22f4d7f0 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/tank/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/tank/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,14 +13,18 @@ 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 __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: ... @@ -29,7 +33,9 @@ class Tank(jneqsim.process.equipment.ProcessEquipmentBaseClass): def getLiquid(self) -> jneqsim.process.equipment.stream.StreamInterface: ... def getLiquidCarryoverFraction(self) -> float: ... def getLiquidLevel(self) -> float: ... - def getLiquidOutStream(self) -> jneqsim.process.equipment.stream.StreamInterface: ... + def getLiquidOutStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... @typing.overload def getMassBalance(self) -> float: ... @typing.overload @@ -45,16 +51,21 @@ class Tank(jneqsim.process.equipment.ProcessEquipmentBaseClass): 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 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/util/__init__.pyi index 818bb960..cd072632 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/util/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/util/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -19,8 +19,6 @@ 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: ... @@ -30,91 +28,241 @@ class Adjuster(jneqsim.process.equipment.ProcessEquipmentBaseClass): def getTolerance(self) -> float: ... def isActivateWhenLess(self) -> bool: ... @staticmethod - def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + 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 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 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 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: ... + 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: ... + 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]: ... + 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]: ... + 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]: ... + 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]: ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "CalculatorLibrary.Preset": ... @staticmethod - def values() -> typing.MutableSequence['CalculatorLibrary.Preset']: ... + def values() -> typing.MutableSequence["CalculatorLibrary.Preset"]: ... class FlowRateAdjuster(jneqsim.process.equipment.TwoPortEquipment): desiredGasFlow: float = ... @@ -123,35 +271,73 @@ class FlowRateAdjuster(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 __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: ... + 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 __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: ... + 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: ... + 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 __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 @@ -171,24 +357,38 @@ class GORfitter(jneqsim.process.equipment.TwoPortEquipment): 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: ... + 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 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: ... + 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): ... + 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 __init__( + self, streamInterface: jneqsim.process.equipment.stream.StreamInterface + ): ... def getGFV(self) -> float: ... def getGOR(self) -> float: ... @typing.overload @@ -209,35 +409,63 @@ class MPFMfitter(jneqsim.process.equipment.TwoPortEquipment): 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: ... + 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: ... + 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: ... + 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 __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: ... + 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 __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: ... @@ -253,7 +481,9 @@ class NeqSimUnit(jneqsim.process.equipment.TwoPortEquipment): 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 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: ... @@ -262,16 +492,27 @@ 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): ... + 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: ... + def setPressureDrop( + self, double: float, string: typing.Union[java.lang.String, str] + ) -> None: ... -class Recycle(jneqsim.process.equipment.ProcessEquipmentBaseClass, jneqsim.process.equipment.mixer.MixerInterface): +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 addStream( + self, streamInterface: jneqsim.process.equipment.stream.StreamInterface + ) -> None: ... def calcMixStreamEnthalpy(self) -> float: ... def compositionBalanceCheck(self) -> float: ... def displayResult(self) -> None: ... @@ -291,15 +532,23 @@ class Recycle(jneqsim.process.equipment.ProcessEquipmentBaseClass, jneqsim.proce 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 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 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 replaceStream( + self, + int: int, + streamInterface: jneqsim.process.equipment.stream.StreamInterface, + ) -> None: ... def resetIterations(self) -> None: ... @typing.overload def run(self) -> None: ... @@ -308,16 +557,22 @@ class Recycle(jneqsim.process.equipment.ProcessEquipmentBaseClass, jneqsim.proce def setCompositionTolerance(self, double: float) -> None: ... def setDownstreamProperties(self) -> None: ... @typing.overload - def setDownstreamProperty(self, string: typing.Union[java.lang.String, str]) -> None: ... + 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 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 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: ... @@ -328,7 +583,9 @@ class Recycle(jneqsim.process.equipment.ProcessEquipmentBaseClass, jneqsim.proce @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + def toJson( + self, reportConfig: jneqsim.process.util.report.ReportConfig + ) -> java.lang.String: ... class RecycleController(java.io.Serializable): def __init__(self): ... @@ -354,50 +611,121 @@ class SetPoint(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], processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, string2: typing.Union[java.lang.String, str], processEquipmentInterface2: jneqsim.process.equipment.ProcessEquipmentInterface): ... + 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: ... + 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: ... + 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]]: ... + 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: ... + 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 __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 @@ -405,20 +733,28 @@ class StreamSaturatorUtil(jneqsim.process.equipment.TwoPortEquipment): @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 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 __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: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/valve/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/valve/__init__.pyi index 7615fbc3..7fa08bdd 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/equipment/valve/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/equipment/valve/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,9 +16,10 @@ import jneqsim.process.util.report import jneqsim.thermo.system import typing - - -class ValveInterface(jneqsim.process.equipment.ProcessEquipmentInterface, jneqsim.process.equipment.TwoPortInterface): +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: ... @@ -31,7 +32,7 @@ class ValveInterface(jneqsim.process.equipment.ProcessEquipmentInterface, jneqsi def getPercentValveOpening(self) -> float: ... def getTargetPercentValveOpening(self) -> float: ... def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... - def getTravelModel(self) -> 'ValveTravelModel': ... + def getTravelModel(self) -> "ValveTravelModel": ... def getTravelTime(self) -> float: ... def getTravelTimeConstant(self) -> float: ... def hashCode(self) -> int: ... @@ -40,35 +41,43 @@ class ValveInterface(jneqsim.process.equipment.ProcessEquipmentInterface, jneqsi @typing.overload def setCv(self, double: float) -> None: ... @typing.overload - def setCv(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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 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) # +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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "ValveTravelModel": ... @staticmethod - def values() -> typing.MutableSequence['ValveTravelModel']: ... + 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 __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: ... @@ -84,20 +93,30 @@ class ThrottlingValve(jneqsim.process.equipment.TwoPortEquipment, ValveInterface @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: ... + 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 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 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 getResultTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... def getTargetPercentValveOpening(self) -> float: ... def getThermoSystem(self) -> jneqsim.thermo.system.SystemInterface: ... def getTravelModel(self) -> ValveTravelModel: ... @@ -127,8 +146,12 @@ class ThrottlingValve(jneqsim.process.equipment.TwoPortEquipment, ValveInterface @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 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: ... @@ -140,12 +163,16 @@ class ThrottlingValve(jneqsim.process.equipment.TwoPortEquipment, ValveInterface @typing.overload def setOutletPressure(self, double: float) -> None: ... @typing.overload - def setOutletPressure(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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 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: ... @@ -154,13 +181,19 @@ class ThrottlingValve(jneqsim.process.equipment.TwoPortEquipment, ValveInterface @typing.overload def toJson(self) -> java.lang.String: ... @typing.overload - def toJson(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> java.lang.String: ... + 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 __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: ... @@ -179,7 +212,11 @@ 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 __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 @@ -193,14 +230,22 @@ 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 __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 __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: ... @@ -226,18 +271,29 @@ 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 __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 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 getVotingLogic(self) -> "HIPPSValve.VotingLogic": ... def hasTripped(self) -> bool: ... def isPartialStrokeTestActive(self) -> bool: ... def isProofTestDue(self) -> bool: ... @@ -245,7 +301,10 @@ class HIPPSValve(ThrottlingValve): def performPartialStrokeTest(self, double: float) -> None: ... def performProofTest(self) -> None: ... def recordSpuriousTrip(self) -> None: ... - def removePressureTransmitter(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + def removePressureTransmitter( + self, + measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface, + ) -> None: ... def reset(self) -> None: ... @typing.overload def runTransient(self, double: float) -> None: ... @@ -256,35 +315,50 @@ class HIPPSValve(ThrottlingValve): 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 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'] = ... + + 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) # + _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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "HIPPSValve.VotingLogic": ... @staticmethod - def values() -> typing.MutableSequence['HIPPSValve.VotingLogic']: ... + 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 __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 getPressureTransmitter( + self, + ) -> jneqsim.process.measurementdevice.MeasurementDeviceInterface: ... def hasTripped(self) -> bool: ... def isTripEnabled(self) -> bool: ... - def linkToPressureTransmitter(self, measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface) -> None: ... + def linkToPressureTransmitter( + self, + measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface, + ) -> None: ... def reset(self) -> None: ... @typing.overload def runTransient(self, double: float) -> None: ... @@ -299,7 +373,11 @@ 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 __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: ... @@ -319,22 +397,30 @@ 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 __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 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 getValveType(self) -> "SafetyReliefValve.ValveType": ... def initMechanicalDesign(self) -> None: ... @typing.overload def run(self) -> None: ... @@ -352,120 +438,184 @@ class SafetyReliefValve(ThrottlingValve): 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 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) # + 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: ... + 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': ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "SafetyReliefValve.ValveType": ... @staticmethod - def values() -> typing.MutableSequence['SafetyReliefValve.ValveType']: ... + 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 __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 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 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 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "SafetyValve.FluidService": ... @staticmethod - def values() -> typing.MutableSequence['SafetyValve.FluidService']: ... + 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 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 getRelievingStream( + self, + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def getSetPressure(self) -> java.util.Optional[float]: ... - def getSizingStandard(self) -> 'SafetyValve.SizingStandard': ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "SafetyValve.SizingStandard": ... @staticmethod - def values() -> typing.MutableSequence['SafetyValve.SizingStandard']: ... + 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 __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: ... @@ -477,32 +627,44 @@ class LevelControlValve(ControlValve): @typing.overload def run(self, uUID: java.util.UUID) -> None: ... def setAutoMode(self, boolean: bool) -> None: ... - def setControlAction(self, controlAction: 'LevelControlValve.ControlAction') -> 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "LevelControlValve.ControlAction": ... @staticmethod - def values() -> typing.MutableSequence['LevelControlValve.ControlAction']: ... + 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 __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 getControlMode(self) -> "PressureControlValve.ControlMode": ... def getControllerGain(self) -> float: ... def getPressureSetpoint(self) -> float: ... def getProcessVariable(self) -> float: ... @@ -512,24 +674,31 @@ class PressureControlValve(ControlValve): @typing.overload def run(self, uUID: java.util.UUID) -> None: ... def setAutoMode(self, boolean: bool) -> None: ... - def setControlMode(self, controlMode: 'PressureControlValve.ControlMode') -> 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "PressureControlValve.ControlMode": ... @staticmethod - def values() -> typing.MutableSequence['PressureControlValve.ControlMode']: ... - + def values() -> typing.MutableSequence["PressureControlValve.ControlMode"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.equipment.valve")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/__init__.pyi index f758cca6..10926e36 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -19,8 +19,6 @@ import jneqsim.process.logic.startup import jneqsim.process.logic.voting import typing - - class LogicAction: def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... @@ -32,24 +30,28 @@ class LogicCondition: 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: ... + 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) # +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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "LogicState": ... @staticmethod - def values() -> typing.MutableSequence['LogicState']: ... + def values() -> typing.MutableSequence["LogicState"]: ... class ProcessLogic: def activate(self) -> None: ... @@ -58,12 +60,13 @@ class ProcessLogic: 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/action/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/action/__init__.pyi index 7a84e6ab..ada8b6dd 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/action/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/action/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,17 +14,19 @@ 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 __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 __init__( + self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve + ): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... def getTargetName(self) -> java.lang.String: ... @@ -32,9 +34,20 @@ class CloseValveAction(jneqsim.process.logic.LogicAction): 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]): ... + 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 __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: ... @@ -50,14 +63,18 @@ 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 __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 __init__( + self, throttlingValve: jneqsim.process.equipment.valve.ThrottlingValve + ): ... def execute(self) -> None: ... def getDescription(self) -> java.lang.String: ... def getTargetName(self) -> java.lang.String: ... @@ -77,7 +94,9 @@ class ParallelActionGroup(jneqsim.process.logic.LogicAction): def toString(self) -> java.lang.String: ... class SetSeparatorModeAction(jneqsim.process.logic.LogicAction): - def __init__(self, separator: jneqsim.process.equipment.separator.Separator, boolean: bool): ... + 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: ... @@ -85,14 +104,22 @@ class SetSeparatorModeAction(jneqsim.process.logic.LogicAction): 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 __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 __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: ... @@ -106,7 +133,6 @@ class TripValveAction(jneqsim.process.logic.LogicAction): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/condition/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/condition/__init__.pyi index dca059fb..8104f6d8 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/condition/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/condition/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,29 +11,53 @@ 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]): ... + 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 __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: ... + 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]): ... + 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 __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: ... + def getTargetEquipment( + self, + ) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... class TimerCondition(jneqsim.process.logic.LogicCondition): def __init__(self, double: float): ... @@ -43,22 +67,36 @@ class TimerCondition(jneqsim.process.logic.LogicCondition): def getElapsed(self) -> float: ... def getExpectedValue(self) -> java.lang.String: ... def getRemaining(self) -> float: ... - def getTargetEquipment(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + 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): ... + 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 __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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/control/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/control/__init__.pyi index ae104c9f..6e537f2b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/control/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/control/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,13 +13,22 @@ 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): ... + 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 __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: ... @@ -27,14 +36,15 @@ class PressureControlLogic(jneqsim.process.logic.ProcessLogic): 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/esd/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/esd/__init__.pyi index 7fa79b3f..84e19821 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/esd/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/esd/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,12 +11,12 @@ 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 addAction( + self, logicAction: jneqsim.process.logic.LogicAction, double: float + ) -> None: ... def deactivate(self) -> None: ... def execute(self, double: float) -> None: ... def getActionCount(self) -> int: ... @@ -25,12 +25,13 @@ class ESDLogic(jneqsim.process.logic.ProcessLogic): 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/hipps/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/hipps/__init__.pyi index d50527b0..fe604bcb 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/hipps/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/hipps/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,33 +13,42 @@ 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 __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 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 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 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/shutdown/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/shutdown/__init__.pyi index 94e4628f..f8683cc1 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/shutdown/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/shutdown/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,12 +11,12 @@ 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 addAction( + self, logicAction: jneqsim.process.logic.LogicAction, double: float + ) -> None: ... def deactivate(self) -> None: ... def execute(self, double: float) -> None: ... def getActionCount(self) -> int: ... @@ -28,7 +28,9 @@ class ShutdownLogic(jneqsim.process.logic.ProcessLogic): 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 getTargetEquipment( + self, + ) -> java.util.List[jneqsim.process.equipment.ProcessEquipmentInterface]: ... def isActive(self) -> bool: ... def isComplete(self) -> bool: ... def isEmergencyMode(self) -> bool: ... @@ -37,7 +39,6 @@ class ShutdownLogic(jneqsim.process.logic.ProcessLogic): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/sis/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/sis/__init__.pyi index a443ae77..1abe5720 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/sis/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/sis/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,16 +11,21 @@ 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 __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 getType(self) -> "Detector.DetectorType": ... def isBypassed(self) -> bool: ... def isFaulty(self) -> bool: ... def isTripped(self) -> bool: ... @@ -31,41 +36,55 @@ class Detector: 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'] = ... + + 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) # + _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: ... + 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': ... + 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 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) # + _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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "Detector.DetectorType": ... @staticmethod - def values() -> typing.MutableSequence['Detector.DetectorType']: ... + 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 __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: ... @@ -75,8 +94,10 @@ class SafetyInstrumentedFunction(jneqsim.process.logic.ProcessLogic): 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 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: ... @@ -88,28 +109,29 @@ class SafetyInstrumentedFunction(jneqsim.process.logic.ProcessLogic): 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'] = ... +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) # + _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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "VotingLogic": ... @staticmethod - def values() -> typing.MutableSequence['VotingLogic']: ... - + def values() -> typing.MutableSequence["VotingLogic"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.sis")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/startup/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/startup/__init__.pyi index ecd33252..405f727a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/startup/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/startup/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,30 +11,35 @@ 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 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 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/logic/voting/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/logic/voting/__init__.pyi index 507ad254..8b858f6f 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/logic/voting/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/logic/voting/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,11 +8,10 @@ else: import java.lang import typing +_VotingEvaluator__T = typing.TypeVar("_VotingEvaluator__T") # - -_VotingEvaluator__T = typing.TypeVar('_VotingEvaluator__T') # class VotingEvaluator(typing.Generic[_VotingEvaluator__T]): - def __init__(self, votingPattern: 'VotingPattern'): ... + def __init__(self, votingPattern: "VotingPattern"): ... def addInput(self, t: _VotingEvaluator__T, boolean: bool) -> None: ... def clearInputs(self) -> None: ... def evaluateAverage(self) -> float: ... @@ -20,32 +19,33 @@ class VotingEvaluator(typing.Generic[_VotingEvaluator__T]): def evaluateMedian(self) -> float: ... def evaluateMidValue(self) -> float: ... def getFaultyInputCount(self) -> int: ... - def getPattern(self) -> 'VotingPattern': ... + 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'] = ... +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) # + _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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "VotingPattern": ... @staticmethod - def values() -> typing.MutableSequence['VotingPattern']: ... - + def values() -> typing.MutableSequence["VotingPattern"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.logic.voting")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/__init__.pyi index 3b68adc8..488a40ff 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -20,40 +20,54 @@ 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 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: ... + 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 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 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]): ... +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 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: ... @@ -64,46 +78,73 @@ class MeasurementDeviceBaseClass(jneqsim.util.NamedBaseClass, MeasurementDeviceI @typing.overload def getMeasuredValue(self) -> float: ... @typing.overload - def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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 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 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 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 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): ... + 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: ... + 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 __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: ... @@ -112,7 +153,9 @@ class FireDetector(MeasurementDeviceBaseClass): @typing.overload def getMeasuredValue(self) -> float: ... @typing.overload - def getMeasuredValue(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getMeasuredValue( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getSignalLevel(self) -> float: ... def isFireDetected(self) -> bool: ... def reset(self) -> None: ... @@ -124,40 +167,61 @@ class FireDetector(MeasurementDeviceBaseClass): class FlowInducedVibrationAnalyser(MeasurementDeviceBaseClass): @typing.overload - def __init__(self, string: typing.Union[java.lang.String, str], pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills): ... + 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 __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 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 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 __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 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 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: ... @@ -168,59 +232,90 @@ class GasDetector(MeasurementDeviceBaseClass): 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'] = ... + + 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) # + _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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "GasDetector.GasType": ... @staticmethod - def values() -> typing.MutableSequence['GasDetector.GasType']: ... + 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): ... + 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: ... + 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): ... + 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 __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 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 __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 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 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 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: ... @@ -228,66 +323,123 @@ class PushButton(MeasurementDeviceBaseClass): 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 __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: ... + 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): ... + 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 __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 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): ... + 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 __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: ... + 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 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): ... + 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 __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: ... + 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 __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 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): ... + 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 __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 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: ... @@ -295,98 +447,172 @@ class HydrocarbonDewPointAnalyser(StreamMeasurementDeviceBaseClass): class MolarMassAnalyser(StreamMeasurementDeviceBaseClass): @typing.overload - def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + 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 __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 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): ... + 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 __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 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 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: ... + 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): ... + 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 __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: ... + 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): ... + 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 __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 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): ... + 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 __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 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): ... + 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 __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 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): ... + 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 __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 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): ... + 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 __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 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: ... @@ -394,32 +620,55 @@ class WaterDewPointAnalyser(StreamMeasurementDeviceBaseClass): class WellAllocator(StreamMeasurementDeviceBaseClass): @typing.overload - def __init__(self, string: typing.Union[java.lang.String, str], streamInterface: jneqsim.process.equipment.stream.StreamInterface): ... + 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 __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: ... + 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): ... + 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 __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 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")``. @@ -429,7 +678,9 @@ class __module_protocol__(Protocol): FireDetector: typing.Type[FireDetector] FlowInducedVibrationAnalyser: typing.Type[FlowInducedVibrationAnalyser] GasDetector: typing.Type[GasDetector] - HydrateEquilibriumTemperatureAnalyser: typing.Type[HydrateEquilibriumTemperatureAnalyser] + HydrateEquilibriumTemperatureAnalyser: typing.Type[ + HydrateEquilibriumTemperatureAnalyser + ] HydrocarbonDewPointAnalyser: typing.Type[HydrocarbonDewPointAnalyser] LevelTransmitter: typing.Type[LevelTransmitter] MeasurementDeviceBaseClass: typing.Type[MeasurementDeviceBaseClass] @@ -449,4 +700,6 @@ class __module_protocol__(Protocol): WellAllocator: typing.Type[WellAllocator] pHProbe: typing.Type[pHProbe] online: jneqsim.process.measurementdevice.online.__module_protocol__ - simpleflowregime: jneqsim.process.measurementdevice.simpleflowregime.__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 index 70182b12..c7277908 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/online/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/online/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,17 +10,18 @@ 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/simpleflowregime/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/simpleflowregime/__init__.pyi index be5923a5..fa9c7832 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/simpleflowregime/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/measurementdevice/simpleflowregime/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,8 +12,6 @@ import jneqsim.process.measurementdevice import jneqsim.thermo.system import typing - - class FluidSevereSlug: def getGasConstant(self) -> float: ... def getLiqDensity(self) -> float: ... @@ -40,49 +38,127 @@ class SevereSlugAnalyser(jneqsim.process.measurementdevice.MeasurementDeviceBase @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): ... + 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): ... + 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): ... + 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): ... + 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): ... + 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 __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: ... + def getMeasuredValue( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload - def getMeasuredValue(self, fluidSevereSlug: FluidSevereSlug, pipe: Pipe, severeSlugAnalyser: 'SevereSlugAnalyser') -> float: ... + 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 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/__init__.pyi index 59004555..5da6e0a1 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -23,12 +23,10 @@ import jneqsim.process.mechanicaldesign.valve import jneqsim.process.processmodel import typing - - class DesignLimitData(java.io.Serializable): - EMPTY: typing.ClassVar['DesignLimitData'] = ... + EMPTY: typing.ClassVar["DesignLimitData"] = ... @staticmethod - def builder() -> 'DesignLimitData.Builder': ... + def builder() -> "DesignLimitData.Builder": ... def equals(self, object: typing.Any) -> bool: ... def getCorrosionAllowance(self) -> float: ... def getJointEfficiency(self) -> float: ... @@ -38,14 +36,15 @@ class DesignLimitData(java.io.Serializable): 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': ... + 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 = ... @@ -76,31 +75,59 @@ class MechanicalDesign(java.io.Serializable): 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 __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 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 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 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 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: ... @@ -121,7 +148,9 @@ class MechanicalDesign(java.io.Serializable): def getModuleWidth(self) -> float: ... def getOuterDiameter(self) -> float: ... def getPressureMarginFactor(self) -> float: ... - def getProcessEquipment(self) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... + def getProcessEquipment( + self, + ) -> jneqsim.process.equipment.ProcessEquipmentInterface: ... def getTantanLength(self) -> float: ... def getTensileStrength(self) -> float: ... def getVolumeTotal(self) -> float: ... @@ -138,20 +167,50 @@ class MechanicalDesign(java.io.Serializable): 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 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 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 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: ... @@ -173,7 +232,10 @@ class MechanicalDesign(java.io.Serializable): 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 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: ... @@ -186,13 +248,29 @@ class MechanicalDesign(java.io.Serializable): def setWeigthInternals(self, double: float) -> None: ... def setWeigthVesselShell(self, double: float) -> None: ... @typing.overload - def validateOperatingEnvelope(self) -> 'MechanicalDesignMarginResult': ... + def validateOperatingEnvelope(self) -> "MechanicalDesignMarginResult": ... @typing.overload - def validateOperatingEnvelope(self, double: float, double2: float, double3: float, double4: float, double5: float, double6: float) -> 'MechanicalDesignMarginResult': ... + 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): ... + 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: ... @@ -207,7 +285,9 @@ class MechanicalDesignMarginResult(java.io.Serializable): 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 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: ... @@ -215,10 +295,11 @@ class SystemMechanicalDesign(java.io.Serializable): def getTotalWeight(self) -> float: ... def hashCode(self) -> int: ... def runDesignCalculation(self) -> None: ... - def setCompanySpecificDesignStandards(self, string: typing.Union[java.lang.String, str]) -> 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")``. @@ -230,7 +311,9 @@ class __module_protocol__(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__ + 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__ diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/absorber/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/absorber/__init__.pyi index 79c9eb65..c55e67c9 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/absorber/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/absorber/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,10 +9,13 @@ 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): ... +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: ... @@ -21,7 +24,6 @@ class AbsorberMechanicalDesign(jneqsim.process.mechanicaldesign.separator.Separa 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/adsorber/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/adsorber/__init__.pyi index 9e19863e..47115cd4 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/adsorber/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/adsorber/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,10 +9,11 @@ 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 __init__( + self, + processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, + ): ... def calcDesign(self) -> None: ... def getOuterDiameter(self) -> float: ... def getWallThickness(self) -> float: ... @@ -21,7 +22,6 @@ class AdsorberMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/compressor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/compressor/__init__.pyi index a3a481ca..613cc70f 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/compressor/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/compressor/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,10 +9,11 @@ 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 __init__( + self, + processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, + ): ... def calcDesign(self) -> None: ... def displayResults(self) -> None: ... def getOuterDiameter(self) -> float: ... @@ -22,7 +23,6 @@ class CompressorMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesi 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/data/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/data/__init__.pyi index 1ac7ea03..751cf9a8 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/data/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/data/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,19 +12,30 @@ 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]: ... + 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]: ... + 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]: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/designstandards/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/designstandards/__init__.pyi index 964e8746..b1d225cf 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/designstandards/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/designstandards/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,66 +10,114 @@ 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 __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 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 __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 __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 __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 __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 __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 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 __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 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 __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 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: ... @@ -79,45 +127,86 @@ 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 __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 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 __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: ... + 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): ... + 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 __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: ... + 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 __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 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 __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] + AdsorptionDehydrationDesignStandard: typing.Type[ + AdsorptionDehydrationDesignStandard + ] CompressorDesignStandard: typing.Type[CompressorDesignStandard] DesignStandard: typing.Type[DesignStandard] GasScrubberDesignStandard: typing.Type[GasScrubberDesignStandard] diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/ejector/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/ejector/__init__.pyi index 19202819..f79de0eb 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/ejector/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/ejector/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,10 +9,11 @@ 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 __init__( + self, + processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface, + ): ... def getBodyVolume(self) -> float: ... def getConnectedPipingVolume(self) -> float: ... def getDiffuserOutletArea(self) -> float: ... @@ -37,8 +38,27 @@ class EjectorMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign) 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/heatexchanger/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/heatexchanger/__init__.pyi index d42124de..4f6431ac 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/heatexchanger/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/heatexchanger/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,52 +12,75 @@ 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 __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 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 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: ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "HeatExchangerMechanicalDesign.SelectionCriterion": ... @staticmethod - def values() -> typing.MutableSequence['HeatExchangerMechanicalDesign.SelectionCriterion']: ... + def values() -> ( + typing.MutableSequence["HeatExchangerMechanicalDesign.SelectionCriterion"] + ): ... class HeatExchangerSizingResult: @staticmethod - def builder() -> 'HeatExchangerSizingResult.Builder': ... + 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 getMetric( + self, selectionCriterion: HeatExchangerMechanicalDesign.SelectionCriterion + ) -> float: ... def getModuleHeight(self) -> float: ... def getModuleLength(self) -> float: ... def getModuleWidth(self) -> float: ... @@ -67,48 +90,82 @@ class HeatExchangerSizingResult: def getRequiredUA(self) -> float: ... def getTubeCount(self) -> int: ... def getTubePasses(self) -> int: ... - def getType(self) -> 'HeatExchangerType': ... + 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': ... + 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: ... +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) # + _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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "HeatExchangerType": ... @staticmethod - def values() -> typing.MutableSequence['HeatExchangerType']: ... - + def values() -> typing.MutableSequence["HeatExchangerType"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.mechanicaldesign.heatexchanger")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/pipeline/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/pipeline/__init__.pyi index 2d02ff25..e5114a44 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/pipeline/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/pipeline/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,8 +12,6 @@ import jneqsim.process.equipment import jneqsim.process.mechanicaldesign import typing - - class PipeDesign: NPS5: typing.ClassVar[typing.MutableSequence[float]] = ... S5i: typing.ClassVar[typing.MutableSequence[float]] = ... @@ -88,34 +86,63 @@ class PipeDesign: @staticmethod def erosionalVelocity(double: float, double2: float) -> float: ... @staticmethod - def gaugeFromThickness(double: float, boolean: bool, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... + 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]: ... + 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: ... + 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]): ... + 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): ... + 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 __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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/__init__.pyi index f85d2fc4..017da93f 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,25 +10,30 @@ 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 __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 __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__ + 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 index e976dd2c..6be9fe19 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/sectiontype/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/separator/sectiontype/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,14 +9,15 @@ 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 __init__( + self, + separatorSection: jneqsim.process.equipment.separator.sectiontype.SeparatorSection, + ): ... def calcDesign(self) -> None: ... def getANSIclass(self) -> int: ... def getNominalSize(self) -> java.lang.String: ... @@ -28,26 +29,40 @@ class SepDesignSection: def setTotalWeight(self, double: float) -> None: ... class DistillationTraySection(SepDesignSection): - def __init__(self, separatorSection: jneqsim.process.equipment.separator.sectiontype.SeparatorSection): ... + 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 __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 __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 __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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/valve/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/valve/__init__.pyi index e13a5725..6677b070 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/valve/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/mechanicaldesign/valve/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,13 +14,28 @@ 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 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: ... @@ -31,7 +46,10 @@ class ValveCharacteristic(java.io.Serializable): def getOpeningFactor(self, double: float) -> float: ... class ValveMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign): - def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + 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: ... @@ -40,9 +58,15 @@ class ValveMechanicalDesign(jneqsim.process.mechanicaldesign.MechanicalDesign): 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: ... + 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 @@ -50,12 +74,38 @@ class ControlValveSizing(ControlValveSizingInterface, java.io.Serializable): @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 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: ... @@ -68,29 +118,59 @@ class LinearCharacteristic(ValveCharacteristic): def getOpeningFactor(self, double: float) -> float: ... class SafetyValveMechanicalDesign(ValveMechanicalDesign): - def __init__(self, processEquipmentInterface: jneqsim.process.equipment.ProcessEquipmentInterface): ... + 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 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']: ... + 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 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 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 getFluidService( + self, + ) -> jneqsim.process.equipment.valve.SafetyValve.FluidService: ... def getOverpressureMarginBar(self) -> float: ... def getOverpressureMarginPa(self) -> float: ... def getRelievingPressureBar(self) -> float: ... @@ -99,7 +179,9 @@ class SafetyValveMechanicalDesign(ValveMechanicalDesign): def getScenarioName(self) -> java.lang.String: ... def getSetPressureBar(self) -> float: ... def getSetPressurePa(self) -> float: ... - def getSizingStandard(self) -> jneqsim.process.equipment.valve.SafetyValve.SizingStandard: ... + def getSizingStandard( + self, + ) -> jneqsim.process.equipment.valve.SafetyValve.SizingStandard: ... def isActiveScenario(self) -> bool: ... def isControllingScenario(self) -> bool: ... @@ -108,34 +190,147 @@ class ControlValveSizing_IEC_60534(ControlValveSizing): def __init__(self): ... @typing.overload def __init__(self, valveMechanicalDesign: ValveMechanicalDesign): ... - def calcValveSize(self, double: float) -> java.util.Map[java.lang.String, typing.Any]: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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 findOutletPressureForFixedKvLiquid( + self, + double: float, + streamInterface: jneqsim.process.equipment.stream.StreamInterface, + ) -> float: ... def getD(self) -> float: ... def getD1(self) -> float: ... def getD2(self) -> float: ... @@ -153,21 +348,69 @@ class ControlValveSizing_IEC_60534(ControlValveSizing): 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "ControlValveSizing_IEC_60534.FluidType": ... @staticmethod - def values() -> typing.MutableSequence['ControlValveSizing_IEC_60534.FluidType']: ... + def values() -> ( + typing.MutableSequence["ControlValveSizing_IEC_60534.FluidType"] + ): ... class ControlValveSizing_simple(ControlValveSizing): @typing.overload @@ -176,36 +419,118 @@ class ControlValveSizing_simple(ControlValveSizing): 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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 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]: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/__init__.pyi index 12f32cb4..07c277da 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -25,8 +25,6 @@ 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] = ... @@ -47,7 +45,14 @@ class DexpiMetadata: 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 __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: ... @@ -59,14 +64,24 @@ class DexpiProcessUnit(jneqsim.process.equipment.ProcessEquipmentBaseClass): class DexpiRoundTripProfile: @staticmethod - def minimalRunnableProfile() -> 'DexpiRoundTripProfile': ... - def validate(self, processSystem: 'ProcessSystem') -> 'DexpiRoundTripProfile.ValidationResult': ... + 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 __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: ... @@ -74,48 +89,84 @@ class DexpiStream(jneqsim.process.equipment.stream.Stream): class DexpiXmlReader: @typing.overload @staticmethod - def load(file: typing.Union[java.io.File, jpype.protocol.SupportsPath], processSystem: 'ProcessSystem') -> None: ... + 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: ... + 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: ... + 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: ... + 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': ... + 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': ... + 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': ... + def read(inputStream: java.io.InputStream) -> "ProcessSystem": ... @typing.overload @staticmethod - def read(inputStream: java.io.InputStream, stream: jneqsim.process.equipment.stream.Stream) -> 'ProcessSystem': ... + 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): ... + 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: ... + 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: ... + 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 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 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: ... @@ -123,46 +174,90 @@ class ModuleInterface(jneqsim.process.equipment.ProcessEquipmentInterface): 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: ... + 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: ... + 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: ... + 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: ... + 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']]: ... + 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: ... + 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 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: ... @@ -177,27 +272,41 @@ class ProcessModel(java.lang.Runnable): class ProcessModule(jneqsim.process.SimulationBaseClass): def __init__(self, string: typing.Union[java.lang.String, str]): ... @typing.overload - def add(self, processModule: 'ProcessModule') -> None: ... + def add(self, processModule: "ProcessModule") -> None: ... @typing.overload - def add(self, processSystem: 'ProcessSystem') -> None: ... + def add(self, processSystem: "ProcessSystem") -> None: ... @typing.overload - def checkMassBalance(self) -> java.util.Map[java.lang.String, 'ProcessSystem.MassBalanceResult']: ... + 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 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 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( + 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: ... @@ -219,75 +328,149 @@ class ProcessSystem(jneqsim.process.SimulationBaseClass): @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) # + 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 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 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 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 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 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']: ... + 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']: ... + 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 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 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 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 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: ... @@ -298,21 +481,37 @@ class ProcessSystem(jneqsim.process.SimulationBaseClass): @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 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 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: ... + 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 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 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 reportResults( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... def reset(self) -> None: ... @typing.overload def run(self) -> None: ... @@ -332,9 +531,18 @@ class ProcessSystem(jneqsim.process.SimulationBaseClass): 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 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: ... @@ -346,8 +554,14 @@ class ProcessSystem(jneqsim.process.SimulationBaseClass): 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 __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: ... @@ -356,17 +570,29 @@ class ProcessSystem(jneqsim.process.SimulationBaseClass): class ProcessSystemGraphvizExporter: def __init__(self): ... @typing.overload - def export(self, processSystem: ProcessSystem, string: typing.Union[java.lang.String, str]) -> None: ... + 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: ... + def export( + self, + processSystem: ProcessSystem, + string: typing.Union[java.lang.String, str], + graphvizExportOptions: "ProcessSystemGraphvizExporter.GraphvizExportOptions", + ) -> None: ... + class GraphvizExportOptions: @staticmethod - def builder() -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder': ... + def builder() -> ( + "ProcessSystemGraphvizExporter.GraphvizExportOptions.Builder" + ): ... @staticmethod - def defaults() -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions': ... + def defaults() -> "ProcessSystemGraphvizExporter.GraphvizExportOptions": ... def getFlowRateUnit(self) -> java.lang.String: ... def getPressureUnit(self) -> java.lang.String: ... - def getTablePlacement(self) -> 'ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement': ... + def getTablePlacement( + self, + ) -> "ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement": ... def getTemperatureUnit(self) -> java.lang.String: ... def includeStreamFlowRates(self) -> bool: ... def includeStreamPressures(self) -> bool: ... @@ -375,31 +601,77 @@ class ProcessSystemGraphvizExporter: 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> ( + "ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement" + ): ... @staticmethod - def values() -> typing.MutableSequence['ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement']: ... + def values() -> ( + typing.MutableSequence[ + "ProcessSystemGraphvizExporter.GraphvizExportOptions.TablePlacement" + ] + ): ... class XmlUtil: @staticmethod @@ -410,17 +682,25 @@ class ProcessModuleBaseClass(jneqsim.process.SimulationBaseClass, ModuleInterfac 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: ... + 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: ... + 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 getMechanicalDesign( + self, + ) -> jneqsim.process.mechanicaldesign.MechanicalDesign: ... def getOperations(self) -> ProcessSystem: ... def getPreferedThermodynamicModel(self) -> java.lang.String: ... @typing.overload @@ -428,7 +708,9 @@ class ProcessModuleBaseClass(jneqsim.process.SimulationBaseClass, ModuleInterfac @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 getResultTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... def getSpecification(self) -> java.lang.String: ... @typing.overload def getTemperature(self) -> float: ... @@ -437,8 +719,13 @@ class ProcessModuleBaseClass(jneqsim.process.SimulationBaseClass, ModuleInterfac 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: ... + 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 @@ -447,28 +734,43 @@ class ProcessModuleBaseClass(jneqsim.process.SimulationBaseClass, ModuleInterfac 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 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 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: ... + 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 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 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: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/processmodules/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/processmodules/__init__.pyi index e087cba1..ccbf1aae 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/processmodules/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/processmodel/processmodules/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,18 +13,26 @@ 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 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -33,13 +41,21 @@ class AdsorptionDehydrationlModule(jneqsim.process.processmodel.ProcessModuleBas @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 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 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 getOutputStream( + self, string: typing.Union[java.lang.String, str] + ) -> jneqsim.process.equipment.stream.StreamInterface: ... def initializeModule(self) -> None: ... def initializeStreams(self) -> None: ... @typing.overload @@ -50,14 +66,22 @@ class CO2RemovalModule(jneqsim.process.processmodel.ProcessModuleBaseClass): 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 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -66,21 +90,31 @@ class DPCUModule(jneqsim.process.processmodel.ProcessModuleBaseClass): @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 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 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -88,20 +122,35 @@ class GlycolDehydrationlModule(jneqsim.process.processmodel.ProcessModuleBaseCla 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: ... + 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 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 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -111,13 +160,21 @@ class MEGReclaimerModule(jneqsim.process.processmodel.ProcessModuleBaseClass): 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 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -126,17 +183,27 @@ class MixerGasProcessingModule(jneqsim.process.processmodel.ProcessModuleBaseCla @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 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 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -146,18 +213,28 @@ class PropaneCoolingModule(jneqsim.process.processmodel.ProcessModuleBaseClass): @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 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 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -166,17 +243,27 @@ class SeparationTrainModule(jneqsim.process.processmodel.ProcessModuleBaseClass) @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 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 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -185,17 +272,27 @@ class SeparationTrainModuleSimple(jneqsim.process.processmodel.ProcessModuleBase @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 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 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... @typing.overload def run(self) -> None: ... @typing.overload @@ -204,8 +301,9 @@ class WellFluidModule(jneqsim.process.processmodel.ProcessModuleBaseClass): @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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/safety/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/safety/__init__.pyi index ce1965cb..3231df15 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/safety/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/safety/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -15,21 +15,57 @@ 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: ... + 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 __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 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']: ... + 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: ... @@ -42,23 +78,51 @@ class ProcessSafetyAnalyzer(java.io.Serializable): @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: ... + 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]: ... + 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: ... + 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: ... + 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 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']: ... + 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: ... @@ -67,27 +131,73 @@ class ProcessSafetyLoadCase(java.io.Serializable): class ProcessSafetyResultRepository: def findAll(self) -> java.util.List[ProcessSafetyAnalysisSummary]: ... - def save(self, processSafetyAnalysisSummary: ProcessSafetyAnalysisSummary) -> None: ... + def save( + self, processSafetyAnalysisSummary: ProcessSafetyAnalysisSummary + ) -> None: ... class ProcessSafetyScenario(java.io.Serializable): - def applyTo(self, processSystem: jneqsim.process.processmodel.ProcessSystem) -> None: ... + def applyTo( + self, processSystem: jneqsim.process.processmodel.ProcessSystem + ) -> None: ... @staticmethod - def builder(string: typing.Union[java.lang.String, str]) -> 'ProcessSafetyScenario.Builder': ... + 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 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/safety/dto/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/safety/dto/__init__.pyi index 27f08fba..1f3c1c1b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/safety/dto/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/safety/dto/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,30 +11,58 @@ 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 __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 __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 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/__init__.pyi index 501df3fc..a1e1128e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/util/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,7 +14,6 @@ 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/example/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/example/__init__.pyi index 82737301..2d50ac60 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/util/example/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/example/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,88 +9,117 @@ 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... - + 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")``. @@ -105,9 +134,13 @@ class __module_protocol__(Protocol): HIPPSExample: typing.Type[HIPPSExample] HIPPSWithESDExample: typing.Type[HIPPSWithESDExample] IntegratedSafetySystemExample: typing.Type[IntegratedSafetySystemExample] - IntegratedSafetySystemWithLogicExample: typing.Type[IntegratedSafetySystemWithLogicExample] + IntegratedSafetySystemWithLogicExample: typing.Type[ + IntegratedSafetySystemWithLogicExample + ] ProcessLogicAlarmIntegratedExample: typing.Type[ProcessLogicAlarmIntegratedExample] ProcessLogicIntegratedExample: typing.Type[ProcessLogicIntegratedExample] SelectiveLogicExecutionExample: typing.Type[SelectiveLogicExecutionExample] - SeparatorFireDepressurizationExample: typing.Type[SeparatorFireDepressurizationExample] + 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 index 442c8db3..1d2a7fd4 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/util/fielddevelopment/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/fielddevelopment/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,41 +16,112 @@ 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 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 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 __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 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 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 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 __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 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: ... @@ -58,9 +129,29 @@ class FacilityCapacity(java.io.Serializable): 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: ... + + 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: ... @@ -82,55 +173,128 @@ class ProductionProfile(java.io.Serializable): @typing.overload def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... @staticmethod - def calculateCumulativeProduction(declineParameters: 'ProductionProfile.DeclineParameters', double: float) -> float: ... + 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 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]): ... + 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]): ... + 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 __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 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "ProductionProfile.DeclineType": ... @staticmethod - def values() -> typing.MutableSequence['ProductionProfile.DeclineType']: ... + 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 __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 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 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 __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: ... @@ -146,34 +310,117 @@ class SensitivityAnalysis(java.io.Serializable): @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 __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 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "SensitivityAnalysis.DistributionType": ... @staticmethod - def values() -> typing.MutableSequence['SensitivityAnalysis.DistributionType']: ... + 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 __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 getHistogramData( + self, int: int + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... def getMax(self) -> float: ... def getMean(self) -> float: ... def getMin(self) -> float: ... @@ -186,41 +433,88 @@ class SensitivityAnalysis(java.io.Serializable): 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 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 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': ... + 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: ... + + 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 __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: ... @@ -228,40 +522,129 @@ class SensitivityAnalysis(java.io.Serializable): 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': ... + 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 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': ... + 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': ... + 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': ... + 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 __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']): + 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 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: ... @@ -270,88 +653,160 @@ class WellScheduler(java.io.Serializable): def getExpectedProductionGain(self) -> float: ... def getPriority(self) -> int: ... def getStartDate(self) -> java.time.LocalDate: ... - def getType(self) -> 'WellScheduler.InterventionType': ... + 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 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 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) # + _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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "WellScheduler.InterventionType": ... @staticmethod - def values() -> typing.MutableSequence['WellScheduler.InterventionType']: ... + 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 __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 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 __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 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 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 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 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) # + _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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "WellScheduler.WellStatus": ... @staticmethod - def values() -> typing.MutableSequence['WellScheduler.WellStatus']: ... - + def values() -> typing.MutableSequence["WellScheduler.WellStatus"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.fielddevelopment")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/fire/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/fire/__init__.pyi index 0e509a64..e8445bd7 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/util/fire/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/fire/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,18 +9,26 @@ 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: ... + 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': ... + 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: ... @@ -29,15 +37,43 @@ class FireHeatTransferCalculator: class SeparatorFireExposure: @staticmethod - def applyFireHeating(separator: jneqsim.process.equipment.separator.Separator, fireExposureResult: 'SeparatorFireExposure.FireExposureResult', double: float) -> float: ... + 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': ... + 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': ... + 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 __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: ... @@ -47,10 +83,13 @@ class SeparatorFireExposure: def totalFireHeat(self) -> float: ... def unwettedArea(self) -> float: ... def unwettedRadiativeHeat(self) -> float: ... - def unwettedWall(self) -> FireHeatTransferCalculator.SurfaceTemperatureResult: ... + 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: ... @@ -58,16 +97,36 @@ class SeparatorFireExposure: 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 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: ... @@ -82,7 +141,6 @@ class VesselRuptureCalculator: @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/monitor/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/monitor/__init__.pyi index 55d30d86..97a7d773 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/util/monitor/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/monitor/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -28,18 +28,24 @@ 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): ... + 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: ... + def __init__( + self, + measurementDeviceInterface: jneqsim.process.measurementdevice.MeasurementDeviceInterface, + ): ... + def applyConfig( + self, reportConfig: jneqsim.process.util.report.ReportConfig + ) -> None: ... class FluidComponentResponse: name: java.lang.String = ... @@ -47,7 +53,11 @@ class FluidComponentResponse: @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): ... + 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: ... @@ -60,14 +70,20 @@ class FluidResponse: @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): ... + 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 addScenario( + self, string: typing.Union[java.lang.String, str], scenarioKPI: "ScenarioKPI" + ) -> None: ... def clear(self) -> None: ... def getScenarioCount(self) -> int: ... def printDashboard(self) -> None: ... @@ -75,7 +91,7 @@ class KPIDashboard: class ScenarioKPI: def __init__(self): ... @staticmethod - def builder() -> 'ScenarioKPI.Builder': ... + def builder() -> "ScenarioKPI.Builder": ... def calculateEnvironmentalScore(self) -> float: ... def calculateOverallScore(self) -> float: ... def calculateProcessScore(self) -> float: ... @@ -102,45 +118,56 @@ class ScenarioKPI: 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': ... + 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]): ... + 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): ... + def __init__( + self, wellAllocator: jneqsim.process.measurementdevice.WellAllocator + ): ... class ComponentSplitterResponse(BaseResponse): data: java.util.HashMap = ... - def __init__(self, componentSplitter: jneqsim.process.equipment.splitter.ComponentSplitter): ... + def __init__( + self, componentSplitter: jneqsim.process.equipment.splitter.ComponentSplitter + ): ... class CompressorResponse(BaseResponse): suctionTemperature: float = ... @@ -163,7 +190,9 @@ class CompressorResponse(BaseResponse): def __init__(self): ... @typing.overload def __init__(self, compressor: jneqsim.process.equipment.compressor.Compressor): ... - def applyConfig(self, reportConfig: jneqsim.process.util.report.ReportConfig) -> None: ... + def applyConfig( + self, reportConfig: jneqsim.process.util.report.ReportConfig + ) -> None: ... class DistillationColumnResponse(BaseResponse): massBalanceError: float = ... @@ -174,11 +203,16 @@ class DistillationColumnResponse(BaseResponse): trayLiquidFlowRate: typing.MutableSequence[float] = ... trayFeedFlow: typing.MutableSequence[float] = ... trayMassBalance: typing.MutableSequence[float] = ... - def __init__(self, distillationColumn: jneqsim.process.equipment.distillation.DistillationColumn): ... + 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): ... + def __init__( + self, furnaceBurner: jneqsim.process.equipment.reactor.FurnaceBurner + ): ... class HXResponse(BaseResponse): feedTemperature1: float = ... @@ -192,7 +226,9 @@ class HXResponse(BaseResponse): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, heatExchanger: jneqsim.process.equipment.heatexchanger.HeatExchanger): ... + def __init__( + self, heatExchanger: jneqsim.process.equipment.heatexchanger.HeatExchanger + ): ... class HeaterResponse(BaseResponse): data: java.util.HashMap = ... @@ -205,7 +241,9 @@ class MPMResponse(BaseResponse): gasDensity: float = ... oilDensity: float = ... waterDensity: float = ... - def __init__(self, multiPhaseMeter: jneqsim.process.measurementdevice.MultiPhaseMeter): ... + def __init__( + self, multiPhaseMeter: jneqsim.process.measurementdevice.MultiPhaseMeter + ): ... class ManifoldResponse(BaseResponse): data: java.util.HashMap = ... @@ -222,7 +260,10 @@ class MultiStreamHeatExchanger2Response(BaseResponse): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, multiStreamHeatExchanger2: jneqsim.process.equipment.heatexchanger.MultiStreamHeatExchanger2): ... + def __init__( + self, + multiStreamHeatExchanger2: jneqsim.process.equipment.heatexchanger.MultiStreamHeatExchanger2, + ): ... class MultiStreamHeatExchangerResponse(BaseResponse): data: java.util.HashMap = ... @@ -230,7 +271,10 @@ class MultiStreamHeatExchangerResponse(BaseResponse): dischargeTemperature: typing.MutableSequence[float] = ... duty: typing.MutableSequence[float] = ... flowRate: typing.MutableSequence[float] = ... - def __init__(self, multiStreamHeatExchanger: jneqsim.process.equipment.heatexchanger.MultiStreamHeatExchanger): ... + def __init__( + self, + multiStreamHeatExchanger: jneqsim.process.equipment.heatexchanger.MultiStreamHeatExchanger, + ): ... class PipeBeggsBrillsResponse(BaseResponse): inletPressure: float = ... @@ -243,7 +287,9 @@ class PipeBeggsBrillsResponse(BaseResponse): outletVolumeFlow: float = ... inletMassFlow: float = ... outletMassFlow: float = ... - def __init__(self, pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills): ... + def __init__( + self, pipeBeggsAndBrills: jneqsim.process.equipment.pipeline.PipeBeggsAndBrills + ): ... class PumpResponse(BaseResponse): data: java.util.HashMap = ... @@ -269,15 +315,18 @@ class RecycleResponse(BaseResponse): class SeparatorResponse(BaseResponse): gasLoadFactor: float = ... - feed: 'StreamResponse' = ... - gas: 'StreamResponse' = ... - liquid: 'StreamResponse' = ... - oil: 'StreamResponse' = ... - water: 'StreamResponse' = ... + 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): ... + def __init__( + self, + threePhaseSeparator: jneqsim.process.equipment.separator.ThreePhaseSeparator, + ): ... class SplitterResponse(BaseResponse): data: java.util.HashMap = ... @@ -287,8 +336,12 @@ 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 __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): @@ -303,17 +356,24 @@ class ThreePhaseSeparatorResponse(BaseResponse): @typing.overload def __init__(self, separator: jneqsim.process.equipment.separator.Separator): ... @typing.overload - def __init__(self, threePhaseSeparator: jneqsim.process.equipment.separator.ThreePhaseSeparator): ... + def __init__( + self, + threePhaseSeparator: jneqsim.process.equipment.separator.ThreePhaseSeparator, + ): ... class TurboExpanderCompressorResponse(BaseResponse): - def __init__(self, turboExpanderCompressor: jneqsim.process.equipment.expander.TurboExpanderCompressor): ... + 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/optimization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/optimization/__init__.pyi index a0c08531..9f602e0a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/util/optimization/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/optimization/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -15,111 +15,304 @@ 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']: ... + 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': ... + 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: ... + 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: ... + def formatUtilizationTable( + list: java.util.List["ProductionOptimizer.UtilizationRecord"], + ) -> java.lang.String: ... @staticmethod - def formatUtilizationTimeline(list: java.util.List['ProductionOptimizer.IterationRecord']) -> java.lang.String: ... + 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': ... + 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': ... + 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': ... + 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) # + 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: ... + 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': ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "ProductionOptimizer.ConstraintSeverity": ... @staticmethod - def values() -> typing.MutableSequence['ProductionOptimizer.ConstraintSeverity']: ... + 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 __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 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 __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 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 __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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "ProductionOptimizer.ObjectiveType": ... @staticmethod - def values() -> typing.MutableSequence['ProductionOptimizer.ObjectiveType']: ... + 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 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: ... @@ -130,54 +323,186 @@ class ProductionOptimizer: 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': ... + 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 __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': ... + 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: ... + 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: ... + 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): ... + 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 __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 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 __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 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 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 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 __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: ... @@ -185,73 +510,188 @@ class ProductionOptimizer: def getUtilization(self) -> float: ... def getUtilizationLimit(self) -> float: ... def getUtilizationMargin(self) -> float: ... - def getUtilizations(self) -> java.util.List['ProductionOptimizer.UtilizationRecord']: ... + 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 __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']: ... + 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 __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': ... + def objectiveValue( + string: typing.Union[java.lang.String, str] + ) -> "ProductionOptimizer.ScenarioKpi": ... @staticmethod - def optimalRate(string: typing.Union[java.lang.String, str]) -> 'ProductionOptimizer.ScenarioKpi': ... + def optimalRate( + string: typing.Union[java.lang.String, str] + ) -> "ProductionOptimizer.ScenarioKpi": ... @staticmethod - def score() -> 'ProductionOptimizer.ScenarioKpi': ... + 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']): ... + 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 __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 getObjectives( + self, + ) -> java.util.List["ProductionOptimizer.OptimizationObjective"]: ... def getProcess(self) -> jneqsim.process.processmodel.ProcessSystem: ... - def getVariables(self) -> java.util.List['ProductionOptimizer.ManipulatedVariable']: ... + def getVariables( + self, + ) -> java.util.List["ProductionOptimizer.ManipulatedVariable"]: ... + class ScenarioResult: - def __init__(self, string: typing.Union[java.lang.String, str], optimizationResult: 'ProductionOptimizer.OptimizationResult'): ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "ProductionOptimizer.SearchMode": ... @staticmethod - def values() -> typing.MutableSequence['ProductionOptimizer.SearchMode']: ... + 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 __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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/report/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/report/__init__.pyi index ab661a59..239eda83 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/util/report/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/report/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,17 +12,21 @@ import jneqsim.process.util.report.safety import jneqsim.thermo.system import typing - - class Report: @typing.overload - def __init__(self, processEquipmentBaseClass: jneqsim.process.equipment.ProcessEquipmentBaseClass): ... + 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): ... + def __init__( + self, + processModuleBaseClass: jneqsim.process.processmodel.ProcessModuleBaseClass, + ): ... @typing.overload def __init__(self, processSystem: jneqsim.process.processmodel.ProcessSystem): ... @typing.overload @@ -30,31 +34,42 @@ class Report: @typing.overload def generateJsonReport(self) -> java.lang.String: ... @typing.overload - def generateJsonReport(self, reportConfig: 'ReportConfig') -> java.lang.String: ... + def generateJsonReport(self, reportConfig: "ReportConfig") -> java.lang.String: ... class ReportConfig: - detailLevel: 'ReportConfig.DetailLevel' = ... + 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) # + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "ReportConfig.DetailLevel": ... @staticmethod - def values() -> typing.MutableSequence['ReportConfig.DetailLevel']: ... - + def values() -> typing.MutableSequence["ReportConfig.DetailLevel"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.report")``. 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 index d5f7220e..0116431c 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/util/report/safety/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/report/safety/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,61 +12,105 @@ import jneqsim.process.processmodel import jneqsim.process.util.report import typing - - class ProcessSafetyReport: - def getConditionFindings(self) -> java.util.List['ProcessSafetyReport.ConditionFinding']: ... + 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 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 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 __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 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 __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 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 __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 getSeverity(self) -> "SeverityLevel": ... def getUnitName(self) -> java.lang.String: ... + class SystemKpiSnapshot: - def __init__(self, double: float, double2: float, severityLevel: 'SeverityLevel', severityLevel2: 'SeverityLevel'): ... + def __init__( + self, + double: float, + double2: float, + severityLevel: "SeverityLevel", + severityLevel2: "SeverityLevel", + ): ... def getEntropyChangeKjPerK(self) -> float: ... - def getEntropySeverity(self) -> 'SeverityLevel': ... + def getEntropySeverity(self) -> "SeverityLevel": ... def getExergyChangeKj(self) -> float: ... - def getExergySeverity(self) -> 'SeverityLevel': ... + 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': ... + 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 __init__(self, processSafetyThresholds: "ProcessSafetyThresholds"): ... def getEntropyChangeCritical(self) -> float: ... def getEntropyChangeWarning(self) -> float: ... def getExergyChangeCritical(self) -> float: ... @@ -75,30 +119,37 @@ class ProcessSafetyThresholds: 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': ... + 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) # +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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "SeverityLevel": ... @staticmethod - def values() -> typing.MutableSequence['SeverityLevel']: ... - + def values() -> typing.MutableSequence["SeverityLevel"]: ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.process.util.report.safety")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/process/util/scenario/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/process/util/scenario/__init__.pyi index 542d6bb5..80bbb183 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/process/util/scenario/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/process/util/scenario/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,15 +13,17 @@ 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 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 @@ -31,18 +33,38 @@ class ProcessScenarioRunner: 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': ... + 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 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 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]: ... @@ -50,34 +72,79 @@ class ScenarioExecutionSummary: 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: ... + 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 __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 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: ... + 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 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/__init__.pyi index 4f6e72cb..aacc8c1d 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,7 +11,6 @@ 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/modeltuning/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/modeltuning/__init__.pyi index 8a5364a3..bbb209e9 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/modeltuning/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/modeltuning/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,8 +8,6 @@ else: import jneqsim.pvtsimulation.simulation import typing - - class TuningInterface: def getSimulation(self) -> jneqsim.pvtsimulation.simulation.SimulationInterface: ... def run(self) -> None: ... @@ -18,7 +16,9 @@ class TuningInterface: class BaseTuningClass(TuningInterface): saturationTemperature: float = ... saturationPressure: float = ... - def __init__(self, simulationInterface: jneqsim.pvtsimulation.simulation.SimulationInterface): ... + def __init__( + self, simulationInterface: jneqsim.pvtsimulation.simulation.SimulationInterface + ): ... def getSimulation(self) -> jneqsim.pvtsimulation.simulation.SimulationInterface: ... def isTunePlusMolarMass(self) -> bool: ... def isTuneVolumeCorrection(self) -> bool: ... @@ -28,10 +28,11 @@ class BaseTuningClass(TuningInterface): def setTuneVolumeCorrection(self, boolean: bool) -> None: ... class TuneToSaturation(BaseTuningClass): - def __init__(self, simulationInterface: jneqsim.pvtsimulation.simulation.SimulationInterface): ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/reservoirproperties/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/reservoirproperties/__init__.pyi index b99e8f30..0f11ef52 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/reservoirproperties/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/reservoirproperties/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -7,8 +7,6 @@ else: import typing - - class CompositionEstimation: def __init__(self, double: float, double2: float): ... @typing.overload @@ -16,7 +14,6 @@ class CompositionEstimation: @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi index 2fd456e4..e09b58b5 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/simulation/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,24 +12,36 @@ 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 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: ... + 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 = ... + 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 getOptimizer( + self, + ) -> ( + jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardt + ): ... def getPressure(self) -> float: ... def getPressures(self) -> typing.MutableSequence[float]: ... def getSaturationPressure(self) -> float: ... @@ -38,14 +50,25 @@ class BasePVTsimulation(SimulationInterface): 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 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: ... + 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: ... + 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): ... @@ -61,10 +84,16 @@ class ConstantMassExpansion(BasePVTsimulation): 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 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: ... + 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): ... @@ -76,10 +105,16 @@ class ConstantVolumeDepletion(BasePVTsimulation): 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 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: ... + 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): ... @@ -88,10 +123,16 @@ class DensitySim(BasePVTsimulation): 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 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: ... + 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): ... @@ -106,7 +147,9 @@ class DifferentialLiberation(BasePVTsimulation): 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 main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... def runCalc(self) -> None: ... class GOR(BasePVTsimulation): @@ -114,23 +157,33 @@ class GOR(BasePVTsimulation): 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 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: ... + 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 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 main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... def run(self) -> None: ... class SeparatorTest(BasePVTsimulation): @@ -138,15 +191,27 @@ class SeparatorTest(BasePVTsimulation): 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 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: ... + 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 __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 main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... def run(self) -> None: ... def setNumberOfSlimTubeNodes(self, int: int) -> None: ... @@ -155,12 +220,22 @@ class SwellingTest(BasePVTsimulation): 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 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: ... + 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): ... @@ -168,10 +243,16 @@ class ViscositySim(BasePVTsimulation): 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 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: ... + 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): ... @@ -182,11 +263,19 @@ class ViscosityWaxOilSim(BasePVTsimulation): 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 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: ... + 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): ... @@ -194,11 +283,16 @@ class WaxFractionSim(BasePVTsimulation): 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/__init__.pyi index e277f0bc..2cc5d151 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,7 +8,6 @@ else: import jneqsim.pvtsimulation.util.parameterfitting import typing - class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.pvtsimulation.util")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/parameterfitting/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/parameterfitting/__init__.pyi index e5531a20..a76c73a7 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/parameterfitting/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/pvtsimulation/util/parameterfitting/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,84 +11,133 @@ import jneqsim.statistics.parameterfitting.nonlinearparameterfitting import jneqsim.thermo.system import typing - - -class CMEFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +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: ... + 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: ... + def setFittingParams( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... -class CVDFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +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: ... + 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: ... + def setFittingParams( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... -class DensityFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +class DensityFunction( + jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction +): def __init__(self): ... - def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + 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: ... + def setFittingParams( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... -class FunctionJohanSverderup(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +class FunctionJohanSverderup( + jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction +): def __init__(self): ... - def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + 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: ... + def setFittingParams( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... -class SaturationPressureFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +class SaturationPressureFunction( + jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction +): def __init__(self): ... - def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + 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: ... + 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: ... + 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: ... + 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... -class ViscosityFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +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: ... + 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: ... + def setFittingParams( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... -class WaxFunction(jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction): +class WaxFunction( + jneqsim.statistics.parameterfitting.nonlinearparameterfitting.LevenbergMarquardtFunction +): def __init__(self): ... - def calcValue(self, doubleArray: typing.Union[typing.List[float], jpype.JArray]) -> float: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/standards/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/standards/__init__.pyi index aa81e80f..302db806 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/standards/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/standards/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,55 +14,97 @@ 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 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 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: ... + 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 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: ... + 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: ... + 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]): ... + 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 __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 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: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/standards/gasquality/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/standards/gasquality/__init__.pyi index d1bd2c5b..5a88dd9e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/standards/gasquality/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/standards/gasquality/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,57 +12,87 @@ 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: ... + 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 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: ... + 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 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: ... + 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 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: ... + 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 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: ... + 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 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): @@ -70,36 +100,65 @@ class Standard_ISO6578(jneqsim.standards.Standard): 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: ... + 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 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): +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): ... + 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 __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 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 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: ... + 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 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: ... @@ -111,11 +170,17 @@ class Standard_ISO6976(jneqsim.standards.Standard, jneqsim.thermo.ThermodynamicC 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: ... + 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 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): @@ -123,11 +188,17 @@ class UKspecifications_ICF_SI(jneqsim.standards.Standard): 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: ... + 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 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): @@ -137,14 +208,25 @@ 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 __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: ... + 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/standards/oilquality/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/standards/oilquality/__init__.pyi index 263ef45b..e6fd5a4d 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/standards/oilquality/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/standards/oilquality/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,23 +11,30 @@ 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: ... + 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 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/standards/salescontract/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/standards/salescontract/__init__.pyi index af7ebe28..caf2163b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/standards/salescontract/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/standards/salescontract/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,12 +12,12 @@ 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 getResultTable( + self, + ) -> typing.MutableSequence[typing.MutableSequence[java.lang.String]]: ... def getSpecificationsNumber(self) -> int: ... def getWaterDewPointSpecPressure(self) -> float: ... def getWaterDewPointTemperature(self) -> float: ... @@ -25,13 +25,32 @@ class ContractInterface: 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 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 __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: ... @@ -51,7 +70,9 @@ class ContractSpecification(jneqsim.util.NamedBaseClass): 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 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: ... @@ -61,24 +82,53 @@ class BaseContract(ContractInterface): @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 __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 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/__init__.pyi index 4de2aed8..988675cc 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,12 +12,15 @@ 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__ + 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 index e804dc52..02866800 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,7 +8,6 @@ else: import jneqsim.statistics.dataanalysis.datasmoothing import typing - class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.dataanalysis")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/datasmoothing/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/datasmoothing/__init__.pyi index 8984079f..8fe00ad0 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/datasmoothing/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/dataanalysis/datasmoothing/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,16 +8,20 @@ else: 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/__init__.pyi index 6651e63b..b12540fa 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,14 +8,13 @@ else: 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__ + 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 index d585e8f5..471d5a4f 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/wettedwallcolumndata/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalequipmentdata/wettedwallcolumndata/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,9 +8,9 @@ else: import jneqsim.statistics.experimentalequipmentdata import typing - - -class WettedWallColumnData(jneqsim.statistics.experimentalequipmentdata.ExperimentalEquipmentData): +class WettedWallColumnData( + jneqsim.statistics.experimentalequipmentdata.ExperimentalEquipmentData +): @typing.overload def __init__(self): ... @typing.overload @@ -22,7 +22,6 @@ class WettedWallColumnData(jneqsim.statistics.experimentalequipmentdata.Experime 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/__init__.pyi index 0b5765ca..f8bcb991 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,9 +9,12 @@ 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__ + 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 index 92703d0b..06b126ee 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,8 +11,6 @@ import jpype import jneqsim.statistics.experimentalsamplecreation.readdatafromfile.wettedwallcolumnreader import typing - - class DataObjectInterface: ... class DataReaderInterface: @@ -28,10 +26,11 @@ class DataReader(DataReaderInterface): 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 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")``. @@ -39,4 +38,6 @@ class __module_protocol__(Protocol): DataObjectInterface: typing.Type[DataObjectInterface] DataReader: typing.Type[DataReader] DataReaderInterface: typing.Type[DataReaderInterface] - wettedwallcolumnreader: jneqsim.statistics.experimentalsamplecreation.readdatafromfile.wettedwallcolumnreader.__module_protocol__ + 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 index 6ad03530..6d00383f 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/wettedwallcolumnreader/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/readdatafromfile/wettedwallcolumnreader/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,9 +10,9 @@ import jpype import jneqsim.statistics.experimentalsamplecreation.readdatafromfile import typing - - -class WettedWallColumnDataObject(jneqsim.statistics.experimentalsamplecreation.readdatafromfile.DataObject): +class WettedWallColumnDataObject( + jneqsim.statistics.experimentalsamplecreation.readdatafromfile.DataObject +): def __init__(self): ... def getCo2SupplyFlow(self) -> float: ... def getColumnWallTemperature(self) -> float: ... @@ -35,16 +35,19 @@ class WettedWallColumnDataObject(jneqsim.statistics.experimentalsamplecreation.r def setPressure(self, double: float) -> None: ... def setTime(self, string: typing.Union[java.lang.String, str]) -> None: ... -class WettedWallDataReader(jneqsim.statistics.experimentalsamplecreation.readdatafromfile.DataReader): +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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/__init__.pyi index 44b40d9b..eac7d937 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,19 +11,27 @@ 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: ... - + 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__ + 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 index e7a3938a..432ec387 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/wettedwallcolumnsamplecreator/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/experimentalsamplecreation/samplecreator/wettedwallcolumnsamplecreator/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,20 +10,21 @@ import jpype import jneqsim.statistics.experimentalsamplecreation.samplecreator import typing - - -class WettedWallColumnSampleCreator(jneqsim.statistics.experimentalsamplecreation.samplecreator.SampleCreator): +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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/montecarlosimulation/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/montecarlosimulation/__init__.pyi index 16975fdd..507779ef 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/montecarlosimulation/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/montecarlosimulation/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,20 +8,24 @@ else: 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): ... + def __init__( + self, + statisticsBaseClass: jneqsim.statistics.parameterfitting.StatisticsBaseClass, + int: int, + ): ... @typing.overload - def __init__(self, statisticsInterface: jneqsim.statistics.parameterfitting.StatisticsInterface): ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/__init__.pyi index d5fd8de6..c85e08bb 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -15,12 +15,12 @@ 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 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: ... @@ -30,29 +30,42 @@ class FunctionInterface(java.lang.Cloneable): 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 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: ... + 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: ... + 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']): ... + 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 __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': ... + def getSample(self, int: int) -> "SampleValue": ... class SampleValue(java.lang.Cloneable): system: jneqsim.thermo.system.SystemInterface = ... @@ -60,10 +73,21 @@ class SampleValue(java.lang.Cloneable): @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 __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: ... @@ -75,14 +99,18 @@ class SampleValue(java.lang.Cloneable): @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 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 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: ... + def setThermodynamicSystem( + self, systemInterface: jneqsim.thermo.system.SystemInterface + ) -> None: ... class StatisticsInterface: - def createNewRandomClass(self) -> 'StatisticsBaseClass': ... + def createNewRandomClass(self) -> "StatisticsBaseClass": ... def displayCurveFit(self) -> None: ... def displayResult(self) -> None: ... def getNumberOfTuningParameters(self) -> int: ... @@ -100,8 +128,10 @@ class BaseFunction(FunctionInterface): 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 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: ... @@ -111,22 +141,35 @@ class BaseFunction(FunctionInterface): 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 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: ... + 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 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 calcDerivatives( + self, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... def calcDeviation(self) -> None: ... def calcParameterStandardDeviation(self) -> None: ... def calcParameterUncertainty(self) -> None: ... @@ -136,10 +179,12 @@ class StatisticsBaseClass(java.lang.Cloneable, StatisticsInterface): 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 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 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: ... @@ -153,13 +198,14 @@ class StatisticsBaseClass(java.lang.Cloneable, StatisticsInterface): @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 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")``. @@ -170,4 +216,6 @@ class __module_protocol__(Protocol): SampleValue: typing.Type[SampleValue] StatisticsBaseClass: typing.Type[StatisticsBaseClass] StatisticsInterface: typing.Type[StatisticsInterface] - nonlinearparameterfitting: jneqsim.statistics.parameterfitting.nonlinearparameterfitting.__module_protocol__ + 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 index 9519068c..61d3e757 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/nonlinearparameterfitting/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/statistics/parameterfitting/nonlinearparameterfitting/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,21 +10,23 @@ import jpype import jneqsim.statistics.parameterfitting import typing - - class LevenbergMarquardt(jneqsim.statistics.parameterfitting.StatisticsBaseClass): def __init__(self): ... - def clone(self) -> 'LevenbergMarquardt': ... + 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 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: ... + def calcValue( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> float: ... @typing.overload def getFittingParams(self, int: int) -> float: ... @typing.overload @@ -32,24 +34,29 @@ class LevenbergMarquardtFunction(jneqsim.statistics.parameterfitting.BaseFunctio 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: ... + 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 calcAlphaMatrix( + self, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... def calcBetaMatrix(self) -> typing.MutableSequence[float]: ... def calcChiSquare(self) -> float: ... - def clone(self) -> 'LevenbergMarquardtAbsDev': ... + def clone(self) -> "LevenbergMarquardtAbsDev": ... class LevenbergMarquardtBiasDev(LevenbergMarquardt): def __init__(self): ... - def calcAlphaMatrix(self) -> typing.MutableSequence[typing.MutableSequence[float]]: ... + def calcAlphaMatrix( + self, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... def calcBetaMatrix(self) -> typing.MutableSequence[float]: ... def calcChiSquare(self) -> float: ... - def clone(self) -> 'LevenbergMarquardtBiasDev': ... - + def clone(self) -> "LevenbergMarquardtBiasDev": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.statistics.parameterfitting.nonlinearparameterfitting")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/__init__.pyi index 0dd7ddb9..44472949 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -17,27 +17,43 @@ 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: ... + 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: ... + 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 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 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 setThermoMixingRule( + self, string: typing.Union[java.lang.String, str] + ) -> None: ... def setThermoModel(self, string: typing.Union[java.lang.String, str]) -> None: ... class FluidCreator: @@ -47,13 +63,21 @@ class FluidCreator: thermoMixingRule: typing.ClassVar[java.lang.String] = ... @typing.overload @staticmethod - def create(string: typing.Union[java.lang.String, str]) -> jneqsim.thermo.system.SystemInterface: ... + 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: ... + 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: ... + 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] = ... @@ -90,7 +114,6 @@ class ThermodynamicModelTest(ThermodynamicConstantsInterface): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/atomelement/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/atomelement/__init__.pyi index 45b62139..4072cfb7 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/atomelement/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/atomelement/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,8 +13,6 @@ 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 @@ -22,19 +20,29 @@ class Element(jneqsim.thermo.ThermodynamicConstantsInterface): 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: ... + def getNumberOfElements( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... -class UNIFACgroup(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.Comparable['UNIFACgroup']): +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 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 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: ... @@ -72,12 +80,13 @@ class UNIFACgroup(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.Comp 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/characterization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/characterization/__init__.pyi index 8a57c45d..9e9e7535 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/characterization/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/characterization/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -13,29 +13,33 @@ 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 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 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: ... + 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 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]: ... @@ -56,11 +60,15 @@ class CharacteriseInterface: @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 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 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: ... @@ -80,7 +88,11 @@ class NewtonSolveAB(java.io.Serializable): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, tBPCharacterize: 'TBPCharacterize'): ... + def __init__( + self, + systemInterface: jneqsim.thermo.system.SystemInterface, + tBPCharacterize: "TBPCharacterize", + ): ... def setJac(self) -> None: ... def setfvec(self) -> None: ... def solve(self) -> None: ... @@ -89,7 +101,11 @@ class NewtonSolveABCD(java.io.Serializable): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, tBPCharacterize: 'TBPCharacterize'): ... + def __init__( + self, + systemInterface: jneqsim.thermo.system.SystemInterface, + tBPCharacterize: "TBPCharacterize", + ): ... def setJac(self) -> None: ... def setfvec(self) -> None: ... def solve(self) -> None: ... @@ -98,25 +114,39 @@ class NewtonSolveCDplus(java.io.Serializable): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, plusCharacterize: 'PlusCharacterize'): ... + 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 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 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 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 clone(self) -> "OilAssayCharacterisation.AssayCut": ... def getMassFraction(self) -> float: ... def getName(self) -> java.lang.String: ... def getVolumeFraction(self) -> float: ... @@ -126,22 +156,44 @@ class OilAssayCharacterisation(java.lang.Cloneable, java.io.Serializable): 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': ... + 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 __init__( + self, + systemInterface: jneqsim.thermo.system.SystemInterface, + pedersenPlusModel: "PlusFractionModel.PedersenPlusModel", + ): ... def setJacAB(self) -> None: ... def setJacCD(self) -> None: ... def setfvecAB(self) -> None: ... @@ -150,11 +202,16 @@ class PedersenPlusModelSolver(java.io.Serializable): class PlusFractionModel(java.io.Serializable): def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... - def getModel(self, string: typing.Union[java.lang.String, str]) -> 'PlusFractionModelInterface': ... + 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 characterizePlusFraction( + self, tBPModelInterface: "TBPModelInterface" + ) -> bool: ... def getCoef(self, int: int) -> float: ... def getCoefs(self) -> typing.MutableSequence[float]: ... def getDens(self) -> typing.MutableSequence[float]: ... @@ -175,16 +232,32 @@ class PlusFractionModelInterface(java.io.Serializable): class PseudoComponentCombiner: @staticmethod - def characterizeToReference(systemInterface: jneqsim.thermo.system.SystemInterface, systemInterface2: jneqsim.thermo.system.SystemInterface) -> jneqsim.thermo.system.SystemInterface: ... + 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: ... + 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: ... + 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 __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: ... @@ -199,10 +272,17 @@ class TBPModelInterface: 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 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 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: ... @@ -210,21 +290,31 @@ class TBPModelInterface: class WaxModelInterface(java.io.Serializable, java.lang.Cloneable): def addTBPWax(self) -> None: ... - def clone(self) -> 'WaxModelInterface': ... + def clone(self) -> "WaxModelInterface": ... def getParameterWaxHeatOfFusion(self) -> typing.MutableSequence[float]: ... - def getParameterWaxTriplePointTemperature(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: ... + 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: ... + def setParameterWaxTriplePointTemperature( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... @typing.overload - def setParameterWaxTriplePointTemperature(self, int: int, double: float) -> None: ... + 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: ... + def setWaxParameters( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... class PlusCharacterize(java.io.Serializable, CharacteriseInterface): @typing.overload @@ -236,7 +326,9 @@ class PlusCharacterize(java.io.Serializable, CharacteriseInterface): 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 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: ... @@ -258,18 +350,24 @@ class PlusCharacterize(java.io.Serializable, CharacteriseInterface): def hasPlusFraction(self) -> bool: ... def isPseudocomponents(self) -> bool: ... def removeTBPfraction(self) -> None: ... - def setCarbonNumberVector(self, intArray: typing.Union[typing.List[int], 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 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 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: ... @@ -302,37 +400,64 @@ class TBPCharacterize(PlusCharacterize): 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: ... + 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 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 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 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'): ... + + 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'): ... + + 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 getLumpedComponentNames( + self, + ) -> typing.MutableSequence[java.lang.String]: ... def getName(self) -> java.lang.String: ... def getNumberOfLumpedComponents(self) -> int: ... def getNumberOfPseudoComponents(self) -> int: ... @@ -341,56 +466,103 @@ class LumpingModel(java.io.Serializable): class TBPfractionModel(java.io.Serializable): def __init__(self): ... - def getModel(self, string: typing.Union[java.lang.String, str]) -> TBPModelInterface: ... + def getModel( + self, string: typing.Union[java.lang.String, str] + ) -> TBPModelInterface: ... + class LeeKesler(jneqsim.thermo.characterization.TBPfractionModel.TBPBaseModel): - def __init__(self, tBPfractionModel: 'TBPfractionModel'): ... + 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 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'): ... + + 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'): ... + + 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 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'): ... + + 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 __init__(self, tBPfractionModel: "TBPfractionModel"): ... def calcAcentricFactor(self, double: float, double2: float) -> float: ... - def calcAcentricFactorKeslerLee(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 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 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 __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 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: ... @@ -398,39 +570,56 @@ class TBPfractionModel(java.io.Serializable): class WaxCharacterise(java.io.Serializable, java.lang.Cloneable): def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... - def clone(self) -> 'WaxCharacterise': ... + def clone(self) -> "WaxCharacterise": ... @typing.overload def getModel(self) -> WaxModelInterface: ... @typing.overload - def getModel(self, string: typing.Union[java.lang.String, str]) -> WaxModelInterface: ... + 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'): ... + + 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 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 __init__(self, waxCharacterise: "WaxCharacterise"): ... def addTBPWax(self) -> None: ... - def clone(self) -> 'WaxCharacterise.WaxBaseModel': ... + def clone(self) -> "WaxCharacterise.WaxBaseModel": ... def getParameterWaxHeatOfFusion(self) -> typing.MutableSequence[float]: ... - def getParameterWaxTriplePointTemperature(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: ... + 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: ... + def setParameterWaxTriplePointTemperature( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... @typing.overload - def setParameterWaxTriplePointTemperature(self, int: int, double: float) -> None: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/component/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/__init__.pyi index c066de2c..62a74c19 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/component/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -15,22 +15,49 @@ 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: ... +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 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 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: ... @@ -43,7 +70,9 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la def getAssociationScheme(self) -> java.lang.String: ... def getAssociationVolume(self) -> float: ... def getAssociationVolumeSAFT(self) -> float: ... - def getAttractiveTerm(self) -> jneqsim.thermo.component.attractiveeosterm.AttractiveTermInterface: ... + def getAttractiveTerm( + self, + ) -> jneqsim.thermo.component.attractiveeosterm.AttractiveTermInterface: ... def getAttractiveTermNumber(self) -> int: ... def getCASnumber(self) -> java.lang.String: ... def getCCsolidVaporPressure(self, double: float) -> float: ... @@ -51,18 +80,34 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la @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 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 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: ... + 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 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: ... @@ -113,21 +158,29 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la 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: ... + 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 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: ... + 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 getNormalLiquidDensity( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getNumberOfAssociationSites(self) -> int: ... def getNumberOfMolesInPhase(self) -> float: ... def getNumberOfmoles(self) -> float: ... @@ -161,7 +214,9 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la 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 getTotalFlowRate( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getTriplePointDensity(self) -> float: ... def getTriplePointPressure(self) -> float: ... def getTriplePointTemperature(self) -> float: ... @@ -181,8 +236,12 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la 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 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: ... @@ -191,10 +250,18 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la 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 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: ... @@ -203,7 +270,9 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la 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 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: ... @@ -223,7 +292,9 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la 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 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: ... @@ -237,13 +308,17 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la 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: ... + 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 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: ... @@ -252,9 +327,11 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la @typing.overload def setPC(self, double: float) -> None: ... @typing.overload - def setPC(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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 setProperties(self, componentInterface: "ComponentInterface") -> None: ... def setRacketZ(self, double: float) -> None: ... def setRacketZCPA(self, double: float) -> None: ... def setReferencePotential(self, double: float) -> None: ... @@ -267,7 +344,9 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la @typing.overload def setTC(self, double: float) -> None: ... @typing.overload - def setTC(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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: ... @@ -290,22 +369,63 @@ class ComponentInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.la 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: ... + 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 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 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: ... @@ -318,24 +438,40 @@ class Component(ComponentInterface): def getAssociationScheme(self) -> java.lang.String: ... def getAssociationVolume(self) -> float: ... def getAssociationVolumeSAFT(self) -> float: ... - def getAttractiveTerm(self) -> jneqsim.thermo.component.attractiveeosterm.AttractiveTermInterface: ... + 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: ... + 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: ... + 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 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: ... @@ -360,7 +496,9 @@ class Component(ComponentInterface): 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 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: ... @@ -393,21 +531,29 @@ class Component(ComponentInterface): 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: ... + 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 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: ... + 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 getNormalLiquidDensity( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getNumberOfAssociationSites(self) -> int: ... def getNumberOfMolesInPhase(self) -> float: ... def getNumberOfmoles(self) -> float: ... @@ -443,7 +589,9 @@ class Component(ComponentInterface): 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 getTotalFlowRate( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getTriplePointDensity(self) -> float: ... def getTriplePointPressure(self) -> float: ... def getTriplePointTemperature(self) -> float: ... @@ -463,8 +611,12 @@ class Component(ComponentInterface): 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 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: ... @@ -474,10 +626,18 @@ class Component(ComponentInterface): 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 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: ... @@ -486,7 +646,9 @@ class Component(ComponentInterface): 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 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: ... @@ -506,7 +668,9 @@ class Component(ComponentInterface): 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 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: ... @@ -520,15 +684,21 @@ class Component(ComponentInterface): 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: ... + 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: ... + 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 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: ... @@ -537,7 +707,9 @@ class Component(ComponentInterface): @typing.overload def setPC(self, double: float) -> None: ... @typing.overload - def setPC(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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: ... @@ -555,7 +727,9 @@ class Component(ComponentInterface): @typing.overload def setTC(self, double: float) -> None: ... @typing.overload - def setTC(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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: ... @@ -580,10 +754,35 @@ 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 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: ... @@ -619,7 +818,26 @@ 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 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: ... @@ -628,10 +846,22 @@ class ComponentGEInterface(ComponentInterface): 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 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]: ... @@ -658,19 +888,67 @@ class ComponentEos(Component, ComponentEosInterface): 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 __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 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: ... @@ -681,14 +959,22 @@ class ComponentEos(Component, ComponentEosInterface): 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 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: ... + 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]: ... @@ -705,17 +991,38 @@ class ComponentEos(Component, ComponentEosInterface): 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 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 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: ... @@ -729,12 +1036,41 @@ class ComponentEos(Component, ComponentEosInterface): 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 __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: ... + 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: ... @@ -745,62 +1081,164 @@ class ComponentGE(Component, ComponentGEInterface): 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: ... + 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: ... + 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 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 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 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: ... + 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 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 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: ... + 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 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: ... @@ -808,57 +1246,173 @@ 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 __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: ... + 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 __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 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: ... + 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 __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: ... + 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: ... + 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 __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 clone(self) -> "ComponentGERG2004": ... def diffaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... def fugcoef(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... @@ -866,168 +1420,599 @@ class ComponentGERG2004(ComponentEos): 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 __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 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: ... + 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): ... + 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: ... + 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 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): ... + 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: ... + 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: ... + 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 __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 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): ... + 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 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 __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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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 __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 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: ... @@ -1035,12 +2020,26 @@ class ComponentLeachmanEos(ComponentEos): 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 __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 clone(self) -> "ComponentPR": ... def getQpure(self, double: float) -> float: ... def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... def getVolumeCorrection(self) -> float: ... @@ -1049,12 +2048,26 @@ class ComponentPR(ComponentEos): 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 __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 clone(self) -> "ComponentRK": ... def getQpure(self, double: float) -> float: ... def getVolumeCorrection(self) -> float: ... def getdQpuredT(self, double: float) -> float: ... @@ -1062,18 +2075,66 @@ class ComponentRK(ComponentEos): 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 __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 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: ... @@ -1081,12 +2142,26 @@ class ComponentSpanWagnerEos(ComponentEos): 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 __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 clone(self) -> "ComponentSrk": ... def getQpure(self, double: float) -> float: ... def getSurfaceTenisionInfluenceParameter(self, double: float) -> float: ... def getVolumeCorrection(self) -> float: ... @@ -1095,12 +2170,26 @@ class ComponentSrk(ComponentEos): 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 __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 clone(self) -> "ComponentTST": ... def getQpure(self, double: float) -> float: ... def getVolumeCorrection(self) -> float: ... def getdQpuredT(self, double: float) -> float: ... @@ -1108,18 +2197,66 @@ class ComponentTST(ComponentEos): 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 __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 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: ... @@ -1127,36 +2264,117 @@ class ComponentVegaEos(ComponentEos): 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 __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 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 __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': ... + 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 __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: ... @@ -1175,149 +2393,626 @@ class ComponentBWRS(ComponentSrk): 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 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 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 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 __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 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: ... + 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': ... + 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): ... + 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 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): ... + 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 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 __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: ... + 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: ... + 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 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 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: ... + 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): ... + 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: ... + 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 __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 __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 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 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: ... @@ -1331,43 +3026,247 @@ class ComponentModifiedFurstElectrolyteEos(ComponentSrk): 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 __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 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 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: ... @@ -1381,29 +3280,120 @@ class ComponentModifiedFurstElectrolyteEosMod2004(ComponentSrk): 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 __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 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: ... @@ -1415,91 +3405,302 @@ 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 __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 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 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: ... + 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 __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 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: ... + 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): ... + 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 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: ... + 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': ... + 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 __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 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 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]: ... @@ -1514,18 +3715,27 @@ class ComponentSrkCPA(ComponentSrk, ComponentCPAInterface): 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: ... + 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: ... + 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: ... + 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: ... @@ -1533,65 +3743,227 @@ class ComponentSrkCPA(ComponentSrk, ComponentCPAInterface): 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 __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 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 __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 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 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: ... + 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 __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 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 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]: ... @@ -1605,49 +3977,146 @@ class ComponentUMRCPA(ComponentPR, ComponentCPAInterface): 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: ... + 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: ... + 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: ... + 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): ... +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 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 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]: ... @@ -1661,45 +4130,131 @@ class ComponentElectrolyteCPA(ComponentModifiedFurstElectrolyteEos, ComponentCPA 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: ... + 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: ... + 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: ... + 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: ... +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 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]: ... @@ -1708,11 +4263,15 @@ class ComponentElectrolyteCPAOld(ComponentModifiedFurstElectrolyteEos, Component 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: ... + 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: ... + 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: ... @@ -1723,72 +4282,244 @@ class ComponentElectrolyteCPAOld(ComponentModifiedFurstElectrolyteEos, Component 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: ... + 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: ... + 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 __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: ... + 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 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 __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: ... + 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: ... + 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: ... @@ -1798,54 +4529,131 @@ class ComponentPCSAFTa(ComponentPCSAFT, ComponentCPAInterface): 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': ... + 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): ... + 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 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): ... + 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: ... + 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): ... + 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: ... + 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': ... - + 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")``. @@ -1888,8 +4696,12 @@ class __module_protocol__(Protocol): ComponentInterface: typing.Type[ComponentInterface] ComponentKentEisenberg: typing.Type[ComponentKentEisenberg] ComponentLeachmanEos: typing.Type[ComponentLeachmanEos] - ComponentModifiedFurstElectrolyteEos: typing.Type[ComponentModifiedFurstElectrolyteEos] - ComponentModifiedFurstElectrolyteEosMod2004: typing.Type[ComponentModifiedFurstElectrolyteEosMod2004] + ComponentModifiedFurstElectrolyteEos: typing.Type[ + ComponentModifiedFurstElectrolyteEos + ] + ComponentModifiedFurstElectrolyteEosMod2004: typing.Type[ + ComponentModifiedFurstElectrolyteEosMod2004 + ] ComponentPCSAFT: typing.Type[ComponentPCSAFT] ComponentPCSAFTa: typing.Type[ComponentPCSAFTa] ComponentPR: typing.Type[ComponentPR] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/component/attractiveeosterm/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/attractiveeosterm/__init__.pyi index aa4dd6da..2d6435d4 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/component/attractiveeosterm/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/attractiveeosterm/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,12 +11,10 @@ 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 clone(self) -> "AttractiveTermInterface": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -28,10 +26,12 @@ class AttractiveTermInterface(java.lang.Cloneable, java.io.Serializable): def setm(self, double: float) -> None: ... class AttractiveTermBaseClass(AttractiveTermInterface): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 clone(self) -> "AttractiveTermBaseClass": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -44,12 +44,18 @@ class AttractiveTermBaseClass(AttractiveTermInterface): class AttractiveTermMollerup(AttractiveTermBaseClass): @typing.overload - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 __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 clone(self) -> "AttractiveTermMollerup": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -57,10 +63,12 @@ class AttractiveTermMollerup(AttractiveTermBaseClass): def init(self) -> None: ... class AttractiveTermPr(AttractiveTermBaseClass): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 clone(self) -> "AttractiveTermPr": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -69,10 +77,12 @@ class AttractiveTermPr(AttractiveTermBaseClass): def setm(self, double: float) -> None: ... class AttractiveTermRk(AttractiveTermBaseClass): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 clone(self) -> "AttractiveTermRk": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -81,12 +91,18 @@ class AttractiveTermRk(AttractiveTermBaseClass): class AttractiveTermSchwartzentruber(AttractiveTermBaseClass): @typing.overload - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 __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 clone(self) -> "AttractiveTermSchwartzentruber": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -94,10 +110,12 @@ class AttractiveTermSchwartzentruber(AttractiveTermBaseClass): def init(self) -> None: ... class AttractiveTermSrk(AttractiveTermBaseClass): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 clone(self) -> "AttractiveTermSrk": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -106,10 +124,12 @@ class AttractiveTermSrk(AttractiveTermBaseClass): def setm(self, double: float) -> None: ... class AttractiveTermTwuCoon(AttractiveTermBaseClass): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 clone(self) -> "AttractiveTermTwuCoon": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -118,12 +138,18 @@ class AttractiveTermTwuCoon(AttractiveTermBaseClass): class AttractiveTermTwuCoonParam(AttractiveTermBaseClass): @typing.overload - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 __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 clone(self) -> "AttractiveTermTwuCoonParam": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -132,12 +158,18 @@ class AttractiveTermTwuCoonParam(AttractiveTermBaseClass): class AttractiveTermTwuCoonStatoil(AttractiveTermBaseClass): @typing.overload - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 __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 clone(self) -> "AttractiveTermTwuCoonStatoil": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -145,10 +177,12 @@ class AttractiveTermTwuCoonStatoil(AttractiveTermBaseClass): def init(self) -> None: ... class AttractiveTermCPAstatoil(AttractiveTermSrk): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 clone(self) -> "AttractiveTermCPAstatoil": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -156,7 +190,9 @@ class AttractiveTermCPAstatoil(AttractiveTermSrk): def init(self) -> None: ... class AttractiveTermGERG(AttractiveTermPr): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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: ... @@ -167,12 +203,18 @@ class AttractiveTermGERG(AttractiveTermPr): class AttractiveTermMatCop(AttractiveTermSrk): @typing.overload - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 __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 clone(self) -> "AttractiveTermMatCop": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -181,12 +223,18 @@ class AttractiveTermMatCop(AttractiveTermSrk): class AttractiveTermMatCopPR(AttractiveTermPr): @typing.overload - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 __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 clone(self) -> "AttractiveTermMatCopPR": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -194,28 +242,38 @@ class AttractiveTermMatCopPR(AttractiveTermPr): class AttractiveTermMatCopPRUMR(AttractiveTermPr): @typing.overload - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 __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 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, 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 __init__( + self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface + ): ... def aT(self, double: float) -> float: ... def alpha(self, double: float) -> float: ... - def clone(self) -> 'AttractiveTermPrGassem2001': ... + def clone(self) -> "AttractiveTermPrGassem2001": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -223,10 +281,12 @@ class AttractiveTermPrGassem2001(AttractiveTermPr): def init(self) -> None: ... class AttractiveTermTwu(AttractiveTermSrk): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 clone(self) -> "AttractiveTermTwu": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -234,28 +294,38 @@ class AttractiveTermTwu(AttractiveTermSrk): def init(self) -> None: ... class AttractiveTermUMRPRU(AttractiveTermPr): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... - def clone(self) -> 'AttractiveTermUMRPRU': ... + 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): ... + 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 __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 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 __init__( + self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface + ): ... def aT(self, double: float) -> float: ... def alpha(self, double: float) -> float: ... - def clone(self) -> 'AttractiveTermPrDanesh': ... + def clone(self) -> "AttractiveTermPrDanesh": ... def diffaT(self, double: float) -> float: ... def diffalphaT(self, double: float) -> float: ... def diffdiffaT(self, double: float) -> float: ... @@ -263,23 +333,26 @@ class AttractiveTermPrDanesh(AttractiveTermPr1978): def init(self) -> None: ... class AttractiveTermPrDelft1998(AttractiveTermPr1978): - def __init__(self, componentEosInterface: jneqsim.thermo.component.ComponentEosInterface): ... + 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 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/component/repulsiveeosterm/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/repulsiveeosterm/__init__.pyi index e32f2399..1910a740 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/component/repulsiveeosterm/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/component/repulsiveeosterm/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -7,11 +7,8 @@ else: import typing - - class RepulsiveTermInterface: ... - class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.component.repulsiveeosterm")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/mixingrule/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/mixingrule/__init__.pyi index a42d2a30..76159306 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/mixingrule/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/mixingrule/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,8 +14,6 @@ import jneqsim.thermo.component import jneqsim.thermo.phase import typing - - class MixingRuleHandler(jneqsim.thermo.ThermodynamicConstantsInterface): def __init__(self): ... def getName(self) -> java.lang.String: ... @@ -26,42 +24,175 @@ class MixingRuleTypeInterface: 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'] = ... +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': ... + def byName(string: typing.Union[java.lang.String, str]) -> "CPAMixingRuleType": ... @staticmethod - def byValue(int: int) -> 'CPAMixingRuleType': ... + def byValue(int: int) -> "CPAMixingRuleType": ... def getValue(self) -> int: ... - _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + _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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "CPAMixingRuleType": ... @staticmethod - def values() -> typing.MutableSequence['CPAMixingRuleType']: ... + 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: ... + 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: ... + 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: ... + 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: ... @@ -74,55 +205,130 @@ class ElectrolyteMixingRulesInterface(MixingRulesInterface): 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'] = ... +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': ... + def byName(string: typing.Union[java.lang.String, str]) -> "EosMixingRuleType": ... @staticmethod - def byValue(int: int) -> 'EosMixingRuleType': ... + def byValue(int: int) -> "EosMixingRuleType": ... def getValue(self) -> int: ... - _valueOf_0__T = typing.TypeVar('_valueOf_0__T', bound=java.lang.Enum) # + _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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "EosMixingRuleType": ... @staticmethod - def values() -> typing.MutableSequence['EosMixingRuleType']: ... + 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 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 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 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 setMixingRuleGEModel( + self, string: typing.Union[java.lang.String, str] + ) -> None: ... def setnEOSkij(self, double: float) -> None: ... class HVMixingRulesInterface(EosMixingRulesInterface): @@ -137,59 +343,325 @@ class HVMixingRulesInterface(EosMixingRulesInterface): 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]]: ... + 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: ... + 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]]: ... + 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'): ... + 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: ... + 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 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: ... + 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: ... + 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: ... + 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'): ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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 = ... @@ -208,115 +680,395 @@ class EosMixingRuleHandler(MixingRuleHandler): 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 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 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 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 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 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: ... + 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 __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'): ... + 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 __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 __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: ... + 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: ... + 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 __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 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 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 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 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: ... + 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: ... + 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 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: ... @@ -327,16 +1079,83 @@ class EosMixingRuleHandler(MixingRuleHandler): 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): + + 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]): ... + 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 __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: ... @@ -346,55 +1165,304 @@ class EosMixingRuleHandler(MixingRuleHandler): 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): + + 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]): ... + 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 __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 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): + + 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]): ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/phase/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/phase/__init__.pyi index b0704802..ccd9925d 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/phase/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/phase/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -16,15 +16,37 @@ 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: ... + 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): +class PhaseInterface( + jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.Cloneable +): def FB(self) -> float: ... def FBB(self) -> float: ... def FBD(self) -> float: ... @@ -41,23 +63,77 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C 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 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 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 clone(self) -> "PhaseInterface": ... def dFdT(self) -> float: ... def dFdTdT(self) -> float: ... def dFdTdV(self) -> float: ... @@ -87,26 +163,46 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C @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_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 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 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 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: ... @@ -130,7 +226,9 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C @typing.overload def getDensity_Leachman(self) -> float: ... @typing.overload - def getDensity_Leachman(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getDensity_Leachman( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getDensity_Vega(self) -> float: ... @typing.overload def getEnthalpy(self) -> float: ... @@ -162,13 +260,17 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C @typing.overload def getInternalEnergy(self) -> float: ... @typing.overload - def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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 getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getKappa(self) -> float: ... def getLogActivityCoefficient(self, int: int, int2: int) -> float: ... @typing.overload @@ -180,7 +282,9 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C 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 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]: ... @@ -199,11 +303,15 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C def getNumberOfMolesInPhase(self) -> float: ... def getOsmoticCoefficient(self, int: int) -> float: ... def getOsmoticCoefficientOfWater(self) -> float: ... - def getPhase(self) -> 'PhaseInterface': ... + 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: ... + def getPhysicalProperties( + self, + ) -> jneqsim.physicalproperties.system.PhysicalProperties: ... + def getPhysicalPropertyModel( + self, + ) -> jneqsim.physicalproperties.system.PhysicalPropertyModel: ... @typing.overload def getPressure(self) -> float: ... @typing.overload @@ -213,7 +321,9 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C @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_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: ... @@ -222,9 +332,9 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C @typing.overload def getPureComponentFugacity(self, int: int, boolean: bool) -> float: ... @typing.overload - def getRefPhase(self, int: int) -> 'PhaseInterface': ... + def getRefPhase(self, int: int) -> "PhaseInterface": ... @typing.overload - def getRefPhase(self) -> typing.MutableSequence['PhaseInterface']: ... + def getRefPhase(self) -> typing.MutableSequence["PhaseInterface"]: ... @typing.overload def getSoundSpeed(self) -> float: ... @typing.overload @@ -237,9 +347,11 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C @typing.overload def getThermalConductivity(self) -> float: ... @typing.overload - def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermalConductivity( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getTotalVolume(self) -> float: ... - def getType(self) -> 'PhaseType': ... + def getType(self) -> "PhaseType": ... @typing.overload def getViscosity(self) -> float: ... @typing.overload @@ -253,13 +365,21 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C 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 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 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: ... @@ -269,13 +389,17 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C def getg(self) -> float: ... def getpH(self) -> float: ... @typing.overload - def hasComponent(self, string: typing.Union[java.lang.String, str], boolean: bool) -> bool: ... + 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: ... + def init( + self, double: float, int: int, int2: int, phaseType: "PhaseType", double2: float + ) -> None: ... @typing.overload def init(self) -> None: ... @typing.overload @@ -283,105 +407,173 @@ class PhaseInterface(jneqsim.thermo.ThermodynamicConstantsInterface, java.lang.C @typing.overload def initPhysicalProperties(self) -> None: ... @typing.overload - def initPhysicalProperties(self, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType) -> None: ... + def initPhysicalProperties( + self, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType + ) -> None: ... @typing.overload - def initPhysicalProperties(self, string: typing.Union[java.lang.String, str]) -> None: ... + 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 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 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 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: ... + 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 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 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 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: ... + 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 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: ... + def setProperties(self, phaseInterface: "PhaseInterface") -> None: ... @typing.overload - def setRefPhase(self, int: int, phaseInterface: 'PhaseInterface') -> None: ... + def setRefPhase(self, int: int, phaseInterface: "PhaseInterface") -> None: ... @typing.overload - def setRefPhase(self, phaseInterfaceArray: typing.Union[typing.List['PhaseInterface'], jpype.JArray]) -> None: ... + 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: ... + 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'] = ... +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': ... + def byDesc(string: typing.Union[java.lang.String, str]) -> "PhaseType": ... @staticmethod - def byName(string: typing.Union[java.lang.String, str]) -> 'PhaseType': ... + def byName(string: typing.Union[java.lang.String, str]) -> "PhaseType": ... @staticmethod - def byValue(int: int) -> 'PhaseType': ... + 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) # + _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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "PhaseType": ... @staticmethod - def values() -> typing.MutableSequence['PhaseType']: ... + def values() -> typing.MutableSequence["PhaseType"]: ... -class StateOfMatter(java.lang.Enum['StateOfMatter']): - GAS: typing.ClassVar['StateOfMatter'] = ... - LIQUID: typing.ClassVar['StateOfMatter'] = ... - SOLID: typing.ClassVar['StateOfMatter'] = ... +class StateOfMatter(java.lang.Enum["StateOfMatter"]): + GAS: typing.ClassVar["StateOfMatter"] = ... + LIQUID: typing.ClassVar["StateOfMatter"] = ... + SOLID: typing.ClassVar["StateOfMatter"] = ... @staticmethod - def fromPhaseType(phaseType: PhaseType) -> 'StateOfMatter': ... + 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) # + _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: ... + 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': ... + def valueOf(string: typing.Union[java.lang.String, str]) -> "StateOfMatter": ... @staticmethod - def values() -> typing.MutableSequence['StateOfMatter']: ... + def values() -> typing.MutableSequence["StateOfMatter"]: ... class Phase(PhaseInterface): numberOfComponents: int = ... - componentArray: typing.MutableSequence[jneqsim.thermo.component.ComponentInterface] = ... + componentArray: typing.MutableSequence[ + jneqsim.thermo.component.ComponentInterface + ] = ... calcMolarVolume: bool = ... physicalPropertyHandler: jneqsim.physicalproperties.PhysicalPropertyHandler = ... chemSyst: bool = ... @@ -405,31 +597,94 @@ class Phase(PhaseInterface): 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 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 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 clone(self) -> "Phase": ... def dFdT(self) -> float: ... def dFdTdT(self) -> float: ... def dFdTdV(self) -> float: ... @@ -461,15 +716,27 @@ class Phase(PhaseInterface): @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_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 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: ... @@ -477,11 +744,19 @@ class Phase(PhaseInterface): @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 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 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: ... @@ -506,7 +781,9 @@ class Phase(PhaseInterface): @typing.overload def getDensity_Leachman(self) -> float: ... @typing.overload - def getDensity_Leachman(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getDensity_Leachman( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getDensity_Vega(self) -> float: ... def getDiElectricConstant(self) -> float: ... @typing.overload @@ -543,13 +820,17 @@ class Phase(PhaseInterface): @typing.overload def getInternalEnergy(self) -> float: ... @typing.overload - def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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 getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getKappa(self) -> float: ... def getLogActivityCoefficient(self, int: int, int2: int) -> float: ... @typing.overload @@ -563,7 +844,9 @@ class Phase(PhaseInterface): def getMass(self) -> float: ... def getMeanIonicActivity(self, int: int, int2: int) -> float: ... def getMixGibbsEnergy(self) -> float: ... - def getMixingRuleType(self) -> jneqsim.thermo.mixingrule.MixingRuleTypeInterface: ... + 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]: ... @@ -583,8 +866,12 @@ class Phase(PhaseInterface): 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: ... + def getPhysicalProperties( + self, + ) -> jneqsim.physicalproperties.system.PhysicalProperties: ... + def getPhysicalPropertyModel( + self, + ) -> jneqsim.physicalproperties.system.PhysicalPropertyModel: ... @typing.overload def getPressure(self) -> float: ... @typing.overload @@ -594,7 +881,9 @@ class Phase(PhaseInterface): @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_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: ... @@ -619,7 +908,9 @@ class Phase(PhaseInterface): @typing.overload def getThermalConductivity(self) -> float: ... @typing.overload - def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... @@ -636,13 +927,21 @@ class Phase(PhaseInterface): 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 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 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: ... @@ -654,7 +953,9 @@ class Phase(PhaseInterface): 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: ... + 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: ... @@ -664,44 +965,91 @@ class Phase(PhaseInterface): @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 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: ... + 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 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 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 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 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 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 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 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 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: ... @@ -718,7 +1066,9 @@ class PhaseEosInterface(PhaseInterface): 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 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: ... @@ -732,7 +1082,9 @@ class PhaseEosInterface(PhaseInterface): class PhaseCPAInterface(PhaseEosInterface): def getCpaMixingRule(self) -> jneqsim.thermo.mixingrule.CPAMixingRulesInterface: ... - def getCrossAssosiationScheme(self, int: int, int2: int, int3: int, int4: int) -> int: ... + def getCrossAssosiationScheme( + self, int: int, int2: int, int3: int, int4: int + ) -> int: ... def getGcpa(self) -> float: ... def getGcpav(self) -> float: ... def getHcpatot(self) -> float: ... @@ -743,11 +1095,21 @@ 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 __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 @@ -758,14 +1120,35 @@ class PhaseDefault(Phase): 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: ... + 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: ... + 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 = ... @@ -790,25 +1173,84 @@ class PhaseEos(Phase, PhaseEosInterface): 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 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 clone(self) -> "PhaseEos": ... def dFdN(self, int: int) -> float: ... def dFdNdN(self, int: int, int2: int) -> float: ... def dFdNdT(self, int: int) -> float: ... @@ -822,8 +1264,12 @@ class PhaseEos(Phase, PhaseEosInterface): 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 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: ... @@ -851,7 +1297,9 @@ class PhaseEos(Phase, PhaseEosInterface): def getHresTP(self) -> float: ... def getHresdP(self) -> float: ... @typing.overload - def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... def getKappa(self) -> float: ... @@ -865,13 +1313,21 @@ class PhaseEos(Phase, PhaseEosInterface): 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 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 getdTVndSVnJaobiMatrix( + self, + ) -> typing.MutableSequence[typing.MutableSequence[float]]: ... def getdUdSVn(self) -> float: ... def getdUdSdSVn(self) -> float: ... def getdUdSdVn(self, phaseInterface: PhaseInterface) -> float: ... @@ -888,15 +1344,43 @@ class PhaseEos(Phase, PhaseEosInterface): @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: ... + 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: ... + 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): ... @@ -928,7 +1412,9 @@ class PhaseGE(Phase, PhaseGEInterface): @typing.overload def getEntropy(self) -> float: ... @typing.overload - def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... def getMixingRule(self) -> jneqsim.thermo.mixingrule.EosMixingRulesInterface: ... @@ -946,15 +1432,38 @@ class PhaseGE(Phase, PhaseGEInterface): @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: ... + 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: ... + 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 @@ -962,10 +1471,18 @@ class PhaseHydrate(Phase): @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 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: ... @@ -976,23 +1493,52 @@ class PhaseHydrate(Phase): @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: ... + 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 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 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 @@ -1001,7 +1547,9 @@ class PhaseIdealGas(Phase, jneqsim.thermo.ThermodynamicConstantsInterface): 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: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... def getMixingRule(self) -> jneqsim.thermo.mixingrule.EosMixingRulesInterface: ... @@ -1016,32 +1564,63 @@ class PhaseIdealGas(Phase, jneqsim.thermo.ThermodynamicConstantsInterface): @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: ... + 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 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 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 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]]: ... + 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 @@ -1065,12 +1644,16 @@ class PhaseAmmoniaEos(PhaseEos): def getGibbsEnergy(self) -> float: ... def getHresTP(self) -> float: ... @typing.overload - def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... @typing.overload @@ -1078,7 +1661,9 @@ class PhaseAmmoniaEos(PhaseEos): @typing.overload def getSoundSpeed(self) -> float: ... @typing.overload - def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermalConductivity( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getThermalConductivity(self) -> float: ... @typing.overload @@ -1091,15 +1676,32 @@ class PhaseAmmoniaEos(PhaseEos): @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 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: ... + 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 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 @@ -1110,7 +1712,14 @@ class PhaseDesmukhMather(PhaseGE): @typing.overload def getExcessGibbsEnergy(self) -> float: ... @typing.overload - def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + 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: ... @@ -1121,70 +1730,225 @@ class PhaseDesmukhMather(PhaseGE): @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: ... + 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: ... + 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: ... + 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 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 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: ... + 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: ... + 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: ... + 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 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: ... + 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: ... + 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: ... + 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': ... + 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 @@ -1203,11 +1967,15 @@ class PhaseGERG2004Eos(PhaseEos): def getEntropy(self) -> float: ... def getGibbsEnergy(self) -> float: ... @typing.overload - def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... @typing.overload @@ -1215,19 +1983,36 @@ class PhaseGERG2004Eos(PhaseEos): @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 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 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 clone(self) -> "PhaseGERG2008Eos": ... def dFdN(self, int: int) -> float: ... def dFdNdN(self, int: int, int2: int) -> float: ... def dFdNdT(self, int: int) -> float: ... @@ -1235,7 +2020,9 @@ class PhaseGERG2008Eos(PhaseEos): 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]]: ... + 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 @@ -1260,11 +2047,15 @@ class PhaseGERG2008Eos(PhaseEos): def getGresTP(self) -> float: ... def getHresTP(self) -> float: ... @typing.overload - def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... def getZ(self) -> float: ... @@ -1276,60 +2067,186 @@ class PhaseGERG2008Eos(PhaseEos): @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 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: ... + 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 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: ... + 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: ... + 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 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: ... + 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: ... + 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 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 clone(self) -> "PhaseLeachmanEos": ... def dFdN(self, int: int) -> float: ... def dFdNdN(self, int: int, int2: int) -> float: ... def dFdNdT(self, int: int) -> float: ... @@ -1356,11 +2273,15 @@ class PhaseLeachmanEos(PhaseEos): def getEntropy(self) -> float: ... def getGibbsEnergy(self) -> float: ... @typing.overload - def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... def getZ(self) -> float: ... @@ -1372,15 +2293,32 @@ class PhaseLeachmanEos(PhaseEos): @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 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: ... + 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 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 @@ -1401,46 +2339,106 @@ class PhasePitzer(PhaseGE): @typing.overload def getExcessGibbsEnergy(self) -> float: ... @typing.overload - def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + 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: ... + 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: ... + 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': ... + 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': ... + 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: ... + 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': ... + 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 @@ -1459,11 +2457,15 @@ class PhaseSpanWagnerEos(PhaseEos): def getEntropy(self) -> float: ... def getGibbsEnergy(self) -> float: ... @typing.overload - def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... @typing.overload @@ -1476,34 +2478,67 @@ class PhaseSpanWagnerEos(PhaseEos): @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 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': ... + 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': ... + 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 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 clone(self) -> "PhaseVegaEos": ... def dFdN(self, int: int) -> float: ... def dFdNdN(self, int: int, int2: int) -> float: ... def dFdNdT(self, int: int) -> float: ... @@ -1530,11 +2565,15 @@ class PhaseVegaEos(PhaseEos): def getEntropy(self) -> float: ... def getGibbsEnergy(self) -> float: ... @typing.overload - def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... def getZ(self) -> float: ... @@ -1546,18 +2585,35 @@ class PhaseVegaEos(PhaseEos): @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 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 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': ... + def clone(self) -> "PhaseWaterIAPWS": ... @typing.overload def getCp(self, string: typing.Union[java.lang.String, str]) -> float: ... @typing.overload @@ -1576,7 +2632,9 @@ class PhaseWaterIAPWS(PhaseEos): def getEntropy(self) -> float: ... def getGibbsEnergy(self) -> float: ... @typing.overload - def getInternalEnergy(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getInternalEnergy( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getInternalEnergy(self) -> float: ... @typing.overload @@ -1588,31 +2646,70 @@ class PhaseWaterIAPWS(PhaseEos): @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 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 __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: ... + 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 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 clone(self) -> "PhaseBWRSEos": ... def dFdT(self) -> float: ... def dFdTdT(self) -> float: ... def dFdTdV(self) -> float: ... @@ -1638,7 +2735,9 @@ class PhaseBWRSEos(PhaseSrkEos): def getFpoldVdVdV(self) -> float: ... def getGammadRho(self) -> float: ... @typing.overload - def getJouleThomsonCoefficient(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getJouleThomsonCoefficient( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... @typing.overload def getJouleThomsonCoefficient(self) -> float: ... def getMolarDensity(self) -> float: ... @@ -1651,16 +2750,33 @@ class PhaseBWRSEos(PhaseSrkEos): @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: ... + 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 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: ... @@ -1675,8 +2791,17 @@ class PhaseCSPsrkEos(PhaseSrkEos): @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 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: ... @@ -1686,16 +2811,26 @@ class PhaseCSPsrkEos(PhaseSrkEos): 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 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 getAlphares_GERG2008( + self, + ) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... def getProperties_GERG2008(self) -> typing.MutableSequence[float]: ... def getdPdTVn(self) -> float: ... @typing.overload @@ -1703,41 +2838,142 @@ class PhaseEOSCGEos(PhaseGERG2008Eos): @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 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: ... + 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 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: ... + 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: ... + 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 __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: ... @@ -1746,41 +2982,87 @@ class PhaseGEUnifac(PhaseGEUniquac): @typing.overload def getExcessGibbsEnergy(self) -> float: ... @typing.overload - def getExcessGibbsEnergy(self, phaseInterface: PhaseInterface, int: int, double: float, double2: float, phaseType: PhaseType) -> float: ... + 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 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: ... + 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: ... + 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 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 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: ... + 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 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 @@ -1833,9 +3115,17 @@ class PhaseModifiedFurstElectrolyteEos(PhaseSrkEos): 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 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: ... @@ -1854,12 +3144,36 @@ class PhaseModifiedFurstElectrolyteEos(PhaseSrkEos): 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 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 clone(self) -> "PhaseModifiedFurstElectrolyteEos": ... def dFBorndT(self) -> float: ... def dFBorndTdT(self) -> float: ... def dFLRdT(self) -> float: ... @@ -1893,7 +3207,9 @@ class PhaseModifiedFurstElectrolyteEos(PhaseSrkEos): def getDielectricConstant(self) -> float: ... def getDielectricT(self) -> float: ... def getDielectricV(self) -> float: ... - def getElectrolyteMixingRule(self) -> jneqsim.thermo.mixingrule.ElectrolyteMixingRulesInterface: ... + def getElectrolyteMixingRule( + self, + ) -> jneqsim.thermo.mixingrule.ElectrolyteMixingRulesInterface: ... def getEps(self) -> float: ... def getEpsIonic(self) -> float: ... def getEpsIonicdV(self) -> float: ... @@ -1913,10 +3229,21 @@ class PhaseModifiedFurstElectrolyteEos(PhaseSrkEos): @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 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 setFurstIonicCoefficient( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... def volInit(self) -> None: ... class PhaseModifiedFurstElectrolyteEosMod2004(PhaseSrkEos): @@ -1966,9 +3293,17 @@ class PhaseModifiedFurstElectrolyteEosMod2004(PhaseSrkEos): 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 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: ... @@ -1987,12 +3322,36 @@ class PhaseModifiedFurstElectrolyteEosMod2004(PhaseSrkEos): 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 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 clone(self) -> "PhaseModifiedFurstElectrolyteEosMod2004": ... def dFBorndT(self) -> float: ... def dFBorndTdT(self) -> float: ... def dFLRdT(self) -> float: ... @@ -2026,7 +3385,9 @@ class PhaseModifiedFurstElectrolyteEosMod2004(PhaseSrkEos): def getDielectricConstant(self) -> float: ... def getDielectricT(self) -> float: ... def getDielectricV(self) -> float: ... - def getElectrolyteMixingRule(self) -> jneqsim.thermo.mixingrule.ElectrolyteMixingRulesInterface: ... + def getElectrolyteMixingRule( + self, + ) -> jneqsim.thermo.mixingrule.ElectrolyteMixingRulesInterface: ... def getEps(self) -> float: ... def getEpsIonic(self) -> float: ... def getEpsIonicdV(self) -> float: ... @@ -2046,10 +3407,21 @@ class PhaseModifiedFurstElectrolyteEosMod2004(PhaseSrkEos): @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 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 setFurstIonicCoefficient( + self, doubleArray: typing.Union[typing.List[float], jpype.JArray] + ) -> None: ... def volInit(self) -> None: ... class PhasePCSAFT(PhaseSrkEos): @@ -2058,9 +3430,17 @@ class PhasePCSAFT(PhaseSrkEos): 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 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: ... @@ -2093,7 +3473,7 @@ class PhasePCSAFT(PhaseSrkEos): def calcmSAFT(self) -> float: ... def calcmdSAFT(self) -> float: ... def calcmmin1SAFT(self) -> float: ... - def clone(self) -> 'PhasePCSAFT': ... + def clone(self) -> "PhasePCSAFT": ... def dF_DISP1_SAFTdT(self) -> float: ... def dF_DISP1_SAFTdTdT(self) -> float: ... def dF_DISP1_SAFTdTdV(self) -> float: ... @@ -2134,8 +3514,22 @@ class PhasePCSAFT(PhaseSrkEos): 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 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: ... @@ -2145,9 +3539,20 @@ class PhasePCSAFT(PhaseSrkEos): @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 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: ... @@ -2173,9 +3578,17 @@ class PhasePrCPA(PhasePrEos, PhaseCPAInterface): 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 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: ... @@ -2184,7 +3597,7 @@ class PhasePrCPA(PhasePrEos, PhaseCPAInterface): def calc_lngVV(self) -> float: ... def calc_lngVVV(self) -> float: ... def calc_lngni(self, int: int) -> float: ... - def clone(self) -> 'PhasePrCPA': ... + def clone(self) -> "PhasePrCPA": ... def dFCPAdT(self) -> float: ... def dFCPAdTdT(self) -> float: ... def dFCPAdV(self) -> float: ... @@ -2197,7 +3610,9 @@ class PhasePrCPA(PhasePrEos, PhaseCPAInterface): 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 getCrossAssosiationScheme( + self, int: int, int2: int, int3: int, int4: int + ) -> int: ... def getF(self) -> float: ... def getGcpa(self) -> float: ... def getGcpav(self) -> float: ... @@ -2208,7 +3623,9 @@ class PhasePrCPA(PhasePrEos, PhaseCPAInterface): @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 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: ... @@ -2226,17 +3643,51 @@ class PhasePrEosvolcor(PhasePrEos): 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 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 clone(self) -> "PhasePrEosvolcor": ... def dFdT(self) -> float: ... def dFdTdT(self) -> float: ... def dFdTdV(self) -> float: ... @@ -2267,23 +3718,45 @@ class PhasePrEosvolcor(PhasePrEos): 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: ... + 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: ... + 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 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: ... @@ -2294,17 +3767,27 @@ class PhaseSolid(PhaseSrkEos): @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 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 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 clone(self) -> "PhaseSoreideWhitson": ... def getSalinity(self, double: float) -> float: ... def getSalinityConcentration(self) -> float: ... def setSalinityConcentration(self, double: float) -> None: ... @@ -2315,9 +3798,17 @@ class PhaseSrkCPA(PhaseSrkEos, PhaseCPAInterface): 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 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: ... @@ -2327,8 +3818,16 @@ class PhaseSrkCPA(PhaseSrkEos, PhaseCPAInterface): 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 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: ... @@ -2342,7 +3841,9 @@ class PhaseSrkCPA(PhaseSrkEos, PhaseCPAInterface): 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 getCrossAssosiationScheme( + self, int: int, int2: int, int3: int, int4: int + ) -> int: ... def getF(self) -> float: ... def getGcpa(self) -> float: ... def getGcpav(self) -> float: ... @@ -2354,20 +3855,57 @@ class PhaseSrkCPA(PhaseSrkEos, PhaseCPAInterface): @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 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 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 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: ... @@ -2380,9 +3918,17 @@ class PhaseSrkCPA_proceduralMatrices(PhaseSrkEos, PhaseCPAInterface): 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 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: ... @@ -2393,7 +3939,15 @@ class PhaseSrkCPA_proceduralMatrices(PhaseSrkEos, PhaseCPAInterface): 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 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: ... @@ -2407,7 +3961,9 @@ class PhaseSrkCPA_proceduralMatrices(PhaseSrkEos, PhaseCPAInterface): 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 getCrossAssosiationScheme( + self, int: int, int2: int, int3: int, int4: int + ) -> int: ... def getF(self) -> float: ... def getGcpa(self) -> float: ... def getGcpav(self) -> float: ... @@ -2418,17 +3974,45 @@ class PhaseSrkCPA_proceduralMatrices(PhaseSrkEos, PhaseCPAInterface): @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 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 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 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: ... @@ -2446,17 +4030,51 @@ class PhaseSrkEosvolcor(PhaseSrkEos): 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 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 clone(self) -> "PhaseSrkEosvolcor": ... def dFdT(self) -> float: ... def dFdTdT(self) -> float: ... def dFdTdV(self) -> float: ... @@ -2487,23 +4105,45 @@ class PhaseSrkEosvolcor(PhaseSrkEos): 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: ... + 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: ... + 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': ... + 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 = ... @@ -2511,9 +4151,17 @@ class PhaseUMRCPA(PhasePrEos, PhaseCPAInterface): 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 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: ... @@ -2523,8 +4171,16 @@ class PhaseUMRCPA(PhasePrEos, PhaseCPAInterface): 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 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: ... @@ -2538,7 +4194,9 @@ class PhaseUMRCPA(PhasePrEos, PhaseCPAInterface): 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 getCrossAssosiationScheme( + self, int: int, int2: int, int3: int, int4: int + ) -> int: ... def getF(self) -> float: ... def getGcpa(self) -> float: ... def getGcpav(self) -> float: ... @@ -2550,20 +4208,57 @@ class PhaseUMRCPA(PhasePrEos, PhaseCPAInterface): @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 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 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 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: ... @@ -2576,9 +4271,17 @@ class PhaseElectrolyteCPA(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface): 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 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: ... @@ -2588,8 +4291,16 @@ class PhaseElectrolyteCPA(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface): 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 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: ... @@ -2603,7 +4314,9 @@ class PhaseElectrolyteCPA(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface): 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 getCrossAssosiationScheme( + self, int: int, int2: int, int3: int, int4: int + ) -> int: ... def getF(self) -> float: ... def getGcpa(self) -> float: ... def getGcpav(self) -> float: ... @@ -2614,17 +4327,45 @@ class PhaseElectrolyteCPA(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface): @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 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 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 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: ... @@ -2635,9 +4376,17 @@ class PhaseElectrolyteCPAOld(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface 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 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: ... @@ -2647,7 +4396,7 @@ class PhaseElectrolyteCPAOld(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface def calc_lngVV(self) -> float: ... def calc_lngVVV(self) -> float: ... def calc_lngni(self, int: int) -> float: ... - def clone(self) -> 'PhaseElectrolyteCPAOld': ... + def clone(self) -> "PhaseElectrolyteCPAOld": ... def dFCPAdT(self) -> float: ... def dFCPAdTdT(self) -> float: ... def dFCPAdV(self) -> float: ... @@ -2660,7 +4409,9 @@ class PhaseElectrolyteCPAOld(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface 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 getCrossAssosiationScheme( + self, int: int, int2: int, int3: int, int4: int + ) -> int: ... def getF(self) -> float: ... def getGcpa(self) -> float: ... def getGcpav(self) -> float: ... @@ -2672,16 +4423,44 @@ class PhaseElectrolyteCPAOld(PhaseModifiedFurstElectrolyteEos, PhaseCPAInterface @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 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 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: ... @@ -2691,69 +4470,201 @@ 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: ... + 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 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: ... + 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 __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: ... + 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: ... + 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 __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 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 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: ... + def setMixingRule( + self, + mixingRuleTypeInterface: typing.Union[ + jneqsim.thermo.mixingrule.MixingRuleTypeInterface, typing.Callable + ], + ) -> None: ... class PhasePCSAFTRahmat(PhasePCSAFT): def __init__(self): ... @@ -2761,9 +4672,17 @@ class PhasePCSAFTRahmat(PhasePCSAFT): 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 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: ... @@ -2791,7 +4710,7 @@ class PhasePCSAFTRahmat(PhasePCSAFT): def calcmSAFT(self) -> float: ... def calcmdSAFT(self) -> float: ... def calcmmin1SAFT(self) -> float: ... - def clone(self) -> 'PhasePCSAFTRahmat': ... + def clone(self) -> "PhasePCSAFTRahmat": ... def dF_DISP1_SAFTdT(self) -> float: ... def dF_DISP1_SAFTdV(self) -> float: ... def dF_DISP1_SAFTdVdV(self) -> float: ... @@ -2809,16 +4728,39 @@ class PhasePCSAFTRahmat(PhasePCSAFT): 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 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 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): @@ -2827,14 +4769,22 @@ class PhasePCSAFTa(PhasePCSAFT, PhaseCPAInterface): 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 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 clone(self) -> "PhasePCSAFTa": ... def dFCPAdT(self) -> float: ... def dFCPAdTdT(self) -> float: ... def dFCPAdV(self) -> float: ... @@ -2847,7 +4797,9 @@ class PhasePCSAFTa(PhasePCSAFT, PhaseCPAInterface): 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 getCrossAssosiationScheme( + self, int: int, int2: int, int3: int, int4: int + ) -> int: ... def getF(self) -> float: ... def getGcpa(self) -> float: ... def getGcpav(self) -> float: ... @@ -2858,81 +4810,130 @@ class PhasePCSAFTa(PhasePCSAFT, PhaseCPAInterface): @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 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 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': ... + def clone(self) -> "PhasePureComponentSolid": ... class PhaseSolidComplex(PhaseSolid): def __init__(self): ... - def clone(self) -> 'PhaseSolidComplex': ... + 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: ... + 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 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': ... + 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: ... + 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': ... + 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: ... + 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 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': ... + 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 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': ... - + def clone(self) -> "PhaseSrkCPAsOld": ... class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.phase")``. @@ -2971,7 +4972,9 @@ class __module_protocol__(Protocol): PhaseKentEisenberg: typing.Type[PhaseKentEisenberg] PhaseLeachmanEos: typing.Type[PhaseLeachmanEos] PhaseModifiedFurstElectrolyteEos: typing.Type[PhaseModifiedFurstElectrolyteEos] - PhaseModifiedFurstElectrolyteEosMod2004: typing.Type[PhaseModifiedFurstElectrolyteEosMod2004] + PhaseModifiedFurstElectrolyteEosMod2004: typing.Type[ + PhaseModifiedFurstElectrolyteEosMod2004 + ] PhasePCSAFT: typing.Type[PhasePCSAFT] PhasePCSAFTRahmat: typing.Type[PhasePCSAFTRahmat] PhasePCSAFTa: typing.Type[PhasePCSAFTa] diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/system/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/system/__init__.pyi index 58e99733..813eeec2 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/system/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/system/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -20,89 +20,222 @@ 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: ... + 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: ... + 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: ... + 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: ... + 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': ... + def addFluid(self, systemInterface: "SystemInterface") -> "SystemInterface": ... @typing.overload - def addFluid(self, systemInterface: 'SystemInterface', int: int) -> 'SystemInterface': ... + def addFluid( + self, systemInterface: "SystemInterface", int: int + ) -> "SystemInterface": ... @staticmethod - def addFluids(systemInterface: 'SystemInterface', systemInterface2: 'SystemInterface') -> 'SystemInterface': ... + 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 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: ... + 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 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 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: ... + 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': ... + 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': ... + def clone(self) -> "SystemInterface": ... @staticmethod - def combineReservoirFluids(int: int, *systemInterface: 'SystemInterface') -> 'SystemInterface': ... + 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 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: ... @@ -119,14 +252,18 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): 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 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 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: ... @@ -143,7 +280,7 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): def getDensity(self) -> float: ... @typing.overload def getDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... - def getEmptySystemClone(self) -> 'SystemInterface': ... + def getEmptySystemClone(self) -> "SystemInterface": ... @typing.overload def getEnthalpy(self) -> float: ... @typing.overload @@ -155,7 +292,9 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @typing.overload def getExergy(self, double: float) -> float: ... @typing.overload - def getExergy(self, double: float, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... @@ -166,27 +305,45 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): def getHeatOfVaporization(self) -> float: ... def getHelmholtzEnergy(self) -> float: ... def getHydrateCheck(self) -> bool: ... - def getIdealLiquidDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... + 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: ... + 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: ... + 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 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 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: ... @@ -214,7 +371,9 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): def getNumberOfMoles(self) -> float: ... def getNumberOfOilFractionComponents(self) -> int: ... def getNumberOfPhases(self) -> int: ... - def getOilAssayCharacterisation(self) -> jneqsim.thermo.characterization.OilAssayCharacterisation: ... + 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]: ... @@ -223,36 +382,63 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @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: ... + 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: ... + 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: ... + def getPhaseIndex( + self, phaseInterface: jneqsim.thermo.phase.PhaseInterface + ) -> int: ... @typing.overload - def getPhaseNumberOfPhase(self, phaseType: jneqsim.thermo.phase.PhaseType) -> int: ... + 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]: ... + 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': ... + 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: ... + 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]]: ... + 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 @@ -260,7 +446,9 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @typing.overload def getStandard(self) -> jneqsim.standards.StandardInterface: ... @typing.overload - def getStandard(self, string: typing.Union[java.lang.String, str]) -> jneqsim.standards.StandardInterface: ... + def getStandard( + self, string: typing.Union[java.lang.String, str] + ) -> jneqsim.standards.StandardInterface: ... def getTC(self) -> float: ... @typing.overload def getTemperature(self) -> float: ... @@ -271,7 +459,9 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @typing.overload def getThermalConductivity(self) -> float: ... @typing.overload - def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermalConductivity( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getTotalNumberOfMoles(self) -> float: ... @typing.overload def getViscosity(self) -> float: ... @@ -282,7 +472,9 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @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 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: ... @@ -294,7 +486,9 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @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: ... + 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 @@ -311,9 +505,13 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @typing.overload def initPhysicalProperties(self) -> None: ... @typing.overload - def initPhysicalProperties(self, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType) -> None: ... + def initPhysicalProperties( + self, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType + ) -> None: ... @typing.overload - def initPhysicalProperties(self, string: typing.Union[java.lang.String, str]) -> None: ... + def initPhysicalProperties( + self, string: typing.Union[java.lang.String, str] + ) -> None: ... def initProperties(self) -> None: ... def initRefPhases(self) -> None: ... def initThermoProperties(self) -> None: ... @@ -338,23 +536,37 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): def normalizeBeta(self) -> None: ... def orderByDensity(self) -> None: ... @typing.overload - def phaseToSystem(self, int: int) -> 'SystemInterface': ... + def phaseToSystem(self, int: int) -> "SystemInterface": ... @typing.overload - def phaseToSystem(self, int: int, int2: int) -> 'SystemInterface': ... + def phaseToSystem(self, int: int, int2: int) -> "SystemInterface": ... @typing.overload - def phaseToSystem(self, string: typing.Union[java.lang.String, str]) -> 'SystemInterface': ... + def phaseToSystem( + self, string: typing.Union[java.lang.String, str] + ) -> "SystemInterface": ... @typing.overload - def phaseToSystem(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> 'SystemInterface': ... + 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 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 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: ... @@ -364,9 +576,17 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @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 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: ... @@ -376,30 +596,61 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @typing.overload def setBeta(self, int: int, double: float) -> None: ... @typing.overload - def setBinaryInteractionParameter(self, int: int, int2: int, double: float) -> None: ... + 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 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: ... + 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 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: ... + def setForceSinglePhase( + self, string: typing.Union[java.lang.String, str] + ) -> None: ... @typing.overload - def setForceSinglePhase(self, phaseType: jneqsim.thermo.phase.PhaseType) -> None: ... + 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: ... @@ -407,42 +658,78 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): 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: ... + 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: ... + 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 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 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: ... + 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: ... + 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: ... + 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: ... + 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 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 @@ -450,15 +737,26 @@ class SystemInterface(java.lang.Cloneable, java.io.Serializable): @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 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 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: ... + 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] = ... @@ -476,8 +774,16 @@ class SystemThermo(SystemInterface): 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: ... + 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 @@ -485,69 +791,182 @@ class SystemThermo(SystemInterface): @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: ... + 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 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 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 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: ... + 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 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: ... + 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 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 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: ... @@ -565,7 +984,9 @@ class SystemThermo(SystemInterface): 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 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]: ... @@ -596,7 +1017,9 @@ class SystemThermo(SystemInterface): @typing.overload def getExergy(self, double: float) -> float: ... @typing.overload - def getExergy(self, double: float, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... @@ -606,27 +1029,45 @@ class SystemThermo(SystemInterface): def getHeatOfVaporization(self) -> float: ... def getHelmholtzEnergy(self) -> float: ... def getHydrateCheck(self) -> bool: ... - def getIdealLiquidDensity(self, string: typing.Union[java.lang.String, str]) -> float: ... + 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: ... + 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: ... + 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: ... + 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 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 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: ... @@ -653,7 +1094,9 @@ class SystemThermo(SystemInterface): def getNumberOfComponents(self) -> int: ... def getNumberOfOilFractionComponents(self) -> int: ... def getNumberOfPhases(self) -> int: ... - def getOilAssayCharacterisation(self) -> jneqsim.thermo.characterization.OilAssayCharacterisation: ... + 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]: ... @@ -662,22 +1105,40 @@ class SystemThermo(SystemInterface): @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: ... + 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: ... + 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: ... + def getPhaseIndex( + self, phaseInterface: jneqsim.thermo.phase.PhaseInterface + ) -> int: ... @typing.overload - def getPhaseNumberOfPhase(self, string: typing.Union[java.lang.String, str]) -> int: ... + 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]: ... + 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 @@ -688,10 +1149,19 @@ class SystemThermo(SystemInterface): @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: ... + 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]]: ... + 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 @@ -699,7 +1169,9 @@ class SystemThermo(SystemInterface): @typing.overload def getStandard(self) -> jneqsim.standards.StandardInterface: ... @typing.overload - def getStandard(self, string: typing.Union[java.lang.String, str]) -> jneqsim.standards.StandardInterface: ... + def getStandard( + self, string: typing.Union[java.lang.String, str] + ) -> jneqsim.standards.StandardInterface: ... def getSumBeta(self) -> float: ... def getTC(self) -> float: ... @typing.overload @@ -711,7 +1183,9 @@ class SystemThermo(SystemInterface): @typing.overload def getThermalConductivity(self) -> float: ... @typing.overload - def getThermalConductivity(self, string: typing.Union[java.lang.String, str]) -> float: ... + def getThermalConductivity( + self, string: typing.Union[java.lang.String, str] + ) -> float: ... def getTotalNumberOfMoles(self) -> float: ... @typing.overload def getViscosity(self) -> float: ... @@ -722,7 +1196,9 @@ class SystemThermo(SystemInterface): @typing.overload def getVolume(self) -> float: ... def getVolumeFraction(self, int: int) -> float: ... - def getWaxCharacterisation(self) -> jneqsim.thermo.characterization.WaxCharacterise: ... + 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: ... @@ -754,11 +1230,15 @@ class SystemThermo(SystemInterface): @typing.overload def initNumeric(self, int: int, int2: int) -> None: ... @typing.overload - def initPhysicalProperties(self, string: typing.Union[java.lang.String, str]) -> None: ... + 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 initPhysicalProperties( + self, physicalPropertyType: jneqsim.physicalproperties.PhysicalPropertyType + ) -> None: ... def initRefPhases(self) -> None: ... def initTotalNumberOfMoles(self, double: float) -> None: ... def init_x_y(self) -> None: ... @@ -786,19 +1266,33 @@ class SystemThermo(SystemInterface): @typing.overload def phaseToSystem(self, int: int, int2: int) -> SystemInterface: ... @typing.overload - def phaseToSystem(self, string: typing.Union[java.lang.String, str]) -> SystemInterface: ... + def phaseToSystem( + self, string: typing.Union[java.lang.String, str] + ) -> SystemInterface: ... @typing.overload - def phaseToSystem(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> SystemInterface: ... + 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 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 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: ... @@ -808,9 +1302,17 @@ class SystemThermo(SystemInterface): @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 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: ... @@ -820,30 +1322,61 @@ class SystemThermo(SystemInterface): @typing.overload def setBeta(self, int: int, double: float) -> None: ... @typing.overload - def setBinaryInteractionParameter(self, int: int, int2: int, double: float) -> None: ... + 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 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: ... + 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 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: ... + def setForceSinglePhase( + self, string: typing.Union[java.lang.String, str] + ) -> None: ... @typing.overload - def setForceSinglePhase(self, phaseType: jneqsim.thermo.phase.PhaseType) -> None: ... + 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: ... @@ -856,37 +1389,74 @@ class SystemThermo(SystemInterface): @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 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 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 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: ... + 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: ... + 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: ... + 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 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 @@ -894,19 +1464,30 @@ class SystemThermo(SystemInterface): @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 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 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: ... + 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 @@ -922,7 +1503,7 @@ class SystemIdealGas(SystemThermo): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemIdealGas': ... + def clone(self) -> "SystemIdealGas": ... class SystemAmmoniaEos(SystemEos): @typing.overload @@ -934,22 +1515,46 @@ class SystemAmmoniaEos(SystemEos): @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: ... + 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 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': ... + 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 @@ -958,7 +1563,7 @@ class SystemBWRSEos(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemBWRSEos': ... + def clone(self) -> "SystemBWRSEos": ... class SystemBnsEos(SystemEos): @typing.overload @@ -966,21 +1571,50 @@ class SystemBnsEos(SystemEos): @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 __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: ... + 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: ... + 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: ... + 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 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): @@ -990,7 +1624,7 @@ class SystemDesmukhMather(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemDesmukhMather': ... + def clone(self) -> "SystemDesmukhMather": ... class SystemDuanSun(SystemEos): @typing.overload @@ -1002,22 +1636,46 @@ class SystemDuanSun(SystemEos): @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: ... + 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 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': ... + 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 @@ -1026,7 +1684,7 @@ class SystemEOSCGEos(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemEOSCGEos': ... + def clone(self) -> "SystemEOSCGEos": ... def commonInitialization(self) -> None: ... class SystemGERG2004Eos(SystemEos): @@ -1036,7 +1694,7 @@ class SystemGERG2004Eos(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemGERG2004Eos': ... + def clone(self) -> "SystemGERG2004Eos": ... def commonInitialization(self) -> None: ... class SystemGERG2008Eos(SystemEos): @@ -1046,7 +1704,7 @@ class SystemGERG2008Eos(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemGERG2008Eos': ... + def clone(self) -> "SystemGERG2008Eos": ... def commonInitialization(self) -> None: ... class SystemGEWilson(SystemEos): @@ -1056,7 +1714,7 @@ class SystemGEWilson(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemGEWilson': ... + def clone(self) -> "SystemGEWilson": ... class SystemKentEisenberg(SystemEos): @typing.overload @@ -1065,7 +1723,7 @@ class SystemKentEisenberg(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemKentEisenberg': ... + def clone(self) -> "SystemKentEisenberg": ... class SystemLeachmanEos(SystemEos): @typing.overload @@ -1077,22 +1735,46 @@ class SystemLeachmanEos(SystemEos): @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: ... + 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 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 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): @@ -1102,7 +1784,7 @@ class SystemNRTL(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemNRTL': ... + def clone(self) -> "SystemNRTL": ... class SystemPitzer(SystemEos): @typing.overload @@ -1111,15 +1793,24 @@ class SystemPitzer(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPitzer': ... + 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: ... + 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: ... + def setMixingRule( + self, + string: typing.Union[java.lang.String, str], + string2: typing.Union[java.lang.String, str], + ) -> None: ... class SystemPrEos(SystemEos): @typing.overload @@ -1128,7 +1819,7 @@ class SystemPrEos(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPrEos': ... + def clone(self) -> "SystemPrEos": ... class SystemRKEos(SystemEos): @typing.overload @@ -1137,7 +1828,7 @@ class SystemRKEos(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemRKEos': ... + def clone(self) -> "SystemRKEos": ... class SystemSpanWagnerEos(SystemEos): @typing.overload @@ -1149,22 +1840,46 @@ class SystemSpanWagnerEos(SystemEos): @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: ... + 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 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 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): @@ -1174,7 +1889,7 @@ class SystemSrkEos(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemSrkEos': ... + def clone(self) -> "SystemSrkEos": ... class SystemTSTEos(SystemEos): @typing.overload @@ -1183,7 +1898,7 @@ class SystemTSTEos(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemTSTEos': ... + def clone(self) -> "SystemTSTEos": ... class SystemUNIFAC(SystemEos): @typing.overload @@ -1192,7 +1907,7 @@ class SystemUNIFAC(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemUNIFAC': ... + def clone(self) -> "SystemUNIFAC": ... class SystemUNIFACpsrk(SystemEos): @typing.overload @@ -1201,7 +1916,7 @@ class SystemUNIFACpsrk(SystemEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemUNIFACpsrk': ... + def clone(self) -> "SystemUNIFACpsrk": ... class SystemVegaEos(SystemEos): @typing.overload @@ -1217,18 +1932,42 @@ class SystemVegaEos(SystemEos): @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 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): @@ -1245,18 +1984,42 @@ class SystemWaterIF97(SystemEos): @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 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): @@ -1266,21 +2029,21 @@ class SystemCSPsrkEos(SystemSrkEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemCSPsrkEos': ... + 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': ... + 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': ... + def clone(self) -> "SystemFurstElectrolyteEosMod2004": ... class SystemGERGwaterEos(SystemPrEos): @typing.overload @@ -1289,7 +2052,7 @@ class SystemGERGwaterEos(SystemPrEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemGERGwaterEos': ... + def clone(self) -> "SystemGERGwaterEos": ... class SystemPCSAFT(SystemSrkEos): @typing.overload @@ -1299,10 +2062,25 @@ class SystemPCSAFT(SystemSrkEos): @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 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): @@ -1312,7 +2090,7 @@ class SystemPCSAFTa(SystemSrkEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPCSAFTa': ... + def clone(self) -> "SystemPCSAFTa": ... class SystemPrCPA(SystemPrEos): @typing.overload @@ -1321,7 +2099,7 @@ class SystemPrCPA(SystemPrEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPrCPA': ... + def clone(self) -> "SystemPrCPA": ... class SystemPrDanesh(SystemPrEos): @typing.overload @@ -1330,7 +2108,7 @@ class SystemPrDanesh(SystemPrEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPrDanesh': ... + def clone(self) -> "SystemPrDanesh": ... class SystemPrEos1978(SystemPrEos): @typing.overload @@ -1339,7 +2117,7 @@ class SystemPrEos1978(SystemPrEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPrEos1978': ... + def clone(self) -> "SystemPrEos1978": ... class SystemPrEosDelft1998(SystemPrEos): @typing.overload @@ -1348,7 +2126,7 @@ class SystemPrEosDelft1998(SystemPrEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPrEosDelft1998': ... + def clone(self) -> "SystemPrEosDelft1998": ... class SystemPrEosvolcor(SystemPrEos): @typing.overload @@ -1363,7 +2141,7 @@ class SystemPrGassemEos(SystemPrEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPrGassemEos': ... + def clone(self) -> "SystemPrGassemEos": ... class SystemPrMathiasCopeman(SystemPrEos): @typing.overload @@ -1372,7 +2150,7 @@ class SystemPrMathiasCopeman(SystemPrEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPrMathiasCopeman': ... + def clone(self) -> "SystemPrMathiasCopeman": ... class SystemPsrkEos(SystemSrkEos): @typing.overload @@ -1381,7 +2159,7 @@ class SystemPsrkEos(SystemSrkEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemPsrkEos': ... + def clone(self) -> "SystemPsrkEos": ... class SystemSrkCPA(SystemSrkEos): @typing.overload @@ -1393,22 +2171,46 @@ class SystemSrkCPA(SystemSrkEos): @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: ... + 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 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): @@ -1424,7 +2226,7 @@ class SystemSrkMathiasCopeman(SystemSrkEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemSrkMathiasCopeman': ... + def clone(self) -> "SystemSrkMathiasCopeman": ... class SystemSrkPenelouxEos(SystemSrkEos): @typing.overload @@ -1433,7 +2235,7 @@ class SystemSrkPenelouxEos(SystemSrkEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemSrkPenelouxEos': ... + def clone(self) -> "SystemSrkPenelouxEos": ... class SystemSrkSchwartzentruberEos(SystemSrkEos): @typing.overload @@ -1442,7 +2244,7 @@ class SystemSrkSchwartzentruberEos(SystemSrkEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemSrkSchwartzentruberEos': ... + def clone(self) -> "SystemSrkSchwartzentruberEos": ... class SystemSrkTwuCoonEos(SystemSrkEos): @typing.overload @@ -1451,7 +2253,7 @@ class SystemSrkTwuCoonEos(SystemSrkEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemSrkTwuCoonEos': ... + def clone(self) -> "SystemSrkTwuCoonEos": ... class SystemSrkTwuCoonParamEos(SystemSrkEos): @typing.overload @@ -1460,7 +2262,7 @@ class SystemSrkTwuCoonParamEos(SystemSrkEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemSrkTwuCoonParamEos': ... + def clone(self) -> "SystemSrkTwuCoonParamEos": ... class SystemSrkTwuCoonStatoilEos(SystemSrkEos): @typing.overload @@ -1469,7 +2271,7 @@ class SystemSrkTwuCoonStatoilEos(SystemSrkEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemSrkTwuCoonStatoilEos': ... + def clone(self) -> "SystemSrkTwuCoonStatoilEos": ... class SystemUMRCPAEoS(SystemPrEos): @typing.overload @@ -1484,7 +2286,7 @@ class SystemUMRPRUEos(SystemPrEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemUMRPRUEos': ... + def clone(self) -> "SystemUMRPRUEos": ... def commonInitialization(self) -> None: ... class SystemElectrolyteCPA(SystemFurstElectrolyteEos): @@ -1492,14 +2294,14 @@ class SystemElectrolyteCPA(SystemFurstElectrolyteEos): def __init__(self): ... @typing.overload def __init__(self, double: float, double2: float): ... - def clone(self) -> 'SystemElectrolyteCPA': ... + 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': ... + def clone(self) -> "SystemElectrolyteCPAstatoil": ... class SystemSoreideWhitson(SystemPrEos1978): @typing.overload @@ -1509,13 +2311,22 @@ class SystemSoreideWhitson(SystemPrEos1978): @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: ... + 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 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 clone(self) -> "SystemSoreideWhitson": ... def getSalinity(self) -> float: ... - def setSalinity(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + def setSalinity( + self, double: float, string: typing.Union[java.lang.String, str] + ) -> None: ... class SystemSrkCPAs(SystemSrkCPA): @typing.overload @@ -1524,7 +2335,7 @@ class SystemSrkCPAs(SystemSrkCPA): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemSrkCPAs': ... + def clone(self) -> "SystemSrkCPAs": ... class SystemUMRPRUMCEos(SystemUMRPRUEos): @typing.overload @@ -1533,7 +2344,7 @@ class SystemUMRPRUMCEos(SystemUMRPRUEos): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemUMRPRUMCEos': ... + def clone(self) -> "SystemUMRPRUMCEos": ... class SystemSrkCPAstatoil(SystemSrkCPAs): @typing.overload @@ -1542,7 +2353,7 @@ class SystemSrkCPAstatoil(SystemSrkCPAs): def __init__(self, double: float, double2: float): ... @typing.overload def __init__(self, double: float, double2: float, boolean: bool): ... - def clone(self) -> 'SystemSrkCPAstatoil': ... + def clone(self) -> "SystemSrkCPAstatoil": ... class SystemUMRPRUMCEosNew(SystemUMRPRUMCEos): @typing.overload @@ -1550,7 +2361,6 @@ class SystemUMRPRUMCEosNew(SystemUMRPRUMCEos): @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/Vega/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/Vega/__init__.pyi index 012a82bc..370c0a05 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/Vega/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/Vega/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,42 +11,89 @@ 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]]: ... + 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: ... + 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 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]: ... + 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 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 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/__init__.pyi index 6b2ca979..78248585 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -19,7 +19,6 @@ 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/benchmark/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/benchmark/__init__.pyi index af230659..90911ef5 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/benchmark/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/benchmark/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,23 +9,26 @@ 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: ... + 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: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/constants/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/constants/__init__.pyi index deb46998..ae1cee30 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/constants/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/constants/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,8 +9,6 @@ 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]] = ... @@ -24,7 +22,6 @@ class FurstElectrolyteConstants(java.io.Serializable): @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/empiric/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/empiric/__init__.pyi index a039a5cc..66f243f7 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/empiric/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/empiric/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,33 +9,40 @@ 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: ... + 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: ... + 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: ... + 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: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/gerg/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/gerg/__init__.pyi index cbfa3ab6..a3124a3b 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/gerg/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/gerg/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,61 +11,300 @@ 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 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 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 __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 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 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: ... + 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 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: ... + def main( + stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray] + ) -> None: ... class NeqSimAGA8Detail: @typing.overload @@ -75,21 +314,33 @@ class NeqSimAGA8Detail: @typing.overload def getDensity(self) -> float: ... @typing.overload - def getDensity(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> float: ... + 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 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 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 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 propertiesDetail( + self, phaseInterface: jneqsim.thermo.phase.PhaseInterface + ) -> typing.MutableSequence[float]: ... def setPhase(self, phaseInterface: jneqsim.thermo.phase.PhaseInterface) -> None: ... class NeqSimEOSCG: @@ -98,18 +349,28 @@ class NeqSimEOSCG: @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]]: ... + 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: ... + 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 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 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: ... @@ -120,28 +381,41 @@ class NeqSimGERG2008: @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]]: ... + 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: ... + 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 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 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 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/humidair/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/humidair/__init__.pyi index 7be24693..1189ec12 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/humidair/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/humidair/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -7,8 +7,6 @@ else: import typing - - class HumidAir: @staticmethod def cairSat(double: float) -> float: ... @@ -23,7 +21,6 @@ class HumidAir: @staticmethod def saturationPressureWater(double: float) -> float: ... - class __module_protocol__(Protocol): # A module protocol which reflects the result of ``jp.JPackage("jneqsim.thermo.util.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 index 41c4037d..ee39c8bd 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/jni/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/jni/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,43 +9,349 @@ 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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]: ... + 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]: ... + 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: ... + 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]: ... + 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: ... + 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: ... + 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 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/leachman/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/leachman/__init__.pyi index da6badba..2a3fa1a2 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/leachman/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/leachman/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,46 +11,97 @@ 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: ... + 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: ... + 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 __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]]: ... + 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: ... + 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 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]: ... + 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 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/readwrite/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/readwrite/__init__.pyi index 664bf364..0c476667 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/readwrite/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/readwrite/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,40 +11,66 @@ 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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: ... + 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]]: ... + 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: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/referenceequations/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/referenceequations/__init__.pyi index 66ccfabd..543ceca4 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/referenceequations/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/referenceequations/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,15 +11,15 @@ 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 getAlphaRes( + self, + ) -> typing.MutableSequence[typing.MutableSequence[org.netlib.util.doubleW]]: ... def getDensity(self) -> float: ... def getThermalConductivity(self) -> float: ... def getViscosity(self) -> float: ... @@ -30,10 +30,11 @@ 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/spanwagner/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/spanwagner/__init__.pyi index 53a1bcd4..0e12dba8 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/spanwagner/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/spanwagner/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,12 +8,11 @@ else: import jneqsim.thermo.phase import typing - - class NeqSimSpanWagner: @staticmethod - def getProperties(double: float, double2: float, phaseType: jneqsim.thermo.phase.PhaseType) -> typing.MutableSequence[float]: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/steam/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/steam/__init__.pyi index 7853ef0c..39b6b988 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermo/util/steam/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermo/util/steam/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -7,8 +7,6 @@ else: import typing - - class Iapws_if97: @staticmethod def T4_p(double: float) -> float: ... @@ -29,7 +27,6 @@ class Iapws_if97: @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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/__init__.pyi index 25972564..333c7ed4 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -18,15 +18,27 @@ 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 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 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: ... @@ -35,14 +47,36 @@ class ThermodynamicOperations(java.io.Serializable, java.lang.Cloneable): 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: ... + 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 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: ... @@ -51,7 +85,9 @@ class ThermodynamicOperations(java.io.Serializable, java.lang.Cloneable): @typing.overload def PSflash(self, double: float) -> None: ... @typing.overload - def PSflash(self, double: float, string: typing.Union[java.lang.String, str]) -> None: ... + 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: ... @@ -59,51 +95,110 @@ class ThermodynamicOperations(java.io.Serializable, java.lang.Cloneable): @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 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: ... + 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: ... + 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: ... + 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 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: ... + 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: ... + 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: ... + 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 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 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: ... @@ -117,13 +212,27 @@ class ThermodynamicOperations(java.io.Serializable, java.lang.Cloneable): 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 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: ... + 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 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: ... @@ -131,8 +240,15 @@ class ThermodynamicOperations(java.io.Serializable, java.lang.Cloneable): 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 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: ... @@ -142,17 +258,32 @@ class ThermodynamicOperations(java.io.Serializable, java.lang.Cloneable): 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: ... + 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 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 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 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: ... @@ -163,16 +294,34 @@ class ThermodynamicOperations(java.io.Serializable, java.lang.Cloneable): 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 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 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 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 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: ... @@ -180,41 +329,66 @@ class ThermodynamicOperations(java.io.Serializable, java.lang.Cloneable): 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) # + + 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: ... + 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': ... + def valueOf( + string: typing.Union[java.lang.String, str] + ) -> "ThermodynamicOperations.FlashType": ... @staticmethod - def values() -> typing.MutableSequence['ThermodynamicOperations.FlashType']: ... + 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 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__ + chemicalequilibrium: ( + jneqsim.thermodynamicoperations.chemicalequilibrium.__module_protocol__ + ) flashops: jneqsim.thermodynamicoperations.flashops.__module_protocol__ - phaseenvelopeops: jneqsim.thermodynamicoperations.phaseenvelopeops.__module_protocol__ - propertygenerator: jneqsim.thermodynamicoperations.propertygenerator.__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 index 83f601bf..7f05b79a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/chemicalequilibrium/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/chemicalequilibrium/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,18 +11,21 @@ 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi index 3ffbf3d9..a5bbe082 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -15,17 +15,25 @@ 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 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 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: ... @@ -33,10 +41,24 @@ class Flash(jneqsim.thermodynamicoperations.BaseOperation): 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 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: ... @@ -45,9 +67,20 @@ class RachfordRice(java.io.Serializable): class SysNewtonRhapsonPHflash(jneqsim.thermo.ThermodynamicConstantsInterface): @typing.overload - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int): ... + 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, + 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: ... @@ -56,7 +89,12 @@ class SysNewtonRhapsonPHflash(jneqsim.thermo.ThermodynamicConstantsInterface): 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, + systemInterface: jneqsim.thermo.system.SystemInterface, + int: int, + int2: int, + ): ... def init(self) -> None: ... def setJac(self) -> None: ... def setfvec(self) -> None: ... @@ -64,7 +102,12 @@ class SysNewtonRhapsonTPflash(java.io.Serializable): def solve(self) -> float: ... class SysNewtonRhapsonTPflashNew(java.io.Serializable): - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, int: int, int2: int): ... + def __init__( + self, + systemInterface: jneqsim.thermo.system.SystemInterface, + int: int, + int2: int, + ): ... def init(self) -> None: ... def setJac(self) -> None: ... def setfvec(self) -> None: ... @@ -72,9 +115,15 @@ class SysNewtonRhapsonTPflashNew(java.io.Serializable): 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 __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): @@ -85,94 +134,163 @@ class CriticalPointFlash(Flash): def run(self) -> None: ... class ImprovedVUflashQfunc(Flash): - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + 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 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 __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 __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 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 __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 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 __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 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 __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 __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 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 __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 __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 __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 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 __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 __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 getJFreeChart( + self, string: typing.Union[java.lang.String, str] + ) -> org.jfree.chart.JFreeChart: ... def run(self) -> None: ... def solveQ(self) -> float: ... @@ -182,10 +300,14 @@ class TPflash(Flash): @typing.overload def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... @typing.overload - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool): ... + 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 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: ... @@ -195,7 +317,12 @@ class TPgradientFlash(Flash): @typing.overload def __init__(self): ... @typing.overload - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float, double2: float): ... + 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: ... @@ -203,74 +330,135 @@ class TPgradientFlash(Flash): def setfvec(self) -> None: ... class TVflash(Flash): - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + 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 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 __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 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 __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 __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 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 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 __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 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 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 __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 __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 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 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 __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 __init__( + self, + systemInterface: jneqsim.thermo.system.SystemInterface, + double: float, + int: int, + ): ... def calcdQdT(self) -> float: ... def calcdQdTT(self) -> float: ... def onPhaseSolve(self) -> None: ... @@ -278,21 +466,27 @@ class PSFlash(QfuncFlash): def solveQ(self) -> float: ... class PSFlashGERG2008(QfuncFlash): - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + 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 __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 __init__( + self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float + ): ... def calcdQdT(self) -> float: ... def calcdQdTT(self) -> float: ... def run(self) -> None: ... @@ -301,14 +495,18 @@ class PSFlashVega(QfuncFlash): 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 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 __init__( + self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool + ): ... def calcE(self) -> None: ... def calcMultiPhaseBeta(self) -> None: ... def calcQ(self) -> float: ... @@ -354,7 +552,9 @@ 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 __init__( + self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool + ): ... def calcE(self) -> None: ... def calcMultiPhaseBeta(self) -> None: ... def calcQ(self) -> float: ... @@ -370,7 +570,9 @@ 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 __init__( + self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool + ): ... def calcE(self) -> None: ... def calcMultiPhaseBeta(self) -> None: ... def calcQ(self) -> float: ... @@ -380,20 +582,27 @@ class TPmultiflashWAX(TPflash): def stabilityAnalysis(self) -> None: ... class TSFlash(QfuncFlash): - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + 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 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 __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")``. @@ -438,4 +647,6 @@ class __module_protocol__(Protocol): VUflashQfunc: typing.Type[VUflashQfunc] VUflashSingleComp: typing.Type[VUflashSingleComp] dTPflash: typing.Type[dTPflash] - saturationops: jneqsim.thermodynamicoperations.flashops.saturationops.__module_protocol__ + 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 index 5f2ae08a..5c725ae4 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/saturationops/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/flashops/saturationops/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,13 +14,16 @@ 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, + systemInterface: jneqsim.thermo.system.SystemInterface, + int: int, + int2: int, + ): ... def init(self) -> None: ... def setJac(self) -> None: ... def setfvec(self) -> None: ... @@ -30,10 +33,18 @@ class CricondenBarTemp(java.io.Serializable): 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 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: ... @@ -48,18 +59,32 @@ class ConstantDutyFlash(ConstantDutyFlashInterface): 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 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 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 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: ... @@ -69,14 +94,24 @@ class ConstantDutyTemperatureFlash(ConstantDutyFlash): 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 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 __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: ... @@ -101,13 +136,21 @@ class BubblePointTemperatureNoDer(ConstantDutyTemperatureFlash): def run(self) -> None: ... class CalcSaltSatauration(ConstantDutyTemperatureFlash): - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str]): ... + 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 __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: ... @@ -136,7 +179,9 @@ class DewPointTemperatureFlashDer(ConstantDutyTemperatureFlash): def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... def run(self) -> None: ... -class FreezeOut(ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface): +class FreezeOut( + ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface +): FCompTemp: typing.MutableSequence[float] = ... FCompNames: typing.MutableSequence[java.lang.String] = ... noFreezeFlash: bool = ... @@ -144,7 +189,9 @@ class FreezeOut(ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConsta def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... def run(self) -> None: ... -class FreezingPointTemperatureFlash(ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface): +class FreezingPointTemperatureFlash( + ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface +): noFreezeFlash: bool = ... Niterations: int = ... name: java.lang.String = ... @@ -152,12 +199,19 @@ class FreezingPointTemperatureFlash(ConstantDutyTemperatureFlash, jneqsim.thermo @typing.overload def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... @typing.overload - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool): ... + 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 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): @@ -165,7 +219,9 @@ class FreezingPointTemperatureFlashOld(ConstantDutyTemperatureFlash): def printToFile(self, string: typing.Union[java.lang.String, str]) -> None: ... def run(self) -> None: ... -class FreezingPointTemperatureFlashTR(ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface): +class FreezingPointTemperatureFlashTR( + ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface +): noFreezeFlash: bool = ... Niterations: int = ... FCompNames: typing.MutableSequence[java.lang.String] = ... @@ -178,12 +234,16 @@ class FreezingPointTemperatureFlashTR(ConstantDutyTemperatureFlash, jneqsim.ther @typing.overload def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... @typing.overload - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, boolean: bool): ... + 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): +class FugTestConstP( + ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicConstantsInterface +): temp: float = ... pres: float = ... testSystem: jneqsim.thermo.system.SystemInterface = ... @@ -196,7 +256,9 @@ class FugTestConstP(ConstantDutyTemperatureFlash, jneqsim.thermo.ThermodynamicCo @typing.overload def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface): ... @typing.overload - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, double: float): ... + 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: ... @@ -207,8 +269,15 @@ class HCdewPointPressureFlash(ConstantDutyTemperatureFlash): 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 __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): @@ -226,15 +295,27 @@ class HydrateFormationTemperatureFlash(ConstantDutyTemperatureFlash): def stop(self) -> None: ... class HydrateInhibitorConcentrationFlash(ConstantDutyTemperatureFlash): - def __init__(self, systemInterface: jneqsim.thermo.system.SystemInterface, string: typing.Union[java.lang.String, str], double: float): ... + 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 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 __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: ... @@ -246,7 +327,12 @@ class SolidComplexTemperatureCalc(ConstantDutyTemperatureFlash): @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 __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: ... @@ -263,8 +349,15 @@ class WATcalc(ConstantDutyTemperatureFlash): 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 __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): @@ -277,7 +370,6 @@ class WaterDewPointTemperatureMultiphaseFlash(ConstantDutyTemperatureFlash): 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")``. @@ -313,4 +405,6 @@ class __module_protocol__(Protocol): WATcalc: typing.Type[WATcalc] WaterDewPointEquilibriumLine: typing.Type[WaterDewPointEquilibriumLine] WaterDewPointTemperatureFlash: typing.Type[WaterDewPointTemperatureFlash] - WaterDewPointTemperatureMultiphaseFlash: typing.Type[WaterDewPointTemperatureMultiphaseFlash] + 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 index 10fb5fe4..d83a1f58 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -9,9 +9,12 @@ import jneqsim.thermodynamicoperations.phaseenvelopeops.multicomponentenvelopeop 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__ + 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 index bfda6fe4..42db0c07 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/multicomponentenvelopeops/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/multicomponentenvelopeops/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -14,14 +14,18 @@ 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 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: ... @@ -30,14 +34,35 @@ class PTphaseEnvelope(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 addData(self, string: typing.Union[java.lang.String, str], doubleArray: typing.Union[typing.List[typing.MutableSequence[float]], jpype.JArray]) -> None: ... + 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 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: ... @@ -46,12 +71,27 @@ class PTphaseEnvelope(jneqsim.thermodynamicoperations.BaseOperation): 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 __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 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: ... @@ -59,14 +99,35 @@ class PTphaseEnvelope1(jneqsim.thermodynamicoperations.BaseOperation): 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 __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 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: ... @@ -75,12 +136,26 @@ class PTphaseEnvelopeMay(jneqsim.thermodynamicoperations.BaseOperation): 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 __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 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: ... @@ -88,12 +163,25 @@ 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 __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 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: ... @@ -101,25 +189,56 @@ class PTphaseEnvelopeNew2(jneqsim.thermodynamicoperations.BaseOperation): 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 __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 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 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 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: ... @@ -130,7 +249,12 @@ 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 __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: ... @@ -161,7 +285,9 @@ class SysNewtonRhapsonPhaseEnvelope2(java.io.Serializable): def getNpCrit(self) -> int: ... def init(self) -> None: ... @staticmethod - def main(stringArray: typing.Union[typing.List[java.lang.String], jpype.JArray]) -> None: ... + 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: ... @@ -169,7 +295,15 @@ class SysNewtonRhapsonPhaseEnvelope2(java.io.Serializable): 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 __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: ... @@ -178,7 +312,15 @@ class CricondenBarFlash(PTphaseEnvelope): 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 __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: ... @@ -186,7 +328,6 @@ class CricondenThermFlash(PTphaseEnvelope): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/reactivecurves/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/reactivecurves/__init__.pyi index b9d76258..7ca641fe 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/reactivecurves/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/phaseenvelopeops/reactivecurves/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -12,19 +12,31 @@ 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 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 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: ... @@ -32,15 +44,22 @@ class PloadingCurve(jneqsim.thermodynamicoperations.OperationInterface): 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 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi index 28533b78..d5ef4a6e 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/thermodynamicoperations/propertygenerator/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,8 +11,6 @@ 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: ... @@ -22,11 +20,19 @@ class OLGApropertyTableGenerator(jneqsim.thermodynamicoperations.BaseOperation): 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): +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 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: ... @@ -37,9 +43,15 @@ class OLGApropertyTableGeneratorKeywordFormat(jneqsim.thermodynamicoperations.Ba 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 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: ... @@ -50,13 +62,23 @@ class OLGApropertyTableGeneratorWater(jneqsim.thermodynamicoperations.BaseOperat 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: ... + def writeOLGAinpFile2( + self, string: typing.Union[java.lang.String, str] + ) -> None: ... -class OLGApropertyTableGeneratorWaterEven(jneqsim.thermodynamicoperations.BaseOperation): +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 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: ... @@ -67,13 +89,23 @@ class OLGApropertyTableGeneratorWaterEven(jneqsim.thermodynamicoperations.BaseOp 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: ... + def writeOLGAinpFile2( + self, string: typing.Union[java.lang.String, str] + ) -> None: ... -class OLGApropertyTableGeneratorWaterKeywordFormat(jneqsim.thermodynamicoperations.BaseOperation): +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 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: ... @@ -83,11 +115,19 @@ class OLGApropertyTableGeneratorWaterKeywordFormat(jneqsim.thermodynamicoperatio 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): +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 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: ... @@ -98,13 +138,23 @@ class OLGApropertyTableGeneratorWaterStudents(jneqsim.thermodynamicoperations.Ba 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: ... + def writeOLGAinpFile2( + self, string: typing.Union[java.lang.String, str] + ) -> None: ... -class OLGApropertyTableGeneratorWaterStudentsPH(jneqsim.thermodynamicoperations.BaseOperation): +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 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: ... @@ -115,16 +165,27 @@ class OLGApropertyTableGeneratorWaterStudentsPH(jneqsim.thermodynamicoperations. 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: ... - + 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] + OLGApropertyTableGeneratorKeywordFormat: typing.Type[ + OLGApropertyTableGeneratorKeywordFormat + ] OLGApropertyTableGeneratorWater: typing.Type[OLGApropertyTableGeneratorWater] - OLGApropertyTableGeneratorWaterEven: typing.Type[OLGApropertyTableGeneratorWaterEven] - OLGApropertyTableGeneratorWaterKeywordFormat: typing.Type[OLGApropertyTableGeneratorWaterKeywordFormat] - OLGApropertyTableGeneratorWaterStudents: typing.Type[OLGApropertyTableGeneratorWaterStudents] - OLGApropertyTableGeneratorWaterStudentsPH: typing.Type[OLGApropertyTableGeneratorWaterStudentsPH] + 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 index 3cc37148..b7932df7 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/util/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/util/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -17,8 +17,6 @@ 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: ... @@ -39,7 +37,9 @@ class NeqSimLogging: class NeqSimThreadPool: @staticmethod - def execute(runnable: typing.Union[java.lang.Runnable, typing.Callable]) -> None: ... + def execute( + runnable: typing.Union[java.lang.Runnable, typing.Callable] + ) -> None: ... @staticmethod def getDefaultPoolSize() -> int: ... @staticmethod @@ -56,9 +56,11 @@ class NeqSimThreadPool: def isShutdown() -> bool: ... @staticmethod def isTerminated() -> bool: ... - _newCompletionService__T = typing.TypeVar('_newCompletionService__T') # + _newCompletionService__T = typing.TypeVar("_newCompletionService__T") # @staticmethod - def newCompletionService() -> java.util.concurrent.CompletionService[_newCompletionService__T]: ... + def newCompletionService() -> ( + java.util.concurrent.CompletionService[_newCompletionService__T] + ): ... @staticmethod def resetPoolSize() -> None: ... @staticmethod @@ -72,16 +74,25 @@ class NeqSimThreadPool: @staticmethod def shutdown() -> None: ... @staticmethod - def shutdownAndAwait(long: int, timeUnit: java.util.concurrent.TimeUnit) -> bool: ... + def shutdownAndAwait( + long: int, timeUnit: java.util.concurrent.TimeUnit + ) -> bool: ... @staticmethod def shutdownNow() -> None: ... - _submit_1__T = typing.TypeVar('_submit_1__T') # + _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]: ... + 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]: ... + 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 = ... @@ -91,7 +102,6 @@ class NamedBaseClass(NamedInterface, java.io.Serializable): 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/database/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/database/__init__.pyi index 031de4c8..4465d133 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/util/database/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/util/database/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,16 +11,22 @@ 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: ... + 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 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 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): @@ -33,7 +39,9 @@ class NeqSimBlobDatabase(jneqsim.util.util.FileSystemSettings, java.io.Serializa 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 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 @@ -44,14 +52,19 @@ class NeqSimBlobDatabase(jneqsim.util.util.FileSystemSettings, java.io.Serializa 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: ... + 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): +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: ... @@ -66,7 +79,9 @@ class NeqSimDataBase(jneqsim.util.util.FileSystemSettings, java.io.Serializable, 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 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: ... @@ -76,7 +91,10 @@ class NeqSimDataBase(jneqsim.util.util.FileSystemSettings, java.io.Serializable, 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: ... + 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 @@ -86,7 +104,10 @@ class NeqSimDataBase(jneqsim.util.util.FileSystemSettings, java.io.Serializable, 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: ... + 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: ... @@ -97,11 +118,16 @@ class NeqSimDataBase(jneqsim.util.util.FileSystemSettings, java.io.Serializable, 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: ... + 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): +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] = ... @@ -114,7 +140,9 @@ class NeqSimExperimentDatabase(jneqsim.util.util.FileSystemSettings, java.io.Ser 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 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 @@ -125,7 +153,10 @@ class NeqSimExperimentDatabase(jneqsim.util.util.FileSystemSettings, java.io.Ser 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: ... + 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: ... @@ -138,10 +169,18 @@ class NeqSimFluidDataBase(jneqsim.util.util.FileSystemSettings, java.io.Serializ 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: ... + 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] = ... @@ -153,7 +192,10 @@ class NeqSimContractDataBase(NeqSimDataBase): 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: ... + 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] = ... @@ -162,12 +204,14 @@ class NeqSimProcessDesignDataBase(NeqSimDataBase): def initH2DatabaseFromCSVfiles() -> None: ... @typing.overload @staticmethod - def updateTable(string: typing.Union[java.lang.String, str], string2: typing.Union[java.lang.String, str]) -> None: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/exception/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/exception/__init__.pyi index 2319be75..47233a61 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/util/exception/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/util/exception/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,62 +8,153 @@ else: 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]): ... + 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]): ... + 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]): ... + 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]): ... + 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]): ... + 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]): ... + 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]): ... + 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): ... + 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): ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/generator/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/generator/__init__.pyi index cecd9fbe..b1a915c2 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/util/generator/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/util/generator/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -11,14 +11,18 @@ 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 __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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/serialization/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/serialization/__init__.pyi index bcd85c2b..9182f40a 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/util/serialization/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/util/serialization/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,22 +8,23 @@ else: 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: ... + 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: ... - + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/unit/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/unit/__init__.pyi index e555bf6d..bdb8640d 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/util/unit/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/util/unit/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -10,25 +10,32 @@ 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 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: ... + 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: ... + 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: ... @@ -50,28 +57,52 @@ class Units: @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 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: ... + 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]): ... + 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: ... + 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: ... + 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: ... + 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: ... @@ -80,41 +111,75 @@ class LengthUnit(BaseUnit): 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: ... + 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: ... + 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: ... + 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: ... + 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 __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: ... + 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: ... + 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: ... + 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")``. diff --git a/src/jneqsim-stubs/jneqsim-stubs/util/util/__init__.pyi b/src/jneqsim-stubs/jneqsim-stubs/util/util/__init__.pyi index 620e9bf8..ccfe72d9 100644 --- a/src/jneqsim-stubs/jneqsim-stubs/util/util/__init__.pyi +++ b/src/jneqsim-stubs/jneqsim-stubs/util/util/__init__.pyi @@ -1,5 +1,5 @@ - import sys + if sys.version_info >= (3, 8): from typing import Protocol else: @@ -8,14 +8,12 @@ else: 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 clone(self) -> "DoubleCloneable": ... def doubleValue(self) -> float: ... def set(self, double: float) -> None: ... @@ -27,7 +25,6 @@ class FileSystemSettings: 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")``. diff --git a/src/jneqsim-stubs/jpype-stubs/__init__.pyi b/src/jneqsim-stubs/jpype-stubs/__init__.pyi index fe25482e..380acf75 100644 --- a/src/jneqsim-stubs/jpype-stubs/__init__.pyi +++ b/src/jneqsim-stubs/jpype-stubs/__init__.pyi @@ -1,8 +1,8 @@ import types import typing - import sys + if sys.version_info >= (3, 8): from typing import Literal else: @@ -10,14 +10,8 @@ else: import neqsim - @typing.overload -def JPackage(__package_name: Literal['neqsim']) -> jneqsim.__module_protocol__: ... - - +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/neqsim/neqsimpython.py b/src/neqsim/neqsimpython.py index 438ea73c..18435ecc 100644 --- a/src/neqsim/neqsimpython.py +++ b/src/neqsim/neqsimpython.py @@ -3,6 +3,7 @@ class NeqSimJVMError(Exception): """Exception raised when JVM initialization fails.""" + pass diff --git a/src/neqsim/process/measurement.py b/src/neqsim/process/measurement.py index 22ad297e..bf96cbc3 100644 --- a/src/neqsim/process/measurement.py +++ b/src/neqsim/process/measurement.py @@ -136,4 +136,4 @@ def acknowledgeAlarm(self): def getAlarmConfig(self): # Add the logic to get alarm configuration. # This is a placeholder implementation. - return getattr(self, 'alarmConfig', None) + return getattr(self, "alarmConfig", None) diff --git a/src/neqsim/process/processTools.py b/src/neqsim/process/processTools.py index e2f893da..226df098 100644 --- a/src/neqsim/process/processTools.py +++ b/src/neqsim/process/processTools.py @@ -28,13 +28,13 @@ >>> from neqsim.thermo import fluid >>> from neqsim.process import stream, compressor, runProcess, clearProcess - >>> + >>> >>> clearProcess() >>> my_fluid = fluid('srk') >>> my_fluid.addComponent('methane', 1.0) >>> my_fluid.setTemperature(30.0, 'C') >>> my_fluid.setPressure(10.0, 'bara') - >>> + >>> >>> inlet = stream('inlet', my_fluid) >>> comp = compressor('compressor1', inlet, pres=50.0) >>> runProcess() @@ -50,12 +50,12 @@ >>> from neqsim.thermo import fluid >>> from neqsim.process import ProcessContext - >>> + >>> >>> with ProcessContext("Compression") as ctx: ... my_fluid = fluid('srk') ... my_fluid.addComponent('methane', 1.0) ... my_fluid.setPressure(10.0, 'bara') - ... + ... ... inlet = ctx.stream('inlet', my_fluid) ... comp = ctx.compressor('comp1', inlet, pres=50.0) ... ctx.run() @@ -71,16 +71,16 @@ >>> from neqsim.thermo import fluid >>> from neqsim.process import ProcessBuilder - >>> + >>> >>> my_fluid = fluid('srk') >>> my_fluid.addComponent('methane', 1.0) >>> my_fluid.setPressure(10.0, 'bara') - >>> + >>> >>> process = (ProcessBuilder("Compression") ... .add_stream('inlet', my_fluid) ... .add_compressor('comp1', 'inlet', pressure=50.0) ... .run()) - >>> + >>> >>> print(f"Power: {process.get('comp1').getPower()/1e6:.2f} MW") Pros: Very readable, chainable, equipment by name, declarative style @@ -92,15 +92,15 @@ >>> from neqsim import jneqsim >>> from neqsim.thermo import fluid - >>> + >>> >>> my_fluid = fluid('srk') >>> my_fluid.addComponent('methane', 1.0) >>> my_fluid.setPressure(10.0, 'bara') - >>> + >>> >>> inlet = jneqsim.process.equipment.stream.Stream('inlet', my_fluid) >>> comp = jneqsim.process.equipment.compressor.Compressor('comp1', inlet) >>> comp.setOutletPressure(50.0) - >>> + >>> >>> process = jneqsim.process.processmodel.ProcessSystem() >>> process.add(inlet) >>> process.add(comp) @@ -115,7 +115,7 @@ process control while keeping concise syntax: >>> from neqsim.process import stream, compressor, newProcess - >>> + >>> >>> my_process = newProcess('MyProcess') >>> inlet = stream('inlet', my_fluid, process=my_process) >>> comp = compressor('comp1', inlet, pres=50.0, process=my_process) @@ -153,6 +153,7 @@ Classes: ProcessContext, ProcessBuilder """ + from __future__ import annotations import json @@ -171,105 +172,105 @@ class ProcessContext: """ Context manager for explicit process simulation management. - + ProcessContext provides a clean way to create and manage process simulations without relying on global state. Each context has its own ProcessSystem, allowing multiple independent processes. - + Args: name: Name of the process (optional). - + Attributes: process: The underlying ProcessSystem object. equipment: Dictionary of equipment by name. - + Example: >>> from neqsim.thermo import fluid >>> from neqsim.process import ProcessContext - >>> + >>> >>> with ProcessContext("Compression") as ctx: ... feed = fluid('srk') ... feed.addComponent('methane', 1.0) ... feed.setPressure(10.0, 'bara') - ... + ... ... inlet = ctx.stream('inlet', feed) ... comp = ctx.compressor('comp1', inlet, pres=50.0) ... ctx.run() ... print(f"Power: {comp.getPower()/1e6:.2f} MW") - + Example without context manager: >>> ctx = ProcessContext("MyProcess") >>> inlet = ctx.stream('inlet', my_fluid) >>> comp = ctx.compressor('comp1', inlet, pres=50.0) >>> ctx.run() """ - + def __init__(self, name: str = ""): """Create a new ProcessContext with its own ProcessSystem.""" self.process = jneqsim.process.processmodel.ProcessSystem(name) self.equipment: Dict[str, Any] = {} self._name = name - - def __enter__(self) -> 'ProcessContext': + + def __enter__(self) -> "ProcessContext": """Enter the context manager.""" return self - + def __exit__(self, exc_type, exc_val, exc_tb) -> bool: """Exit the context manager.""" return False - + def add(self, equipment: Any) -> Any: """ Add equipment to the process. - + Args: equipment: Equipment object to add. - + Returns: The equipment object (for chaining). """ self.process.add(equipment) - if hasattr(equipment, 'getName'): + if hasattr(equipment, "getName"): self.equipment[equipment.getName()] = equipment return equipment - - def run(self) -> 'ProcessContext': + + def run(self) -> "ProcessContext": """ Run the process simulation. - + Returns: Self for method chaining. """ self.process.run() return self - - def run_transient(self, dt: float, time: float) -> 'ProcessContext': + + def run_transient(self, dt: float, time: float) -> "ProcessContext": """ Run transient simulation. - + Args: dt: Time step in seconds. time: Total simulation time in seconds. - + Returns: Self for method chaining. """ self.process.setTimeStep(dt) self.process.runTransient(time) return self - + def get(self, name: str) -> Any: """ Get equipment by name. - + Args: name: Name of the equipment. - + Returns: The equipment object. """ return self.equipment.get(name) - + def stream(self, name: str, thermo_system: Any, t: float = 0, p: float = 0) -> Any: """Create a stream and add to this process.""" if t != 0: @@ -278,90 +279,100 @@ def stream(self, name: str, thermo_system: Any, t: float = 0, p: float = 0) -> A thermo_system.setPressure(p) s = jneqsim.process.equipment.stream.Stream(name, thermo_system) return self.add(s) - + def separator(self, name: str, inlet_stream: Any) -> Any: """Create a separator and add to this process.""" sep = jneqsim.process.equipment.separator.Separator(name, inlet_stream) return self.add(sep) - + def separator3phase(self, name: str, inlet_stream: Any) -> Any: """Create a 3-phase separator and add to this process.""" - sep = jneqsim.process.equipment.separator.ThreePhaseSeparator(name, inlet_stream) + sep = jneqsim.process.equipment.separator.ThreePhaseSeparator( + name, inlet_stream + ) return self.add(sep) - - def compressor(self, name: str, inlet_stream: Any, pres: float = 0, - efficiency: float = 0.75) -> Any: + + def compressor( + self, name: str, inlet_stream: Any, pres: float = 0, efficiency: float = 0.75 + ) -> Any: """Create a compressor and add to this process.""" comp = jneqsim.process.equipment.compressor.Compressor(name, inlet_stream) if pres > 0: comp.setOutletPressure(pres) comp.setIsentropicEfficiency(efficiency) return self.add(comp) - - def pump(self, name: str, inlet_stream: Any, pres: float = 0, - efficiency: float = 0.75) -> Any: + + def pump( + self, name: str, inlet_stream: Any, pres: float = 0, efficiency: float = 0.75 + ) -> Any: """Create a pump and add to this process.""" p = jneqsim.process.equipment.pump.Pump(name, inlet_stream) if pres > 0: p.setOutletPressure(pres) p.setIsentropicEfficiency(efficiency) return self.add(p) - + def expander(self, name: str, inlet_stream: Any, pres: float = 0) -> Any: """Create an expander and add to this process.""" exp = jneqsim.process.equipment.expander.Expander(name, inlet_stream) if pres > 0: exp.setOutletPressure(pres) return self.add(exp) - + def valve(self, name: str, inlet_stream: Any, pres: float = 0) -> Any: """Create a valve and add to this process.""" v = jneqsim.process.equipment.valve.ThrottlingValve(name, inlet_stream) if pres > 0: v.setOutletPressure(pres) return self.add(v) - + def heater(self, name: str, inlet_stream: Any, temp: float = 0) -> Any: """Create a heater and add to this process.""" h = jneqsim.process.equipment.heatexchanger.Heater(name, inlet_stream) if temp > 0: h.setOutTemperature(temp) return self.add(h) - + def cooler(self, name: str, inlet_stream: Any, temp: float = 0) -> Any: """Create a cooler and add to this process.""" c = jneqsim.process.equipment.heatexchanger.Cooler(name, inlet_stream) if temp > 0: c.setOutTemperature(temp) return self.add(c) - + def mixer(self, name: str) -> Any: """Create a mixer and add to this process.""" m = jneqsim.process.equipment.mixer.Mixer(name) return self.add(m) - - def splitter(self, name: str, inlet_stream: Any, split_factors: List[float] = None) -> Any: + + def splitter( + self, name: str, inlet_stream: Any, split_factors: List[float] = None + ) -> Any: """Create a splitter and add to this process.""" s = jneqsim.process.equipment.splitter.Splitter(name, inlet_stream) if split_factors: s.setSplitFactors(split_factors) return self.add(s) - - def heat_exchanger(self, name: str, hot_stream: Any, cold_stream: Any, - approach_temp: float = 10.0) -> Any: + + def heat_exchanger( + self, name: str, hot_stream: Any, cold_stream: Any, approach_temp: float = 10.0 + ) -> Any: """Create a heat exchanger and add to this process.""" - hx = jneqsim.process.equipment.heatexchanger.HeatExchanger(name, hot_stream, cold_stream) + hx = jneqsim.process.equipment.heatexchanger.HeatExchanger( + name, hot_stream, cold_stream + ) hx.setApproachTemperature(approach_temp) return self.add(hx) - - def pipe(self, name: str, inlet_stream: Any, length: float = 100.0, - diameter: float = 0.1) -> Any: + + def pipe( + self, name: str, inlet_stream: Any, length: float = 100.0, diameter: float = 0.1 + ) -> Any: """Create a pipe and add to this process.""" p = jneqsim.process.equipment.pipeline.AdiabaticPipe(name, inlet_stream) p.setLength(length) p.setDiameter(diameter) return self.add(p) - + def recycle(self, name: str, inlet_stream: Any = None) -> Any: """Create a recycle and add to this process.""" r = jneqsim.process.equipment.util.Recycle(name) @@ -373,115 +384,125 @@ def recycle(self, name: str, inlet_stream: Any = None) -> Any: class ProcessBuilder: """ Fluent builder for constructing process simulations. - + ProcessBuilder provides a chainable API for building processes step by step. Equipment is referenced by name, making it easy to construct processes from configuration data. - + Example: >>> from neqsim.thermo import fluid >>> from neqsim.process import ProcessBuilder - >>> + >>> >>> feed = fluid('srk') >>> feed.addComponent('methane', 0.9) >>> feed.addComponent('ethane', 0.1) >>> feed.setPressure(30.0, 'bara') >>> feed.setTemperature(30.0, 'C') - >>> + >>> >>> process = (ProcessBuilder("Compression Train") ... .add_stream('inlet', feed) ... .add_compressor('comp1', 'inlet', pressure=60.0) ... .add_cooler('cooler1', 'comp1', temperature=303.15) ... .add_compressor('comp2', 'cooler1', pressure=120.0) ... .run()) - >>> + >>> >>> print(f"Stage 1 power: {process.get('comp1').getPower()/1e6:.2f} MW") >>> print(f"Stage 2 power: {process.get('comp2').getPower()/1e6:.2f} MW") """ - + def __init__(self, name: str = ""): """Create a new ProcessBuilder.""" self.process = jneqsim.process.processmodel.ProcessSystem(name) self.equipment: Dict[str, Any] = {} self._name = name - + def _get_outlet(self, ref: Union[str, Any]) -> Any: """ Get outlet stream from equipment reference (name or object). - + Supports dot notation for selecting specific outlets from separators: - 'separator.gas' or 'separator.vapor' - gas/vapor outlet - 'separator.liquid' - liquid outlet (2-phase separator) - 'separator.oil' - oil outlet (3-phase separator) - 'separator.water' or 'separator.aqueous' - water outlet (3-phase separator) - + Examples: >>> builder.add_compressor('comp', 'sep.gas', pressure=100) >>> builder.add_pump('pump', 'sep.oil', pressure=50) """ if isinstance(ref, str): # Check for dot notation (e.g., 'separator.gas') - if '.' in ref: - parts = ref.split('.', 1) + if "." in ref: + parts = ref.split(".", 1) equip_name = parts[0] outlet_type = parts[1].lower() - + equip = self.equipment.get(equip_name) if equip is None: raise ValueError(f"Equipment '{equip_name}' not found") - + # Map outlet type to method outlet_methods = { - 'gas': ['getGasOutStream', 'getOutletStream'], - 'vapor': ['getGasOutStream', 'getOutletStream'], - 'liquid': ['getLiquidOutStream', 'getOilOutStream'], - 'oil': ['getOilOutStream', 'getLiquidOutStream'], - 'water': ['getWaterOutStream', 'getAqueousOutStream'], - 'aqueous': ['getWaterOutStream', 'getAqueousOutStream'], + "gas": ["getGasOutStream", "getOutletStream"], + "vapor": ["getGasOutStream", "getOutletStream"], + "liquid": ["getLiquidOutStream", "getOilOutStream"], + "oil": ["getOilOutStream", "getLiquidOutStream"], + "water": ["getWaterOutStream", "getAqueousOutStream"], + "aqueous": ["getWaterOutStream", "getAqueousOutStream"], } - + if outlet_type not in outlet_methods: - raise ValueError(f"Unknown outlet type '{outlet_type}'. " - f"Valid types: {list(outlet_methods.keys())}") - + raise ValueError( + f"Unknown outlet type '{outlet_type}'. " + f"Valid types: {list(outlet_methods.keys())}" + ) + for method_name in outlet_methods[outlet_type]: if hasattr(equip, method_name): return getattr(equip, method_name)() - - raise ValueError(f"Equipment '{equip_name}' does not have a '{outlet_type}' outlet") - + + raise ValueError( + f"Equipment '{equip_name}' does not have a '{outlet_type}' outlet" + ) + # Standard lookup without dot notation equip = self.equipment.get(ref) if equip is None: raise ValueError(f"Equipment '{ref}' not found") - if hasattr(equip, 'getOutletStream'): + if hasattr(equip, "getOutletStream"): return equip.getOutletStream() - elif hasattr(equip, 'getOutStream'): + elif hasattr(equip, "getOutStream"): return equip.getOutStream() - elif hasattr(equip, 'getGasOutStream'): + elif hasattr(equip, "getGasOutStream"): return equip.getGasOutStream() return equip return ref - - def add_stream(self, name: str, thermo_system: Any, - temperature: float = None, pressure: float = None, - flow_rate: float = None, flow_unit: str = 'kg/sec') -> 'ProcessBuilder': + + def add_stream( + self, + name: str, + thermo_system: Any, + temperature: float = None, + pressure: float = None, + flow_rate: float = None, + flow_unit: str = "kg/sec", + ) -> "ProcessBuilder": """ Add a stream to the process. - + Args: name: Name of the stream. thermo_system: Fluid/thermodynamic system. temperature: Optional temperature in Kelvin. pressure: Optional pressure in bara. - flow_rate: Optional flow rate. If not specified, uses the flow rate + flow_rate: Optional flow rate. If not specified, uses the flow rate already set on the fluid. flow_unit: Unit for flow rate (default 'kg/sec'). Common units include 'kg/sec', 'kg/hr', 'MSm3/day', 'Sm3/day', 'mole/sec'. - + Returns: Self for method chaining. - + Example: >>> process = (ProcessBuilder("Test") ... .add_stream('inlet', feed, flow_rate=10.0, flow_unit='MSm3/day') @@ -497,20 +518,25 @@ def add_stream(self, name: str, thermo_system: Any, self.equipment[name] = s self.process.add(s) return self - - def add_separator(self, name: str, inlet: str, three_phase: bool = False) -> 'ProcessBuilder': + + def add_separator( + self, name: str, inlet: str, three_phase: bool = False + ) -> "ProcessBuilder": """Add a separator to the process.""" inlet_stream = self._get_outlet(inlet) if three_phase: - sep = jneqsim.process.equipment.separator.ThreePhaseSeparator(name, inlet_stream) + sep = jneqsim.process.equipment.separator.ThreePhaseSeparator( + name, inlet_stream + ) else: sep = jneqsim.process.equipment.separator.Separator(name, inlet_stream) self.equipment[name] = sep self.process.add(sep) return self - - def add_compressor(self, name: str, inlet: str, pressure: float = None, - efficiency: float = 0.75) -> 'ProcessBuilder': + + def add_compressor( + self, name: str, inlet: str, pressure: float = None, efficiency: float = 0.75 + ) -> "ProcessBuilder": """Add a compressor to the process.""" inlet_stream = self._get_outlet(inlet) comp = jneqsim.process.equipment.compressor.Compressor(name, inlet_stream) @@ -520,9 +546,10 @@ def add_compressor(self, name: str, inlet: str, pressure: float = None, self.equipment[name] = comp self.process.add(comp) return self - - def add_pump(self, name: str, inlet: str, pressure: float = None, - efficiency: float = 0.75) -> 'ProcessBuilder': + + def add_pump( + self, name: str, inlet: str, pressure: float = None, efficiency: float = 0.75 + ) -> "ProcessBuilder": """Add a pump to the process.""" inlet_stream = self._get_outlet(inlet) p = jneqsim.process.equipment.pump.Pump(name, inlet_stream) @@ -532,8 +559,10 @@ def add_pump(self, name: str, inlet: str, pressure: float = None, self.equipment[name] = p self.process.add(p) return self - - def add_expander(self, name: str, inlet: str, pressure: float = None) -> 'ProcessBuilder': + + def add_expander( + self, name: str, inlet: str, pressure: float = None + ) -> "ProcessBuilder": """Add an expander to the process.""" inlet_stream = self._get_outlet(inlet) exp = jneqsim.process.equipment.expander.Expander(name, inlet_stream) @@ -542,8 +571,10 @@ def add_expander(self, name: str, inlet: str, pressure: float = None) -> 'Proces self.equipment[name] = exp self.process.add(exp) return self - - def add_valve(self, name: str, inlet: str, pressure: float = None) -> 'ProcessBuilder': + + def add_valve( + self, name: str, inlet: str, pressure: float = None + ) -> "ProcessBuilder": """Add a valve to the process.""" inlet_stream = self._get_outlet(inlet) v = jneqsim.process.equipment.valve.ThrottlingValve(name, inlet_stream) @@ -552,9 +583,10 @@ def add_valve(self, name: str, inlet: str, pressure: float = None) -> 'ProcessBu self.equipment[name] = v self.process.add(v) return self - - def add_heater(self, name: str, inlet: str, temperature: float = None, - duty: float = None) -> 'ProcessBuilder': + + def add_heater( + self, name: str, inlet: str, temperature: float = None, duty: float = None + ) -> "ProcessBuilder": """Add a heater to the process.""" inlet_stream = self._get_outlet(inlet) h = jneqsim.process.equipment.heatexchanger.Heater(name, inlet_stream) @@ -565,9 +597,10 @@ def add_heater(self, name: str, inlet: str, temperature: float = None, self.equipment[name] = h self.process.add(h) return self - - def add_cooler(self, name: str, inlet: str, temperature: float = None, - duty: float = None) -> 'ProcessBuilder': + + def add_cooler( + self, name: str, inlet: str, temperature: float = None, duty: float = None + ) -> "ProcessBuilder": """Add a cooler to the process.""" inlet_stream = self._get_outlet(inlet) c = jneqsim.process.equipment.heatexchanger.Cooler(name, inlet_stream) @@ -578,8 +611,8 @@ def add_cooler(self, name: str, inlet: str, temperature: float = None, self.equipment[name] = c self.process.add(c) return self - - def add_mixer(self, name: str, inlets: List[str]) -> 'ProcessBuilder': + + def add_mixer(self, name: str, inlets: List[str]) -> "ProcessBuilder": """Add a mixer to the process.""" m = jneqsim.process.equipment.mixer.Mixer(name) for inlet in inlets: @@ -588,9 +621,10 @@ def add_mixer(self, name: str, inlets: List[str]) -> 'ProcessBuilder': self.equipment[name] = m self.process.add(m) return self - - def add_splitter(self, name: str, inlet: str, - split_factors: List[float] = None) -> 'ProcessBuilder': + + def add_splitter( + self, name: str, inlet: str, split_factors: List[float] = None + ) -> "ProcessBuilder": """Add a splitter to the process.""" inlet_stream = self._get_outlet(inlet) s = jneqsim.process.equipment.splitter.Splitter(name, inlet_stream) @@ -599,20 +633,29 @@ def add_splitter(self, name: str, inlet: str, self.equipment[name] = s self.process.add(s) return self - - def add_heat_exchanger(self, name: str, hot_inlet: str, cold_inlet: str, - approach_temp: float = 10.0) -> 'ProcessBuilder': + + def add_heat_exchanger( + self, name: str, hot_inlet: str, cold_inlet: str, approach_temp: float = 10.0 + ) -> "ProcessBuilder": """Add a heat exchanger to the process.""" hot_stream = self._get_outlet(hot_inlet) cold_stream = self._get_outlet(cold_inlet) - hx = jneqsim.process.equipment.heatexchanger.HeatExchanger(name, hot_stream, cold_stream) + hx = jneqsim.process.equipment.heatexchanger.HeatExchanger( + name, hot_stream, cold_stream + ) hx.setApproachTemperature(approach_temp) self.equipment[name] = hx self.process.add(hx) return self - - def add_pipe(self, name: str, inlet: str, length: float = 100.0, - diameter: float = 0.1, elevation: float = 0.0) -> 'ProcessBuilder': + + def add_pipe( + self, + name: str, + inlet: str, + length: float = 100.0, + diameter: float = 0.1, + elevation: float = 0.0, + ) -> "ProcessBuilder": """Add a pipe to the process.""" inlet_stream = self._get_outlet(inlet) p = jneqsim.process.equipment.pipeline.AdiabaticPipe(name, inlet_stream) @@ -623,55 +666,60 @@ def add_pipe(self, name: str, inlet: str, length: float = 100.0, self.equipment[name] = p self.process.add(p) return self - - def add_equipment(self, equipment_type: str, name: str, **kwargs) -> 'ProcessBuilder': + + def add_equipment( + self, equipment_type: str, name: str, **kwargs + ) -> "ProcessBuilder": """ Add equipment by type name. Useful for configuration-driven design. - + Args: equipment_type: Type of equipment ('stream', 'compressor', 'separator', etc.) name: Name of the equipment. **kwargs: Equipment-specific parameters. - + Returns: Self for method chaining. - + Example: >>> builder.add_equipment('compressor', 'comp1', inlet='inlet', pressure=100.0) """ method_map = { - 'stream': self.add_stream, - 'separator': self.add_separator, - 'compressor': self.add_compressor, - 'pump': self.add_pump, - 'expander': self.add_expander, - 'valve': self.add_valve, - 'heater': self.add_heater, - 'cooler': self.add_cooler, - 'mixer': self.add_mixer, - 'splitter': self.add_splitter, - 'heat_exchanger': self.add_heat_exchanger, - 'pipe': self.add_pipe, + "stream": self.add_stream, + "separator": self.add_separator, + "compressor": self.add_compressor, + "pump": self.add_pump, + "expander": self.add_expander, + "valve": self.add_valve, + "heater": self.add_heater, + "cooler": self.add_cooler, + "mixer": self.add_mixer, + "splitter": self.add_splitter, + "heat_exchanger": self.add_heat_exchanger, + "pipe": self.add_pipe, } method = method_map.get(equipment_type.lower()) if method is None: - raise ValueError(f"Unknown equipment type: {equipment_type}. " - f"Available: {list(method_map.keys())}") + raise ValueError( + f"Unknown equipment type: {equipment_type}. " + f"Available: {list(method_map.keys())}" + ) return method(name, **kwargs) - - def add_from_config(self, equipment_list: List[Dict[str, Any]], - fluids: Dict[str, Any] = None) -> 'ProcessBuilder': + + def add_from_config( + self, equipment_list: List[Dict[str, Any]], fluids: Dict[str, Any] = None + ) -> "ProcessBuilder": """ Add multiple equipment items from a configuration list. - + Args: equipment_list: List of equipment configurations. Each item should have 'type', 'name', and equipment-specific parameters. fluids: Dictionary mapping fluid names to fluid objects. Used for streams. - + Returns: Self for method chaining. - + Example: >>> config = [ ... {'type': 'stream', 'name': 'inlet', 'fluid': 'feed'}, @@ -680,36 +728,38 @@ def add_from_config(self, equipment_list: List[Dict[str, Any]], >>> builder.add_from_config(config, fluids={'feed': my_fluid}) """ fluids = fluids or {} - + for item in equipment_list: item = item.copy() # Don't modify original - eq_type = item.pop('type') - name = item.pop('name') - + eq_type = item.pop("type") + name = item.pop("name") + # Handle fluid reference for streams - if eq_type == 'stream' and 'fluid' in item: - fluid_name = item.pop('fluid') + if eq_type == "stream" and "fluid" in item: + fluid_name = item.pop("fluid") if fluid_name in fluids: - item['thermo_system'] = fluids[fluid_name] + item["thermo_system"] = fluids[fluid_name] else: raise ValueError(f"Fluid '{fluid_name}' not found in fluids dict") - + self.add_equipment(eq_type, name, **item) - + return self - + @classmethod - def from_dict(cls, config: Dict[str, Any], fluids: Dict[str, Any] = None) -> 'ProcessBuilder': + def from_dict( + cls, config: Dict[str, Any], fluids: Dict[str, Any] = None + ) -> "ProcessBuilder": """ Create a ProcessBuilder from a dictionary configuration. - + Args: config: Dictionary with 'name' and 'equipment' keys. fluids: Dictionary mapping fluid names to fluid objects. - + Returns: ProcessBuilder instance (not yet run). - + Example: >>> config = { ... 'name': 'Compression Train', @@ -721,23 +771,25 @@ def from_dict(cls, config: Dict[str, Any], fluids: Dict[str, Any] = None) -> 'Pr ... } >>> process = ProcessBuilder.from_dict(config, fluids={'feed': my_fluid}).run() """ - builder = cls(config.get('name', '')) - if 'equipment' in config: - builder.add_from_config(config['equipment'], fluids) + builder = cls(config.get("name", "")) + if "equipment" in config: + builder.add_from_config(config["equipment"], fluids) return builder - + @classmethod - def from_json(cls, json_path: str, fluids: Dict[str, Any] = None) -> 'ProcessBuilder': + def from_json( + cls, json_path: str, fluids: Dict[str, Any] = None + ) -> "ProcessBuilder": """ Create a ProcessBuilder from a JSON file. - + Args: json_path: Path to JSON configuration file. fluids: Dictionary mapping fluid names to fluid objects. - + Returns: ProcessBuilder instance (not yet run). - + Example: >>> # process_config.json: >>> # { @@ -747,27 +799,29 @@ def from_json(cls, json_path: str, fluids: Dict[str, Any] = None) -> 'ProcessBui >>> # {"type": "compressor", "name": "comp1", "inlet": "inlet", "pressure": 100} >>> # ] >>> # } - >>> process = ProcessBuilder.from_json('process_config.json', + >>> process = ProcessBuilder.from_json('process_config.json', ... fluids={'feed': my_fluid}).run() """ - with open(json_path, 'r') as f: + with open(json_path, "r") as f: config = json.load(f) return cls.from_dict(config, fluids) - + @classmethod - def from_yaml(cls, yaml_path: str, fluids: Dict[str, Any] = None) -> 'ProcessBuilder': + def from_yaml( + cls, yaml_path: str, fluids: Dict[str, Any] = None + ) -> "ProcessBuilder": """ Create a ProcessBuilder from a YAML file. - + Requires PyYAML to be installed (pip install pyyaml). - + Args: yaml_path: Path to YAML configuration file. fluids: Dictionary mapping fluid names to fluid objects. - + Returns: ProcessBuilder instance (not yet run). - + Example: >>> # process_config.yaml: >>> # name: Compression Train @@ -785,45 +839,47 @@ def from_yaml(cls, yaml_path: str, fluids: Dict[str, Any] = None) -> 'ProcessBui try: import yaml except ImportError: - raise ImportError("PyYAML is required for YAML support. Install with: pip install pyyaml") - - with open(yaml_path, 'r') as f: + raise ImportError( + "PyYAML is required for YAML support. Install with: pip install pyyaml" + ) + + with open(yaml_path, "r") as f: config = yaml.safe_load(f) return cls.from_dict(config, fluids) - - def run(self) -> 'ProcessBuilder': + + def run(self) -> "ProcessBuilder": """ Run the process simulation. - + Returns: Self for method chaining. """ self.process.run() return self - + def get(self, name: str) -> Any: """ Get equipment by name. - + Args: name: Name of the equipment. - + Returns: The equipment object. """ return self.equipment.get(name) - + def get_process(self) -> Any: """Get the underlying ProcessSystem object.""" return self.process - + def results_json(self) -> Dict[str, Any]: """ Get simulation results as a JSON-compatible dictionary. - + Returns: Dictionary with all process results. - + Example: >>> process = ProcessBuilder("Test").add_stream(...).run() >>> results = process.results_json() @@ -831,15 +887,15 @@ def results_json(self) -> Dict[str, Any]: """ json_report = str(self.process.getReport_json()) return json.loads(json_report) - + def results_dataframe(self) -> pd.DataFrame: """ Get simulation results as a pandas DataFrame. - + Returns: DataFrame with equipment results including temperatures, pressures, flow rates, power, and duties. - + Example: >>> process = ProcessBuilder("Test").add_stream(...).run() >>> df = process.results_dataframe() @@ -847,54 +903,54 @@ def results_dataframe(self) -> pd.DataFrame: """ rows = [] for name, eq in self.equipment.items(): - row = {'Equipment': name} - + row = {"Equipment": name} + # Get outlet stream properties out_stream = None - if hasattr(eq, 'getOutletStream'): + if hasattr(eq, "getOutletStream"): out_stream = eq.getOutletStream() - elif hasattr(eq, 'getOutStream'): + elif hasattr(eq, "getOutStream"): out_stream = eq.getOutStream() - elif hasattr(eq, 'getGasOutStream'): + elif hasattr(eq, "getGasOutStream"): out_stream = eq.getGasOutStream() - + if out_stream: try: - row['T_out (°C)'] = round(out_stream.getTemperature() - 273.15, 2) + row["T_out (°C)"] = round(out_stream.getTemperature() - 273.15, 2) except: pass try: - row['P_out (bara)'] = round(out_stream.getPressure(), 2) + row["P_out (bara)"] = round(out_stream.getPressure(), 2) except: pass try: - row['Flow (kg/hr)'] = round(out_stream.getFlowRate('kg/hr'), 1) + row["Flow (kg/hr)"] = round(out_stream.getFlowRate("kg/hr"), 1) except: pass - + # Get power/duty - if hasattr(eq, 'getPower'): + if hasattr(eq, "getPower"): try: - row['Power (kW)'] = round(eq.getPower() / 1e3, 2) + row["Power (kW)"] = round(eq.getPower() / 1e3, 2) except: pass - if hasattr(eq, 'getDuty'): + if hasattr(eq, "getDuty"): try: - row['Duty (kW)'] = round(eq.getDuty() / 1e3, 2) + row["Duty (kW)"] = round(eq.getDuty() / 1e3, 2) except: pass - + rows.append(row) - + return pd.DataFrame(rows) - - def print_results(self) -> 'ProcessBuilder': + + def print_results(self) -> "ProcessBuilder": """ Print a formatted summary of simulation results. - + Returns: Self for method chaining. - + Example: >>> (ProcessBuilder("Test") ... .add_stream('inlet', feed) @@ -905,22 +961,24 @@ def print_results(self) -> 'ProcessBuilder': print(f"\n{'='*60}") print(f"Process Results: {self._name}") print(f"{'='*60}\n") - + for name, eq in self.equipment.items(): print(f"📦 {name}") - + # Get outlet stream properties out_stream = None - if hasattr(eq, 'getOutletStream'): + if hasattr(eq, "getOutletStream"): out_stream = eq.getOutletStream() - elif hasattr(eq, 'getOutStream'): + elif hasattr(eq, "getOutStream"): out_stream = eq.getOutStream() - elif hasattr(eq, 'getGasOutStream'): + elif hasattr(eq, "getGasOutStream"): out_stream = eq.getGasOutStream() - + if out_stream: try: - print(f" Temperature: {out_stream.getTemperature() - 273.15:.1f} °C") + print( + f" Temperature: {out_stream.getTemperature() - 273.15:.1f} °C" + ) except: pass try: @@ -931,47 +989,49 @@ def print_results(self) -> 'ProcessBuilder': print(f" Flow rate: {out_stream.getFlowRate('kg/hr'):.0f} kg/hr") except: pass - - if hasattr(eq, 'getPower'): + + if hasattr(eq, "getPower"): try: print(f" Power: {eq.getPower()/1e3:.2f} kW") except: pass - if hasattr(eq, 'getDuty'): + if hasattr(eq, "getDuty"): try: print(f" Duty: {eq.getDuty()/1e3:.2f} kW") except: pass print() - + return self - - def save_results(self, filename: str, format: str = 'json') -> 'ProcessBuilder': + + def save_results(self, filename: str, format: str = "json") -> "ProcessBuilder": """ Save simulation results to a file. - + Args: filename: Output file path. format: Output format - 'json', 'csv', or 'excel'. - + Returns: Self for method chaining. - + Example: >>> process.run().save_results('results.json') >>> process.save_results('results.csv', format='csv') >>> process.save_results('results.xlsx', format='excel') """ - if format == 'json': - with open(filename, 'w') as f: + if format == "json": + with open(filename, "w") as f: json.dump(self.results_json(), f, indent=2) - elif format == 'csv': + elif format == "csv": self.results_dataframe().to_csv(filename, index=False) - elif format == 'excel': + elif format == "excel": self.results_dataframe().to_excel(filename, index=False) else: - raise ValueError(f"Unknown format: {format}. Use 'json', 'csv', or 'excel'.") - + raise ValueError( + f"Unknown format: {format}. Use 'json', 'csv', or 'excel'." + ) + print(f"Results saved to {filename}") return self @@ -979,7 +1039,7 @@ def save_results(self, filename: str, format: str = 'json') -> 'ProcessBuilder': def _add_to_process(equipment: Any, process: Any = None) -> None: """ Helper to add equipment to a process. - + If process is provided, adds to that process. Otherwise, adds to global processoperations if not in loop mode. """ @@ -1033,8 +1093,9 @@ def set_loop_mode(loop_mode: bool) -> None: _loop_mode = loop_mode -def stream(name: str, thermoSystem: Any, t: float = 0, p: float = 0, - process: Any = None) -> Any: +def stream( + name: str, thermoSystem: Any, t: float = 0, p: float = 0, process: Any = None +) -> Any: """ Create a stream with the given name and thermodynamic system. @@ -1046,7 +1107,7 @@ def stream(name: str, thermoSystem: Any, t: float = 0, p: float = 0, thermoSystem: The thermodynamic system (fluid) for the stream. t: Temperature to set (optional). If 0, uses system default. p: Pressure to set (optional). If 0, uses system default. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: @@ -1057,7 +1118,7 @@ def stream(name: str, thermoSystem: Any, t: float = 0, p: float = 0, >>> my_fluid = fluid('srk') >>> my_fluid.addComponent('methane', 1.0) >>> inlet_stream = stream('inlet', my_fluid, t=25.0, p=10.0) - + # With explicit process: >>> my_process = newProcess('MyProcess') >>> inlet = stream('inlet', my_fluid, process=my_process) @@ -1172,12 +1233,12 @@ def separator(name: str, teststream: Any, process: Any = None) -> Any: Args: name: The name of the separator. teststream: The inlet stream to be separated. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: Separator: The created separator object. - + Example: >>> sep = separator('HP separator', inlet_stream) >>> gas = sep.getGasOutStream() @@ -1238,21 +1299,19 @@ def separator3phase(name: str, teststream: Any, process: Any = None) -> Any: Args: name: The name of the separator. teststream: The inlet stream to be separated. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: ThreePhaseSeparator: The created three-phase separator object. - + Example: >>> sep3 = separator3phase('3-phase sep', inlet_stream) >>> gas = sep3.getGasOutStream() >>> oil = sep3.getOilOutStream() >>> water = sep3.getWaterOutStream() """ - sep = jneqsim.process.equipment.separator.ThreePhaseSeparator( - name, teststream - ) + sep = jneqsim.process.equipment.separator.ThreePhaseSeparator(name, teststream) sep.setName(name) _add_to_process(sep, process) return sep @@ -1266,12 +1325,12 @@ def valve(name: str, teststream: Any, p: float = 1.0, process: Any = None) -> An name: The name of the valve. teststream: The inlet stream. p: The outlet pressure in bara. Default is 1.0. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: ThrottlingValve: The created throttling valve object. - + Example: >>> v = valve('letdown valve', inlet_stream, p=10.0) >>> runProcess() @@ -1305,8 +1364,9 @@ def filters(name, teststream): return filter2 -def compressor(name: str, teststream: Any, pres: float = 10.0, - process: Any = None) -> Any: +def compressor( + name: str, teststream: Any, pres: float = 10.0, process: Any = None +) -> Any: """ Create and configure a compressor for a given stream. @@ -1314,7 +1374,7 @@ def compressor(name: str, teststream: Any, pres: float = 10.0, name: The name of the compressor. teststream: The inlet stream to be compressed. pres: The outlet pressure in bara. Defaults to 10.0. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: @@ -1325,7 +1385,7 @@ def compressor(name: str, teststream: Any, pres: float = 10.0, >>> runProcess() >>> print(f"Power: {comp.getPower()/1e6:.2f} MW") >>> print(f"Polytropic efficiency: {comp.getPolytropicEfficiency():.2%}") - + # With explicit process: >>> my_process = newProcess('Compression') >>> comp = compressor('comp1', inlet, pres=50.0, process=my_process) @@ -1378,12 +1438,12 @@ def pump(name: str, teststream: Any, p: float = 1.0, process: Any = None) -> Any name: The name of the pump. teststream: The inlet stream to be pumped. p: The outlet pressure in bara. Default is 1.0. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: Pump: The created pump object. - + Example: >>> p = pump('feed pump', liquid_stream, p=50.0) >>> runProcess() @@ -1403,12 +1463,12 @@ def expander(name: str, teststream: Any, p: float, process: Any = None) -> Any: name: The name of the expander. teststream: The inlet stream to be expanded. p: The outlet pressure in bara. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: Expander: The configured expander object. - + Example: >>> exp = expander('turbo expander', gas_stream, p=20.0) >>> runProcess() @@ -1427,12 +1487,12 @@ def mixer(name: str = "", process: Any = None) -> Any: Args: name: The name of the mixer. Default is empty string. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: Mixer: An instance of the Mixer class. - + Example: >>> m = mixer('gas mixer') >>> m.addStream(stream1) @@ -1474,8 +1534,9 @@ def compsplitter(name, teststream, splitfactors): return compSplitter -def splitter(name: str, teststream: Any, splitfactors: List[float] = None, - process: Any = None) -> Any: +def splitter( + name: str, teststream: Any, splitfactors: List[float] = None, process: Any = None +) -> Any: """ Create a splitter process equipment. @@ -1484,12 +1545,12 @@ def splitter(name: str, teststream: Any, splitfactors: List[float] = None, teststream: The inlet stream to be split. splitfactors: List of split fractions. Length determines number of outlets. Values should sum to 1.0. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: Splitter: The created splitter object. - + Example: >>> sp = splitter('flow split', inlet, splitfactors=[0.3, 0.7]) >>> runProcess() @@ -1511,12 +1572,12 @@ def heater(name: str, teststream: Any, process: Any = None) -> Any: Args: name: The name of the heater. teststream: The inlet stream to be heated. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: Heater: The created heater object. - + Example: >>> h = heater('feed heater', cold_stream) >>> h.setOutTemperature(350.0) # Kelvin @@ -1550,12 +1611,12 @@ def cooler(name: str, teststream: Any, process: Any = None) -> Any: Args: name: The name of the cooler. teststream: The inlet stream to be cooled. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: Cooler: The configured cooler object. - + Example: >>> c = cooler('discharge cooler', hot_stream) >>> c.setOutTemperature(303.15) # 30°C in Kelvin @@ -1568,22 +1629,23 @@ def cooler(name: str, teststream: Any, process: Any = None) -> Any: return c -def heatExchanger(name: str, stream1: Any, stream2: Any = None, - process: Any = None) -> Any: +def heatExchanger( + name: str, stream1: Any, stream2: Any = None, process: Any = None +) -> Any: """ Create a heat exchanger process unit. Args: name: The name of the heat exchanger. stream1: The first (hot) input stream. - stream2: The second (cold) input stream. If not provided, + stream2: The second (cold) input stream. If not provided, creates a single-stream heat exchanger. - process: Optional ProcessSystem, ProcessContext, or ProcessBuilder + process: Optional ProcessSystem, ProcessContext, or ProcessBuilder to add this equipment to. If None, uses global process. Returns: HeatExchanger: The created heat exchanger object. - + Example: >>> hx = heatExchanger('economizer', hot_gas, cold_feed) >>> hx.setApproachTemperature(10.0) # 10 K approach @@ -1789,31 +1851,35 @@ def process_report(process: Optional[Any] = None) -> pd.DataFrame: rows = [] for unit_name, unit_data in results.items(): if isinstance(unit_data, dict): - row = {'Unit Name': unit_name} + row = {"Unit Name": unit_name} # Extract common properties - if 'feed' in unit_data: - feed = unit_data['feed'] - if 'temperature' in feed: - row['Feed Temp [C]'] = feed.get('temperature', {}).get('value') - if 'pressure' in feed: - row['Feed Pres [bara]'] = feed.get('pressure', {}).get('value') - if 'product' in unit_data: - product = unit_data['product'] - if 'temperature' in product: - row['Product Temp [C]'] = product.get('temperature', {}).get('value') - if 'pressure' in product: - row['Product Pres [bara]'] = product.get('pressure', {}).get('value') - if 'power' in unit_data: - row['Power [kW]'] = unit_data.get('power', {}).get('value') + if "feed" in unit_data: + feed = unit_data["feed"] + if "temperature" in feed: + row["Feed Temp [C]"] = feed.get("temperature", {}).get("value") + if "pressure" in feed: + row["Feed Pres [bara]"] = feed.get("pressure", {}).get("value") + if "product" in unit_data: + product = unit_data["product"] + if "temperature" in product: + row["Product Temp [C]"] = product.get("temperature", {}).get( + "value" + ) + if "pressure" in product: + row["Product Pres [bara]"] = product.get("pressure", {}).get( + "value" + ) + if "power" in unit_data: + row["Power [kW]"] = unit_data.get("power", {}).get("value") rows.append(row) if rows: return pd.DataFrame(rows) else: - return pd.DataFrame({'Message': ['No unit operations found in process']}) + return pd.DataFrame({"Message": ["No unit operations found in process"]}) except Exception as e: - return pd.DataFrame({'Error': [f'Failed to generate report: {e}']}) + return pd.DataFrame({"Error": [f"Failed to generate report: {e}"]}) def results_json(process, filename=None): @@ -1843,6 +1909,7 @@ def results_json(process, filename=None): print(f"Error generating JSON report: {e}") return None + def ejector(name: str, motive_stream: Any, suction_stream: Any) -> Any: """ Create an ejector (gas/steam jet) for mixing streams. @@ -1864,14 +1931,21 @@ def ejector(name: str, motive_stream: Any, suction_stream: Any) -> Any: >>> runProcess() >>> print(ejector1.getOutletStream().getPressure('bara')) """ - ejector_unit = jneqsim.process.equipment.ejector.Ejector(name, motive_stream, suction_stream) + ejector_unit = jneqsim.process.equipment.ejector.Ejector( + name, motive_stream, suction_stream + ) if not _loop_mode: processoperations.add(ejector_unit) return ejector_unit -def flare(name: str, inlet_stream: Any, flame_height: float = 30.0, - radiant_fraction: float = 0.18, tip_diameter: float = 0.3) -> Any: +def flare( + name: str, + inlet_stream: Any, + flame_height: float = 30.0, + radiant_fraction: float = 0.18, + tip_diameter: float = 0.3, +) -> Any: """ Create a flare unit for combustion of relief gases. @@ -1904,8 +1978,13 @@ def flare(name: str, inlet_stream: Any, flame_height: float = 30.0, return flare_unit -def safety_valve(name: str, inlet_stream: Any, set_pressure: float, - full_open_pressure: float = None, blowdown: float = 7.0) -> Any: +def safety_valve( + name: str, + inlet_stream: Any, + set_pressure: float, + full_open_pressure: float = None, + blowdown: float = 7.0, +) -> Any: """ Create a Pressure Safety Valve (PSV) for overpressure protection. @@ -1942,9 +2021,14 @@ def safety_valve(name: str, inlet_stream: Any, set_pressure: float, return psv -def beggs_brill_pipe(name: str, inlet_stream: Any, length: float, - diameter: float, elevation: float = 0.0, - roughness: float = 50e-6) -> Any: +def beggs_brill_pipe( + name: str, + inlet_stream: Any, + length: float, + diameter: float, + elevation: float = 0.0, + roughness: float = 50e-6, +) -> Any: """ Create a Beggs and Brill multiphase pipeline. @@ -2001,7 +2085,9 @@ def create_equipment(name: str, equipment_type: str) -> Any: >>> valve = create_equipment('v1', 'ThrottlingValve') >>> sep = create_equipment('sep1', 'Separator') """ - return jneqsim.process.equipment.EquipmentFactory.createEquipment(name, equipment_type) + return jneqsim.process.equipment.EquipmentFactory.createEquipment( + name, equipment_type + ) def staticmixer(name: str) -> Any: @@ -2327,7 +2413,9 @@ def co2electrolyzer(name: str, inlet_stream: Any = None) -> Any: >>> runProcess() """ if inlet_stream is not None: - elec = jneqsim.process.equipment.electrolyzer.CO2Electrolyzer(name, inlet_stream) + elec = jneqsim.process.equipment.electrolyzer.CO2Electrolyzer( + name, inlet_stream + ) else: elec = jneqsim.process.equipment.electrolyzer.CO2Electrolyzer(name) if not _loop_mode: @@ -2385,8 +2473,9 @@ def setter(name: str) -> Any: return setter_unit -def wellflow(name: str, inlet_stream: Any, well_depth: float = 1000.0, - well_diameter: float = 0.1) -> Any: +def wellflow( + name: str, inlet_stream: Any, well_depth: float = 1000.0, well_diameter: float = 0.1 +) -> Any: """ Create a well flow model for production or injection wells. @@ -2403,7 +2492,7 @@ def wellflow(name: str, inlet_stream: Any, well_depth: float = 1000.0, Well flow object. Example: - >>> well = wellflow('prod_well_1', reservoir_stream, + >>> well = wellflow('prod_well_1', reservoir_stream, ... well_depth=2500.0, well_diameter=0.1) >>> runProcess() >>> wellhead = well.getOutletStream() @@ -2440,4 +2529,4 @@ def energystream(name: str, power: float = 0.0) -> Any: es.setDuty(power) if not _loop_mode: processoperations.add(es) - return es \ No newline at end of file + return es diff --git a/src/neqsim/thermo/thermoTools.py b/src/neqsim/thermo/thermoTools.py index 2e48e28a..7339ea04 100644 --- a/src/neqsim/thermo/thermoTools.py +++ b/src/neqsim/thermo/thermoTools.py @@ -332,7 +332,9 @@ def fluid(name="srk", temperature=298.15, pressure=1.01325): object: An instance of the specified thermodynamic fluid system. """ if name not in fluid_type: - raise ValueError(f"Fluid model {name} not found. Available models are {list(fluid_type.keys())}") + raise ValueError( + f"Fluid model {name} not found. Available models are {list(fluid_type.keys())}" + ) fluid_function = fluid_type[name] return fluid_function(temperature, pressure) @@ -440,11 +442,10 @@ def fluid_df( else: # When only pseudo components exist, create an empty base fluid fluid7 = fluid("pr") - + # Check if we have TBP/pseudo components to add (components with MolarMass) hasTBPComponents = ( - "MolarMass[kg/mol]" in reservoirFluiddf - and TBPComponentsFrame.size > 0 + "MolarMass[kg/mol]" in reservoirFluiddf and TBPComponentsFrame.size > 0 ) if hasTBPComponents: addOilFractions( From 7c108f7514fc93f7ebd0c3e5775f181781532943 Mon Sep 17 00:00:00 2001 From: Even Solbraa <41290109+EvenSol@users.noreply.github.com> Date: Fri, 12 Dec 2025 17:01:09 +0100 Subject: [PATCH 6/7] [pre-commit.ci lite] apply automatic fixes --- examples/processBuilderGUI.py | 397 +++++++++++++++++++--------------- 1 file changed, 227 insertions(+), 170 deletions(-) diff --git a/examples/processBuilderGUI.py b/examples/processBuilderGUI.py index 7486024e..c261e0e0 100644 --- a/examples/processBuilderGUI.py +++ b/examples/processBuilderGUI.py @@ -21,13 +21,13 @@ # Session State Initialization # ============================================================================= -if 'fluids' not in st.session_state: +if "fluids" not in st.session_state: st.session_state.fluids = {} -if 'equipment_list' not in st.session_state: +if "equipment_list" not in st.session_state: st.session_state.equipment_list = [] -if 'process_result' not in st.session_state: +if "process_result" not in st.session_state: st.session_state.process_result = None -if 'results_data' not in st.session_state: +if "results_data" not in st.session_state: st.session_state.results_data = None # ============================================================================= @@ -35,108 +35,122 @@ # ============================================================================= COMPONENT_OPTIONS = [ - 'methane', 'ethane', 'propane', 'i-butane', 'n-butane', - 'i-pentane', 'n-pentane', 'n-hexane', 'n-heptane', 'n-octane', - 'nitrogen', 'CO2', 'H2S', 'water', 'H2', 'oxygen' + "methane", + "ethane", + "propane", + "i-butane", + "n-butane", + "i-pentane", + "n-pentane", + "n-hexane", + "n-heptane", + "n-octane", + "nitrogen", + "CO2", + "H2S", + "water", + "H2", + "oxygen", ] -EOS_OPTIONS = ['srk', 'pr', 'cpa'] +EOS_OPTIONS = ["srk", "pr", "cpa"] EQUIPMENT_TYPES = { - 'stream': {'inlet': False, 'has_fluid': True}, - 'separator': {'inlet': True, 'has_fluid': False}, - 'compressor': {'inlet': True, 'has_fluid': False}, - 'pump': {'inlet': True, 'has_fluid': False}, - 'expander': {'inlet': True, 'has_fluid': False}, - 'valve': {'inlet': True, 'has_fluid': False}, - 'heater': {'inlet': True, 'has_fluid': False}, - 'cooler': {'inlet': True, 'has_fluid': False}, - 'pipe': {'inlet': True, 'has_fluid': False}, + "stream": {"inlet": False, "has_fluid": True}, + "separator": {"inlet": True, "has_fluid": False}, + "compressor": {"inlet": True, "has_fluid": False}, + "pump": {"inlet": True, "has_fluid": False}, + "expander": {"inlet": True, "has_fluid": False}, + "valve": {"inlet": True, "has_fluid": False}, + "heater": {"inlet": True, "has_fluid": False}, + "cooler": {"inlet": True, "has_fluid": False}, + "pipe": {"inlet": True, "has_fluid": False}, } -FLOW_UNITS = ['kg/sec', 'kg/hr', 'MSm3/day', 'Sm3/day', 'mole/sec'] +FLOW_UNITS = ["kg/sec", "kg/hr", "MSm3/day", "Sm3/day", "mole/sec"] + def get_available_inlets() -> List[str]: """Get list of equipment names that can be used as inlets.""" - return [eq['name'] for eq in st.session_state.equipment_list] + return [eq["name"] for eq in st.session_state.equipment_list] + def create_fluid_from_config(config: Dict) -> Any: """Create a NeqSim fluid from configuration.""" - f = fluid(config['eos']) - for comp, frac in config['components'].items(): + f = fluid(config["eos"]) + for comp, frac in config["components"].items(): if frac > 0: f.addComponent(comp, frac) - f.setTemperature(config['temperature'], 'C') - f.setPressure(config['pressure'], 'bara') - if config.get('flow_rate'): - f.setTotalFlowRate(config['flow_rate'], config.get('flow_unit', 'kg/sec')) + f.setTemperature(config["temperature"], "C") + f.setPressure(config["pressure"], "bara") + if config.get("flow_rate"): + f.setTotalFlowRate(config["flow_rate"], config.get("flow_unit", "kg/sec")) return f + def run_process(): """Build and run the process from current configuration.""" if not st.session_state.equipment_list: st.error("Add at least one piece of equipment before running") return - + # Create fluids fluids_dict = {} for name, config in st.session_state.fluids.items(): fluids_dict[name] = create_fluid_from_config(config) - + # Build equipment config equipment_config = [] for eq in st.session_state.equipment_list: - eq_config = {'type': eq['type'], 'name': eq['name']} - eq_config.update(eq.get('params', {})) + eq_config = {"type": eq["type"], "name": eq["name"]} + eq_config.update(eq.get("params", {})) equipment_config.append(eq_config) - - config = { - 'name': 'GUI Process', - 'equipment': equipment_config - } - + + config = {"name": "GUI Process", "equipment": equipment_config} + try: process = ProcessBuilder.from_dict(config, fluids=fluids_dict).run() st.session_state.process_result = process - + # Collect results results = [] for eq in st.session_state.equipment_list: - name = eq['name'] + name = eq["name"] eq_obj = process.get(name) if eq_obj: - result = {'Equipment': name, 'Type': eq['type']} - + result = {"Equipment": name, "Type": eq["type"]} + # Try to get common properties - if hasattr(eq_obj, 'getOutletStream'): + if hasattr(eq_obj, "getOutletStream"): out = eq_obj.getOutletStream() - result['Outlet T (°C)'] = f"{out.getTemperature() - 273.15:.1f}" - result['Outlet P (bara)'] = f"{out.getPressure():.1f}" - elif hasattr(eq_obj, 'getOutStream'): + result["Outlet T (°C)"] = f"{out.getTemperature() - 273.15:.1f}" + result["Outlet P (bara)"] = f"{out.getPressure():.1f}" + elif hasattr(eq_obj, "getOutStream"): out = eq_obj.getOutStream() - result['Outlet T (°C)'] = f"{out.getTemperature() - 273.15:.1f}" - result['Outlet P (bara)'] = f"{out.getPressure():.1f}" - elif hasattr(eq_obj, 'getGasOutStream'): + result["Outlet T (°C)"] = f"{out.getTemperature() - 273.15:.1f}" + result["Outlet P (bara)"] = f"{out.getPressure():.1f}" + elif hasattr(eq_obj, "getGasOutStream"): out = eq_obj.getGasOutStream() - result['Outlet T (°C)'] = f"{out.getTemperature() - 273.15:.1f}" - result['Outlet P (bara)'] = f"{out.getPressure():.1f}" - - if hasattr(eq_obj, 'getPower'): + result["Outlet T (°C)"] = f"{out.getTemperature() - 273.15:.1f}" + result["Outlet P (bara)"] = f"{out.getPressure():.1f}" + + if hasattr(eq_obj, "getPower"): power = eq_obj.getPower() - result['Power (kW)'] = f"{power/1e3:.1f}" - - if hasattr(eq_obj, 'getDuty'): + result["Power (kW)"] = f"{power/1e3:.1f}" + + if hasattr(eq_obj, "getDuty"): duty = eq_obj.getDuty() - result['Duty (kW)'] = f"{duty/1e3:.1f}" - + result["Duty (kW)"] = f"{duty/1e3:.1f}" + results.append(result) - + st.session_state.results_data = pd.DataFrame(results) st.success("Process simulation completed!") - + except Exception as e: st.error(f"Error running process: {str(e)}") + # ============================================================================= # Main UI # ============================================================================= @@ -153,57 +167,68 @@ def run_process(): with tab1: st.header("Define Fluids") - + col1, col2 = st.columns([1, 2]) - + with col1: st.subheader("Create New Fluid") - + fluid_name = st.text_input("Fluid Name", value="feed", key="new_fluid_name") eos = st.selectbox("Equation of State", EOS_OPTIONS) - + st.markdown("**Composition (mole fractions)**") components = {} cols = st.columns(2) for i, comp in enumerate(COMPONENT_OPTIONS[:10]): with cols[i % 2]: - val = st.number_input(comp, min_value=0.0, max_value=1.0, - value=0.9 if comp == 'methane' else 0.1 if comp == 'ethane' else 0.0, - step=0.01, key=f"comp_{comp}") + val = st.number_input( + comp, + min_value=0.0, + max_value=1.0, + value=( + 0.9 if comp == "methane" else 0.1 if comp == "ethane" else 0.0 + ), + step=0.01, + key=f"comp_{comp}", + ) if val > 0: components[comp] = val - + st.markdown("**Conditions**") temperature = st.number_input("Temperature (°C)", value=30.0) pressure = st.number_input("Pressure (bara)", value=50.0, min_value=0.1) - + st.markdown("**Flow Rate (optional)**") flow_rate = st.number_input("Flow Rate", value=10.0, min_value=0.0) flow_unit = st.selectbox("Flow Unit", FLOW_UNITS, index=2) - + if st.button("➕ Add Fluid", type="primary"): if fluid_name and components: st.session_state.fluids[fluid_name] = { - 'eos': eos, - 'components': components, - 'temperature': temperature, - 'pressure': pressure, - 'flow_rate': flow_rate if flow_rate > 0 else None, - 'flow_unit': flow_unit + "eos": eos, + "components": components, + "temperature": temperature, + "pressure": pressure, + "flow_rate": flow_rate if flow_rate > 0 else None, + "flow_unit": flow_unit, } st.success(f"Fluid '{fluid_name}' added!") st.rerun() - + with col2: st.subheader("Defined Fluids") if st.session_state.fluids: for name, config in st.session_state.fluids.items(): with st.expander(f"📦 {name}", expanded=True): st.write(f"**EOS:** {config['eos']}") - st.write(f"**T:** {config['temperature']} °C | **P:** {config['pressure']} bara") - if config.get('flow_rate'): - st.write(f"**Flow:** {config['flow_rate']} {config['flow_unit']}") - st.write("**Composition:**", config['components']) + st.write( + f"**T:** {config['temperature']} °C | **P:** {config['pressure']} bara" + ) + if config.get("flow_rate"): + st.write( + f"**Flow:** {config['flow_rate']} {config['flow_unit']}" + ) + st.write("**Composition:**", config["components"]) if st.button(f"🗑️ Remove", key=f"del_fluid_{name}"): del st.session_state.fluids[name] st.rerun() @@ -216,99 +241,121 @@ def run_process(): with tab2: st.header("Build Process") - + col1, col2 = st.columns([1, 2]) - + with col1: st.subheader("Add Equipment") - + eq_type = st.selectbox("Equipment Type", list(EQUIPMENT_TYPES.keys())) eq_name = st.text_input("Equipment Name", value=f"{eq_type}_1") - + params = {} - + # Equipment-specific parameters - if EQUIPMENT_TYPES[eq_type]['has_fluid']: + if EQUIPMENT_TYPES[eq_type]["has_fluid"]: if st.session_state.fluids: - params['fluid'] = st.selectbox("Select Fluid", list(st.session_state.fluids.keys())) + params["fluid"] = st.selectbox( + "Select Fluid", list(st.session_state.fluids.keys()) + ) else: st.warning("Define a fluid first in the 'Define Fluids' tab") - - if EQUIPMENT_TYPES[eq_type]['inlet']: + + if EQUIPMENT_TYPES[eq_type]["inlet"]: inlets = get_available_inlets() if inlets: - params['inlet'] = st.selectbox("Inlet From", inlets) + params["inlet"] = st.selectbox("Inlet From", inlets) else: st.warning("Add a stream first") - - if eq_type == 'compressor': - params['pressure'] = st.number_input("Outlet Pressure (bara)", value=100.0, min_value=0.1) - params['efficiency'] = st.slider("Isentropic Efficiency", 0.5, 1.0, 0.75) - - elif eq_type == 'pump': - params['pressure'] = st.number_input("Outlet Pressure (bara)", value=100.0, min_value=0.1) - params['efficiency'] = st.slider("Efficiency", 0.5, 1.0, 0.75) - - elif eq_type == 'expander': - params['pressure'] = st.number_input("Outlet Pressure (bara)", value=10.0, min_value=0.1) - - elif eq_type == 'valve': - params['pressure'] = st.number_input("Outlet Pressure (bara)", value=10.0, min_value=0.1) - - elif eq_type == 'heater': - params['temperature'] = st.number_input("Outlet Temperature (K)", value=350.0) - - elif eq_type == 'cooler': - params['temperature'] = st.number_input("Outlet Temperature (K)", value=300.0) - - elif eq_type == 'separator': - params['three_phase'] = st.checkbox("Three-phase separator") - - elif eq_type == 'pipe': - params['length'] = st.number_input("Length (m)", value=100.0) - params['diameter'] = st.number_input("Diameter (m)", value=0.1) - + + if eq_type == "compressor": + params["pressure"] = st.number_input( + "Outlet Pressure (bara)", value=100.0, min_value=0.1 + ) + params["efficiency"] = st.slider("Isentropic Efficiency", 0.5, 1.0, 0.75) + + elif eq_type == "pump": + params["pressure"] = st.number_input( + "Outlet Pressure (bara)", value=100.0, min_value=0.1 + ) + params["efficiency"] = st.slider("Efficiency", 0.5, 1.0, 0.75) + + elif eq_type == "expander": + params["pressure"] = st.number_input( + "Outlet Pressure (bara)", value=10.0, min_value=0.1 + ) + + elif eq_type == "valve": + params["pressure"] = st.number_input( + "Outlet Pressure (bara)", value=10.0, min_value=0.1 + ) + + elif eq_type == "heater": + params["temperature"] = st.number_input( + "Outlet Temperature (K)", value=350.0 + ) + + elif eq_type == "cooler": + params["temperature"] = st.number_input( + "Outlet Temperature (K)", value=300.0 + ) + + elif eq_type == "separator": + params["three_phase"] = st.checkbox("Three-phase separator") + + elif eq_type == "pipe": + params["length"] = st.number_input("Length (m)", value=100.0) + params["diameter"] = st.number_input("Diameter (m)", value=0.1) + # Add button can_add = True - if EQUIPMENT_TYPES[eq_type]['inlet'] and not get_available_inlets(): + if EQUIPMENT_TYPES[eq_type]["inlet"] and not get_available_inlets(): can_add = False - if EQUIPMENT_TYPES[eq_type]['has_fluid'] and not st.session_state.fluids: + if EQUIPMENT_TYPES[eq_type]["has_fluid"] and not st.session_state.fluids: can_add = False - + if st.button("➕ Add Equipment", type="primary", disabled=not can_add): - st.session_state.equipment_list.append({ - 'type': eq_type, - 'name': eq_name, - 'params': params - }) + st.session_state.equipment_list.append( + {"type": eq_type, "name": eq_name, "params": params} + ) st.success(f"Added {eq_type} '{eq_name}'") st.rerun() - + with col2: st.subheader("Process Equipment") - + if st.session_state.equipment_list: for i, eq in enumerate(st.session_state.equipment_list): - with st.expander(f"{'🔵' if eq['type'] == 'stream' else '⚙️'} {eq['name']} ({eq['type']})", expanded=True): - for key, value in eq['params'].items(): + with st.expander( + f"{'🔵' if eq['type'] == 'stream' else '⚙️'} {eq['name']} ({eq['type']})", + expanded=True, + ): + for key, value in eq["params"].items(): st.write(f"**{key}:** {value}") - + col_a, col_b = st.columns(2) with col_a: - if st.button("⬆️ Move Up", key=f"up_{i}", disabled=i==0): - st.session_state.equipment_list[i], st.session_state.equipment_list[i-1] = \ - st.session_state.equipment_list[i-1], st.session_state.equipment_list[i] + if st.button("⬆️ Move Up", key=f"up_{i}", disabled=i == 0): + ( + st.session_state.equipment_list[i], + st.session_state.equipment_list[i - 1], + ) = ( + st.session_state.equipment_list[i - 1], + st.session_state.equipment_list[i], + ) st.rerun() with col_b: if st.button("🗑️ Remove", key=f"del_{i}"): st.session_state.equipment_list.pop(i) st.rerun() - + st.divider() - + col_run, col_clear = st.columns(2) with col_run: - if st.button("▶️ Run Simulation", type="primary", use_container_width=True): + if st.button( + "▶️ Run Simulation", type="primary", use_container_width=True + ): run_process() with col_clear: if st.button("🗑️ Clear All", use_container_width=True): @@ -317,7 +364,9 @@ def run_process(): st.session_state.results_data = None st.rerun() else: - st.info("No equipment added yet. Use the form on the left to add equipment.") + st.info( + "No equipment added yet. Use the form on the left to add equipment." + ) # ============================================================================= # Tab 3: Results @@ -325,67 +374,73 @@ def run_process(): with tab3: st.header("Simulation Results") - + if st.session_state.results_data is not None: st.dataframe(st.session_state.results_data, use_container_width=True) - + # Show detailed results for each equipment st.subheader("Detailed Equipment Results") - + if st.session_state.process_result: for eq in st.session_state.equipment_list: - eq_obj = st.session_state.process_result.get(eq['name']) + eq_obj = st.session_state.process_result.get(eq["name"]) if eq_obj: with st.expander(f"📋 {eq['name']} Details"): # Get outlet stream properties out_stream = None - if hasattr(eq_obj, 'getOutletStream'): + if hasattr(eq_obj, "getOutletStream"): out_stream = eq_obj.getOutletStream() - elif hasattr(eq_obj, 'getOutStream'): + elif hasattr(eq_obj, "getOutStream"): out_stream = eq_obj.getOutStream() - elif hasattr(eq_obj, 'getGasOutStream'): + elif hasattr(eq_obj, "getGasOutStream"): out_stream = eq_obj.getGasOutStream() - + if out_stream: col1, col2, col3 = st.columns(3) with col1: - st.metric("Temperature", f"{out_stream.getTemperature() - 273.15:.1f} °C") + st.metric( + "Temperature", + f"{out_stream.getTemperature() - 273.15:.1f} °C", + ) with col2: - st.metric("Pressure", f"{out_stream.getPressure():.1f} bara") + st.metric( + "Pressure", f"{out_stream.getPressure():.1f} bara" + ) with col3: try: - st.metric("Flow Rate", f"{out_stream.getFlowRate('kg/hr'):.0f} kg/hr") + st.metric( + "Flow Rate", + f"{out_stream.getFlowRate('kg/hr'):.0f} kg/hr", + ) except: pass - - if hasattr(eq_obj, 'getPower'): + + if hasattr(eq_obj, "getPower"): st.metric("Power", f"{eq_obj.getPower()/1e3:.2f} kW") - if hasattr(eq_obj, 'getDuty'): + if hasattr(eq_obj, "getDuty"): st.metric("Duty", f"{eq_obj.getDuty()/1e3:.2f} kW") - + # Export config button st.subheader("Export Configuration") - + equipment_config = [] for eq in st.session_state.equipment_list: - eq_config = {'type': eq['type'], 'name': eq['name']} - eq_config.update(eq.get('params', {})) + eq_config = {"type": eq["type"], "name": eq["name"]} + eq_config.update(eq.get("params", {})) equipment_config.append(eq_config) - - config = { - 'name': 'Exported Process', - 'equipment': equipment_config - } - + + config = {"name": "Exported Process", "equipment": equipment_config} + import json + json_str = json.dumps(config, indent=2) st.download_button( label="📥 Download JSON Config", data=json_str, file_name="process_config.json", - mime="application/json" + mime="application/json", ) - + st.code(json_str, language="json") else: st.info("Run a simulation to see results here.") @@ -396,18 +451,19 @@ def run_process(): with st.sidebar: st.header("ℹ️ About") - st.markdown(""" + st.markdown( + """ **NeqSim Process Builder GUI** - - A visual tool for building and simulating + + A visual tool for building and simulating process systems using NeqSim. - + **Workflow:** 1. Define fluids with compositions 2. Add process equipment 3. Run simulation 4. View and export results - + **Supported Equipment:** - Streams - Separators (2/3 phase) @@ -417,10 +473,11 @@ def run_process(): - Valves - Heaters/Coolers - Pipes - """) - + """ + ) + st.divider() - + if st.button("🔄 Reset All"): st.session_state.fluids = {} st.session_state.equipment_list = [] From 56a21eddcec0c0273bf3dfd341e9d7bea4650453 Mon Sep 17 00:00:00 2001 From: Even Solbraa <41290109+EvenSol@users.noreply.github.com> Date: Fri, 12 Dec 2025 17:01:51 +0100 Subject: [PATCH 7/7] fix: update pre-commit workflow to fix artifact API error --- .github/workflows/pre-commit.yaml | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/pre-commit.yaml b/.github/workflows/pre-commit.yaml index 0e331c65..5b3843af 100644 --- a/.github/workflows/pre-commit.yaml +++ b/.github/workflows/pre-commit.yaml @@ -10,10 +10,10 @@ jobs: main: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v3 - - uses: actions/setup-python@v4 + - uses: actions/checkout@v4 + - uses: actions/setup-python@v5 with: - python-version: 3.x - - uses: pre-commit/action@v3.0.0 - - uses: pre-commit-ci/lite-action@v1.0.1 + python-version: "3.12" + - uses: pre-commit/action@v3.0.1 + - uses: pre-commit-ci/lite-action@v1.1.0 if: always()