Preface

Process simulation in industry has historically belonged to dedicated desktop applications: HYSYS, UniSim, ProMax, Pro/II, and a handful of in-house tools. Each comes with its own user interface, its own scripting language, its own data model, and its own licensing model. Engineers who learn one of them are typically locked into that ecosystem for the lifetime of a project.

NeqSim takes a different path. It is an open-source Java library that grew from NTNU research into a mature industrial simulation toolkit, exposing its full thermodynamic and process simulation engine through plain Java method calls. Anything the Java code can do — create a fluid, run a flash, build a recompression train, calculate a hydrate temperature, run a transient depressurization, write a JSON report — can be done from Python using a single bridge package: neqsim-python.

The aim of this book is to be a state-of-the-art introduction to that stack: NeqSim as the calculation engine, Python as the engineering workbench, and notebooks, APIs, automation variables, validation checks, and AI-assisted tools as normal parts of the same workflow. The goal is not only to reproduce a desktop simulator in code. The goal is to make process models versioned, inspectable, automatable, and easy to defend in a technical review.

This is what makes NeqSim particularly powerful for industrial process modeling in 2026. A modern facility engineer rarely lives inside a single GUI. They work with Jupyter notebooks, plant historians, REST APIs, FastAPI services, LangChain agents, Excel dashboards, Power BI reports, MQTT brokers, and Git repositories. NeqSim slots into that ecosystem natively, because its Python interface is not a wrapper around a subset of features — it is a direct view into the same Java objects that drive the simulator.

What This Book Covers

This book teaches you to build industrial-grade process models in Python using NeqSim. It starts from the absolute basics:

• How NeqSim is built as a Java library, and why that matters when you call it from Python.
• The neqsim-python package, how it bridges Java and Python through JPype, and the four ways to use it.
• Direct Java access via jneqsim, the recommended approach for serious process modeling because you get the complete API with full type information.

It then takes you through the full modeling stack:

• Fluid creation with all major equations of state (SRK, PR, CPA, UMR-PRU, GERG-2008, Electrolyte CPA).
• Fluid characterization, including TBP cuts, plus-fraction splitting, hypothetical components, and Eclipse/E300 fluid transfer.
• PVT simulations — CME, CVD, differential liberation, separator tests, swelling, saturation pressure, viscosity.
• Unit operations — separators, compressors, heat exchangers, valves, pipes, mixers, splitters, pumps, expanders, reactors.
• Process simulation — building flowsheets, recycles, adjusters, multi-area models with ProcessModel.
• Distillation and columns — tray numbering, staged specifications, homotopy, side draws, pumparounds, hydraulics, rate-based packed columns, and the current direct, damped, inside-out, matrix inside-out, sum-rates, Naphtali-Sandholm, MESH residual, and AUTO solver workflows.
• Dynamic process simulation — transient flowsheets, PID controllers, measurement devices, depressurization, surge analysis.
• The Automation API — string-addressable variable access, self-healing diagnostics, and plant-data integration via tagreader.
• Reporting and visualization — JSON state, Plotly, matplotlib, results.json, and the professional reporting toolkit.
• Web APIs — wrapping NeqSim in FastAPI services, NeqSimAPI patterns, and stateful operations-runtime interfaces.

Finally, it closes with a capstone path. You first assemble and audit a generic integrated offshore topside model with all inputs, reporting, and serialization made explicit. You then tour selected notebooks from the NeqSim-Colab collection as a reusable example library. The final chapter turns those converged process models into optimization and debottlenecking workflows grounded in the official NeqSim documentation and examples.

This book is meant to be read beside the living NeqSim documentation at https://equinor.github.io/neqsim/. The public site is the authoritative reference for API changes, quickstarts, examples, and package-specific guides. In particular, readers should keep these sections open while working through the book:

• Python quickstart: https://equinor.github.io/neqsim/quickstart/python-quickstart.html
• Reference manual: https://equinor.github.io/neqsim/REFERENCE_MANUAL_INDEX.html
• Process equipment: https://equinor.github.io/neqsim/process/README.html
• Recycle loops: https://equinor.github.io/neqsim/process/equipment/util/recycles.html
• Process recipes: https://equinor.github.io/neqsim/cookbook/process-recipes.html
• Process optimization: https://equinor.github.io/neqsim/process/optimization/OPTIMIZATION_OVERVIEW.html
• External optimizer integration: https://equinor.github.io/neqsim/integration/EXTERNAL_OPTIMIZER_INTEGRATION.html
• Compressors: https://equinor.github.io/neqsim/process/equipment/compressors.html
• Compressor curves: https://equinor.github.io/neqsim/process/equipment/compressor_curves.html
• Distillation equipment: https://equinor.github.io/neqsim/process/equipment/distillation.html
• Examples: https://equinor.github.io/neqsim/examples/

The chapters teach a stable modelling workflow; the documentation site gives the up-to-date class names, examples, and deeper reference pages.

How This Book Teaches

The book is built around a reproducible learning loop: read the concept, run the notebook, explain the output, change one input, validate the result, and package the evidence. That loop appears in the front-matter Learning Roadmap, in the chapter notebooks, in the expected-output sections, and in the Capstone Portfolio checklist at the end of the book.

This is intentional. NeqSim is powerful enough to produce numbers quickly, but industrial learning requires more than numbers. A state-of-the-art simulation workflow should leave behind the model code, input assumptions, figures, validation checks, saved state, machine-readable results, and a short engineering recommendation. The reader should not only know how to run NeqSim; they should know how to make a NeqSim result reviewable by another engineer, callable by a service, and understandable to an AI agent or downstream tool.

Each chapter therefore has three jobs:

• Teach the concept or API surface.
• Provide runnable code or a notebook-backed example.
• Point toward an artifact that belongs in a growing process-model portfolio.

What This Book Does Not Cover

This book is not a thermodynamics textbook. It assumes you know what a flash calculation is and what a cubic equation of state does. Compressor curves and distillation columns are now covered as NeqSim modelling workflows, but if you need deeper underlying theory, the companion online book Industrial Agentic Engineering with NeqSim and the standard texts of Prausnitz, Smith–Van Ness, and Kontogeorgis are good starting points.

It is also not a Java tutorial. You do not need to be a Java programmer to use NeqSim from Python — that is the entire point — but you will write code that calls Java classes, so a basic familiarity with object-oriented programming helps.

How to Read This Book

Start with the Learning Roadmap that follows this preface. It explains the book-level outcomes, the mastery loop, suggested reader paths, and the capstone portfolio rhythm.

Read Part I in order. The four chapters on the Java architecture, the Python package, and direct Java access are the conceptual foundation that makes everything else feel obvious instead of mysterious.

After that, the parts are independent. Part II is for thermodynamicists and PVT engineers. Part III is for process engineers building flowsheets. Part IV is for engineers who want to expose models to other tools — REST APIs, dashboards, agents, plant data. Part V deepens the equipment work: compressor maps, distillation diagnostics, LNG heat exchangers, coupled turboexpander-compressors, custom units, and parameter databases. Part VI then turns those pieces into study work: Chapter 18 optimizes converged models, Chapter 19 is the integrated capstone base case, and Chapter 20 points to the curated notebook library for smaller patterns.

The code in this book is written to be copy-pasteable. Every snippet imports the classes it uses, so you can drop any block into a Jupyter cell and run it. The accompanying notebooks under notebooks/ in each chapter directory contain the executed versions with figures.

If you are using the book for self-study or teaching, keep a small project folder as you read. Save one artifact from each part: an environment check, a fluid report, a process model, a saved state or report, and a final capstone study. By the end, that folder is stronger evidence of learning than a set of highlighted pages.

Acknowledgements

This book builds on twenty-four years of NeqSim development. Special thanks to Even Solbraa for the underlying Java engine, to the engineers and contributors who pressure-tested the Python interface in real process-modeling workflows, and to Even Sølbe for the NeqSim-Colab notebook collection that introduced thousands of engineers and students to NeqSim through a browser.

Learning Roadmap

This book is designed as a learning system, not only as a reference manual. The goal is that a reader can move from a first NeqSim notebook to a defensible industrial process model with validation evidence, generated figures, exported state files, and a clear engineering recommendation.

The Mastery Loop

Use the same loop in every chapter:

1. Read the concept. Identify the physical or software idea being taught.
2. Run the notebook. Execute the chapter notebook or code block before changing it.
3. Explain the output. Write one or two sentences describing what changed, why it changed, and whether the number is physically plausible.
4. Modify one input. Change pressure, temperature, composition, flow rate, efficiency, or a model option and rerun.
5. Validate the result. Check mass balance, units, convergence, and whether the result agrees with a simpler hand estimate or reference case.
6. Package the evidence. Save the figure, table, results.json, .neqsim archive, or lifecycle-state JSON that would let another engineer reproduce the conclusion.

This loop is the difference between running a simulation and learning process modeling. A notebook that produces a number is a calculation. A notebook that can be explained, modified, validated, and shared is engineering evidence.

Code and Case-Study Contract

Every chapter follows the same reproducibility contract. Runnable Python blocks are checked in chapter order, while short API fragments that require surrounding context are marked ` in the Markdown source. The refreshed code_block_report.json` is therefore a book-level health check: it should have zero failed runnable examples before a release.

The book also uses one recurring wet rich-gas export case. It begins as a fluid definition, becomes a PVT and process-simulation case, is exposed through automation and reporting, and ends as an optimization exercise. The back-matter appendix "Reproducibility, Running Case, and Engineering Interpretation" gives the ledger readers should maintain as the same case grows across chapters.

Book-Level Learning Outcomes

By the end of the book, you should be able to:

1. Build thermodynamic fluids in NeqSim from Python and choose an equation of state that matches the engineering question.
2. Run flash, PVT, and physical-property calculations while respecting NeqSim's initialization and unit conventions.
3. Assemble steady-state and dynamic process models from streams and unit operations using direct Java access through jneqsim.
4. Use ProcessSystem, ProcessModel, ProcessAutomation, lifecycle-state JSON, and .neqsim archives to make models reusable and inspectable.
5. Produce notebook-backed figures, tables, reports, and exports that support a design or operating decision.
6. Compare NeqSim results with reference data, plant data, another simulator, or an independent calculation.
7. Run parameter sweeps, batch studies, managed parallel scenario studies, and bounded optimization without losing traceability.
8. Package a complete process-model study as a small reproducible portfolio.

Learning Paths

Different readers can take different routes through the same book.

Competency Matrix

What Counts as State of the Art

For this book, state of the art does not mean using the most complicated model available. It means using the smallest model that is technically defensible and leaving enough evidence that another engineer can reproduce the decision.

Use these habits throughout the book:

• Prefer direct Java access for serious process models so the Python code stays aligned with the current NeqSim API.
• Set a mixing rule for every EOS fluid and initialize properties before reading transport or physical-property values.
• Keep inputs and outputs structured: dictionaries, dataclasses, JSON, or ProcessAutomation variables are easier to audit than scattered notebook cells.
• Design for automation from the start: stable unit names, explicit input and output variables, lifecycle-state files, and MCP/API boundaries make the same model usable by notebooks, dashboards, optimizers, and AI agents.
• Treat plots as engineering evidence: label axes, include units, and explain what the curve means for design or operation.
• Compare against a benchmark whenever possible: a hand estimate, a published case, plant data, another simulator, or a previous version of the same model.
• Use managed parallelism for independent studies. Build one process model per case and use the runAsTask()/Future pattern for large batches.
• Save the final state. If a result matters, preserve the notebook, figure, input table, output JSON, and model archive.

Suggested Portfolio Rhythm

At the end of each part, keep one small artifact:

• After Part I: a one-cell environment check and a direct-access mini model.
• After Part II: a fluid notebook with an EOS choice and a reference check.
• After Part III: a steady-state process notebook with mass-balance closure.
• After Part IV: a saved model state and a machine-readable output file.
• After Part V: one equipment deep-dive artifact: compressor map envelope, anti-surge margin table, distillation solver diagnostic report, or advanced-equipment checklist.
• After Part VI: a complete capstone study with scenarios, validation, and a recommendation.

The Capstone Portfolio in the back matter gives a compact checklist and rubric for turning these artifacts into a finished learning project.

Task Decision Tree — "I Want to ___"

The reader-path matrix in the Learning Roadmap is organised by role. This page is organised by task — the question a working process engineer types into a search box on a Monday morning. Find your task, load the listed class, jump to the chapter.

Thermodynamics and Fluids

Steady-State Process Modelling

Dynamic and Safety

Industrial Integration

Optimisation and Studies

When in Doubt

If your task is not in this table, search docs/development/TASK_LOG.md in the NeqSim repository — every solved engineering task is indexed there with keywords and solution paths.

Glossary

Adjuster — A ProcessSystem element that varies one variable to drive a target to a setpoint by iteration; the steady-state equivalent of a PID controller.

Anti-surge controller — Control loop that opens a recycle valve around a compressor when the operating point approaches the surge line.

Approach temperature — Smallest temperature difference between hot and cold streams in a heat exchanger. Sub-5 °C approaches imply very large area; sub-1 °C is usually a model error.

Automation API — ProcessAutomation. String-addressable variable interface to a ProcessSystem or ProcessModel.

Bubble point — The pressure (at fixed T) or temperature (at fixed P) at which the first bubble of vapour appears in a liquid mixture.

Capstone portfolio — A compact set of reproducible study artifacts: problem statement, fluid definition, runnable notebook, validation evidence, figures or tables, machine-readable output, saved model state, and decision memo.

CME — Constant Mass Expansion. PVT laboratory test stepping pressure down at constant temperature and composition.

CPA — Cubic-Plus-Association equation of state. Adds an association term to a cubic EOS for hydrogen-bonding systems (water, glycols, methanol, hydrate inhibitors).

Cricondenbar — The highest pressure on the phase envelope above which the mixture is single-phase regardless of temperature.

Cricondentherm — The highest temperature on the phase envelope above which the mixture is single-phase regardless of pressure.

CVD — Constant Volume Depletion. PVT test simulating gas-condensate reservoir depletion.

Dew point — The pressure or temperature at which the first drop of liquid appears in a vapour mixture.

Dew-point spec — A sales-gas quality requirement that the hydrocarbon (or water) dew point must lie below a specified temperature at a stated pressure. NeqSim computes both via calcPTphaseEnvelope and hydrateFormationTemperature.

Differential Liberation (DL) — PVT test releasing equilibrium gas in stages, simulating a black-oil reservoir.

Direct Java Access — The book's recommended NeqSim-from-Python style: from neqsim import jneqsim as J; J.subpackage.Class(...). Full access to the Java API with JPype type conversion.

E300 / Eclipse fluid — A NeqSim text format compatible with Schlumberger Eclipse's E300 compositional simulator; carries Tc, Pc, acentric factor, MW, and BIPs.

EOS — Equation of state. A mathematical relationship between P, V, and T for a fluid. NeqSim ships SRK, PR, CPA, GERG-2008, and others.

Factory dictionary — Python idiom in this book: {"SRK": J.thermo.system.SystemSrkEos} — table-driven constructor lookup.

Flash — A thermodynamic calculation that determines phase split and composition given two state variables (TP, PH, PS, UV, etc.).

Future — Java concurrency object returned by runAsTask() or NeqSimThreadPool.submit(...). It represents a running or completed calculation and supports get(), isDone(), cancellation, and timeout handling.

GERG-2008 — Reference EOS for natural gas mixtures, accurate to custody-transfer specs across wide T and P ranges.

HMB — Heat and Material Balance. The reference table of stream properties used to validate process models.

Inside-out solver — A column-convergence algorithm using linearised "inside" tray equations with periodic "outside" property updates. Robust for highly non-ideal systems.

JPype — Python library that starts a JVM and exposes Java classes as Python objects.

K-value — The ratio $K_i = y_i / x_i$ between a component's vapour and liquid mole fractions at equilibrium. The fundamental output of a flash calculation; light components have $K > 1$, heavy components $K < 1$.

Lifecycle state — ProcessSystemState / ProcessModelState. JSON snapshots of a model for save, load, version, and diff.

MDMT — Minimum Design Metal Temperature. The lowest temperature at which a vessel may safely be pressurised, set by the material's impact-toughness curve. Checked against the end-of-blowdown temperature in every depressurisation study (see skill neqsim-depressurization-mdmt).

Mixing rule — Combining rule for pure-component EOS parameters in a mixture. NeqSim's default is "classic" (van der Waals one-fluid). Required for every EOS-based fluid.

Multi-area model — A ProcessModel composed of multiple ProcessSystem objects, each representing a process area.

Naphtali-Sandholm solver — A simultaneous-correction column solver solving all equilibrium and mass-balance equations as one Newton system.

NeqSimThreadPool — Managed Java thread pool used to run independent process simulations concurrently. Prefer runAsTask() with Future objects over unmanaged runAsThread() calls.

Pinch analysis — Heat-integration technique that targets minimum utility demand subject to a chosen ΔTmin.

Plus-fraction — A pseudo-component representing all hydrocarbons heavier than a cut (e.g., C7+). Characterised into sub-components by a splitter algorithm (Pedersen, Whitson).

Polytropic efficiency — Compressor efficiency defined for an infinitesimal compression step; preferred over isentropic for multi-stage machines.

Process model — ProcessModel. A container of named ProcessSystem objects that iterate to convergence as a unit.

Process system — ProcessSystem. A NeqSim flowsheet — equipment, streams, controllers, recycles, adjusters.

results.json — Machine-readable result file used in this book's notebook-backed workflow. It should contain key results, validation flags, figure captions, assumptions, and references needed to regenerate reports.

Recycle — A ProcessSystem element that closes a loop by passing its outlet back to a target equipment's inlet. Iterates with damping (Wegstein) until convergence.

Sequential solver — A column solver that converges trays one-at-a- time. Fast for ideal systems, slow for non-ideal.

Stream introspection — Walking a ProcessSystem graph via getInletStreams() and getOutletStreams() on each equipment object.

Surge margin — Distance, expressed as a percentage of flow, between a centrifugal compressor's operating point and its surge line. Anti-surge controllers typically open the recycle valve at a 10 – 15 % margin.

TBP — True Boiling Point. A laboratory crude assay producing a boiling-point curve used to characterise a heavy oil.

Three-phase separator — Separator vessel producing three product streams: gas, oil, and water.

TPflash — Constant-pressure, constant-temperature flash. The default and most common operation.

Wegstein damping — A relaxation method accelerating fixed-point iteration; used by Recycle to suppress oscillation.

WET process — A process system that includes a water phase throughout — common for produced fluids and gas treatment.

First-Hour Troubleshooting

This appendix collects the errors a process engineer is most likely to hit in the first hour of using NeqSim from Python. Each entry follows the same shape: symptom → cause → fix → why it happened.

E.1 The Big Six

1. NaN density or zero viscosity

Symptom. fluid.getDensity("kg/m3") returns nan or fluid.getPhase("gas").getViscosity("kg/msec") returns exactly 0.0.

Cause. You called TPflash() (or any flash) but forgot fluid.initProperties() afterwards. The flash initialises thermodynamic properties but not transport properties.

Fix.

ops.TPflash()
fluid.initProperties()      # ← MANDATORY before getViscosity/getThermalConductivity

Why. init(3) alone does not initialise physical-property models; initProperties() calls both init(2) and initPhysicalProperties(). This is documented in the NeqSim agent skill neqsim-api-patterns but trips up almost every new user.

---

2. Mixing rule not set or strange flash results

Symptom. Either an exception about mixing rules, or a flash that produces obviously wrong K-values (e.g., methane K-value far from unity at 60 bara, 25 °C).

Cause. You created an EOS fluid but forgot fluid.setMixingRule("classic").

Fix. Always call it before adding the last component or before flashing. For CPA fluids use fluid.setMixingRule(10).

---

3. Component xxx not found in database

Symptom. addComponent("C20+", 0.01) raises a database lookup error.

Cause. Plus-fraction names contain the + character which is not a valid component-database key. Use "C20" and characterise via characterisePlusFraction() afterwards.

Fix.

fluid.addComponent("C20", 0.01)
fluid.setHeavyTBPfractionAsPlusFraction()
fluid.characterisePlusFraction()

---

4. Phase-envelope branches look swapped

Symptom. getBubblePointTemperatures() and getDewPointTemperatures() return data that visually looks the wrong way around — the "bubble" branch contains the cricondentherm.

Cause. When calcPTphaseEnvelope(True, 1.0) is called with bubblePointFirst=True, the getter method names are physically swapped. This is a long-standing quirk preserved for backward compatibility.

Fix. Always classify by physics, never by getter name:

A_T = np.asarray(env.getBubblePointTemperatures())
B_T = np.asarray(env.getDewPointTemperatures())
if A_T.max() > B_T.max():
    dew_T, bub_T = A_T, B_T    # "bubble" getter actually returned dew data
else:
    dew_T, bub_T = B_T, A_T

The branch containing the highest temperature is the dew branch (it owns the cricondentherm).

---

5. JPype JVM already started / cannot change classpath

Symptom. A second import neqsim in the same Python process fails or ignores classpath changes.

Cause. JPype starts the JVM once per process. You cannot swap JARs mid-session.

Fix. Restart the Python kernel before changing the NeqSim installation. In notebooks: Kernel → Restart. If you are running parametric studies that mutate the classpath, use the NeqSim Runner (devtools/neqsim_runner/) which isolates each job in its own JVM.

---

6. Mass balance does not close on a recycle

Symptom. ProcessSystem.run() returns but Σ(in) ≠ Σ(out) by more than rounding.

Cause. Either the recycle did not converge (default tolerance is loose) or you forgot to register the Recycle element on the ProcessSystem.

Fix.

recycle = J.process.util.recycle.Recycle("REC-1")
recycle.addStream(loop_return)
recycle.setOutletStream(loop_guess)
recycle.setTolerance(1e-4)
proc.add(recycle)             # ← easy to forget
proc.run()

---

E.2 Unit-String Gotchas

NeqSim uses unit strings on almost every getter and setter. The most frequent mistakes:

Habit to form. Always pass an explicit unit string. The Java API will accept the default, but your code will be unreadable in six months.

E.3 Python ↔ Java Type Surprises

• Java int vs Python int. Some setters require int; passing numpy.int64 raises No matching overloads. Cast with int(x).
• Java double[] vs numpy array. Most NeqSim methods accept lists or numpy arrays and copy them. Returned arrays are JArray — wrap in np.asarray(...) if you need numpy semantics.
• null handling. Java null becomes Python None. Check with if stream is None before calling getters.

E.4 When the Solver Diverges

See the dedicated skill neqsim-troubleshooting (in the NeqSim agent skills directory) for a ranked recovery checklist:

1. Run a TP flash alone first — if that fails, the flowsheet is irrelevant.
2. Loosen the recycle tolerance temporarily, then tighten back once convergence is found.
3. Provide an explicit Recycle guess close to the expected solution.
4. For distillation columns: switch solver (DistillationColumn.SolverType.INSIDE_OUT is the most robust), double the tray count, or check feed-tray placement.
5. For dynamic runs that blow up: reduce the timestep by 10× and re-check.

E.5 When Numbers Look "Almost Right"

Process-engineering intuition catches errors a unit test never will. A 2 %-off compressor power for a wet gas at 60 bara is almost certainly a wrong EOS, a missing component, or a missing initProperties(). When in doubt:

• Re-run with SystemPrEos or SystemSrkCPAstatoil and compare.
• Compare to a hand calculation with $W = \dot m \cdot c_p \cdot \Delta T / \eta$.
• Compare to a literature value or a previous HYSYS/UniSim case.

The Capstone Portfolio backmatter expects every result to carry one such independent check.

E.6 Quick "Is Anything Working?" Script

If you hit anything weird, run this five-line sanity check before investigating further:

from neqsim import jneqsim as J
f = J.thermo.system.SystemSrkEos(298.15, 60.0)
f.addComponent("methane", 1.0); f.setMixingRule("classic")
J.thermodynamicoperations.ThermodynamicOperations(f).TPflash()
f.initProperties()
print(f.getDensity("kg/m3"))    # expect ~44 kg/m3

If this prints a reasonable number, NeqSim is fine and the bug is in your model.

Reproducibility, Running Case, and Engineering Interpretation

This appendix turns the book's three practical promises into a checklist: code that can be rerun, one process-modeling case that connects the chapters, and results that are interpreted as engineering evidence rather than left as raw numbers.

Code Execution Contract

The source chapters use two kinds of Python blocks.

1. Runnable chapter examples are ordinary python fences. They are verified in chapter order because later cells often depend on objects created earlier in the same chapter.
2. Reference fragments are preceded by the noexec marker. These show API calls, patterns, or placeholders that need surrounding project context. They are preserved for readers but skipped by the verifier.

The book-level quality gate is:

python neqsim-paperlab/tools/verify_book_code_blocks.py \
    neqsim-paperlab/books/process_modeling_with_neqsim_python_2026 \
    --mode concat \
    --report neqsim-paperlab/books/process_modeling_with_neqsim_python_2026/code_block_report.json

Use --mode concat for this book because the reader experience is chapter based: import NeqSim once, create a fluid, run the next calculation, and then plot or report the result. Isolated snippets are still useful while editing, but they are stricter than the way the chapter examples are meant to be read.

The Running Case

The recurring case is a wet rich-gas export system. It starts as a fluid, grows into a PVT case, becomes a separator and compression train, is exposed through the Automation API, and finally becomes an optimization and reporting exercise.

The case is intentionally generic. Readers can replace the composition, pressure levels, and equipment tags with their own project data while keeping the structure: fluid factory, model builder, run function, validation function, and reporting function.

Running-Case Ledger

Keep a small ledger as the case moves through the book.

The ledger prevents a common failure mode: by Chapter 18 the optimization result looks precise, but nobody remembers which component database, feed composition, or process limits produced it.

Engineering Interpretation Blocks

After every important figure, table, flash, PVT result, process result, or optimization result, write four short sentences.

This structure is deliberately compact. It makes a notebook easier to review and gives the reporting toolchain enough material to build a useful discussion section from figure_discussion entries in results.json.

When Not to Trust the Result Yet

Treat a result as provisional when any of these are true:

• The component comes from the extended database and no independent property data has been checked.
• A flash converges but the phase count contradicts the expected envelope.
• A process model meets the target only because a hidden utility, recycle, or equipment limit was unconstrained.
• A plotted curve has the right shape but no benchmark point, hand estimate, or previous-case comparison.
• An optimization selects a point on a boundary without reporting the active constraint and margin.

The remedy is not always a larger model. Often it is a simpler cross-check: a mass balance, a single NIST point, a vendor curve, a manual compressor power estimate, or rerunning the same model after saving and restoring its state.

Full Integrated Process Model Code Listing

This appendix preserves the long, no-execute generalized code listing that used to sit inside the integrated offshore process-model chapter. It remains available for implementation comparison and audit, but it no longer interrupts the main teaching path through the capstone narrative.

The runnable, anonymous companion notebook remains linked from the capstone chapter and should be the first place readers go when they want executable code. Use this appendix when you need to inspect how a larger project notebook was organized cell by cell.

Original Full Generalized Notebook Code Listing

The listing below contains every code cell from the source process-model notebook, in notebook order. It is marked no-execute in the book because it depends on project- specific input files such as process-condition spreadsheets and fluid-characterization exports. The code is anonymized: replace generic asset, train, route, and tag names with your own project names before running it.

Code cell 1: Content of notebook

Notebook cell 3. This code belongs to the Content of notebook section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

simulation_year: int = 2025 # 1, 2, 2025, 2026, 2027, 2028, 2029, 2030, 2031, 2032, 2033, 2034, 2035, 2036, 2037, 2038, 2039, 2040, 2041, 2042, 2043, 2044, 2045

Code cell 2: Content of notebook

Notebook cell 4. This code belongs to the Content of notebook section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

simulation_case: str = 'base' # 'low', 'high', 'base','benchmark'

Code cell 3: Content of notebook

Notebook cell 5. This code belongs to the Content of notebook section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

results_path: str = 'results/basecase' #/highN2' basecase highcase # path to the results folder

Code cell 4: Content of notebook

Notebook cell 6. This code belongs to the Content of notebook section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

third_party_feed_case: str = 'unstable' #stable / unstable

Code cell 5: 1. Define input parameters

Notebook cell 9. This code belongs to the 1. Define input parameters section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

from dataclasses import dataclass, field
from typing import List
import math
from IPython.display import clear_output

@dataclass
class ProcessInput:
    # Core
    #  parameters
    Year: int = 2029  # Current year of the simulation

    rich_gas_bypass: bool = False  # Flag for rich gas pass
    #lpg_injection_flow: float = 20000.0  # LPG injection flow rate in kg/hr
    lpg_injection_fraction: float = 0.001

    third_party_feed_case:str='unstable'#"unstable" #unstable" #"stable" # "no third_party_feed"

    results_path:str='results'

    heater_start_year: int = 2026  # Year when the heater starts operation
    year_pre_compression: int = 2028  # Year before compression starts
    tex_start_year: int = 2029  # Year when TEX starts operation

    cold_gas_bypass_multidunk = 0.05

    # Scenario flags
    simulation_case:str='base'  # Simulation case: 'low', 'high', 'base'

    # Process parameters
    new_compressor_pressure: float = 62.0  # Pressure of the new compressor in bar
    # Outlet temperature of the new compressor cooler in °C
    new_compressor_cooler_out_temperature: float = 30.0
    # CalibrationStream separation pressure tuning parameter in bar
    reference_stream_c_calibration_stream_separator_pressure: float = 29.11
    # Gas fraction to CALIB_STAGE tuning parameter the rest is sent to recompressor
    reference_stream_c_gas_fraction_to_CALIB_STAGE = 0.999999
    reference_stream_c_CALIB_STAGE_compressor_cooler_temperature = 30.0
    # Low-pressure well feed temperature in °C
    satellite_heater_temperature: float = 70.0
    first_stage_pressure = 62.0  # Pressure of the first stage in bar
    first_stage_heater_temperature: float = 80.0  # Temperature of the second stage in °C
    second_stage_pressure: float = 20.0  # Pressure of the second stage in bar
    third_stage_pressure: float = 7.0  # Pressure of the third stage in bar
    fourth_stage_pressure: float = 3.0  # Pressure of the fourth stage in bar
    flare_gas_recovery_pressure: float = 1.96  # Flare gas recovery pressure in bar

    first_stage_scrubber_temperature: float = 30.0 # Temperature of the first stage scrubber in °C
    second_stage_suction_cooler_temperature : float = 30.0
    third_stage_suction_cooler_temperature : float = 30.0
    fourth_stage_suction_cooler_temperature : float = 30.0
    fifth_stage_suction_cooler_temperature : float = 30.0
    use_both_gas_recompression_trains_1_2_stage : int = 0  # Use both gas recompression trains (1) or not (0)
    use_both_gas_recompression_trains_3_stage : int = 0
    fuel_gas_rate: float = 0.2  # Fuel gas rate in MSm3/day
    dew_point_scrubber_temperature: float = 24.0 # Dew point scrubber temperature in °C
    expander_out_pressure: float = 42.5  # Expander outlet pressure in bar
    pre_flash_drum_pressure: float = 20.0  # Pre-flash drum pressure in bar
    # NGL column reboiler temperature in °C
    ngl_column_reboiler_temperature: float = 42.0
    ngl_column_pressure: float = 7.0  # NGL column pressure in bar
    ngl_routing_to_oil: float = 0.999  # NGL routing to oil fraction
    export_compressor_pressure: float = 150  # Export compressor pressure in bar
    # Injection compressor pressure in bar
    injection_compressor_pressure: float = 250
    injection_gas_rate_ht: float = 0.0  # Injection gas rate in MSm3/day
    injection_gas_rate_ht_split_to_train_A: float = 0.0  # Injection gas rate split to Train A in MSm3/day
    speed_EXPORT_COMPRESSOR: int = 8000  # Speed of compressor EXPORT_COMPRESSOR in RPM
    speed_EXPORT_COMPRESSOR: int = 8000  # Speed of compressor EXPORT_COMPRESSOR in RPM
    injection_gas_rate_dx : float = 2.3 # Injection gas rate in MSm3/day
    gas_lift_rate : float = 0.6  # Gas lift rate in MSm3/day

    # Reservoir production parameters
    calibration_stream_scale_factor_low: float = 0.9  # Low calibration_stream scale factor
    calibration_stream_scale_factor_intermediate: float = 1.0  # Intermediate calibration_stream scale factor
    calibration_stream_scale_factor_high: float = 1.1  # High calibration_stream scale factor
    calibration_stream_temperature: float = 80.0  # CalibrationStream temperature in °C
    calibration_stream_water: float = 10000.0  # CalibrationStream water in m3/day
    reference_stream_c_reference_stream_a_temperature: float = 80.0  # ReferenceStreamA temperature tuning in °C
    reference_stream_c_reference_stream_a_water: float = 10000.0  # ReferenceStreamA water tuning in m3/day
    reference_stream_c_reference_stream_b_temperature: float = 80.0  # ReferenceStreamB temperature tuning in °C
    reference_stream_c_reference_stream_b_water: float = 10000.0  # ReferenceStreamB water tuning in m3/day
    cluster_d_temperature: float = 80.0  # Cluster D temperature in °C
    cluster_d_water: float = 10000.0  # Cluster D water in m3/day
    cluster_c_temperature: float = 80.0  # Cluster C temperature in °C
    cluster_c_water: float = 10000.0  # Cluster C water in m3/day
    reference_stream_b_scale_factor_low: float = 0.9  # Low ReferenceStreamB scale factor
    reference_stream_b_scale_factor_intermediate: float = 1.0  # Intermediate ReferenceStreamB scale factor
    reference_stream_b_scale_factor_high: float = 1.1  # High ReferenceStreamB scale factor
    reference_stream_b_temperature: float = 80.0  # ReferenceStreamB temperature in °C
    reference_stream_b_water: float = 10000.0  # ReferenceStreamB water in m3/day
    cluster_a_scale_factor_low: float = 0.9  # Low Cluster A scale factor
    cluster_a_scale_factor_intermediate: float = 1.0  # Intermediate Cluster A scale factor
    cluster_a_scale_factor_high: float = 1.1  # High Cluster A scale factor
    cluster_a_temperature: float = 80.0  # Cluster A temperature in °C
    cluster_a_water: float = 10000.0  # Cluster A water in m3/day
    condensate_area_scale_factor_low: float = 0.9  # Low Condensate Area scale factor
    condensate_area_scale_factor_intermediate: float = 1.0  # Intermediate Condensate Area scale factor
    condensate_area_scale_factor_high: float = 1.1  # High Condensate Area scale factor
    condensate_area_temperature: float = 20.0  # Condensate Area temperature in °C
    condensate_area_water: float = 10000.0  # Condensate Area water in m3/day
    third_party_feed_temperature: float = 20.0  # ThirdPartyFeed temperature in °C
    third_party_feed_water: float = 1.0  # ThirdPartyFeed water in m3/day
    offshore_asset_east_temperature: float = 80.0  # Offshore Area East temperature in °C
    offshore_asset_east_water: float = 10000.0  # Offshore Area East water in m3/day
    offshore_east_scale_factor_low: float = 0.9  # Low Offshore Area East scale factor
    offshore_east_scale_factor_intermediate: float = 1.0  # Intermediate Offshore Area East scale factor
    offshore_east_scale_factor_high: float = 1.1  # High Offshore Area East scale factor
    offshore_asset_south_temperature: float = 80.0  # Offshore Area South temperature in °C
    offshore_asset_south_water: float = 10000.0  # Offshore Area South water in m3/day
    cluster_b_scale_factor_low: float = 0.9  # Low Cluster B scale factor
    # Intermediate Cluster B scale factor
    cluster_b_scale_factor_intermediate: float = 1.0
    cluster_b_scale_factor_high: float = 1.1  # High Cluster B scale factor
    cluster_b_temperature: float = 80.0  # Cluster B temperature in °C
    cluster_b_water: float = 10000.0  # Cluster B water in m3/day

    # Example hydrocarbon flow rates and compositions
    hc_flow_rate_cluster_a: float = 2.931e6  # Hydrocarbon flow rate for Cluster A in Sm3/day
    hc_composition_cluster_a: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for Cluster A
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    hc_flow_rate_calibration_stream: float = 1.843e6  # Hydrocarbon flow rate for CalibrationStream in Sm3/day
    hc_composition_calibration_stream: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for CalibrationStream
        0.6417, 1.8505, 83.9189, 7.6914, 3.1650, 0.3587, 0.6610, 0.1740,
        0.1930, 0.2134, 0.3393, 0.3568, 0.1782, 0.2254, 0.0319, 0.0007, 0.0
    ])

    # Hydrocarbon flow rate for Main ReferenceStreamB in Sm3/day
    hc_flow_rate_main_reference_stream_b: float = 2.931e6
    hc_composition_main_reference_stream_b: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for Main ReferenceStreamB
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    # Hydrocarbon flow rate for Cluster B in Sm3/day
    hc_flow_rate_cluster_b: float = 2.931e6
    hc_composition_cluster_b: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for Cluster B
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    hc_flow_rate_condensate_area: float = 2.931e6  # Hydrocarbon flow rate for Condensate Area in Sm3/day
    hc_composition_condensate_area: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for Condensate Area
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    # Hydrocarbon flow rate for ReferenceStreamC ReferenceStreamA in Sm3/day
    hc_flow_rate_reference_stream_creference_stream_a: float = 2.931e6
    hc_composition_reference_stream_creference_stream_a: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for ReferenceStreamC ReferenceStreamA
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    # Hydrocarbon flow rate for ReferenceStreamC ReferenceStreamB in Sm3/day
    hc_flow_rate_reference_stream_creference_stream_b: float = 2.931e6
    hc_composition_reference_stream_creference_stream_b: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for ReferenceStreamC ReferenceStreamB
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    # Hydrocarbon flow rate for Cluster D in Sm3/day
    hc_flow_rate_cluster_d: float = 2.931e6
    hc_composition_cluster_d: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for Cluster D
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    # Hydrocarbon flow rate for Cluster C in Sm3/day
    hc_flow_rate_cluster_c: float = 2.931e6
    hc_composition_cluster_c: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for Cluster C
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    # Hydrocarbon flow rate for Offshore Area East in Sm3/day
    hc_flow_rate_offshore_east: float = 2.931e6
    hc_composition_offshore_east: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for Offshore Area East
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    # Hydrocarbon flow rate for Offshore Area South in Sm3/day
    hc_flow_rate_offshore_south: float = 2.931e6
    hc_composition_offshore_south: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for Offshore Area South
        0.2427, 1.4284, 78.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    hc_flow_rate_third_party_feed: float = 100.0  # Hydrocarbon flow rate for ThirdPartyFeed in Sm3/day
    hc_composition_third_party_feed: List[float] = field(default_factory=lambda: [  # Hydrocarbon composition for ThirdPartyFeed
        0.2427, 1.4284, 0.9641, 8.9389, 4.7052, 0.6935, 1.4287, 0.2067,
        0.2469, 0.3546, 0.5473, 0.6345, 0.1843, 0.7085, 0.5630, 0.1528, 0.0
    ])

    expander_efficiency = 77.0

    chartConditions = [] #used to set molecular weight etc.
    headunit = 'kJ/kg'

    surgeflow_first_stage_compressor = [5500, 6269.85, 6878.75, 7488.05, 7979.18, 8567.67, 8811, 9097.54] #single speed
    surgehead_first_stage_compressor = [93.2, 92.54, 91.66, 90.27, 88.18, 84.87, 83.2, 80.61]

    surgeflow_second_stage_compressor = [9758.49, 9578.11, 9397.9, 9248.64, 9006.93, 8749.97, 8508.5, 8179.81, 7799.81, 7111.75, 6480.26, 6007.91, 5607.45] #single speed
    surgehead_second_stage_compressor = [112.65, 121.13, 127.56, 132.13, 137.29, 140.73, 142.98, 144.76, 146.14, 148.05, 148.83, 149.54, 150]

    surgeflow_third_stage_compressor = [2451.6782, 2834.65, 3720.0688, 	4394.420, 5384.2417, 5825.17]
    surgehead_third_stage_compressor = [78.8811, 105.519, 141.39, 158.5963, 180.320, 189.53]

    surgeflow_DX1_stage_compressor = [5115.3633, 5848.66, 6663.91, 7842.191, 8288.40, 8736.8]
    surgehead_DX1_stage_compressor = [ 63.519,  82.8421,  106.11, 124.987,  129.369, 142.5]

    surgeflow_DX2_stage_compressor = [2061.8, 2356.74, 2848.3, 3398.8, 3634.83]
    surgehead_DX2_stage_compressor = [41.4,  51.52, 63.6, 84.2, 92.6]

    surgeflow_DX3_stage_compressor = [2061.8, 2356.74, 2848.3, 3398.8, 3634.83]
    surgehead_DX3_stage_compressor = [41.4,  51.52, 63.6, 84.2, 92.6]

    surgeflow_htA_stage_compressor = [2173.346, 2537.7532, 3150.335, 3591.540, 4220.19,4506.92]
    surgehead_htA_stage_compressor = [81.888,  108.4406,  144.835,  162.46066,185.808, 195.6]

    surgeflow_htB_stage_compressor = [809.729, 920, 1036.75, 1153.513, 1166.48, 1244.3243]
    surgehead_htB_stage_compressor = [35.31, 46.25, 59.03, 70.81, 73.17, 80.9134]

    surgeflow_new_stage_compressor = [7000, 12000, 16000]
    surgehead_new_stage_compressor = [40, 100, 160]

    surgeflow_CALIB_STAGE__compressor_1st_stage = [4200, 6000, 8100]
    surgehead_CALIB_STAGE_compressor_1st_stage = [90, 150, 200]

    surgeflow_CALIB_STAGE__compressor_2nd_stage = [1100, 1500, 1750]
    surgehead_CALIB_STAGE_compressor_2nd_stage = [45, 80, 100]

    surgeflow_third_stage_compressor_speed_new_boundle = [11571]
    surgeflow_third_stage_compressor_flow_new_boundle = [3419.61,	3464.15,	3959.03,	4453.91,	4948.79,	5078.89,	5443.67,	5938.54,	6433.42,	6567.04]
    surgeflow_third_stage_compressor_head_new_boundle = [191.3385288,	191.1080725,	188.1582322,	183.592256,	176.9227533,	174.5269887,	167.8221821,	157.3555446,	131.6895802,	125.1710999]


    reference_stream_c_CALIB_STAGE_compressor_pressure = 200.0  # Tuning parameter for CALIB_STAGE compressor pressure in bar
    speed_export_compressor_stage_1 = 8000  # Speed of compressor EXPORT_COMPRESSOR in RPM
    speed_export_compressor_stage_2 = 8000

    offshore_asset_transport_diameter = 0.67
    offshore_asset_transport_length = 105000

input_parameters = ProcessInput()

Code cell 6: 2. Read process conditions from parameters.xlsx file

Notebook cell 11. This code belongs to the 2. Read process conditions from parameters.xlsx file section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

import pandas as pd
from IPython.display import clear_output

def read_process_conditions(file_path: str, simulation_year: int, inp: ProcessInput):
    """
    Reads process conditions from an Excel file for the given year and updates the `inp` object
    with corresponding attribute values.

    Parameters
    ----------
    file_path : str
        Path to the Excel file (e.g. 'parameters.xlsx').
    simulation_year : int
        The year for which to select data.
    inp : ProcessInput
        An object whose attributes will be set to the values from the Excel row.

    Returns
    -------
    ProcessInput
        The updated input object.
    """
    try:
        df = pd.read_excel(file_path, sheet_name=0, header=0)
    except Exception as e:
        raise IOError(f"Error reading Excel file at {file_path}: {e}")

    # Select the row for the chosen year
    selected = df.loc[df['Year'] == simulation_year]
    if selected.empty:
        raise ValueError(
            f"No data found for year {simulation_year} in {file_path}.")

    # If multiple rows exist, pick the first one
    row = selected.iloc[0]

    # Dynamically update attributes of the input object
    for column in df.columns:
        attribute_name = column.replace(" ", "_")
        if hasattr(inp, attribute_name):
            setattr(inp, attribute_name, float(row[column]))
        else:
            print(f"Warning: {attribute_name} not found in ProcessInput class.")

    return inp


input_parameters = ProcessInput()

# Path to your Excel file
if simulation_case == "high":
    file_path = "./parameters_highcase.xlsx"
elif simulation_case == "low":
    file_path = "./parameters_lowcase.xlsx"
else:
    file_path = "./parameters.xlsx"

# Read process conditions and update the input object
input_parameters = read_process_conditions(
    file_path, simulation_year, input_parameters)

input_parameters.Year = int(simulation_year)
input_parameters.simulation_case = simulation_case
input_parameters.third_party_feed_case = third_party_feed_case
input_parameters.results_path = results_path

# Dynamically print all attributes and their values
for attr, value in vars(input_parameters).items():
    print(f"{attr} = {value}")

Code cell 7: 3. Read reservoir production data from FluidMagic

Notebook cell 13. This code belongs to the 3. Read reservoir production data from FluidMagic section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

import pandas as pd


def read_production_file(inp: ProcessInput, file_path, simulation_year:int):
    """
    Reads a production file with the known format, filters it by the given year,
    and returns the relevant values in a convenient dictionary.
    """
    df = pd.read_csv(file_path, sep=r"\s+", header=0)
    # Filter DataFrame for the chosen year
    data_for_year = df.loc[df['Year'] == simulation_year].copy()
    if data_for_year.empty:
        raise ValueError(
            f"No data found for year {simulation_year} in file '{file_path}'.")

    # Build the composition list. We take columns from index 6 onward.
    composition_columns = data_for_year.columns[6:]
    data_for_year['composition'] = data_for_year[composition_columns].values.tolist()
    # Append [0] to the end of the composition list
    data_for_year['composition'] = data_for_year['composition'].apply(
        lambda x: x + [0])

    # Extract what we need (assuming only one row for that year)
    oil_rate = data_for_year['Oilrate'].values[0]
    gas_rate = data_for_year['Gasrate'].values[0]
    mass_rate = data_for_year['Massrate'].values[0]
    composition = data_for_year['composition'].values[0]

    # Return as a dictionary (or you could return a namedtuple or a custom class if you prefer)
    return {
        'year': simulation_year,
        'oil_rate': oil_rate,
        'gas_rate': gas_rate,
        'mass_rate': mass_rate,
        'composition': composition
    }

files_and_attrs = {
    'cluster_a_north': "./well production from fluid magic/ClusterANorthProfile.txt",
    'main_reference_stream_b': "./well production from fluid magic/main_reference_stream_b.txt",
    'cluster_b': "./well production from fluid magic/cluster_b.txt",
    'calibration_stream': "./well production from fluid magic/calibration_streamrates.txt",
    'condensate_area': "./well production from fluid magic/condensate_area.txt",
    'third_party_feed': "./well production from fluid magic/third_party_feed_unstable.txt",
    'reference_stream_creference_stream_a': "./well production from fluid magic/reference_stream_creference_stream_a.txt",
    'reference_stream_creference_stream_b': "./well production from fluid magic/reference_stream_creference_stream_b.txt",
    'cluster_c': "./well production from fluid magic/cluster_c.txt",
    'cluster_d': "./well production from fluid magic/cluster_d.txt",
    'offshore_south': "./well production from fluid magic/offshore_asset_south.txt",
    'offshore_east': "./well production from fluid magic/offshore_asset_east.txt",
}

if(input_parameters.results_path == "results/highN2"):
    files_and_attrs['main_reference_stream_b'] = "./results/highN2/main_reference_stream_b.txt"
if(input_parameters.simulation_case == "high"):
    files_and_attrs['offshore_south'] = "./well production from fluid magic/offshore_asset_south_high.txt"
if(input_parameters.simulation_case == "low"):
    files_and_attrs['offshore_south'] = "./well production from fluid magic/offshore_asset_south_low.txt"
if(input_parameters.third_party_feed_case == "stable"):
    files_and_attrs['third_party_feed'] = "./well production from fluid magic/third_party_feed.txt"
if(input_parameters.results_path == "results/no_oss"):
    files_and_attrs['offshore_south'] = "./results/no_oss/offshore_asset_south.txt"

def read_production_file_all(inp: ProcessInput, file_path:str, simulation_year:int):
    data_dict = {}
    for name, path in files_and_attrs.items():
        try:
            data_dict[name] = read_production_file(inp, path, inp.Year)
        except ValueError as e:
            # Here we assume that the only reason for ValueError is "No data found"
            # If you'd like to differentiate among multiple error messages, you can parse 'e' or do more specific checks.
            print(f"Warning: {name}")
            print(f"Warning: {e}")
            data_dict[name] = None

    # Then pick out the data, e.g.:
    if data_dict['cluster_a_north'] is None:
        inp.hc_flow_rate_cluster_a = 1.0
        inp.cluster_a_water = 1.0e-3
    else:
        inp.hc_composition_cluster_a = data_dict['cluster_a_north']['composition']
        inp.hc_flow_rate_cluster_a = data_dict['cluster_a_north']['mass_rate']

    if data_dict['main_reference_stream_b'] is None:
        inp.hc_flow_rate_main_reference_stream_b = 1.0
        inp.main_reference_stream_b_water = 1.0e-3
    else:
        inp.hc_flow_rate_main_reference_stream_b = data_dict['main_reference_stream_b']['mass_rate']
        inp.hc_composition_main_reference_stream_b = data_dict['main_reference_stream_b']['composition']

    if data_dict['cluster_b'] is None:
        inp.hc_flow_rate_cluster_b = 1.0
        inp.cluster_b_water = 1.0e-3
    else:
        inp.hc_flow_rate_cluster_b = data_dict['cluster_b']['mass_rate']
        inp.hc_composition_cluster_b = data_dict['cluster_b']['composition']

    if data_dict['calibration_stream'] is None:
        inp.hc_flow_rate_calibration_stream = 1000.0
        inp.calibration_stream_water = 1.0
    else:
        inp.hc_flow_rate_calibration_stream = data_dict['calibration_stream']['mass_rate']
        inp.hc_composition_calibration_stream = data_dict['calibration_stream']['composition']

    if data_dict['condensate_area'] is None:
        inp.hc_flow_rate_condensate_area = 1.0
        inp.condensate_area_water = 1.0e-3
    else:
        inp.hc_flow_rate_condensate_area = data_dict['condensate_area']['mass_rate']
        inp.hc_composition_condensate_area = data_dict['condensate_area']['composition']

    if data_dict['third_party_feed'] is None:
        inp.hc_flow_rate_third_party_feed = 1.0
        inp.third_party_feed_water = 1.0e-3
    else:
        inp.hc_flow_rate_third_party_feed = data_dict['third_party_feed']['mass_rate']
        inp.hc_composition_third_party_feed = data_dict['third_party_feed']['composition']

    if data_dict['reference_stream_creference_stream_a'] is None:
        inp.hc_flow_rate_reference_stream_creference_stream_a = 1.0
        inp.reference_stream_c_reference_stream_a_water = 1.0e-3
    else:
        inp.hc_flow_rate_reference_stream_creference_stream_a = data_dict['reference_stream_creference_stream_a']['mass_rate']
        inp.hc_composition_reference_stream_creference_stream_a = data_dict['reference_stream_creference_stream_a']['composition']

    if data_dict['reference_stream_creference_stream_b'] is None:
        inp.hc_flow_rate_reference_stream_creference_stream_b = 1.0
        inp.reference_stream_c_reference_stream_b_water = 1.0e-3
    else:
        inp.hc_flow_rate_reference_stream_creference_stream_b = data_dict['reference_stream_creference_stream_b']['mass_rate']
        inp.hc_composition_reference_stream_creference_stream_b = data_dict['reference_stream_creference_stream_b']['composition']

    if data_dict['cluster_d'] is None:
        inp.hc_flow_rate_cluster_d = 1.0
        inp.cluster_d_water = 1.0e-3
    else:
        inp.hc_flow_rate_cluster_d = data_dict['cluster_d']['mass_rate']
        inp.hc_composition_cluster_d = data_dict['cluster_d']['composition']

    if data_dict['cluster_c'] is None:
        inp.hc_flow_rate_cluster_c = 1.0
        inp.cluster_c_water = 1.0e-3
    else:
        inp.hc_flow_rate_cluster_c = data_dict['cluster_c']['mass_rate']
        inp.hc_composition_cluster_c = data_dict['cluster_c']['composition']

    if data_dict['offshore_east'] is None:
        inp.hc_flow_rate_offshore_east = 1.0
        inp.offshore_asset_east_water = 1.0e-3
    else:
        inp.hc_flow_rate_offshore_east = data_dict['offshore_east']['mass_rate']
        inp.hc_composition_offshore_east = data_dict['offshore_east']['composition']

    if data_dict['offshore_south'] is None:
        inp.hc_flow_rate_offshore_south = 1.0
        inp.offshore_asset_south_water = 1.0e-3
    else:
        inp.hc_flow_rate_offshore_south = data_dict['offshore_south']['mass_rate']
        inp.hc_composition_offshore_south = data_dict['offshore_south']['composition']


read_production_file_all(
    input_parameters, files_and_attrs, input_parameters.Year)

Code cell 8: Create default well and water stream using E300 characterization

Notebook cell 15. This code belongs to the Create default well and water stream using E300 characterization section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case- specific result folders.

# Improved fluid and stream creation utilities for Offshore Area field

from neqsim.process.processTools import stream, mixer
from neqsim import jneqsim as neqsim

# Load base well fluid
def create_fluid(composition=None):
    wellFluid = neqsim.thermo.util.readwrite.EclipseFluidReadWrite.read('generic_offshore_fluid_water.e300')#.autoSelectModel() #use autoSelectModel if CPA is going to be used
    if composition is not None:
        wellFluid.setMolarComposition(composition)
    wellFluid.setMultiPhaseCheck(True)
    wellFluid.init(0)
    return wellFluid

def create_water_fluid():
    """Create a pure water fluid based on the base fluid."""
    water_fluid = create_fluid()
    n = water_fluid.getNumberOfComponents()
    composition = [0] * n
    composition[-1] = 1  # Assume last component is water
    water_fluid.setMolarComposition(composition)
    water_fluid.init(0)
    return water_fluid

def create_stream(name, composition=None):
    """Create a stream with a given fluid and optional composition."""
    fluid = create_fluid(composition)
    return neqsim.process.equipment.stream.Stream(name, fluid)

def create_gas_stream(name):
    """Create a gas stream (e.g., pure methane)."""
    n = create_fluid().getNumberOfComponents()
    composition = [0] * n
    composition[2] = 1.0  # Assume index 2 is methane
    return create_stream(name, composition)

def create_flare_gas_stream(name):
    """Create a flare gas stream with a specified composition."""
    n = create_fluid().getNumberOfComponents()
    composition = [0] * n
    composition[2] = 0.5  # Methane
    composition[3] = 0.1  # Ethane
    composition[4] = 0.1  # Propane
    composition[5] = 0.1  # Butane
    return create_stream(name, composition)

def create_water_stream(name):
    wstream = create_stream(name)
    water_fluid = wstream.getFluid()
    n = water_fluid.getNumberOfComponents()
    composition = [0] * n
    composition[-1] = 1  # Assume last component is water
    water_fluid.setMolarComposition(composition)
    water_fluid.init(0)
    return wstream

Code cell 9: 4. Create a NeqSim process model for well feed and splitting streams into process feed streams and manifolds

Notebook cell 17. This code belongs to the 4. Create a NeqSim process model for well feed and splitting streams into process feed streams and manifolds section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

def manifold_model(inp: ProcessInput, feedstream, split_factors=None):
    manifold_process = neqsim.process.processmodel.ProcessSystem()

    manifold = neqsim.process.equipment.manifold.Manifold('manifold')
    manifold.addStream(feedstream)
    if split_factors is not None:
        manifold.setSplitFactors(split_factors)
    else:
        manifold.setSplitFactors([0.5, 0.5])
    manifold.run()
    manifold_process.add(manifold)

    return manifold_process

Code cell 10: Offshore Area Well Feed Model Function

Notebook cell 19. This code belongs to the Offshore Area Well Feed Model Function section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

def create_offshore_asset_well_feed_model(inp: ProcessInput):
    well_process = neqsim.process.processmodel.ProcessSystem()

    if (inp.simulation_case == 'high'):
        reference_stream_b_scale_factor = inp.reference_stream_b_scale_factor_high
        cluster_a_scale_factor = inp.cluster_a_scale_factor_high
        condensate_area_scale_factor = inp.condensate_area_scale_factor_high
        cluster_b_scale_factor = inp.cluster_b_scale_factor_high
        calibration_stream_scale_factor = inp.calibration_stream_scale_factor_high
        offshore_east_scale_factor = inp.offshore_east_scale_factor_high
    elif (inp.simulation_case == 'base'):
        reference_stream_b_scale_factor = inp.reference_stream_b_scale_factor_intermediate
        cluster_a_scale_factor = inp.cluster_a_scale_factor_intermediate
        condensate_area_scale_factor = inp.condensate_area_scale_factor_intermediate
        cluster_b_scale_factor = inp.cluster_b_scale_factor_intermediate
        calibration_stream_scale_factor = inp.calibration_stream_scale_factor_intermediate
        offshore_east_scale_factor = inp.offshore_east_scale_factor_intermediate
    elif (inp.simulation_case == 'low'):
        reference_stream_b_scale_factor = inp.reference_stream_b_scale_factor_low
        cluster_a_scale_factor = inp.cluster_a_scale_factor_low
        condensate_area_scale_factor = inp.condensate_area_scale_factor_low
        cluster_b_scale_factor = inp.cluster_b_scale_factor_low
        calibration_stream_scale_factor = inp.calibration_stream_scale_factor_low
        offshore_east_scale_factor = inp.offshore_east_scale_factor_low

    feedstreamgas_lift = create_stream('gas lift feed')
    feedstreamgas_lift.setTemperature(inp.cluster_b_temperature, 'C')
    feedstreamgas_lift.setPressure(inp.first_stage_pressure, 'bara')
    feedstreamgas_lift.setFlowRate(
        0.5, 'MSm3/day')
    feedstreamgas_lift.run()
    well_process.add(feedstreamgas_lift)

    gaslift_splitter = neqsim.process.equipment.splitter.Splitter(
    'lift gas splitter')
    gaslift_splitter.setInletStream(feedstreamgas_lift)
    gaslift_splitter.setSplitFactors(
    [0.5, 0.5])
    gaslift_splitter.run()
    well_process.add(gaslift_splitter)

    feedstream_main_reference_stream_b = create_stream('main reference_stream_b hc feed')
    feedstream_main_reference_stream_b.setTemperature(inp.reference_stream_b_temperature, 'C')
    feedstream_main_reference_stream_b.setPressure(inp.first_stage_pressure, 'bara')
    feedstream_main_reference_stream_b.getFluid().setMolarComposition(inp.hc_composition_main_reference_stream_b)
    feedstream_main_reference_stream_b.setFlowRate(
        inp.hc_flow_rate_main_reference_stream_b*reference_stream_b_scale_factor, 'kg/day')
    feedstream_main_reference_stream_b.run()
    well_process.add(feedstream_main_reference_stream_b)

    waterfeed_main_reference_stream_b = create_water_stream('main reference_stream_b water feed')
    waterfeed_main_reference_stream_b.setTemperature(inp.reference_stream_b_temperature, 'C')
    waterfeed_main_reference_stream_b.setPressure(inp.first_stage_pressure, 'bara')
    waterfeed_main_reference_stream_b.setFlowRate(
        inp.reference_stream_b_water*1e3*reference_stream_b_scale_factor, 'kg/day')
    waterfeed_main_reference_stream_b.run()
    well_process.add(waterfeed_main_reference_stream_b)

    main_reference_stream_b_mixer = neqsim.process.equipment.mixer.Mixer('main reference_stream_b mixer')
    main_reference_stream_b_mixer.addStream(feedstream_main_reference_stream_b)
    main_reference_stream_b_mixer.addStream(waterfeed_main_reference_stream_b)
    main_reference_stream_b_mixer.run()
    well_process.add(main_reference_stream_b_mixer)

    main_reference_stream_b_heater = neqsim.process.equipment.heatexchanger.Heater(
        'main reference_stream_b heater')
    main_reference_stream_b_heater.setInletStream(main_reference_stream_b_mixer.getOutStream())
    main_reference_stream_b_heater.setOutTemperature(inp.reference_stream_b_temperature, 'C')
    main_reference_stream_b_heater.run()
    well_process.add(main_reference_stream_b_heater)

    feedstream_main_reference_stream_b_splitter = neqsim.process.equipment.splitter.Splitter(
        'main reference_stream_b splitter')
    feedstream_main_reference_stream_b_splitter.setInletStream(
        main_reference_stream_b_heater.getOutStream())
    feedstream_main_reference_stream_b_splitter.setSplitFactors(
        [0.65, 0.35, 0.00001, 0.00001, 0.00001])
    feedstream_main_reference_stream_b_splitter.run()
    well_process.add(feedstream_main_reference_stream_b_splitter)

    # Adding cluster_b to first stage
    feedstream_main_cluster_b = create_stream('cluster_b hc feed')
    feedstream_main_cluster_b.setTemperature(
        inp.cluster_b_temperature, 'C')
    feedstream_main_cluster_b.setPressure(inp.first_stage_pressure, 'bara')
    feedstream_main_cluster_b.getFluid().setMolarComposition(
        inp.hc_composition_cluster_b)
    feedstream_main_cluster_b.setFlowRate(
        inp.hc_flow_rate_cluster_b*cluster_b_scale_factor, 'kg/day')
    feedstream_main_cluster_b.run()
    well_process.add(feedstream_main_cluster_b)

    waterfeed_cluster_b = create_water_stream('cluster_b water feed')
    waterfeed_cluster_b.setTemperature(inp.cluster_b_temperature, 'C')
    waterfeed_cluster_b.setPressure(inp.first_stage_pressure, 'bara')
    waterfeed_cluster_b.setFlowRate(inp.cluster_b_water*1e3, 'kg/day')
    waterfeed_cluster_b.run()
    well_process.add(waterfeed_cluster_b)

    cluster_b_mixer = neqsim.process.equipment.mixer.Mixer(
        'cluster_b mixer')
    cluster_b_mixer.addStream(feedstream_main_cluster_b)
    cluster_b_mixer.addStream(waterfeed_cluster_b)
    cluster_b_mixer.run()
    well_process.add(cluster_b_mixer)

    cluster_b_heater = neqsim.process.equipment.heatexchanger.Heater(
        'cluster_b heater')
    cluster_b_heater.setInletStream(cluster_b_mixer.getOutStream())
    cluster_b_heater.setOutTemperature(inp.cluster_b_temperature, 'C')
    cluster_b_heater.run()
    well_process.add(cluster_b_heater)

    feedstream_main_cluster_b_splitter = neqsim.process.equipment.splitter.Splitter(
        'main cluster_b splitter')
    feedstream_main_cluster_b_splitter.setInletStream(
        cluster_b_heater.getOutStream())
    feedstream_main_cluster_b_splitter.setSplitFactors([0.001, 0.999])
    feedstream_main_cluster_b_splitter.run()
    well_process.add(feedstream_main_cluster_b_splitter)

    # Adding Cluster A to first stage
    feedstream_cluster_a = create_stream('cluster_a hc feed')
    feedstream_cluster_a.setTemperature(inp.cluster_a_temperature, 'C')
    feedstream_cluster_a.setPressure(inp.first_stage_pressure, 'bara')
    feedstream_cluster_a.getFluid().setMolarComposition(inp.hc_composition_cluster_a)
    feedstream_cluster_a.setFlowRate(
        inp.hc_flow_rate_cluster_a*cluster_a_scale_factor, 'kg/day')
    feedstream_cluster_a.run()
    well_process.add(feedstream_cluster_a)

    waterfeed_cluster_a = create_water_stream('cluster_a water feed')
    waterfeed_cluster_a.setTemperature(inp.cluster_a_temperature, 'C')
    waterfeed_cluster_a.setPressure(inp.first_stage_pressure, 'bara')
    waterfeed_cluster_a.setFlowRate(inp.cluster_a_water*1e3, 'kg/day')
    waterfeed_cluster_a.run()
    well_process.add(waterfeed_cluster_a)

    cluster_a_well_mixer = neqsim.process.equipment.mixer.Mixer(
        'cluster_a hc water mixer')
    cluster_a_well_mixer.addStream(feedstream_cluster_a)
    cluster_a_well_mixer.addStream(waterfeed_cluster_a)
    cluster_a_well_mixer.run()
    well_process.add(cluster_a_well_mixer)

    cluster_a_heater = neqsim.process.equipment.heatexchanger.Heater(
        'cluster_a heater')
    cluster_a_heater.setInletStream(cluster_a_well_mixer.getOutStream())
    cluster_a_heater.setOutTemperature(inp.cluster_a_temperature, 'C')
    cluster_a_heater.run()
    well_process.add(cluster_a_heater)

    feedstream_cluster_a_splitter = neqsim.process.equipment.splitter.Splitter(
        'cluster_a splitter')
    feedstream_cluster_a_splitter.setInletStream(cluster_a_heater.getOutStream())
    feedstream_cluster_a_splitter.setSplitFactors([0.25, 0.25, 0.25, 0.25, 0.00001])
    feedstream_cluster_a_splitter.run()
    well_process.add(feedstream_cluster_a_splitter)

    HP_manifold_A = neqsim.process.equipment.mixer.Mixer('HP manifold A')
    HP_manifold_A.addStream(feedstream_main_reference_stream_b_splitter.getSplitStream(0))
    HP_manifold_A.addStream(
        feedstream_main_cluster_b_splitter.getSplitStream(0))
    HP_manifold_A.addStream(feedstream_cluster_a_splitter.getSplitStream(0))
    HP_manifold_A.addStream(gaslift_splitter.getSplitStream(0))
    HP_manifold_A.run()
    well_process.add(HP_manifold_A)

    HP_manifold_B = neqsim.process.equipment.mixer.Mixer('HP manifold B')
    HP_manifold_B.addStream(feedstream_main_reference_stream_b_splitter.getSplitStream(1))
    HP_manifold_B.addStream(
        feedstream_main_cluster_b_splitter.getSplitStream(1))
    HP_manifold_B.addStream(feedstream_cluster_a_splitter.getSplitStream(1))
    HP_manifold_B.addStream(gaslift_splitter.getSplitStream(1))
    HP_manifold_B.run()
    well_process.add(HP_manifold_B)

    pressurereduction_reference_stream_b1 = neqsim.process.equipment.valve.ThrottlingValve(
        "pressurereduction_reference_stream_b1", feedstream_main_reference_stream_b_splitter.getSplitStream(2))
    pressurereduction_reference_stream_b1.setOutletPressure(
        inp.second_stage_pressure, 'bara')
    pressurereduction_reference_stream_b1.run()
    well_process.add(pressurereduction_reference_stream_b1)

    pressurereduction_reference_stream_b2 = neqsim.process.equipment.valve.ThrottlingValve(
        "pressurereduction_reference_stream_b2", feedstream_main_reference_stream_b_splitter.getSplitStream(3))
    pressurereduction_reference_stream_b2.setOutletPressure(
        inp.second_stage_pressure, 'bara')
    pressurereduction_reference_stream_b2.run()
    well_process.add(pressurereduction_reference_stream_b2)

    pressurereduction_reference_stream_b3 = neqsim.process.equipment.valve.ThrottlingValve(
        "pressurereduction_reference_stream_b3", feedstream_main_reference_stream_b_splitter.getSplitStream(4))
    pressurereduction_reference_stream_b3.setOutletPressure(
        inp.second_stage_pressure, 'bara')
    pressurereduction_reference_stream_b3.run()
    well_process.add(pressurereduction_reference_stream_b3)

    pressurereduction_cluster_a1 = neqsim.process.equipment.valve.ThrottlingValve(
        "pres red cluster_a1", feedstream_cluster_a_splitter.getSplitStream(2))
    pressurereduction_cluster_a1.setOutletPressure(
        inp.second_stage_pressure, 'bara')
    pressurereduction_cluster_a1.run()
    well_process.add(pressurereduction_cluster_a1)

    pressurereduction_cluster_a2 = neqsim.process.equipment.valve.ThrottlingValve(
        "pres red cluster_a2", feedstream_cluster_a_splitter.getSplitStream(3))
    pressurereduction_cluster_a2.setOutletPressure(
        inp.second_stage_pressure, 'bara')
    pressurereduction_cluster_a2.run()
    well_process.add(pressurereduction_cluster_a2)

    pressurereduction_cluster_a3 = neqsim.process.equipment.valve.ThrottlingValve(
        "pres red cluster_a3", feedstream_cluster_a_splitter.getSplitStream(4))
    pressurereduction_cluster_a3.setOutletPressure(
        inp.second_stage_pressure, 'bara')
    pressurereduction_cluster_a3.run()
    well_process.add(pressurereduction_cluster_a3)

    LP_manifold_A = neqsim.process.equipment.mixer.Mixer('LP manifold A')
    LP_manifold_A.addStream(pressurereduction_reference_stream_b1.getOutStream())
    LP_manifold_A.addStream(pressurereduction_cluster_a1.getOutStream())
    LP_manifold_A.run()
    well_process.add(LP_manifold_A)

    LP_manifold_B = neqsim.process.equipment.mixer.Mixer('LP manifold B')
    LP_manifold_B.addStream(pressurereduction_reference_stream_b2.getOutStream())
    LP_manifold_B.addStream(pressurereduction_cluster_a2.getOutStream())
    LP_manifold_B.run()
    well_process.add(LP_manifold_B)

    test_manifold = neqsim.process.equipment.mixer.Mixer('test manifold')
    test_manifold.addStream(pressurereduction_reference_stream_b3.getOutStream())
    test_manifold.addStream(pressurereduction_cluster_a3.getOutStream())
    test_manifold.run()
    well_process.add(test_manifold)

    # Adding calibration_stream to reference_stream_c calibration_stream separator
    feedstream_calibration_stream = create_stream('calibration_stream hc feed')
    feedstream_calibration_stream.setTemperature(inp.calibration_stream_temperature, 'C')
    feedstream_calibration_stream.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    feedstream_calibration_stream.getFluid().setMolarComposition(inp.hc_composition_calibration_stream)
    feedstream_calibration_stream.setFlowRate(
        inp.hc_flow_rate_calibration_stream*calibration_stream_scale_factor, 'kg/day')
    feedstream_calibration_stream.run()
    well_process.add(feedstream_calibration_stream)

    waterfeed_calibration_stream = create_water_stream('calibration_stream water feed')
    waterfeed_calibration_stream.setTemperature(inp.calibration_stream_temperature, 'C')
    waterfeed_calibration_stream.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    waterfeed_calibration_stream.setFlowRate(inp.calibration_stream_water*1e3, 'kg/day')
    waterfeed_calibration_stream.run()
    well_process.add(waterfeed_calibration_stream)

    calibration_stream_well_mixer = neqsim.process.equipment.mixer.Mixer(
        'calibration_stream hc water mixer')
    calibration_stream_well_mixer.addStream(feedstream_calibration_stream)
    calibration_stream_well_mixer.addStream(waterfeed_calibration_stream)
    calibration_stream_well_mixer.run()
    well_process.add(calibration_stream_well_mixer)

    feedstream_calibration_stream_splitter = neqsim.process.equipment.splitter.Splitter(
        'calibration_stream splitter')
    feedstream_calibration_stream_splitter.setInletStream(calibration_stream_well_mixer.getOutStream())
    feedstream_calibration_stream_splitter.setSplitFactors([1.0])
    feedstream_calibration_stream_splitter.run()
    well_process.add(feedstream_calibration_stream_splitter)

    # Adding calibration_stream to second stage separator
    feedstream_cluster_d = create_stream('cluster_d hc flow')
    feedstream_cluster_d.setTemperature(inp.cluster_d_temperature, 'C')
    feedstream_cluster_d.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    feedstream_cluster_d.getFluid().setMolarComposition(inp.hc_composition_cluster_d)
    feedstream_cluster_d.setFlowRate(inp.hc_flow_rate_cluster_d, 'kg/day')
    feedstream_cluster_d.run()
    well_process.add(feedstream_cluster_d)

    waterfeed_cluster_d = create_water_stream('cluster_d water feed')
    waterfeed_cluster_d.setTemperature(inp.cluster_d_temperature, 'C')
    waterfeed_cluster_d.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    waterfeed_cluster_d.setFlowRate(inp.cluster_d_water*1e3, 'kg/day')
    waterfeed_cluster_d.run()
    well_process.add(waterfeed_cluster_d)

    cluster_d_well_mixer = neqsim.process.equipment.mixer.Mixer(
        'cluster_d hc water mixer')
    cluster_d_well_mixer.addStream(feedstream_cluster_d)
    cluster_d_well_mixer.addStream(waterfeed_cluster_d)
    cluster_d_well_mixer.run()
    well_process.add(cluster_d_well_mixer)

    feedstream_cluster_d_splitter = neqsim.process.equipment.splitter.Splitter(
        'cluster_d splitter')
    feedstream_cluster_d_splitter.setInletStream(cluster_d_well_mixer.getOutStream())
    feedstream_cluster_d_splitter.setSplitFactors([1.0])
    feedstream_cluster_d_splitter.run()
    well_process.add(feedstream_cluster_d_splitter)

    # Adding calibration_stream to second stage separator
    feedstream_cluster_c = create_stream('cluster_c hc flow')
    feedstream_cluster_c.setTemperature(inp.cluster_c_temperature, 'C')
    feedstream_cluster_c.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    feedstream_cluster_c.getFluid().setMolarComposition(inp.hc_composition_cluster_c)
    feedstream_cluster_c.setFlowRate(inp.hc_flow_rate_cluster_c, 'kg/day')
    feedstream_cluster_c.run()
    well_process.add(feedstream_cluster_c)

    waterfeed_cluster_c = create_water_stream('cluster_c water feed')
    waterfeed_cluster_c.setTemperature(inp.cluster_c_temperature, 'C')
    waterfeed_cluster_c.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    waterfeed_cluster_c.setFlowRate(inp.cluster_c_water*1e3, 'kg/day')
    waterfeed_cluster_c.run()
    well_process.add(waterfeed_cluster_c)

    cluster_c_well_mixer = neqsim.process.equipment.mixer.Mixer(
        'cluster_c hc water mixer')
    cluster_c_well_mixer.addStream(feedstream_cluster_c)
    cluster_c_well_mixer.addStream(waterfeed_cluster_c)
    cluster_c_well_mixer.run()
    well_process.add(cluster_c_well_mixer)

    feedstream_cluster_c_splitter = neqsim.process.equipment.splitter.Splitter(
        'cluster_c splitter')
    feedstream_cluster_c_splitter.setInletStream(cluster_c_well_mixer.getOutStream())
    feedstream_cluster_c_splitter.setSplitFactors([1.0])
    feedstream_cluster_c_splitter.run()
    well_process.add(feedstream_cluster_c_splitter)

    # Adding reference_stream_c reference_stream_a to second stage separator
    feedstream_reference_stream_creference_stream_a = create_stream('reference_stream_creference_stream_a hc flow')
    feedstream_reference_stream_creference_stream_a.setTemperature(
        inp.reference_stream_c_reference_stream_a_temperature, 'C')
    feedstream_reference_stream_creference_stream_a.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    feedstream_reference_stream_creference_stream_a.getFluid().setMolarComposition(
        inp.hc_composition_reference_stream_creference_stream_a)
    feedstream_reference_stream_creference_stream_a.setFlowRate(
        inp.hc_flow_rate_reference_stream_creference_stream_a, 'kg/day')
    feedstream_reference_stream_creference_stream_a.run()
    well_process.add(feedstream_reference_stream_creference_stream_a)

    waterfeed_reference_stream_creference_stream_a = create_water_stream('reference_stream_creference_stream_a water feed')
    waterfeed_reference_stream_creference_stream_a.setTemperature(inp.reference_stream_c_reference_stream_a_temperature, 'C')
    waterfeed_reference_stream_creference_stream_a.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    waterfeed_reference_stream_creference_stream_a.setFlowRate(inp.reference_stream_c_reference_stream_a_water*1e3+1, 'kg/day')
    waterfeed_reference_stream_creference_stream_a.run()
    well_process.add(waterfeed_reference_stream_creference_stream_a)

    reference_stream_creference_stream_a_well_mixer = neqsim.process.equipment.mixer.Mixer(
        'reference_stream_c reference_stream_a hc water mixer')
    reference_stream_creference_stream_a_well_mixer.addStream(feedstream_reference_stream_creference_stream_a)
    reference_stream_creference_stream_a_well_mixer.addStream(waterfeed_reference_stream_creference_stream_a)
    reference_stream_creference_stream_a_well_mixer.run()
    well_process.add(reference_stream_creference_stream_a_well_mixer)

    feedstream_reference_stream_creference_stream_a_splitter = neqsim.process.equipment.splitter.Splitter(
        'reference_stream_c reference_stream_a splitter')
    feedstream_reference_stream_creference_stream_a_splitter.setInletStream(
        reference_stream_creference_stream_a_well_mixer.getOutStream())
    feedstream_reference_stream_creference_stream_a_splitter.setSplitFactors([1.0])
    feedstream_reference_stream_creference_stream_a_splitter.run()
    well_process.add(feedstream_reference_stream_creference_stream_a_splitter)

    # Adding reference_stream_c reference_stream_a to second stage separator
    feedstream_reference_stream_creference_stream_b = create_stream('reference_stream_c reference_stream_b hc flow')
    feedstream_reference_stream_creference_stream_b.setTemperature(inp.reference_stream_c_reference_stream_b_temperature, 'C')
    feedstream_reference_stream_creference_stream_b.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    feedstream_reference_stream_creference_stream_b.getFluid().setMolarComposition(inp.hc_composition_reference_stream_creference_stream_b)
    feedstream_reference_stream_creference_stream_b.setFlowRate(inp.hc_flow_rate_reference_stream_creference_stream_b, 'kg/day')
    feedstream_reference_stream_creference_stream_b.run()
    well_process.add(feedstream_reference_stream_creference_stream_b)

    waterfeed_reference_stream_creference_stream_b = create_water_stream('reference_stream_c reference_stream_b water feed')
    waterfeed_reference_stream_creference_stream_b.setTemperature(inp.reference_stream_c_reference_stream_b_temperature, 'C')
    waterfeed_reference_stream_creference_stream_b.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    waterfeed_reference_stream_creference_stream_b.setFlowRate(inp.reference_stream_c_reference_stream_b_water*1e3, 'kg/day')
    waterfeed_reference_stream_creference_stream_b.run()
    well_process.add(waterfeed_reference_stream_creference_stream_b)

    reference_stream_creference_stream_b_well_mixer = neqsim.process.equipment.mixer.Mixer(
        'reference_stream_c reference_stream_b hc water mixer')
    reference_stream_creference_stream_b_well_mixer.addStream(feedstream_reference_stream_creference_stream_b)
    reference_stream_creference_stream_b_well_mixer.addStream(waterfeed_reference_stream_creference_stream_b)
    reference_stream_creference_stream_b_well_mixer.run()
    well_process.add(reference_stream_creference_stream_b_well_mixer)

    feedstream_reference_stream_creference_stream_b_splitter = neqsim.process.equipment.splitter.Splitter(
        'reference_stream_c reference_stream_b splitter')
    feedstream_reference_stream_creference_stream_b_splitter.setInletStream(
        reference_stream_creference_stream_b_well_mixer.getOutStream())
    feedstream_reference_stream_creference_stream_b_splitter.setSplitFactors([1.0])
    feedstream_reference_stream_creference_stream_b_splitter.run()
    well_process.add(feedstream_reference_stream_creference_stream_b_splitter)

    manifold_reference_stream_ccalibration_stream = neqsim.process.equipment.mixer.Mixer(
        'reference_stream_c calibration_stream manifold')
    manifold_reference_stream_ccalibration_stream.addStream(feedstream_calibration_stream_splitter.getSplitStream(0))
    manifold_reference_stream_ccalibration_stream.addStream(
        feedstream_reference_stream_creference_stream_b_splitter.getSplitStream(0))
    if inp.simulation_case == 'high' or inp.Year <= 100:  # added to include in benchmark cases
        manifold_reference_stream_ccalibration_stream.addStream(
            feedstream_cluster_d_splitter.getSplitStream(0))
        manifold_reference_stream_ccalibration_stream.addStream(
            feedstream_cluster_c_splitter.getSplitStream(0))
        manifold_reference_stream_ccalibration_stream.addStream(
            feedstream_reference_stream_creference_stream_a_splitter.getSplitStream(0))
    manifold_reference_stream_ccalibration_stream.run()
    well_process.add(manifold_reference_stream_ccalibration_stream)

    offshore_asset_south_feed = create_stream('Offshore Area South Feed')
    offshore_asset_south_feed.setTemperature(inp.offshore_asset_south_temperature, 'C')
    offshore_asset_south_feed.setPressure(inp.second_stage_pressure, 'bara')
    offshore_asset_south_feed.getFluid().setMolarComposition(inp.hc_composition_offshore_south)
    offshore_asset_south_feed.setFlowRate(inp.hc_flow_rate_offshore_south, 'kg/day')
    offshore_asset_south_feed.run()
    well_process.add(offshore_asset_south_feed)

    offshore_asset_east_feed = create_stream('Offshore Area East Feed')
    offshore_asset_east_feed.setTemperature(inp.offshore_asset_east_temperature, 'C')
    offshore_asset_east_feed.setPressure(inp.second_stage_pressure, 'bara')
    offshore_asset_east_feed.getFluid().setMolarComposition(inp.hc_composition_offshore_east)
    offshore_asset_east_feed.setFlowRate(inp.hc_flow_rate_offshore_east*offshore_east_scale_factor, 'kg/day')
    offshore_asset_east_feed.run()
    well_process.add(offshore_asset_east_feed)

    satelitemixer = neqsim.process.equipment.mixer.Mixer('satellite mixer')
    satelitemixer.addStream(offshore_asset_south_feed)
    satelitemixer.addStream(offshore_asset_east_feed)
    satelitemixer.run()
    well_process.add(satelitemixer)

    lp_feed_pressure_temperature_setter = neqsim.process.equipment.heatexchanger.Heater(
    "satellite heater", satelitemixer.getOutStream())
    lp_feed_pressure_temperature_setter.setOutTemperature(
        inp.satellite_heater_temperature, 'C')
    lp_feed_pressure_temperature_setter.setOutPressure(
        inp.second_stage_pressure, 'bara')
    lp_feed_pressure_temperature_setter.run()
    well_process.add(lp_feed_pressure_temperature_setter)

    manifold_south_east = neqsim.process.equipment.manifold.Manifold(
        'south east manifold')
    manifold_south_east.addStream(lp_feed_pressure_temperature_setter.getOutStream())
    manifold_south_east.setSplitFactors([0.5, 0.5])
    manifold_south_east.run()
    well_process.add(manifold_south_east)

    offshore_asset_condensate_feed = create_stream('Offshore Area C Feed')
    offshore_asset_condensate_feed.setTemperature(inp.condensate_area_temperature, 'C')
    offshore_asset_condensate_feed.setPressure(inp.second_stage_pressure, 'bara')
    offshore_asset_condensate_feed.getFluid().setMolarComposition(inp.hc_composition_condensate_area)
    offshore_asset_condensate_feed.setFlowRate(inp.hc_flow_rate_condensate_area*condensate_area_scale_factor, 'kg/day')
    offshore_asset_condensate_feed.run()
    well_process.add(offshore_asset_condensate_feed)

    third_party_feedFeed =  create_stream('ThirdPartyFeed Feed')
    third_party_feedFeed.setTemperature(inp.third_party_feed_temperature, 'C')
    third_party_feedFeed.setPressure(inp.second_stage_pressure, 'bara')
    third_party_feedFeed.getFluid().setMolarComposition(inp.hc_composition_third_party_feed)
    third_party_feedFeed.setFlowRate(inp.hc_flow_rate_third_party_feed, 'kg/day')
    third_party_feedFeed.run()
    well_process.add(third_party_feedFeed)

    return well_process

Code cell 11: Offshore Area Well Feed Model Function

Notebook cell 21. This code belongs to the Offshore Area Well Feed Model Function section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

%%script false --no-raise-error uncomment if model should be saved to file

offshore_asset_well_feed_model = create_offshore_asset_well_feed_model(input_parameters)
offshore_asset_well_feed_model.run()

clear_output(wait=True)
print("Calculation finished")

multiplier = 0.0
if input_parameters.simulation_case == 'high' or input_parameters.Year <= 100:  # added to include in benchmark cases
    multiplier = 1.0

# Corrected feedflow calculation
feedflow = (
    offshore_asset_well_feed_model.getUnit('gas lift feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('main reference_stream_b mixer').getOutletStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('cluster_b mixer').getOutletStream().getFlowRate('kg/hr')+
    offshore_asset_well_feed_model.getUnit('cluster_a hc water mixer').getOutletStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('calibration_stream hc water mixer').getOutletStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('cluster_d hc water mixer').getOutletStream().getFlowRate('kg/hr')*multiplier +
    offshore_asset_well_feed_model.getUnit('cluster_c hc water mixer').getOutletStream().getFlowRate('kg/hr')*multiplier +
    offshore_asset_well_feed_model.getUnit('reference_stream_c reference_stream_a hc water mixer').getOutletStream().getFlowRate('kg/hr')*multiplier +
    offshore_asset_well_feed_model.getUnit('reference_stream_c reference_stream_b hc water mixer').getOutletStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('Offshore Area South Feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('Offshore Area East Feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('Offshore Area C Feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('ThirdPartyFeed Feed').getFlowRate('kg/hr')
)



# Corrected feedflow calculation
exitflow = (
    offshore_asset_well_feed_model.getUnit('south east manifold').getSplitStream(0).getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('south east manifold').getSplitStream(1).getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('Offshore Area C Feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('ThirdPartyFeed Feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('reference_stream_c calibration_stream manifold').getOutletStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('LP manifold A').getOutletStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('LP manifold B').getOutletStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('test manifold').getOutletStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('HP manifold A').getOutletStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('HP manifold B').getOutletStream().getFlowRate('kg/hr')
)

print(f"Exit flow: {exitflow:.2f} kg/hr")


print('mass balance check: ', (feedflow - exitflow) / feedflow * 100, '%')

Code cell 12: Offshore Area Well Feed Model Function

Notebook cell 22. This code belongs to the Offshore Area Well Feed Model Function section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

%%script false --no-raise-error uncomment if model should be saved to file
print('total first stage HP separator A ', offshore_asset_well_feed_model.getUnit(
    "HP manifold A").getOutletStream().getFluid().getFlowRate("MSm3/day"), 'MSm3/day')
print('total first stage HP separator B ', offshore_asset_well_feed_model.getUnit(
    "HP manifold B").getOutletStream().getFluid().getFlowRate("MSm3/day"), 'MSm3/day')

print('total first stage LP separator A ', offshore_asset_well_feed_model.getUnit(
    "LP manifold A").getOutStream().getFluid().getFlowRate("MSm3/day"), 'MSm3/day')
print('total first stage LP separator B ', offshore_asset_well_feed_model.getUnit(
    "LP manifold B").getOutStream().getFluid().getFlowRate("MSm3/day"), 'MSm3/day')

print('total first stage reference_stream_c-calibration_stream sep ', offshore_asset_well_feed_model.getUnit(
    "reference_stream_c calibration_stream manifold").getOutStream().getFluid().getFlowRate("MSm3/day"), 'MSm3/day')
print('test manifold ', offshore_asset_well_feed_model.getUnit(
    "test manifold").getOutStream().getFluid().getFlowRate("MSm3/day"), 'MSm3/day')

print('offshore_asset east ', offshore_asset_well_feed_model.getUnit(
    "Offshore Area East Feed").getFluid().getFlowRate("idSm3/hr")*24, 'm3/day')
print('offshore_asset south ', offshore_asset_well_feed_model.getUnit(
    "Offshore Area South Feed").getFluid().getFlowRate("idSm3/hr")*24, 'm3/day')

Code cell 13: ReferenceStreamC CalibrationStream Separation Process

Notebook cell 26. This code belongs to the ReferenceStreamC CalibrationStream Separation Process section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

def reference_stream_c_calibration_stream_separation_process(inp: ProcessInput, feed_stream):
    separation_process = neqsim.process.processmodel.ProcessSystem()

    liquidresyclestream =  create_stream('refluxstream_gas_secondstage_1')
    liquidresyclestream.setFlowRate(10.0, 'kg/hr')
    liquidresyclestream.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    liquidresyclestream.run()
    separation_process.add(liquidresyclestream)

    recyclegasstream = create_stream('recycle 1st stage CALIB_STAGE')
    recyclegasstream.setPressure(inp.reference_stream_c_calibration_stream_separator_pressure, 'bara')
    recyclegasstream.setTemperature(25.0, 'C')
    recyclegasstream.setFlowRate(10.0, "kg/hr")
    recyclegasstream.run()
    separation_process.add(recyclegasstream)

    recycle_gas_cooler = neqsim.process.equipment.heatexchanger.Cooler(
        'recycle gas cooler', recyclegasstream)
    recycle_gas_cooler.setOutTemperature(35.0, 'C')
    recycle_gas_cooler.run()
    separation_process.add(recycle_gas_cooler)

    inletmanifold = neqsim.process.equipment.mixer.Mixer('inlet manifold')
    inletmanifold.addStream(feed_stream)
    inletmanifold.addStream(liquidresyclestream)
    inletmanifold.addStream(recycle_gas_cooler.getOutletStream())
    inletmanifold.run()
    separation_process.add(inletmanifold)

    reference_stream_cSeparator = neqsim.process.equipment.separator.Separator(
        "reference_stream_c separator", inletmanifold.getOutStream())
    reference_stream_cSeparator.run()
    separation_process.add(reference_stream_cSeparator)

    intermediate_pressure_compressor = math.sqrt(inp.reference_stream_c_calibration_stream_separator_pressure*inp.reference_stream_c_CALIB_STAGE_compressor_pressure)

    calib_stage_compressor_1st_stage = neqsim.process.equipment.compressor.Compressor(
        'CALIB_STAGE compressor 1st stage', reference_stream_cSeparator.getGasOutStream())
    calib_stage_compressor_1st_stage.setUsePolytropicCalc(True)
    calib_stage_compressor_1st_stage.setPolytropicEfficiency(0.8)
    calib_stage_compressor_1st_stage.setCompressorChartType("interpolate and extrapolate")
    calib_stage_compressor_1st_stage.setOutletPressure(intermediate_pressure_compressor, 'bara')
    calib_stage_compressor_1st_stage.getCompressorChart().setHeadUnit(inp.headunit)
    calib_stage_compressor_1st_stage.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_CALIB_STAGE__compressor_1st_stage, inp.surgehead_CALIB_STAGE_compressor_1st_stage)

    try:
        calib_stage_compressor_1st_stage.run()
    except:
        print('error in calib_stage_compressor 1st stage')
    separation_process.add(calib_stage_compressor_1st_stage)

    gassplitter = neqsim.process.equipment.splitter.Splitter(
    '1st stage anti surge splitter CALIB_STAGE')
    gassplitter.setInletStream(calib_stage_compressor_1st_stage.getOutletStream())
    gassplitter.setFlowRates([-1, 1.0], "kg/hr")
    try:
        gassplitter.run()
    except:
        print('error in gassplitter')
    separation_process.add(gassplitter)

    antisurgeCalculator = neqsim.process.equipment.util.Calculator("anti surge calculator_1")
    antisurgeCalculator.addInputVariable(calib_stage_compressor_1st_stage)
    antisurgeCalculator.setOutputVariable(gassplitter)
    try:
        antisurgeCalculator.run()
    except:
        print('error in antisurgeCalculator')
    separation_process.add(antisurgeCalculator)

    antisurgevalve = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve', gassplitter.getSplitStream(1))
    antisurgevalve.setOutletPressure(inp.reference_stream_c_calibration_stream_separator_pressure, "bara")
    antisurgevalve.run()
    separation_process.add(antisurgevalve)

    recycl = neqsim.process.equipment.util.Recycle("recycle anti surge 1st stage compressor")
    recycl.addStream(antisurgevalve.getOutletStream())
    recycl.setOutletStream(recyclegasstream)
    recycl.setTolerance(1e-2)
    recycl.run()
    separation_process.add(recycl)

    gasmanifold = neqsim.process.equipment.manifold.Manifold('gas manifold')
    gasmanifold.addStream(gassplitter.getSplitStream(0))
    reference_stream_c_gas_fraction_to_CALIB_STAGE = inp.reference_stream_c_gas_fraction_to_CALIB_STAGE
    reference_stream_c_gas_fraction_to_LPseparator = (
        1.0 - reference_stream_c_gas_fraction_to_CALIB_STAGE)/2.0  # split in A/B train
    gasmanifold.setSplitFactors(
        [reference_stream_c_gas_fraction_to_CALIB_STAGE, reference_stream_c_gas_fraction_to_LPseparator, reference_stream_c_gas_fraction_to_LPseparator])
    gasmanifold.run()
    separation_process.add(gasmanifold)

    recyclegasstream2 = create_stream('recycle CALIB_STAGE 2nd stage')
    recyclegasstream2.setPressure(intermediate_pressure_compressor, 'bara')
    recyclegasstream2.setTemperature(25.0, 'C')
    recyclegasstream2.setFlowRate(1.0, "kg/hr")
    recyclegasstream2.run()
    separation_process.add(recyclegasstream2)

    gas_mixer_CALIB_STAGE_2 = neqsim.process.equipment.mixer.Mixer(
        "gas mixer CALIB_STAGE_2")
    gas_mixer_CALIB_STAGE_2.addStream(gasmanifold.getSplitStream(0))
    gas_mixer_CALIB_STAGE_2.addStream(recyclegasstream2)
    try:
        gas_mixer_CALIB_STAGE_2.run()
    except:
        print('error in gas_mixer_CALIB_STAGE_2')
    separation_process.add(gas_mixer_CALIB_STAGE_2)

    gascoolerreference_stream_c = neqsim.process.equipment.heatexchanger.Cooler(
        'reference_stream_c gas cooler', gas_mixer_CALIB_STAGE_2.getOutletStream())
    gascoolerreference_stream_c.setOutTemperature(inp.reference_stream_c_CALIB_STAGE_compressor_cooler_temperature, 'C') # for high case needed to increas it from 25 to 35 from 2033
    try:
        gascoolerreference_stream_c.run()
    except:
        print('error in gascoolerreference_stream_c')
    separation_process.add(gascoolerreference_stream_c)

    reference_stream_cScrubber = neqsim.process.equipment.separator.Separator(
        "reference_stream_c gas scrubber", gascoolerreference_stream_c.getOutletStream())
    try:
        reference_stream_cScrubber.run()
    except:
        print('error in reference_stream_cScrubber')
    separation_process.add(reference_stream_cScrubber)

    liquidresycle  =  neqsim.process.equipment.util.Recycle('reference_stream_c liquid resycle')
    liquidresycle.addStream(reference_stream_cScrubber.getLiquidOutStream())
    liquidresycle.setOutletStream(liquidresyclestream)
    liquidresycle.setTolerance(1e-1)
    try:
        liquidresycle.run()
    except:
        print('error in liquidresycle')
    separation_process.add(liquidresycle)

    oilmanifold = neqsim.process.equipment.manifold.Manifold('manifold')
    oilmanifold.addStream(reference_stream_cSeparator.getLiquidOutStream())
    oilmanifold.setSplitFactors([0.5, 0.5])
    try:
        oilmanifold.run()
    except:
        print('error in oilmanifold')
    separation_process.add(oilmanifold)

    calib_stage_compressor_2nd_stage = neqsim.process.equipment.compressor.Compressor(
        'CALIB_STAGE compressor 2nd stage', reference_stream_cScrubber.getGasOutStream())
    calib_stage_compressor_2nd_stage.setOutletPressure(inp.reference_stream_c_CALIB_STAGE_compressor_pressure, 'bara')
    calib_stage_compressor_2nd_stage.setUsePolytropicCalc(True)
    calib_stage_compressor_2nd_stage.setCompressorChartType("interpolate and extrapolate")
    calib_stage_compressor_2nd_stage.setPolytropicEfficiency(0.8)
    calib_stage_compressor_2nd_stage.getCompressorChart().setHeadUnit(inp.headunit)
    calib_stage_compressor_2nd_stage.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_CALIB_STAGE__compressor_2nd_stage, inp.surgehead_CALIB_STAGE_compressor_2nd_stage)

    try:
        calib_stage_compressor_2nd_stage.run()
    except:
        print('error in CALIB_STAGE compressor')
    separation_process.add(calib_stage_compressor_2nd_stage)

    gassplitter2 = neqsim.process.equipment.splitter.Splitter(
    '2nd stage anti surge splitter')
    gassplitter2.setInletStream(calib_stage_compressor_2nd_stage.getOutletStream())
    gassplitter2.setFlowRates([-1, 1.0], "kg/hr")
    try:
        gassplitter2.run()
    except:
        print('error in gassplitter2')

    separation_process.add(gassplitter2)

    antisurgeCalculator2 = neqsim.process.equipment.util.Calculator("anti surge calculator_2")
    antisurgeCalculator2.addInputVariable(calib_stage_compressor_2nd_stage)
    antisurgeCalculator2.setOutputVariable(gassplitter2)
    antisurgeCalculator2.run()
    separation_process.add(antisurgeCalculator2)

    antisurgevalve2 = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve 2', gassplitter2.getSplitStream(1))
    antisurgevalve2.setOutletPressure(intermediate_pressure_compressor, "bara")
    antisurgevalve2.run()
    separation_process.add(antisurgevalve2)

    recycl2 = neqsim.process.equipment.util.Recycle("recycle anti surge 2nd stage compressor")
    recycl2.addStream(antisurgevalve2.getOutletStream())
    recycl2.setOutletStream(recyclegasstream2)
    recycl2.setTolerance(1e-2)
    recycl2.run()
    separation_process.add(recycl2)

    calib_stage_injection_stream = neqsim.process.equipment.stream.Stream(
        'CALIB_STAGE gas_injection stream', gassplitter2.getSplitStream(0))
    calib_stage_injection_stream.run()
    separation_process.add(calib_stage_injection_stream)

    return separation_process


def test_separation_process(inp: ProcessInput, feed_stream):
    separation_process = neqsim.process.processmodel.ProcessSystem()

    testSeparator = neqsim.process.equipment.separator.Separator(
        "test separator", feed_stream)
    testSeparator.run()
    separation_process.add(testSeparator)

    return separation_process

Code cell 14: ReferenceStreamC CalibrationStream Separation Process

Notebook cell 28. This code belongs to the ReferenceStreamC CalibrationStream Separation Process section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

%%script false --no-raise-error uncomment if model should be saved to file

reference_stream_c_sep_process = reference_stream_c_calibration_stream_separation_process(
    input_parameters, offshore_asset_well_feed_model.getUnit("reference_stream_c calibration_stream manifold").getOutStream())
reference_stream_c_sep_process.run()
#reference_stream_c_sep_process.run()
# Corrected feedflow calculation
feedflow = (
    offshore_asset_well_feed_model.getUnit("reference_stream_c calibration_stream manifold").getOutStream().getFlowRate('kg/hr')
)
print(f"Total feed flow: {feedflow:.2f} kg/hr")

# Corrected feedflow calculation
exitflow = (
   reference_stream_c_sep_process.getUnit("CALIB_STAGE gas_injection stream").getFlowRate('kg/hr') +
    reference_stream_c_sep_process.getUnit("manifold").getSplitStream(0).getFlowRate('kg/hr') +
    reference_stream_c_sep_process.getUnit("manifold").getSplitStream(1).getFlowRate('kg/hr') +
    reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(1).getFlowRate('kg/hr') +
    reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(2).getFlowRate('kg/hr')
)

print(f"Exit flow: {exitflow:.2f} kg/hr")


print('mass balance check: ', (feedflow - exitflow) / feedflow * 100, '%')

Code cell 15: Oil Separation Process Function

Notebook cell 31. This code belongs to the Oil Separation Process Function section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

def create_oil_separation_process(inp: ProcessInput, first_stage_feed, second_stage_feed, lp_gas_split_factor, reference_stream_ccalibration_streamoil=None, south_east_feed=None, test_separator=None, reference_stream_c_calibration_stream_gas=None, other_train_lp_gas_feed=None, other_train_lp2_gas_feed=None, other_train_mp_gas_feed=None, mpsplit = None):

    separation_process = neqsim.process.processmodel.ProcessSystem()

    inlet_TP_setter = neqsim.process.equipment.heatexchanger.Heater(
        "inlet TP setter", first_stage_feed)
    inlet_TP_setter.setdT(0.0)
    inlet_TP_setter.setOutPressure(inp.first_stage_pressure, 'bara')
    inlet_TP_setter.run()
    separation_process.add(inlet_TP_setter)

    firstStageSeparator = neqsim.process.equipment.separator.ThreePhaseSeparator(
        "1st stage separator", inlet_TP_setter.getOutStream())
    firstStageSeparator.setEntrainment(
       0.5, "feed", "volume", "aqueous", "oil")
    try:
        firstStageSeparator.run()
    except:
        print('error in first stage separator')
    separation_process.add(firstStageSeparator)

    oil_1st_stage_mixer = neqsim.process.equipment.mixer.Mixer('oilmix')
    oil_1st_stage_mixer.addStream(firstStageSeparator.getOilOutStream())
    oil_1st_stage_mixer.run()
    separation_process.add(oil_1st_stage_mixer)

    oilvalve1 = neqsim.process.equipment.valve.ThrottlingValve(
        "oil depres valve", oil_1st_stage_mixer.getOutStream())
    oilvalve1.setOutletPressure(inp.second_stage_pressure, 'bara')
    try:
        oilvalve1.run()
    except:
        print('error in oil valve 1')
    separation_process.add(oilvalve1)

    oilfromfirststage = oilvalve1.getOutStream()

    oilHeaterFromFirstStage = neqsim.process.equipment.heatexchanger.Heater(
        "oil heater second stage", oilvalve1.getOutStream())
    if inp.Year >= inp.heater_start_year:
        oilHeaterFromFirstStage.setOutTemperature(
            inp.first_stage_heater_temperature, 'C')
    else:
        oilHeaterFromFirstStage.setdT(0.0)
    oilHeaterFromFirstStage.run()
    separation_process.add(oilHeaterFromFirstStage)

    oilFirstStage = create_stream("frist stage oil reflux")
    oilFirstStage.setFlowRate(100.0, 'kg/hr')
    oilFirstStage.setPressure(inp.second_stage_pressure, 'bara')
    oilFirstStage.setTemperature(30.0, 'C')
    oilFirstStage.run()
    separation_process.add(oilFirstStage)

    oilFirstStageMixer = neqsim.process.equipment.mixer.Mixer(
        "first stage oil mixer")
    oilFirstStageMixer.addStream(oilHeaterFromFirstStage.getOutletStream())
    oilFirstStageMixer.addStream(oilFirstStage)
    oilFirstStageMixer.addStream(second_stage_feed)
    oilFirstStageMixer.addStream(
        south_east_feed)
    if reference_stream_ccalibration_streamoil:
        oilFirstStageMixer.addStream(reference_stream_ccalibration_streamoil)
    if reference_stream_c_calibration_stream_gas:
        oilFirstStageMixer.addStream(reference_stream_c_calibration_stream_gas)
    if test_separator:
        oilFirstStageMixer.addStream(test_separator.getLiquidOutStream())
    try:
        oilFirstStageMixer.run()
    except:
        print('error in first stage oil mixer')
    separation_process.add(oilFirstStageMixer)

    secondStageSeparator = neqsim.process.equipment.separator.ThreePhaseSeparator(
        "2nd stage separator", oilFirstStageMixer.getOutStream())
    secondStageSeparator.setEntrainment(
        0.2, "feed", "volume", "aqueous", "oil")
    try:
        secondStageSeparator.run()
    except:
        print('error in 2nd stage separator')
    separation_process.add(secondStageSeparator)

    oil_2nd_stage_mixer = neqsim.process.equipment.mixer.Mixer('oilmix 2')
    oil_2nd_stage_mixer.addStream(secondStageSeparator.getOilOutStream())
    oil_2nd_stage_mixer.run()
    separation_process.add(oil_2nd_stage_mixer)

    oilSeccondStage = create_stream("seccond stage oil reflux")
    oilSeccondStage.setFlowRate(100.0, 'kg/hr')
    oilSeccondStage.setPressure(inp.third_stage_pressure, 'bara')
    oilSeccondStage.setTemperature(40.0, 'C')
    oilSeccondStage.run()
    separation_process.add(oilSeccondStage)

    valve_oil_from_seccond_stage = neqsim.process.equipment.valve.ThrottlingValve(
        "valve oil from seccond stage", oil_2nd_stage_mixer.getOutStream())
    valve_oil_from_seccond_stage.setOutletPressure(
        inp.third_stage_pressure, 'bara')
    try:
        valve_oil_from_seccond_stage.run()
    except:
        print('error in valve oil from seccond stage')

    separation_process.add(valve_oil_from_seccond_stage)

    oilSeccondStageMixer = neqsim.process.equipment.mixer.Mixer(
        "seccond stage oil mixer")
    oilSeccondStageMixer.addStream(
        valve_oil_from_seccond_stage.getOutletStream())
    oilSeccondStageMixer.addStream(oilSeccondStage)
    oilSeccondStageMixer.run()
    separation_process.add(oilSeccondStageMixer)

    thirdStageSeparator = neqsim.process.equipment.separator.Separator(
        "3rd stage separator", oilSeccondStageMixer.getOutStream())
    try:
        thirdStageSeparator.run()
    except:
        print('error in third stage separator')
    separation_process.add(thirdStageSeparator)

    valve_oil_from_third_stage = neqsim.process.equipment.valve.ThrottlingValve(
        "valve oil from third stage", thirdStageSeparator.getLiquidOutStream())
    valve_oil_from_third_stage.setOutletPressure(
        inp.fourth_stage_pressure, 'bara')
    valve_oil_from_third_stage.run()
    separation_process.add(valve_oil_from_third_stage)

    oilThirdStage = create_stream("third stage oil reflux")
    oilThirdStage.setFlowRate(100.0, 'kg/hr')
    oilThirdStage.setPressure(inp.fourth_stage_pressure, 'bara')
    oilThirdStage.setTemperature(50.0, 'C')
    oilThirdStage.run()
    separation_process.add(oilThirdStage)

    oilThirdStageMixer = neqsim.process.equipment.mixer.Mixer(
        "third stage oil mixer")
    oilThirdStageMixer.addStream(valve_oil_from_third_stage.getOutletStream())
    oilThirdStageMixer.addStream(oilThirdStage)
    oilThirdStageMixer.run()
    separation_process.add(oilThirdStageMixer)

    fourthStageSeparator = neqsim.process.equipment.separator.ThreePhaseSeparator(
        "4th stage separator", oilThirdStageMixer.getOutStream())
    # fourthStageSeparator.setEntrainment(0.001, "product", "volume", "aqueous", "oil")
    try:
        fourthStageSeparator.run()
    except:
        print('error in fourth stage separator')
    separation_process.add(fourthStageSeparator)

    fourth_stage_pressure_control_valve = neqsim.process.equipment.valve.ThrottlingValve(
        "20PV153B", fourthStageSeparator.getGasOutStream())
    fourth_stage_pressure_control_valve.setOutletPressure(
        inp.flare_gas_recovery_pressure, 'bara')
    fourth_stage_pressure_control_valve.run()
    separation_process.add(fourth_stage_pressure_control_valve)

    flareGas = create_flare_gas_stream("flare gas")
    flareGas.setFlowRate(500.0, 'Sm3/hr')
    flareGas.setPressure(inp.flare_gas_recovery_pressure, 'bara')
    flareGas.setTemperature(15.0, 'C')
    flareGas.run()
    separation_process.add(flareGas)

    mixerFlareGas = neqsim.process.equipment.mixer.Mixer("flare gas mixer")
    mixerFlareGas.addStream(fourth_stage_pressure_control_valve.getOutStream())
    mixerFlareGas.addStream(flareGas)
    mixerFlareGas.run()
    separation_process.add(mixerFlareGas)

    pipe_from_fourth_stage = neqsim.process.equipment.pipeline.PipeBeggsAndBrills(
        'pipe from fourth stage', mixerFlareGas.getOutStream())
    pipe_from_fourth_stage.setDiameter(0.5)
    pipe_from_fourth_stage.setPipeWallRoughness(50.0e-6)
    pipe_from_fourth_stage.setLength(100)
    pipe_from_fourth_stage.setElevation(0)
    pipe_from_fourth_stage.run()
    separation_process.add(pipe_from_fourth_stage)

    gas_splitter_lp_gas = neqsim.process.equipment.splitter.Splitter(
        "gas splitter LP gas", pipe_from_fourth_stage.getOutStream())
    gas_splitter_lp_gas.setSplitFactors([lp_gas_split_factor, 1.0-lp_gas_split_factor])
    gas_splitter_lp_gas.run()
    separation_process.add(gas_splitter_lp_gas)

    recyclegasstream = create_stream('recycle 1st stage')
    recyclegasstream.setPressure(inp.fourth_stage_pressure, 'bara')
    recyclegasstream.setTemperature(25.0, 'C')
    recyclegasstream.setFlowRate(1.0, "kg/hr")
    recyclegasstream.run()
    separation_process.add(recyclegasstream)

    gas_mixer_lp_gas = neqsim.process.equipment.mixer.Mixer(
        "gas mixer LP gas")
    gas_mixer_lp_gas.addStream(gas_splitter_lp_gas.getSplitStream(0))
    gas_mixer_lp_gas.addStream(recyclegasstream)
    if other_train_lp_gas_feed:
        gas_mixer_lp_gas.addStream(other_train_lp_gas_feed)
    gas_mixer_lp_gas.run()
    separation_process.add(gas_mixer_lp_gas)

    firstStageCooler = neqsim.process.equipment.heatexchanger.Cooler(
        "1st stage cooler", gas_mixer_lp_gas.getOutletStream())
    firstStageCooler.setOutTemperature(
        inp.first_stage_scrubber_temperature, 'C')
    firstStageCooler.run()
    separation_process.add(firstStageCooler)

    firstStageScrubber = neqsim.process.equipment.separator.Separator(
        "1st stage scrubber", firstStageCooler.getOutStream())
    try:
        firstStageScrubber.run()
    except:
        print('error in third stage separator')
    separation_process.add(firstStageScrubber)

    firststagescrubberpump = neqsim.process.equipment.pump.Pump(
        "1st stage scrubber pump", firstStageScrubber.getLiquidOutStream())
    firststagescrubberpump.setOutletPressure(inp.second_stage_pressure, 'bara')
    firststagescrubberpump.calculateAsCompressor(False)
    try:
        firststagescrubberpump.run()
    except:
        print('error in third stage firststagescrubberpump')
    separation_process.add(firststagescrubberpump)

    recycleliqpumpstream = create_stream('recycle pump stream')
    recycleliqpumpstream.setPressure(inp.third_stage_pressure, 'bara')
    recycleliqpumpstream.setTemperature(25.0, 'C')
    recycleliqpumpstream.setFlowRate(1.0, "kg/hr")
    recycleliqpumpstream.run()
    separation_process.add(recycleliqpumpstream)

    pumpresycle = neqsim.process.equipment.util.Recycle("recycle liquid 1st stage scrubber")
    pumpresycle.addStream(firststagescrubberpump.getOutletStream())
    pumpresycle.setOutletStream(recycleliqpumpstream)
    pumpresycle.setTolerance(1e-1)
    pumpresycle.run()
    separation_process.add(pumpresycle)

    firstStageCompressor = neqsim.process.equipment.compressor.Compressor(
        "1st stage compressor", firstStageScrubber.getGasOutStream())
    firstStageCompressor.setCompressorChartType("interpolate and extrapolate")
    firstStageCompressor.setUsePolytropicCalc(True)
    firstStageCompressor.setPolytropicEfficiency(0.7) #based on performance test 2024 (changed from 0.6 11.08.2025)
    firstStageCompressor.setOutletPressure(inp.third_stage_pressure, 'bara')
    firstStageCompressor.setSpeed(10250)
    firstStageCompressor.getCompressorChart().setHeadUnit(inp.headunit)
    firstStageCompressor.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_first_stage_compressor, inp.surgehead_first_stage_compressor)

    firstStageCompressor.run()
    separation_process.add(firstStageCompressor)

    gassplitter = neqsim.process.equipment.splitter.Splitter(
    '1st stage anti surge splitter')
    gassplitter.setInletStream(firstStageCompressor.getOutletStream())
    gassplitter.setFlowRates([-1, 1.0], "kg/hr")
    try:
        gassplitter.run()
    except:
        print('error in gassplitter')
    separation_process.add(gassplitter)

    antisurgeCalculator = neqsim.process.equipment.util.Calculator("anti surge calculator_1")
    antisurgeCalculator.addInputVariable(firstStageCompressor)
    antisurgeCalculator.setOutputVariable(gassplitter)
    if lp_gas_split_factor > 0.1:
        antisurgeCalculator.run()
        separation_process.add(antisurgeCalculator)

    antisurgevalve = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve', gassplitter.getSplitStream(1))
    antisurgevalve.setOutletPressure(inp.fourth_stage_pressure, "bara")
    antisurgevalve.run()
    separation_process.add(antisurgevalve)

    recycl = neqsim.process.equipment.util.Recycle("recycle anti surge 1st stage compressor")
    recycl.addStream(antisurgevalve.getOutletStream())
    recycl.setOutletStream(recyclegasstream)
    recycl.setTolerance(1)
    if lp_gas_split_factor > 0.1:
        recycl.run()
        separation_process.add(recycl)

    firstStageCompressorAfterValve = neqsim.process.equipment.valve.ThrottlingValve(
        "1st stage compressor after valve", gassplitter.getSplitStream(0))
    firstStageCompressorAfterValve.setCalibrationStreamPressure(0.5, 'bara')
    firstStageCompressorAfterValve.run()
    separation_process.add(firstStageCompressorAfterValve)

    gas_splitter_lp2_gas = neqsim.process.equipment.splitter.Splitter(
        "gas splitter LP2 gas", thirdStageSeparator.getGasOutStream())
    gas_splitter_lp2_gas.setSplitFactors([lp_gas_split_factor, 1.0-lp_gas_split_factor])
    gas_splitter_lp2_gas.run()
    separation_process.add(gas_splitter_lp2_gas)

    recyclegasstream2 = create_stream('recycle 2nd stage')
    recyclegasstream2.setPressure(inp.third_stage_pressure, 'bara')
    recyclegasstream2.setTemperature(25.0, 'C')
    recyclegasstream2.setFlowRate(1.0, "kg/hr")
    recyclegasstream2.run()
    separation_process.add(recyclegasstream2)

    firststagegasmixer = neqsim.process.equipment.mixer.Mixer(
        "first stage mixer")
    firststagegasmixer.addStream(firstStageCompressorAfterValve.getOutStream())
    firststagegasmixer.addStream(gas_splitter_lp2_gas.getSplitStream(0))
    firststagegasmixer.addStream(recyclegasstream2)
    if other_train_lp2_gas_feed:
        firststagegasmixer.addStream(other_train_lp2_gas_feed)  # ← CORRECT - adds to first stage gas mixer
    firststagegasmixer.run()
    separation_process.add(firststagegasmixer)

    firstStageCooler2 = neqsim.process.equipment.heatexchanger.Cooler(
        "1st stage cooler2", firststagegasmixer.getOutStream())
    firstStageCooler2.setOutTemperature(
        inp.second_stage_suction_cooler_temperature, 'C')
    firstStageCooler2.run()
    separation_process.add(firstStageCooler2)

    firstStageScrubber2 = neqsim.process.equipment.separator.Separator(
        "1st stage scrubber2", firstStageCooler2.getOutStream())
    try:
        firstStageScrubber2.run()
    except:
        print('error in 1st stage scrubber2')
    separation_process.add(firstStageScrubber2)

    firstStageCompressor2 = neqsim.process.equipment.compressor.Compressor(
        "2nd stage compressor", firstStageScrubber2.getGasOutStream())
    firstStageCompressor2.setCompressorChartType("interpolate and extrapolate")
    firstStageCompressor2.setUsePolytropicCalc(True)
    firstStageCompressor2.setPolytropicEfficiency(0.8)
    firstStageCompressor2.setOutletPressure(inp.second_stage_pressure, 'bara')
    firstStageCompressor2.setSpeed(10250)
    firstStageCompressor2.getCompressorChart().setHeadUnit(inp.headunit)
    firstStageCompressor2.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_second_stage_compressor, inp.surgehead_second_stage_compressor)

    firstStageCompressor2.run()
    separation_process.add(firstStageCompressor2)

    gassplitter2 = neqsim.process.equipment.splitter.Splitter(
    '2nd stage anti surge splitter')
    gassplitter2.setInletStream(firstStageCompressor2.getOutletStream())
    gassplitter2.setFlowRates([-1, 1.0], "kg/hr")
    try:
        gassplitter2.run()
    except:
        print('error in gassplitter2')
    separation_process.add(gassplitter2)

    antisurgeCalculator2 = neqsim.process.equipment.util.Calculator("anti surge calculator_2")
    antisurgeCalculator2.addInputVariable(firstStageCompressor2)
    antisurgeCalculator2.setOutputVariable(gassplitter2)
    if lp_gas_split_factor> 0.1:
        try:
            antisurgeCalculator2.run()
        except:
            print('error in antisurge calculator 2')
        separation_process.add(antisurgeCalculator2)

    antisurgevalve2 = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve 2', gassplitter2.getSplitStream(1))
    antisurgevalve2.setOutletPressure(inp.third_stage_pressure, "bara")
    antisurgevalve2.run()
    separation_process.add(antisurgevalve2)

    recycl2 = neqsim.process.equipment.util.Recycle("recycle anti surge 2nd stage compressor")
    recycl2.addStream(antisurgevalve2.getOutletStream())
    recycl2.setOutletStream(recyclegasstream2)
    recycl2.setTolerance(1)
    if lp_gas_split_factor > 0.1:
        recycl2.run()
        separation_process.add(recycl2)

    gas_splitter_mp_gas = neqsim.process.equipment.splitter.Splitter(
    "gas splitter MP gas", secondStageSeparator.getGasOutStream())
    gas_splitter_mp_gas.setSplitFactors([mpsplit, 1.0-mpsplit])

    #if(inp.use_both_gas_recompression_trains_3_stage >= 0.5):
    #    gas_splitter_mp_gas.setSplitFactors([0.5, 0.5])
    gas_splitter_mp_gas.run()
    separation_process.add(gas_splitter_mp_gas)

    recyclegasstream3 = create_stream('recycle 3rd stage')
    recyclegasstream3.setPressure(inp.second_stage_pressure, 'bara')
    recyclegasstream3.setTemperature(25.0, 'C')
    recyclegasstream3.setFlowRate(1.0, "kg/hr")
    recyclegasstream3.run()
    separation_process.add(recyclegasstream3)

    secondstagegasmixer = neqsim.process.equipment.mixer.Mixer(
        "second Stage mixer")
    secondstagegasmixer.addStream(gassplitter2.getSplitStream(0))
    secondstagegasmixer.addStream(gas_splitter_mp_gas.getSplitStream(0))
    secondstagegasmixer.addStream(recyclegasstream3)
    if test_separator:
        secondstagegasmixer.addStream(test_separator.getGasOutStream())
    if other_train_mp_gas_feed:
        secondstagegasmixer.addStream(other_train_mp_gas_feed)
    secondstagegasmixer.run()
    separation_process.add(secondstagegasmixer)

    secondStageCooler = neqsim.process.equipment.heatexchanger.Cooler(
        "2nd stage cooler", secondstagegasmixer.getOutStream())
    secondStageCooler.setOutTemperature(
        inp.third_stage_suction_cooler_temperature, 'C')
    secondStageCooler.run()
    separation_process.add(secondStageCooler)

    secondStageScrubber = neqsim.process.equipment.separator.Separator(
        "2nd stage scrubber", secondStageCooler.getOutStream())
    try:
        secondStageScrubber.run()
    except:
        print('error in second stage scrubber')
    separation_process.add(secondStageScrubber)

    secondStageCompressor = neqsim.process.equipment.compressor.Compressor(
        "3rd stage compressor", secondStageScrubber.getGasOutStream())
    secondStageCompressor.setUsePolytropicCalc(True)
    secondStageCompressor.setPolytropicEfficiency(0.71)
    secondStageCompressor.setSpeed(9000)
    secondStageCompressor.getCompressorChart().setHeadUnit(inp.headunit)
    if (inp.Year >= inp.year_pre_compression):
        secondStageCompressor.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_third_stage_compressor_flow_new_boundle, inp.surgeflow_third_stage_compressor_head_new_boundle)
    else:
        secondStageCompressor.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_third_stage_compressor, inp.surgehead_third_stage_compressor)

    if (inp.Year >= inp.year_pre_compression):
        secondStageCompressor.setOutletPressure(
            inp.new_compressor_pressure, 'bara')
    else:
        compressorPresSetter = neqsim.process.equipment.util.SetPoint('compressor pres setter')
        compressorPresSetter.setSourceVariable(firstStageSeparator.getGasOutStream(), "pressure")
        compressorPresSetter.setTargetVariable(secondStageCompressor)
        compressorPresSetter.run()
        separation_process.add(compressorPresSetter)
    try:
        secondStageCompressor.run()
    except:
        print('error in second stage compressor')
    separation_process.add(secondStageCompressor)

    gassplitter3 = neqsim.process.equipment.splitter.Splitter(
    '3rd stage anti surge splitter')
    gassplitter3.setInletStream(secondStageCompressor.getOutletStream())
    gassplitter3.setFlowRates([-1, 1.0], "kg/hr")
    gassplitter3.run()
    separation_process.add(gassplitter3)

    antisurgeCalculator3 = neqsim.process.equipment.util.Calculator("anti surge calculator_3")
    antisurgeCalculator3.addInputVariable(secondStageCompressor)
    antisurgeCalculator3.setOutputVariable(gassplitter3)
    if mpsplit > 0.1:
        try:
            antisurgeCalculator3.run()
        except:
            print('error in antisurge calculator 3')
        separation_process.add(antisurgeCalculator3)

    antisurgevalve3 = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve 3', gassplitter3.getSplitStream(1))
    antisurgevalve3.setOutletPressure(inp.second_stage_pressure, "bara")
    antisurgevalve3.run()
    separation_process.add(antisurgevalve3)



    recycl3 = neqsim.process.equipment.util.Recycle("recycle anti surge 3rd stage compressor")
    recycl3.addStream(antisurgevalve3.getOutletStream())
    recycl3.setOutletStream(recyclegasstream3)
    recycl3.setTolerance(1)
    if mpsplit > 0.1:
        recycl3.run()
        separation_process.add(recycl3)


    outgas = firstStageSeparator.getGasOutStream()

    if (inp.Year >= inp.year_pre_compression):

        recyclegasstreamNew = create_stream('recycle stage')
        recyclegasstreamNew.setPressure(inp.first_stage_pressure, 'bara')
        recyclegasstreamNew.setTemperature(25.0, 'C')
        recyclegasstreamNew.setFlowRate(1.0, "kg/hr")
        recyclegasstreamNew.run()
        separation_process.add(recyclegasstreamNew)

        newgasmixer = neqsim.process.equipment.mixer.Mixer(
            "mixer new")
        newgasmixer.addStream(outgas)
        newgasmixer.addStream(recyclegasstreamNew)
        newgasmixer.run()
        separation_process.add(newgasmixer)

        newcompressor_cooler = neqsim.process.equipment.heatexchanger.Cooler(
            "new compressor cooler", newgasmixer.getOutStream())
        newcompressor_cooler.setOutTemperature(
            inp.new_compressor_cooler_out_temperature, 'C')
        newcompressor_cooler.run()
        separation_process.add(newcompressor_cooler)

        scrubber_newcompressor = neqsim.process.equipment.separator.Separator(
            "new compressor scrubber", newcompressor_cooler.getOutStream())
        try:
            scrubber_newcompressor.run()
        except:
            print('error in new compressor scrubber')
        separation_process.add(scrubber_newcompressor)

        oilFirstStageMixer.addStream(scrubber_newcompressor.getLiquidOutStream())

        newcompressor = neqsim.process.equipment.compressor.Compressor(
            "new compressor", scrubber_newcompressor.getGasOutStream())
        newcompressor.setUsePolytropicCalc(True)
        newcompressor.setPolytropicEfficiency(0.8)
        newcompressor.setOutletPressure(inp.new_compressor_pressure, 'bara')
        newcompressor.getCompressorChart().setHeadUnit(inp.headunit)
        newcompressor.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_new_stage_compressor, inp.surgehead_new_stage_compressor)
        newcompressor.run()
        separation_process.add(newcompressor)

        gassplitterNew = neqsim.process.equipment.splitter.Splitter(
        'new stage anti surge splitter')
        gassplitterNew.setInletStream(newcompressor.getOutletStream())
        gassplitterNew.setFlowRates([-1, 1.0], "kg/hr")
        gassplitterNew.run()
        separation_process.add(gassplitterNew)

        antisurgeCalculatorNew = neqsim.process.equipment.util.Calculator("anti surge calculator new")
        antisurgeCalculatorNew.addInputVariable(newcompressor)
        antisurgeCalculatorNew.setOutputVariable(gassplitterNew)
        antisurgeCalculatorNew.run()
        separation_process.add(antisurgeCalculatorNew)

        antisurgevalveNew = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve new', gassplitterNew.getSplitStream(1))
        antisurgevalveNew.setOutletPressure(inp.first_stage_pressure, "bara")
        antisurgevalveNew.run()
        separation_process.add(antisurgevalveNew)

        recyclNew = neqsim.process.equipment.util.Recycle("recycle anti surge new")
        recyclNew.addStream(antisurgevalveNew.getOutletStream())
        recyclNew.setOutletStream(recyclegasstreamNew)
        recyclNew.setTolerance(1)
        recyclNew.run()
        separation_process.add(recyclNew)

        pipe_from_comp = neqsim.process.equipment.pipeline.PipeBeggsAndBrills(
            'pipe from new compressor', gassplitterNew.getSplitStream(0))
        pipe_from_comp.setDiameter(0.4826)
        pipe_from_comp.setPipeWallRoughness(50.0e-6)
        pipe_from_comp.setLength(161)
        pipe_from_comp.setElevation(8.0)
        pipe_from_comp.setNumberOfIncrements(10)
        pipe_from_comp.setRunIsothermal(True)
        pipe_from_comp.run()
        separation_process.add(pipe_from_comp)

        outgas = pipe_from_comp.getOutStream()

    richGasMixer = neqsim.process.equipment.mixer.Mixer("fourth Stage mixer")
    richGasMixer.addStream( gassplitter3.getSplitStream(0))
    richGasMixer.addStream(outgas)
    richGasMixer.run()
    separation_process.add(richGasMixer)

    mpLiqmixer = neqsim.process.equipment.mixer.Mixer("MP liq gas mixer")
    mpLiqmixer.addStream(secondStageScrubber.getLiquidOutStream())
    try:
        mpLiqmixer.run()
    except:
        print('error in MP liq mixer')
    separation_process.add(mpLiqmixer)

    lpLiqmixer = neqsim.process.equipment.mixer.Mixer("LP liq gas mixer")
    lpLiqmixer.addStream(firstStageScrubber2.getLiquidOutStream())
    lpLiqmixer.addStream(recycleliqpumpstream)
    try:
        lpLiqmixer.run()
    except:
        print('error in LP liq mixer')
    separation_process.add(lpLiqmixer)

    mpResycle = neqsim.process.equipment.util.Recycle("MP liq resycle")
    mpResycle.addStream(mpLiqmixer.getOutStream())
    mpResycle.setOutletStream(oilSeccondStage)
    mpResycle.setTolerance(1e-2)
    try:
        mpResycle.run()
    except:
        print('error in MP liq resycle')
    separation_process.add(mpResycle)

    lpResycle = neqsim.process.equipment.util.Recycle("LP liq resycle")
    lpResycle.addStream(lpLiqmixer.getOutStream())
    lpResycle.setOutletStream(oilThirdStage)
    lpResycle.setTolerance(1e-2)
    try:
        lpResycle.run()
    except:
        print('error in LP liq resycle')
    separation_process.add(lpResycle)

    oilcooler = neqsim.process.equipment.heatexchanger.Cooler(
        "4th stage oil cooler", fourthStageSeparator.getOilOutStream())
    oilcooler.setOutTemperature(20.0, 'C')
    oilcooler.run()
    separation_process.add(oilcooler)

    oilpump = neqsim.process.equipment.pump.Pump("4th stage oil pump", oilcooler.getOutletStream())
    oilpump.setOutletPressure(30.0, 'bara')
    oilpump.run()
    separation_process.add(oilpump)

    NGLiqmixer = neqsim.process.equipment.mixer.Mixer("NGL mixer")
    NGLiqmixer.addStream(oilpump.getOutStream())
    try:
        NGLiqmixer.run()
    except:
        print('error in NGL mixer')
    separation_process.add(NGLiqmixer)

    return separation_process

Code cell 16: Oil Separation Process Function

Notebook cell 33. This code belongs to the Oil Separation Process Function section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

%%script false --no-raise-error uncomment if model should be saved to file

test_sep_process = test_separation_process(
    input_parameters, offshore_asset_well_feed_model.getUnit("test manifold").getOutStream())
test_sep_process.run()

if input_parameters.use_both_gas_recompression_trains_1_2_stage < 0.1:
    lp_split = 0.0001
else:
    lp_split = 0.9999

if input_parameters.use_both_gas_recompression_trains_3_stage < 0.1:
    mp_split = 0.0001
else:
    mp_split = 0.9999

separation_process_train_A = create_oil_separation_process(input_parameters, offshore_asset_well_feed_model.getUnit("HP manifold A").getOutStream(), offshore_asset_well_feed_model.getUnit(
    "LP manifold A").getOutStream(), lp_split, reference_stream_c_sep_process.getUnit("manifold").getSplitStream(0), offshore_asset_well_feed_model.getUnit("south east manifold").getSplitStream(0), test_separator=None, reference_stream_c_calibration_stream_gas=reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(1), mpsplit = mp_split)
separation_process_train_A.run()

separation_process_train_B = create_oil_separation_process(input_parameters, offshore_asset_well_feed_model.getUnit("HP manifold B").getOutletStream(), offshore_asset_well_feed_model.getUnit(
    "LP manifold B").getOutletStream(), 0.9999, reference_stream_c_sep_process.getUnit("manifold").getSplitStream(1), offshore_asset_well_feed_model.getUnit("south east manifold").getSplitStream(1),  test_separator=None, reference_stream_c_calibration_stream_gas=reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(2), other_train_lp_gas_feed=separation_process_train_A.getUnit("gas splitter LP gas").getSplitStream(1),
    other_train_lp2_gas_feed=separation_process_train_A.getUnit("gas splitter LP2 gas").getSplitStream(1), other_train_mp_gas_feed=separation_process_train_A.getUnit("gas splitter MP gas").getSplitStream(1), mpsplit=0.9999)
separation_process_train_B.run()

# Corrected feedflow calculation
feedflow = (
    offshore_asset_well_feed_model.getUnit("HP manifold A").getOutStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit("LP manifold A").getOutStream().getFlowRate('kg/hr') +
    reference_stream_c_sep_process.getUnit("manifold").getSplitStream(0).getFlowRate('kg/hr') +
    reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(1).getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit("south east manifold").getSplitStream(0).getFlowRate('kg/hr') +
    separation_process_train_A.getUnit("flare gas").getFlowRate('kg/hr')
)
print(f"Total feed flow: {feedflow:.2f} kg/hr")

# Corrected feedflow calculation
exitflow = (
    separation_process_train_A.getUnit("4th stage oil pump").getOutletStream().getFlowRate('kg/hr') +
    separation_process_train_A.getUnit("fourth Stage mixer").getOutletStream().getFlowRate('kg/hr') +
    separation_process_train_A.getUnit("4th stage separator").getWaterOutStream().getFlowRate('kg/hr') +
    separation_process_train_A.getUnit("2nd stage separator").getWaterOutStream().getFlowRate('kg/hr') +
    separation_process_train_A.getUnit("1st stage separator").getWaterOutStream().getFlowRate('kg/hr') +

    # to be chacked
    separation_process_train_A.getUnit("gas splitter LP gas").getSplitStream(1).getFlowRate('kg/hr') +
    separation_process_train_A.getUnit("gas splitter MP gas").getSplitStream(1).getFlowRate('kg/hr')

)

print(f"Exit flow: {exitflow:.2f} kg/hr")


print('mass balance check A : ', (feedflow - exitflow) / feedflow * 100, '%')


# Corrected feedflow calculation
feedflow = (
    offshore_asset_well_feed_model.getUnit("HP manifold B").getOutStream().getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit("LP manifold B").getOutStream().getFlowRate('kg/hr') +
    reference_stream_c_sep_process.getUnit("manifold").getSplitStream(1).getFlowRate('kg/hr') +
    reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(2).getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit("south east manifold").getSplitStream(1).getFlowRate('kg/hr') +
    separation_process_train_B.getUnit("flare gas").getFlowRate('kg/hr') +
    separation_process_train_A.getUnit("gas splitter MP gas").getSplitStream(1).getFlowRate('kg/hr') +
    separation_process_train_A.getUnit("gas splitter LP2 gas").getSplitStream(1).getFlowRate('kg/hr')
)
print(f"Total feed flow: {feedflow:.2f} kg/hr")

# Corrected feedflow calculation
exitflow = (
    separation_process_train_B.getUnit("4th stage oil pump").getOutletStream().getFlowRate('kg/hr') +
    separation_process_train_B.getUnit("fourth Stage mixer").getOutletStream().getFlowRate('kg/hr') +
    separation_process_train_B.getUnit("4th stage separator").getWaterOutStream().getFlowRate('kg/hr') +
    separation_process_train_B.getUnit("2nd stage separator").getWaterOutStream().getFlowRate('kg/hr') +
    separation_process_train_B.getUnit("1st stage separator").getWaterOutStream().getFlowRate('kg/hr') +

    # to be checked
    separation_process_train_B.getUnit("gas splitter LP gas").getSplitStream(1).getFlowRate('kg/hr') +
    separation_process_train_B.getUnit("gas splitter MP gas").getSplitStream(1).getFlowRate('kg/hr')

)

print(f"Exit flow: {exitflow:.2f} kg/hr")


print('mass balance check B : ', (feedflow - exitflow) / feedflow * 100, '%')

Code cell 17: Manifold and Pipe Model: LIQUID_TRAIN_A to GAS_TRAIN_B

Notebook cell 35. This code belongs to the Manifold and Pipe Model: LIQUID_TRAIN_A to GAS_TRAIN_B section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

def manifold_and_pipe_model_liquid_train_a_to_gas_train_b(inp: ProcessInput, feedstream1, feedstream2):
    manifold_process = neqsim.process.processmodel.ProcessSystem()

    gas_mixer = neqsim.process.equipment.mixer.Mixer('gas mixer')
    gas_mixer.addStream(feedstream1)
    gas_mixer.addStream(feedstream2)
    gas_mixer.run()
    manifold_process.add(gas_mixer)

    pipe = neqsim.process.equipment.pipeline.PipeBeggsAndBrills(
        'pipeline area_trainA to area_trainB', gas_mixer.getOutStream())
    pipe.setDiameter(0.575)
    pipe.setPipeWallRoughness(50.0e-6)
    pipe.setLength(300)
    pipe.setElevation(0.0)
    pipe.setNumberOfIncrements(10)
    pipe.setRunIsothermal(True)
    pipe.run()
    manifold_process.add(pipe)

    manifold = neqsim.process.equipment.splitter.Splitter(
        'manifold', pipe.getOutStream())
    manifold.setSplitFactors([0.5, 0.5])
    manifold.run()
    manifold_process.add(manifold)

    return manifold_process

Code cell 18: Water treatment

Notebook cell 37. This code belongs to the Water treatment section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

%%script false --no-raise-error uncomment if model should be saved to file
# to use this model - you will have to use CPA-EoS to get accurate results
def water_treatment_process(input_parameters, separation_process_train_A, separation_process_train_B):
    water_treatment_model = neqsim.process.processmodel.ProcessSystem()

    water_manifold = neqsim.process.equipment.mixer.Mixer('water treatment manifold')
    water_manifold.addStream(separation_process_train_A.getUnit('1st stage separator').getWaterOutStream())
    water_manifold.addStream(separation_process_train_A.getUnit('2nd stage separator').getWaterOutStream())
    water_manifold.addStream(separation_process_train_B.getUnit('1st stage separator').getWaterOutStream())
    water_manifold.addStream(separation_process_train_B.getUnit('2nd stage separator').getWaterOutStream())
    water_manifold.run()
    water_treatment_model.add(water_manifold)

    valve_water = neqsim.process.equipment.valve.ThrottlingValve('valve 1', water_manifold.getOutStream())
    valve_water.setOutletPressure(1.01325, 'bara')
    valve_water.run()
    water_treatment_model.add(valve_water)

    water_separator = neqsim.process.equipment.separator.ThreePhaseSeparator('water separator', valve_water.getOutletStream())
    water_separator.run()
    water_treatment_model.add(water_separator)

    emissionEstimator = neqsim.process.measurementdevice.CombustionEmissionsCalculator(
        'gas emissions', water_separator.getGasOutStream())
    water_treatment_model.add(emissionEstimator)
    print(emissionEstimator.getMeasuredValue('kg/hr')/1000.0*360*24, ' tons/year CO2 emissions')

    return water_treatment_model


water_prosess = water_treatment_process(input_parameters, separation_process_train_A, separation_process_train_B)
water_prosess.run()

#from neqsim.thermo import printFrame
#printFrame(water_prosess.getUnit('water separator').getFluid())

print('gas emissions ', water_prosess.getUnit('water separator').getGasOutStream().getFlowRate('kg/hr')/1000*24*360, ' tons year')
print('CO2 emission ', water_prosess.getUnit('water separator').getGasOutStream().getFlowRate('kg/hr')/1000*24*360*2.75, ' tons CO2 per year (emission facor 2.75 kg CO2/kg gas)')
print('produced water rate ', water_prosess.getUnit('water separator').getWaterOutStream().getFlowRate('kg/hr')/1000*24, ' m3/day')

raise SystemExit("Stop right there!")

Code cell 19: 6.1 DPCU process

Notebook cell 40. This code belongs to the 6.1 DPCU process section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

def tex_process(inp: ProcessInput, feedgas, sep_process, jt_mode=False):
    tex_process = neqsim.process.processmodel.ProcessSystem()

    coolingstream1 = create_gas_stream('refluxstream_gas_secondstage_1')
    coolingstream1.setFlowRate(800000.1, 'kg/hr')
    tempguess = -40.0
    if inp.Year >= inp.tex_start_year:
        tempguess = -10.0
    coolingstream1.setTemperature(tempguess, 'C')
    coolingstream1.setPressure(inp.expander_out_pressure, 'bara')
    coolingstream1.run()
    tex_process.add(coolingstream1)

    cooling_gas_splitter = neqsim.process.equipment.splitter.Splitter(
        "cooling gas splitter", coolingstream1)

    cooling_gas_splitter.setSplitFactors([1.0-inp.cold_gas_bypass_multidunk, inp.cold_gas_bypass_multidunk])
    cooling_gas_splitter.run()
    tex_process.add(cooling_gas_splitter)

    coolingstream2 = create_stream('refluxstream_gas_secondstage_2')
    coolingstream2.setFlowRate(50000.1, 'kg/hr')
    coolingstream2.setTemperature(tempguess, 'C')
    coolingstream2.setPressure(inp.expander_out_pressure, 'bara')
    coolingstream2.run()
    tex_process.add(coolingstream2)

    dewPointControlCooler = neqsim.process.equipment.heatexchanger.Cooler(
        "dew point cooler", feedgas)
    dewPointControlCooler.setOutTemperature(
        inp.dew_point_scrubber_temperature, 'C')
    dewPointControlCooler.run()
    tex_process.add(dewPointControlCooler)

    dewPointScrubber = neqsim.process.equipment.separator.Separator(
        "dew point scrubber", dewPointControlCooler.getOutStream())
    dewPointScrubber.run()
    tex_process.add(dewPointScrubber)

    water_dehydration = neqsim.process.equipment.splitter.ComponentSplitter(
        "dehyd", dewPointScrubber.getGasOutStream())
    complen = dewPointScrubber.getGasOutStream().getFluid().getNumberOfComponents()
    water_dehydration.setSplitFactors([1.0] * (complen - 1) + [0.0])
    water_dehydration.run()
    tex_process.add(water_dehydration)

    presuredrop_dehyd = neqsim.process.equipment.valve.ThrottlingValve(
        "dp dehydration", water_dehydration.getSplitStream(0))
    presuredrop_dehyd.setCalibrationStreamPressure(2.3, 'bara')
    presuredrop_dehyd.run()
    tex_process.add(presuredrop_dehyd)

    fuel_gas_splitter = neqsim.process.equipment.splitter.Splitter(
        "fuel gas splitter", presuredrop_dehyd.getOutStream())
    fuel_gas_splitter.setFlowRates([-1, inp.fuel_gas_rate/2.0], 'MSm3/day')
    try:
        fuel_gas_splitter.run()
    except:
        print('error in fuel gas splitter')
    tex_process.add(fuel_gas_splitter)

    fuel_gas_stream = neqsim.process.equipment.stream.Stream(
        "fuel gas stream", fuel_gas_splitter.getSplitStream(1))
    fuel_gas_stream.run()
    tex_process.add(fuel_gas_stream)

    rich_gas_splitter = neqsim.process.equipment.splitter.Splitter(
        "rich gas splitter", fuel_gas_splitter.getSplitStream(0))
    if inp.rich_gas_bypass:
        rich_gas_splitter.setFlowRates([-1, 10], 'kg/hr')
    else:
        rich_gas_splitter.setFlowRates([10, -1], 'kg/hr')
    try:
        rich_gas_splitter.run()
    except:
        print('error in rich gas splitter')
    tex_process.add(rich_gas_splitter)

    hpLiqmixer = neqsim.process.equipment.mixer.Mixer("HP liq gas mixer")
    hpLiqmixer.addStream(dewPointScrubber.getLiquidOutStream())
    hpLiqmixer.run()
    tex_process.add(hpLiqmixer)

    hpResycle = neqsim.process.equipment.util.Recycle("HP liq resycle")
    hpResycle.addStream(hpLiqmixer.getOutStream())
    hpResycle.setOutletStream(sep_process.getUnit("frist stage oil reflux"))
    hpResycle.setTolerance(1)
    hpResycle.run()
    tex_process.add(hpResycle)

    heatEx = neqsim.process.equipment.heatexchanger.MultiStreamHeatExchanger(
        "HX_MULTI_STREAM")
    heatEx.addInStream(rich_gas_splitter.getSplitStream(1))
    heatEx.addInStream(cooling_gas_splitter.getSplitStream(0))
    heatEx.addInStream(coolingstream2)
    tempapproach = 5.5
    heatEx.setTemperatureApproach(tempapproach)
    heatEx.run()
    tex_process.add(heatEx)

    gasdewseparator2 = neqsim.process.equipment.separator.Separator(
        '25VG101', heatEx.getOutStream(0))
    gasdewseparator2.run()
    tex_process.add(gasdewseparator2)

    expander_energy_stream = neqsim.process.equipment.stream.EnergyStream(
        "expander energy")

    jt_tex_splitter = neqsim.process.equipment.splitter.Splitter(
        "jt_tex_splitter", gasdewseparator2.getGasOutStream())

    if jt_mode:
        jt_tex_splitter.setSplitFactors([0.001, 0.999])
    else:
        jt_tex_splitter.setSplitFactors([0.999, 0.001])

    jt_tex_splitter.run()
    tex_process.add(jt_tex_splitter)

    feed_stream_turbo_Expander = neqsim.process.equipment.stream.Stream(
        "feed stream turbo expander", jt_tex_splitter.getSplitStream(0))
    feed_stream_turbo_Expander.run()
    tex_process.add(feed_stream_turbo_Expander)

    turboexpander = neqsim.process.equipment.expander.Expander(
        "TEX", jt_tex_splitter.getSplitStream(0))
    turboexpander.setPolytropicEfficiency(inp.expander_efficiency/100.0)
    turboexpander.setUsePolytropicCalc(True)
    turboexpander.setOutletPressure(inp.expander_out_pressure, 'bara')
    turboexpander.setEnergyStream(expander_energy_stream)
    try:
        turboexpander.run()
    except:
        print('error in turboexpander')
    tex_process.add(turboexpander)

    turboExpanderComp = neqsim.process.equipment.expander.TurboExpanderCompressor("TurboExpanderCompressor", jt_tex_splitter.getSplitStream(0))
    turboExpanderComp.setUCcurve(
        [0.9964751359624449, 0.7590835113213541, 0.984295619176559, 0.8827799803397821,
            0.9552460269880922, 1.0],
        [0.984090909090909, 0.796590909090909, 0.9931818181818183, 0.9363636363636364,
            0.9943181818181818, 1.0])
    turboExpanderComp.setQNEfficiencycurve([0.5, 0.7, 0.85, 1.0, 1.2, 1.4, 1.6],
        [0.88, 0.91, 0.95, 1.0, 0.97, 0.85, 0.6])
    turboExpanderComp.setQNHeadcurve([0.5, 0.8, 1.0, 1.2, 1.4, 1.6],
        [1.1, 1.05, 1.0, 0.9, 0.7, 0.4])
    turboExpanderComp.setImpellerDiameter(0.424)
    turboExpanderComp.setDesignSpeed(6850.0)
    turboExpanderComp.setExpanderDesignIsentropicEfficiency(0.88)
    turboExpanderComp.setDesignUC(0.7)
    turboExpanderComp.setDesignQn(0.03328)
    turboExpanderComp.setExpanderOutPressure(inp.expander_out_pressure)
    turboExpanderComp.setCompressorDesignPolytropicEfficiency(0.81)
    turboExpanderComp.setCompressorDesignPolytropicHead(20.47)
    turboExpanderComp.setMaximumIGVArea(1.637e4)
    turboExpanderComp.run()
    tex_process.add(turboExpanderComp)

    jt_valve = neqsim.process.equipment.valve.ThrottlingValve(
        "jt_valve", jt_tex_splitter.getSplitStream(1))
    jt_valve.setOutletPressure(inp.expander_out_pressure, 'bara')
    try:
        jt_valve.run()
    except:
        print('error in jt valve')
    tex_process.add(jt_valve)

    tex_jt_mixer = neqsim.process.equipment.mixer.Mixer("tex_jt mixer")
    #tex_jt_mixer.addStream(turboexpander.getOutStream())
    tex_jt_mixer.addStream(turboExpanderComp.getExpanderOutletStream())
    tex_jt_mixer.addStream(jt_valve.getOutStream())
    tex_jt_mixer.run()
    tex_process.add(tex_jt_mixer)

    DPCUScrubber = neqsim.process.equipment.separator.Separator(
        "TEX LT scrubber", tex_jt_mixer.getOutStream())
    DPCUScrubber.run()
    tex_process.add(DPCUScrubber)

    NGLpremixer = neqsim.process.equipment.mixer.Mixer("NGL pre mixer")
    NGLpremixer.addStream(DPCUScrubber.getLiquidOutStream())
    NGLpremixer.addStream(gasdewseparator2.getLiquidOutStream())
    NGLpremixer.run()
    tex_process.add(NGLpremixer)

    gas_expander_resycle = neqsim.process.equipment.util.Recycle("gas recycl")
    gas_expander_resycle.addStream(DPCUScrubber.getGasOutStream())
    gas_expander_resycle.setOutletStream(coolingstream1)
    gas_expander_resycle.setTolerance(1.0)
    gas_expander_resycle.run()
    tex_process.add(gas_expander_resycle)

    liq_expander_resycle = neqsim.process.equipment.util.Recycle("liq recycl")
    liq_expander_resycle.addStream(NGLpremixer.getOutStream())
    liq_expander_resycle.setOutletStream(coolingstream2)
    liq_expander_resycle.setTolerance(1.0)
    liq_expander_resycle.run()
    tex_process.add(liq_expander_resycle)

    compressor_feed_mixer = neqsim.process.equipment.mixer.Mixer(
        "compressor feed mixer")
    compressor_feed_mixer.addStream(heatEx.getOutStream(1))
    compressor_feed_mixer.addStream(cooling_gas_splitter.getSplitStream(1))
    compressor_feed_mixer.run()
    tex_process.add(compressor_feed_mixer)

    presuredrop_tex_pre_compressor = neqsim.process.equipment.valve.ThrottlingValve(
    "dp tex pre comp", compressor_feed_mixer.getOutStream())
    presuredrop_tex_pre_compressor.setCalibrationStreamPressure(1.0, 'bara')
    presuredrop_tex_pre_compressor.run()
    tex_process.add(presuredrop_tex_pre_compressor)

    compressor_export_booster = neqsim.process.equipment.compressor.Compressor(
        "comp_export_booster_b", presuredrop_tex_pre_compressor.getOutStream())
    compressor_export_booster.setUsePolytropicCalc(True)
    compressor_export_booster.setPolytropicEfficiency(0.75)
    compressor_export_booster.setEnergyStream(expander_energy_stream)
    compressor_export_booster.setCalcPressureOut(True)
    compressor_export_booster.run()
    tex_process.add(compressor_export_booster)

    turboExpanderComp.setCompressorFeedStream(presuredrop_tex_pre_compressor.getOutStream())
    turboExpanderComp.run()

    #tex_gas_splitter = neqsim.process.equipment.splitter.Splitter(
    #    "tex_gas_splitter", compressor_export_booster.getOutStream())
    tex_gas_splitter = neqsim.process.equipment.splitter.Splitter(
        "tex_gas_splitter", turboExpanderComp.getCompressorOutletStream())
    tex_gas_splitter.setFlowRates([-1.0, inp.injection_gas_rate_ht+0.000001], 'MSm3/day')
    try:
        tex_gas_splitter.run()
    except:
        print('error tex_splitter')
    tex_process.add(tex_gas_splitter)

    gas_to_DX_compressors = neqsim.process.equipment.stream.Stream('gas to dx compressor', tex_gas_splitter.getSplitStream(0))
    if inp.rich_gas_bypass:
        gas_to_DX_compressors = neqsim.process.equipment.stream.Stream('gas to dx compressor', rich_gas_splitter.getSplitStream(0))
    gas_to_DX_compressors.run()
    tex_process.add(gas_to_DX_compressors)

    gas_to_HT_injection_compressors = neqsim.process.equipment.stream.Stream('gas to ht compressor', tex_gas_splitter.getSplitStream(1))
    gas_to_HT_injection_compressors.run()
    tex_process.add(gas_to_HT_injection_compressors)


    return tex_process

Code cell 20: 6.2Testing the well, separation and DPCU process models

Notebook cell 42. This code belongs to the 6.2Testing the well, separation and DPCU process models section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

%%script false --no-raise-error uncomment if model should be saved to file

offshore_asset_well_feed_model = create_offshore_asset_well_feed_model(input_parameters)
offshore_asset_well_feed_model.run()

reference_stream_c_sep_process = reference_stream_c_calibration_stream_separation_process(
    input_parameters, offshore_asset_well_feed_model.getUnit("reference_stream_c calibration_stream manifold").getOutStream())
reference_stream_c_sep_process.run()

test_sep_process = test_separation_process(
    input_parameters, offshore_asset_well_feed_model.getUnit("test manifold").getOutStream())
test_sep_process.run()

if input_parameters.use_both_gas_recompression_trains_1_2_stage < 0.1:
    lp_split = 0.0001
else:
    lp_split = 0.9999

if input_parameters.use_both_gas_recompression_trains_3_stage < 0.1:
    mp_split = 0.0001
else:
    mp_split = 0.9999

separation_process_train_A = create_oil_separation_process(input_parameters, offshore_asset_well_feed_model.getUnit("HP manifold A").getOutStream(), offshore_asset_well_feed_model.getUnit(
    "LP manifold A").getOutStream(), lp_split, reference_stream_c_sep_process.getUnit("manifold").getSplitStream(0), offshore_asset_well_feed_model.getUnit("south east manifold").getSplitStream(0), test_separator=None, reference_stream_c_calibration_stream_gas=reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(1), mpsplit = mp_split)
separation_process_train_A.run()

separation_process_train_B = create_oil_separation_process(input_parameters, offshore_asset_well_feed_model.getUnit("HP manifold B").getOutletStream(), offshore_asset_well_feed_model.getUnit(
    "LP manifold B").getOutletStream(), 0.9999, reference_stream_c_sep_process.getUnit("manifold").getSplitStream(1), offshore_asset_well_feed_model.getUnit("south east manifold").getSplitStream(1),  test_separator=None, reference_stream_c_calibration_stream_gas=reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(2), other_train_lp_gas_feed=separation_process_train_A.getUnit("gas splitter LP gas").getSplitStream(1),
    other_train_lp2_gas_feed=separation_process_train_A.getUnit("gas splitter LP2 gas").getSplitStream(1), other_train_mp_gas_feed=separation_process_train_A.getUnit("gas splitter MP gas").getSplitStream(1), mpsplit=0.9999)
separation_process_train_B.run()

manifold_upstream_TEX = manifold_and_pipe_model_liquid_train_a_to_gas_train_b(input_parameters, separation_process_train_A.getUnit(
    "fourth Stage mixer").getOutStream(), separation_process_train_B.getUnit("fourth Stage mixer").getOutStream())
manifold_upstream_TEX.run()

tex_process_1 = tex_process(input_parameters, manifold_upstream_TEX.getUnit(
    "manifold").getSplitStream(0), separation_process_train_A, jt_mode=False)
tex_process_1.run()

tex_process_2 = tex_process(input_parameters, manifold_upstream_TEX.getUnit(
    "manifold").getSplitStream(1), separation_process_train_B, jt_mode=False)
tex_process_2.run()

clear_output(wait=True)
print("Calculation finished")

Code cell 21: 6.2Testing the well, separation and DPCU process models

Notebook cell 43. This code belongs to the 6.2Testing the well, separation and DPCU process models section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

%%script false --no-raise-error uncomment if model should be saved to file
print('tex in ', tex_process_1.getUnit(
    'TEX').getInStream().getFluid().getTemperature('C'))
print('tex out ', tex_process_1.getUnit(
    'TEX').getOutStream().getFluid().getTemperature('C'))
print('jt in ', tex_process_1.getUnit(
    'jt_valve').getInStream().getFluid().getTemperature('C'))
print('jt out ', tex_process_1.getUnit(
    'jt_valve').getOutStream().getFluid().getTemperature('C'))

Code cell 22: 7. Offshore Area D NGL column model

Notebook cell 45. This code belongs to the 7. Offshore Area D NGL column model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

def ngl_column_model(inp: ProcessInput, feed_stream, separation_process_train_A, separation_process_train_B, lp_split=0.5):
    ngl_column_model = neqsim.process.processmodel.ProcessSystem()

    NGLpreflash_valve = neqsim.process.equipment.valve.ThrottlingValve(
        "NGL pre flash valve", feed_stream)
    NGLpreflash_valve.setOutletPressure(inp.pre_flash_drum_pressure, 'bara')
    try:
        NGLpreflash_valve.run()
    except:
        print('error in NGL pre flash valve')
    ngl_column_model.add(NGLpreflash_valve)

    NGLpreflashsseparator = neqsim.process.equipment.separator.Separator(
        "NGL pre flash separator", NGLpreflash_valve.getOutStream())
    NGLpreflashsseparator.run()
    ngl_column_model.add(NGLpreflashsseparator)

    NGLgassplitter = neqsim.process.equipment.splitter.Splitter(
        "NGL gas splitter", NGLpreflashsseparator.getGasOutStream())
    NGLgassplitter.setSplitFactors([lp_split, 1.0-lp_split])
    NGLgassplitter.run()
    ngl_column_model.add(NGLgassplitter)

    separation_process_train_A.getUnit('second Stage mixer').addStream(
        NGLgassplitter.getSplitStream(0))
    separation_process_train_B.getUnit('second Stage mixer').addStream(
        NGLgassplitter.getSplitStream(1))

    ngl_column_feed_valve = neqsim.process.equipment.valve.ThrottlingValve(
        "ngl valve to column", NGLpreflashsseparator.getLiquidOutStream())
    ngl_column_feed_valve.setOutletPressure(inp.ngl_column_pressure, 'bara')
    try:
        ngl_column_feed_valve.run()
    except:
        print('error in ngl column feed valve')
    ngl_column_model.add(ngl_column_feed_valve)

    NGLcolumn = neqsim.process.equipment.distillation.DistillationColumn(
        'NGL column', 10, True, False)
    NGLcolumn.addFeedStream(ngl_column_feed_valve.getOutStream(), 10)
    NGLcolumn.getReboiler().setOutTemperature(
        273.15 + inp.ngl_column_reboiler_temperature)
    NGLcolumn.setTopPressure(inp.ngl_column_pressure)
    NGLcolumn.setBottomPressure(inp.ngl_column_pressure+0.5)
    NGLcolumn.setTemperatureTolerance(5.0e-1)
    NGLcolumn.setMassBalanceTolerance(5.0e-1)
    NGLcolumn.setEnthalpyBalanceTolerance(5.0e-1)
    NGLcolumn.setMaxNumberOfIterations(10)
    try:
        NGLcolumn.run()
    except:
        print('error in NGL column')
    ngl_column_model.add(NGLcolumn)

    NGLcoumngassplitter = neqsim.process.equipment.splitter.Splitter(
        "NGL column gas splitter", NGLcolumn.getGasOutStream())
    NGLcoumngassplitter.setSplitFactors([lp_split, 1.0-lp_split])
    NGLcoumngassplitter.run()
    ngl_column_model.add(NGLcoumngassplitter)

    separation_process_train_A.getUnit("first stage mixer").addStream(
        NGLcoumngassplitter.getSplitStream(0))
    separation_process_train_B.getUnit("first stage mixer").addStream(
        NGLcoumngassplitter.getSplitStream(1))

    NGLinjectionsplitter = neqsim.process.equipment.splitter.Splitter(
        "NGL injection splitter", NGLcolumn.getLiquidOutStream())
    #NGLinjectionsplitter.setFlowRates(
    #    [-1, inp.lpg_injection_flow], 'kg/hr')
    NGLinjectionsplitter.setSplitFactors(
        [1.0-inp.lpg_injection_fraction, inp.lpg_injection_fraction])
    NGLinjectionsplitter.run()
    ngl_column_model.add(NGLinjectionsplitter)

    NGLsplitter = neqsim.process.equipment.splitter.Splitter(
        "NGL splitter", NGLinjectionsplitter.getSplitStream(0))
    NGLsplitter.setSplitFactors(
        [inp.ngl_routing_to_oil, 1.0-inp.ngl_routing_to_oil])
    NGLsplitter.run()
    ngl_column_model.add(NGLsplitter)

    lpg_injection_stream = neqsim.process.equipment.stream.Stream(
        "lpg injection stream", NGLinjectionsplitter.getSplitStream(1))
    lpg_injection_stream.run()
    ngl_column_model.add(lpg_injection_stream)

    lpg_production_stream = neqsim.process.equipment.stream.Stream(
        "lpg production stream", NGLinjectionsplitter.getSplitStream(0))
    lpg_production_stream.run()
    ngl_column_model.add(lpg_production_stream)

    NGLcoumnliquidsplittertoNGLmixer = neqsim.process.equipment.splitter.Splitter(
        "NGL column liquid splitter", NGLsplitter.getSplitStream(0))
    NGLcoumnliquidsplittertoNGLmixer.setSplitFactors([0.5, 0.5])
    NGLcoumnliquidsplittertoNGLmixer.run()
    ngl_column_model.add(NGLcoumnliquidsplittertoNGLmixer)

    NGLcoumnliquidsplittertoMPliqmixer = neqsim.process.equipment.splitter.Splitter(
        "NGL column liquid splitter2", NGLsplitter.getSplitStream(1))
    NGLcoumnliquidsplittertoMPliqmixer.setSplitFactors([0.5, 0.5])
    NGLcoumnliquidsplittertoMPliqmixer.run()
    ngl_column_model.add(NGLcoumnliquidsplittertoMPliqmixer)

    separation_process_train_A.getUnit("NGL mixer").addStream(
        NGLcoumnliquidsplittertoNGLmixer.getSplitStream(0))
    separation_process_train_B.getUnit("NGL mixer").addStream(
        NGLcoumnliquidsplittertoNGLmixer.getSplitStream(1))
    separation_process_train_A.getUnit("MP liq gas mixer").addStream(
        NGLcoumnliquidsplittertoMPliqmixer.getSplitStream(0))
    separation_process_train_B.getUnit("MP liq gas mixer").addStream(
        NGLcoumnliquidsplittertoMPliqmixer.getSplitStream(1))

    return ngl_column_model

Code cell 23: 8. Export compressor model

Notebook cell 47. This code belongs to the 8. Export compressor model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

import math



def export_compressor_model(inp: ProcessInput, feedstream):

    #print('feed flow ', feedstream.getFlowRate("kg/hr"), 'kg/hr')

    compressor_model = neqsim.process.processmodel.ProcessSystem()



    intermediatePressure = feedstream.getPressure(

    ) * math.sqrt(inp.export_compressor_pressure/feedstream.getPressure())+8



    recyclegasstream = create_stream('recycle dx')

    recyclegasstream.setPressure(feedstream.getPressure()+5.0, 'bara')

    recyclegasstream.setTemperature(25.0, 'C')

    recyclegasstream.setFlowRate(100.0, "kg/hr")

    recyclegasstream.run()

    compressor_model.add(recyclegasstream)



    gas_mixer_hp_gas = neqsim.process.equipment.mixer.Mixer(

        "gas mixer")

    gas_mixer_hp_gas.addStream(feedstream)

    gas_mixer_hp_gas.addStream(recyclegasstream)

    gas_mixer_hp_gas.run()

    compressor_model.add(gas_mixer_hp_gas)



    compressor_EXPORT_COMPRESSOR = neqsim.process.equipment.compressor.Compressor(

        "EXPORT_COMPRESSOR", gas_mixer_hp_gas.getOutStream())

    compressor_EXPORT_COMPRESSOR.setUsePolytropicCalc(True)

    compressor_EXPORT_COMPRESSOR.setPolytropicEfficiency(0.75)

    compressor_EXPORT_COMPRESSOR.setOutletPressure(intermediatePressure, 'bara')

    compressor_EXPORT_COMPRESSOR.setSpeed(9000)

    compressor_EXPORT_COMPRESSOR.getCompressorChart().setHeadUnit(inp.headunit)

    compressor_EXPORT_COMPRESSOR.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_DX1_stage_compressor, inp.surgehead_DX1_stage_compressor)



    try:

        compressor_EXPORT_COMPRESSOR.run()

    except:

        print('error in EXPORT_COMPRESSOR')

    compressor_model.add(compressor_EXPORT_COMPRESSOR)



    cooler_export_stage_1 = neqsim.process.equipment.heatexchanger.Cooler(

        "EXPORT_COOLER_STAGE_1", compressor_EXPORT_COMPRESSOR.getOutStream())

    cooler_export_stage_1.setOutTemperature(30.0, 'C')

    cooler_export_stage_1.setPressureDrop(0.35)

    cooler_export_stage_1.run()

    compressor_model.add(cooler_export_stage_1)



    compressor_EXPORT_COMPRESSOR = neqsim.process.equipment.compressor.Compressor(

        "EXPORT_COMPRESSOR", cooler_export_stage_1.getOutStream())

    compressor_EXPORT_COMPRESSOR.setUsePolytropicCalc(True)

    compressor_EXPORT_COMPRESSOR.setPolytropicEfficiency(0.75)

    compressor_EXPORT_COMPRESSOR.setOutletPressure(

        inp.export_compressor_pressure, 'bara')

    compressor_EXPORT_COMPRESSOR.setSpeed(9000)

    compressor_EXPORT_COMPRESSOR.getCompressorChart().setHeadUnit(inp.headunit)

    compressor_EXPORT_COMPRESSOR.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_DX1_stage_compressor, inp.surgehead_DX1_stage_compressor)



    try:

        compressor_EXPORT_COMPRESSOR.run()

    except:

        print('error in EXPORT_COMPRESSOR')

    compressor_model.add(compressor_EXPORT_COMPRESSOR)



    gassplitter = neqsim.process.equipment.splitter.Splitter(

    'anti surge splitter')

    gassplitter.setInletStream(compressor_EXPORT_COMPRESSOR.getOutletStream())

    gassplitter.setFlowRates([-1, 1.0], "kg/hr")

    try:

        gassplitter.run()

    except:

        print('error in gassplitter')

    compressor_model.add(gassplitter)



    antisurgeCalculator = neqsim.process.equipment.util.Calculator("anti surge calculator_1")

    antisurgeCalculator.addInputVariable(compressor_EXPORT_COMPRESSOR)

    antisurgeCalculator.setOutputVariable(gassplitter)

    antisurgeCalculator.run()

    compressor_model.add(antisurgeCalculator)



    antisurgevalve = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve', gassplitter.getSplitStream(1))

    antisurgevalve.setOutletPressure(feedstream.getPressure()+5.0, "bara")

    antisurgevalve.run()

    compressor_model.add(antisurgevalve)



    recycl = neqsim.process.equipment.util.Recycle("recycle anti surge 1st stage compressor")

    recycl.addStream(antisurgevalve.getOutletStream())

    recycl.setOutletStream(recyclegasstream)

    recycl.setTolerance(1e-2)

    recycl.run()

    compressor_model.add(recycl)



    gassplitter.setFlowRates([-1.0, 1.0], "kg/hr")

    gassplitter.run()



    compressor_out_stream = neqsim.process.equipment.stream.Stream(

        "compressor EXPORT_COMPRESSOR out stream", gassplitter.getSplitStream(0))

    compressor_out_stream.run()

    compressor_model.add(compressor_out_stream)



    #print('out flow ', compressor_out_stream.getFlowRate("kg/hr"), 'kg/hr')



    return compressor_model



def stabilize_export_compressor_outlet(compressor_process, recycle_flow_kg_hr=1.0):

    splitter = compressor_process.getUnit("anti surge splitter")

    splitter.setFlowRates([-1.0, recycle_flow_kg_hr], "kg/hr")

    splitter.run()

    compressor_process.getUnit("compressor EXPORT_COMPRESSOR out stream").run()

Code cell 24: 8. Export compressor model

Notebook cell 48. This code belongs to the 8. Export compressor model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

import math



def create_zero_ht_injection_process(inp: ProcessInput, reference_stream):

    ht_process = neqsim.process.processmodel.ProcessSystem()



    gas_export_ht = neqsim.process.equipment.stream.Stream('gas export ht', reference_stream)

    gas_export_ht.setFlowRate(0.0, 'kg/hr')

    gas_export_ht.setPressure(inp.export_compressor_pressure, 'bara')

    gas_export_ht.run()

    ht_process.add(gas_export_ht)



    gas_injection_ht = neqsim.process.equipment.stream.Stream('gas injection ht', reference_stream)

    gas_injection_ht.setFlowRate(0.0, 'kg/hr')

    gas_injection_ht.setPressure(inp.injection_compressor_pressure, 'bara')

    gas_injection_ht.run()

    ht_process.add(gas_injection_ht)



    return ht_process



def ht_injection_compressor_model(inp: ProcessInput, ht_feed_gas):



    compressor_model = neqsim.process.processmodel.ProcessSystem()



    gasmixer = neqsim.process.equipment.mixer.Mixer('ht gas mixer')

    gasmixer.addStream(ht_feed_gas)

    gasmixer.run()

    compressor_model.add(gasmixer)



    ht_intermediate_pressure = math.sqrt(ht_feed_gas.getPressure()*inp.injection_compressor_pressure)



    recyclegasstream_ht1 = create_stream('recycle ht 1st stage')

    recyclegasstream_ht1.setPressure(ht_intermediate_pressure, 'bara')

    recyclegasstream_ht1.setTemperature(25.0, 'C')

    recyclegasstream_ht1.setFlowRate(1.0, "kg/hr")

    recyclegasstream_ht1.run()

    compressor_model.add(recyclegasstream_ht1)



    gas_mixer_lp_gas = neqsim.process.equipment.mixer.Mixer(

        "gas mixer ht 1 gas")

    gas_mixer_lp_gas.addStream(gasmixer.getOutletStream())

    gas_mixer_lp_gas.addStream(recyclegasstream_ht1)

    gas_mixer_lp_gas.run()

    compressor_model.add(gas_mixer_lp_gas)



    cooler_ht1 = neqsim.process.equipment.heatexchanger.Cooler('ht 1st stage cooler', gas_mixer_lp_gas.getOutStream())

    cooler_ht1.setOutTemperature(inp.fourth_stage_suction_cooler_temperature, 'C')

    cooler_ht1.run()

    compressor_model.add(cooler_ht1)



    separator_gas = neqsim.process.equipment.separator.Separator('gas scrubber for HT compressor stage 1', cooler_ht1.getOutStream())

    separator_gas.run()

    compressor_model.add(separator_gas)





    ht1_compressor = neqsim.process.equipment.compressor.Compressor('ht 1st stage compressor', separator_gas.getGasOutStream())

    ht1_compressor.setUsePolytropicCalc(True)

    ht1_compressor.setPolytropicEfficiency(0.8)

    ht1_compressor.setOutletPressure(ht_intermediate_pressure, 'bara')

    ht1_compressor.getCompressorChart().setHeadUnit(inp.headunit)

    ht1_compressor.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_htA_stage_compressor, inp.surgehead_htA_stage_compressor)

    ht1_compressor.run()

    compressor_model.add(ht1_compressor)



    gassplitter_ht1 = neqsim.process.equipment.splitter.Splitter(

    'ht1 anti surge splitter')

    gassplitter_ht1.setInletStream(ht1_compressor.getOutletStream())

    gassplitter_ht1.setFlowRates([-1, 0.01], "kg/hr")

    try:

        gassplitter_ht1.run()

    except:

        print('error in gassplitter ht1')

    compressor_model.add(gassplitter_ht1)



    antisurgeCalculator = neqsim.process.equipment.util.Calculator("anti surge calculator_1")

    antisurgeCalculator.addInputVariable(ht1_compressor)

    antisurgeCalculator.setOutputVariable(gassplitter_ht1)

    antisurgeCalculator.run()

    compressor_model.add(antisurgeCalculator)



    antisurgevalve_ht = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve', gassplitter_ht1.getSplitStream(1))

    antisurgevalve_ht.setOutletPressure(ht_feed_gas.getPressure()+10.0, "bara")

    antisurgevalve_ht.run()

    compressor_model.add(antisurgevalve_ht)



    recycl = neqsim.process.equipment.util.Recycle("recycle anti surge ht 1 compressor")

    recycl.addStream(antisurgevalve_ht.getOutletStream())

    recycl.setOutletStream(recyclegasstream_ht1)

    recycl.setTolerance(1e-2)

    recycl.run()

    compressor_model.add(recycl)



    recyclegasstream_ht2 = create_stream('recycle ht 2nd stage')

    recyclegasstream_ht2.setPressure(ht_intermediate_pressure, 'bara')

    recyclegasstream_ht2.setTemperature(25.0, 'C')

    recyclegasstream_ht2.setFlowRate(10.0, "kg/hr")

    recyclegasstream_ht2.run()

    compressor_model.add(recyclegasstream_ht2)



    gas_mixer_ht2_gas = neqsim.process.equipment.mixer.Mixer(

        "gas mixer ht 2 gas")

    gas_mixer_ht2_gas.addStream(gassplitter_ht1.getSplitStream(0))

    gas_mixer_ht2_gas.addStream(recyclegasstream_ht2)

    gas_mixer_ht2_gas.run()

    compressor_model.add(gas_mixer_ht2_gas)



    cooler_ht2 = neqsim.process.equipment.heatexchanger.Cooler('ht 2nd stage cooler', gas_mixer_ht2_gas.getOutStream())

    cooler_ht2.setOutTemperature(inp.fifth_stage_suction_cooler_temperature, 'C')

    cooler_ht2.run()

    compressor_model.add(cooler_ht2)



    separator_ht_2= neqsim.process.equipment.separator.Separator('gas scrubber for HT compressor stage 2',cooler_ht2.getOutStream())

    separator_ht_2.run()

    compressor_model.add(separator_ht_2)



    ht2_compressor = neqsim.process.equipment.compressor.Compressor('ht 2nd stage compressor', separator_ht_2.getGasOutStream())

    ht2_compressor.setUsePolytropicCalc(True)

    ht2_compressor.setPolytropicEfficiency(0.8)

    ht2_compressor.setOutletPressure(inp.injection_compressor_pressure, 'bara')

    ht2_compressor.getCompressorChart().setHeadUnit(inp.headunit)

    ht2_compressor.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_htB_stage_compressor, inp.surgehead_htB_stage_compressor)

    ht2_compressor.run()

    compressor_model.add(ht2_compressor)



    gassplitter_ht2 = neqsim.process.equipment.splitter.Splitter(

    'ht2 anti surge splitter')

    gassplitter_ht2.setInletStream(ht2_compressor.getOutletStream())

    gassplitter_ht2.setFlowRates([-1, 1.0], "kg/hr")

    try:

        gassplitter_ht2.run()

    except:

        print('error in gassplitter ht2')

    compressor_model.add(gassplitter_ht2)



    antisurgeCalculator2 = neqsim.process.equipment.util.Calculator("anti surge calculator_2")

    antisurgeCalculator2.addInputVariable(ht2_compressor)

    antisurgeCalculator2.setOutputVariable(gassplitter_ht2)

    antisurgeCalculator2.run()

    compressor_model.add(antisurgeCalculator2)



    antisurgevalve_ht2 = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve ht2', gassplitter_ht2.getSplitStream(1))

    antisurgevalve_ht2.setOutletPressure(ht_intermediate_pressure, "bara")

    antisurgevalve_ht2.run()

    compressor_model.add(antisurgevalve_ht2)



    recycl_2 = neqsim.process.equipment.util.Recycle("recycle anti surge ht 2 compressor")

    recycl_2.addStream(antisurgevalve_ht2.getOutletStream())

    recycl_2.setOutletStream(recyclegasstream_ht2)

    recycl_2.setTolerance(1e-2)

    recycl_2.run()

    compressor_model.add(recycl_2)



    injection_export_splitter = neqsim.process.equipment.splitter.Splitter('export gas splitter', gassplitter_ht2.getSplitStream(0))

    injection_export_splitter.setSplitFactors([0.99999, 0.00001])

    injection_export_splitter.run()

    compressor_model.add(injection_export_splitter)



    injection_gas_ht = neqsim.process.equipment.stream.Stream('gas injection ht', injection_export_splitter.getSplitStream(0))

    injection_gas_ht.run()

    compressor_model.add(injection_gas_ht)



    export_gas_ht = neqsim.process.equipment.stream.Stream('gas export ht', injection_export_splitter.getSplitStream(1))

    export_gas_ht.run()

    compressor_model.add(export_gas_ht)



    return compressor_model

Code cell 25: 8. Export compressor model

Notebook cell 49. This code belongs to the 8. Export compressor model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

def exportgasprocess(inp: ProcessInput, export_compressor_train_A, export_compressor_train_B, offshore_asset_well_feed_model, ht_process_A, ht_process_B):
    export_gas_process = neqsim.process.processmodel.ProcessSystem()
    #print('feed train A ', export_compressor_train_A.getUnit(
    #        "compressor EXPORT_COMPRESSOR out stream").getOutletStream().getFlowRate('kg/hr'))
    #print('feed train B ', export_compressor_train_B.getUnit(
    #        "compressor EXPORT_COMPRESSOR out stream").getOutletStream().getFlowRate('kg/hr'))
    #print('ht train A ', ht_process_A.getOutletStream().getFlowRate('kg/hr'))
    #print('ht train B ', ht_process_B.getOutletStream().getFlowRate('kg/hr'))

    trainA_gas_splitter = neqsim.process.equipment.splitter.Splitter(
        'train A gas splitter', export_compressor_train_A.getUnit(
            "compressor EXPORT_COMPRESSOR out stream"))
    trainA_gas_splitter.setFlowRates([0.0001, -1], 'MSm3/day')
    try:
        trainA_gas_splitter.run()
    except:
        print('error in train A gas splitter')
    export_gas_process.add(trainA_gas_splitter)

    #print('rate exp A', trainA_gas_splitter.getSplitStream(1).getFlowRate('MSm3/day'))

    trainB_gas_splitter = neqsim.process.equipment.splitter.Splitter(
        'train B gas splitter', export_compressor_train_B.getUnit(
            "compressor EXPORT_COMPRESSOR out stream"))
    #print('gas lift rate train B', inp.gas_lift_rate)
    #print('injection gas rate train B', inp.injection_gas_rate_dx)
    trainB_gas_splitter.setFlowRates(
        [inp.gas_lift_rate + inp.injection_gas_rate_dx+0.0001, -1], 'MSm3/day')
    try:
        trainB_gas_splitter.run()
    except:
        print('error in train B gas splitter')
    export_gas_process.add(trainB_gas_splitter)
    #print('rate exp B', trainB_gas_splitter.getSplitStream(1).getFlowRate('MSm3/day'))
    #print('rate exp B', trainB_gas_splitter.getSplitStream(0).getFlowRate('MSm3/day'))

    gas_mixer = neqsim.process.equipment.mixer.Mixer('gas mixer')
    gas_mixer.addStream(trainA_gas_splitter.getSplitStream(1))
    gas_mixer.addStream(trainB_gas_splitter.getSplitStream(1))
    gas_mixer.addStream(ht_process_A.getUnit('gas export ht'))
    gas_mixer.addStream(ht_process_B.getUnit('gas export ht'))
    gas_mixer.run()
    export_gas_process.add(gas_mixer)
    #print('ht feed A', ht_process_A.getUnit('gas export ht').getFlowRate('kg/hr'))
    #print('ht feed B', ht_process_B.getUnit('gas export ht').getFlowRate('kg/hr'))
    #print('mixer out ', gas_mixer.getOutStream().getFlowRate('kg/hr'))


    export_gas_stream = neqsim.process.equipment.stream.Stream(
        'export gas stream', gas_mixer.getOutStream())
    export_gas_stream.run()
    export_gas_process.add(export_gas_stream)
    print('export gas stream', export_gas_stream.getFlowRate('kg/hr'))

    injection_compressor_manifold = neqsim.process.equipment.manifold.Manifold(
        'injection compressor manifold')
    injection_compressor_manifold.addStream(
        trainA_gas_splitter.getSplitStream(0))
    injection_compressor_manifold.addStream(
        trainB_gas_splitter.getSplitStream(0))
    injection_compressor_manifold.setSplitFactors([0.9999, 0.0001])
    injection_compressor_manifold.run()
    export_gas_process.add(injection_compressor_manifold)
    #print('manifold gas stream', injection_compressor_manifold.getSplitStream(0).getFlowRate('MSm3/day'))
    #print('manifold gas stream2 ', injection_compressor_manifold.getSplitStream(1).getFlowRate('MSm3/day'))

    #print('injection 1 ', injection_compressor_manifold.getSplitStream(0).getFlowRate('kg/hr'))
    #print('injection 2 ', injection_compressor_manifold.getSplitStream(1).getFlowRate('kg/hr'))

    recyclegasstream = create_stream('recycle dx stage')
    recyclegasstream.setPressure(inp.export_compressor_pressure, 'bara')
    recyclegasstream.setTemperature(25.0, 'C')
    recyclegasstream.setFlowRate(100.0, "kg/hr")
    recyclegasstream.run()
    export_gas_process.add(recyclegasstream)

    gas_mixer_dx_gas = neqsim.process.equipment.mixer.Mixer(
    "gas mixer dx")
    gas_mixer_dx_gas.addStream(injection_compressor_manifold.getSplitStream(0))
    gas_mixer_dx_gas.addStream(recyclegasstream)
    gas_mixer_dx_gas.run()
    export_gas_process.add(gas_mixer_dx_gas)

    cooler_dx_gas = neqsim.process.equipment.heatexchanger.Cooler(
        "DX gas cooler", gas_mixer_dx_gas.getOutStream())
    cooler_dx_gas.setOutTemperature(30.0, 'C')
    cooler_dx_gas.run()
    export_gas_process.add(cooler_dx_gas)

    injection_compressor1 = neqsim.process.equipment.compressor.Compressor(
        "injection compressor DXA", cooler_dx_gas.getOutStream())
    injection_compressor1.setUsePolytropicCalc(True)
    injection_compressor1.setPolytropicEfficiency(0.75)
    injection_compressor1.setOutletPressure(
        inp.injection_compressor_pressure, 'bara')
    injection_compressor1.getCompressorChart().setHeadUnit(inp.headunit)
    injection_compressor1.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_DX3_stage_compressor, inp.surgehead_DX3_stage_compressor)

    try:
        injection_compressor1.run()
    except:
        print('error in injection compressor 1')
    export_gas_process.add(injection_compressor1)

    gassplitter = neqsim.process.equipment.splitter.Splitter(
    'anti surge splitter')
    gassplitter.setInletStream(injection_compressor1.getOutletStream())
    gassplitter.setFlowRates([-1, 1.0], "kg/hr")
    try:
        gassplitter.run()
    except:
        print('error in gassplitter')
    export_gas_process.add(gassplitter)

    antisurgeCalculator = neqsim.process.equipment.util.Calculator("anti surge calculator 1")
    antisurgeCalculator.addInputVariable(injection_compressor1)
    antisurgeCalculator.setOutputVariable(gassplitter)
    antisurgeCalculator.run()
    export_gas_process.add(antisurgeCalculator)

    antisurgevalve = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve', gassplitter.getSplitStream(1))
    antisurgevalve.setOutletPressure(inp.export_compressor_pressure, "bara")
    antisurgevalve.run()
    export_gas_process.add(antisurgevalve)

    recycl = neqsim.process.equipment.util.Recycle("recycle anti surge")
    recycl.addStream(antisurgevalve.getOutletStream())
    recycl.setOutletStream(recyclegasstream)
    recycl.setTolerance(1e-2)
    recycl.run()
    export_gas_process.add(recycl)

    recyclegasstream2 = create_stream('recycle dx B')
    recyclegasstream2.setPressure(inp.export_compressor_pressure, 'bara')
    recyclegasstream2.setTemperature(25.0, 'C')
    recyclegasstream2.setFlowRate(1.0, "kg/hr")
    recyclegasstream2.run()
    export_gas_process.add(recyclegasstream2)

    gas_mixer_dx_gas2 = neqsim.process.equipment.mixer.Mixer(
    "gas mixer 2")
    gas_mixer_dx_gas2.addStream(injection_compressor_manifold.getSplitStream(1))
    gas_mixer_dx_gas2.addStream(recyclegasstream2)
    gas_mixer_dx_gas2.run()
    export_gas_process.add(gas_mixer_dx_gas2)

    cooler_dx_gas2 = neqsim.process.equipment.heatexchanger.Cooler(
        "DX gas cooler 2", gas_mixer_dx_gas2.getOutStream())
    cooler_dx_gas2.setOutTemperature(30.0, 'C')
    cooler_dx_gas2.run()
    export_gas_process.add(cooler_dx_gas2)

    injection_compressor2 = neqsim.process.equipment.compressor.Compressor(
        "injection compressor INJECTION_HUB", cooler_dx_gas2.getOutStream())
    injection_compressor2.setUsePolytropicCalc(True)
    injection_compressor2.setPolytropicEfficiency(0.75)
    injection_compressor2.setOutletPressure(
        inp.injection_compressor_pressure, 'bara')
    injection_compressor2.getCompressorChart().setHeadUnit(inp.headunit)
    injection_compressor2.getCompressorChart().getSurgeCurve().setCurve(inp.chartConditions, inp.surgeflow_DX3_stage_compressor, inp.surgehead_DX3_stage_compressor)

    try:
        injection_compressor2.run()
    except:
        print('error in injection compressor 2')
    export_gas_process.add(injection_compressor2)

    gassplitter2 = neqsim.process.equipment.splitter.Splitter(
    'anti surge splitter2')
    gassplitter2.setInletStream(injection_compressor2.getOutletStream())
    gassplitter2.setFlowRates([-1, 1.0, ], "kg/hr")
    try:
        gassplitter2.run()
    except:
        print('error in gassplitter 2')
    export_gas_process.add(gassplitter2)

    antisurgeCalculator2 = neqsim.process.equipment.util.Calculator("anti surge calculator 2")
    antisurgeCalculator2.addInputVariable(injection_compressor2)
    antisurgeCalculator2.setOutputVariable(gassplitter2)
    try:
        antisurgeCalculator2.run()
    except:
        print('error in antisurge calculator 2')
    export_gas_process.add(antisurgeCalculator2)

    antisurgevalve2 = neqsim.process.equipment.valve.ThrottlingValve('aniti surge valve 2', gassplitter2.getSplitStream(1))
    antisurgevalve2.setOutletPressure(inp.export_compressor_pressure, "bara")
    antisurgevalve2.run()
    export_gas_process.add(antisurgevalve2)

    recyc2 = neqsim.process.equipment.util.Recycle("recycle anti surge 2")
    recyc2.addStream(antisurgevalve2.getOutletStream())
    recyc2.setOutletStream(recyclegasstream2)
    recyc2.setTolerance(1e-2)
    recyc2.run()
    export_gas_process.add(recyc2)

    gasinjection_manifold = neqsim.process.equipment.manifold.Manifold(
        'gas injection manifold')
    gasinjection_manifold.addStream(gassplitter.getSplitStream(0))
    gasinjection_manifold.addStream(gassplitter2.getSplitStream(0))
    gasinjection_manifold.addStream(ht_process_A.getUnit('gas injection ht'))
    gasinjection_manifold.addStream(ht_process_B.getUnit('gas injection ht'))
    gasinjection_manifold.setSplitFactors([0.9999, 0.0001])
    try:
        gasinjection_manifold.run()
    except:
        print('error in gas injection manifold')
    export_gas_process.add(gasinjection_manifold)

    gas_lift_injection_splitter = neqsim.process.equipment.splitter.Splitter(
        'injection and lift gas splitter', gasinjection_manifold.getSplitStream(0))
    gas_lift_injection_splitter.setFlowRates(
        [inp.gas_lift_rate, -1], 'MSm3/day')
    try:
        gas_lift_injection_splitter.run()
    except:
        print('error in train B gas splitter')
    export_gas_process.add(gas_lift_injection_splitter)

    gas_lift_stream = neqsim.process.equipment.stream.Stream(
        'gas lift stream', gas_lift_injection_splitter.getSplitStream(0))
    gas_lift_stream.run()
    export_gas_process.add(gas_lift_stream)
    print('gas lift stream', gas_lift_stream.getFlowRate('kg/hr'))

    gas_injection_stream = neqsim.process.equipment.stream.Stream(
        'gas injection stream', gas_lift_injection_splitter.getSplitStream(1))
    gas_injection_stream.run()
    export_gas_process.add(gas_injection_stream)
    #print('gas injection stream', gas_injection_stream.getFlowRate('kg/hr'))

    gas_lift_resycle  =  neqsim.process.equipment.util.Recycle('gas lift resycle')
    gas_lift_resycle.addStream(gas_lift_stream)
    gas_lift_resycle.setOutletStream(offshore_asset_well_feed_model.getUnit("gas lift feed"))
    gas_lift_resycle.setTolerance(1e-2)
    gas_lift_resycle.run()
    export_gas_process.add(gas_lift_resycle)

    return export_gas_process

Code cell 26: 8. Export compressor model

Notebook cell 51. This code belongs to the 8. Export compressor model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

offshore_asset_well_feed_model = create_offshore_asset_well_feed_model(input_parameters)

print('start well flow model.....')

offshore_asset_well_feed_model.run()



reference_stream_c_sep_process = reference_stream_c_calibration_stream_separation_process(

    input_parameters, offshore_asset_well_feed_model.getUnit("reference_stream_c calibration_stream manifold").getOutStream())

print('start reference_stream_c model.....')

reference_stream_c_sep_process.run()



test_sep_process = test_separation_process(

    input_parameters, offshore_asset_well_feed_model.getUnit("test manifold").getOutStream())

print('start test manifold.....')

test_sep_process.run()



if input_parameters.use_both_gas_recompression_trains_1_2_stage < 0.1:

    lp_split = 0.0001

else:

    lp_split = 0.9999



if input_parameters.use_both_gas_recompression_trains_3_stage < 0.1:

    mp_split = 0.0001

else:

    mp_split = 0.9999



separation_process_train_A = create_oil_separation_process(input_parameters, offshore_asset_well_feed_model.getUnit("HP manifold A").getOutStream(), offshore_asset_well_feed_model.getUnit(

    "LP manifold A").getOutStream(), lp_split, reference_stream_c_sep_process.getUnit("manifold").getSplitStream(0), offshore_asset_well_feed_model.getUnit("south east manifold").getSplitStream(0), test_separator=None, reference_stream_c_calibration_stream_gas=reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(1), mpsplit = mp_split)

print('start sep A process.....')

separation_process_train_A.run()



separation_process_train_B = create_oil_separation_process(input_parameters, offshore_asset_well_feed_model.getUnit("HP manifold B").getOutletStream(), offshore_asset_well_feed_model.getUnit(

    "LP manifold B").getOutletStream(), 0.9999, reference_stream_c_sep_process.getUnit("manifold").getSplitStream(1), offshore_asset_well_feed_model.getUnit("south east manifold").getSplitStream(1),  test_separator=None, reference_stream_c_calibration_stream_gas=reference_stream_c_sep_process.getUnit("gas manifold").getSplitStream(2), other_train_lp_gas_feed=separation_process_train_A.getUnit("gas splitter LP gas").getSplitStream(1),

    other_train_lp2_gas_feed=separation_process_train_A.getUnit("gas splitter LP2 gas").getSplitStream(1), other_train_mp_gas_feed=separation_process_train_A.getUnit("gas splitter MP gas").getSplitStream(1), mpsplit=0.9999)

print('start sep B process.....')

separation_process_train_B.run()



manifold_upstream_TEX = manifold_and_pipe_model_liquid_train_a_to_gas_train_b(input_parameters, separation_process_train_A.getUnit(

    "fourth Stage mixer").getOutStream(), separation_process_train_B.getUnit("fourth Stage mixer").getOutStream())

print('start manifold_upstream_TEX process.....')

manifold_upstream_TEX.run()



tex_process_1 = tex_process(input_parameters, manifold_upstream_TEX.getUnit(

    "manifold").getSplitStream(0), separation_process_train_A)

print('start tex A process.....')

tex_process_1.run()



tex_process_2 = tex_process(input_parameters, manifold_upstream_TEX.getUnit(

    "manifold").getSplitStream(1), separation_process_train_B)

print('start tex B process.....')

tex_process_2.run()



manifold_upstream_column = manifold_model(

    input_parameters, tex_process_1.getUnit("HX_MULTI_STREAM").getOutStream(2))

manifold_upstream_column.getUnit("manifold").addStream(

    tex_process_2.getUnit("HX_MULTI_STREAM").getOutStream(2))

manifold_upstream_column.getUnit("manifold").setSplitFactors([1.0])

print('start manifold_upstream_column process.....')

manifold_upstream_column.run()



column_model = ngl_column_model(input_parameters, manifold_upstream_column.getUnit(

    "manifold").getSplitStream(0), separation_process_train_A, separation_process_train_B, lp_split)

print('start column_model process.....')

column_model.run()



manifold_upstream_ht_injection_compressors = manifold_model(

    input_parameters, tex_process_1.getUnit("gas to ht compressor"))

manifold_upstream_ht_injection_compressors.getUnit("manifold").addStream(

    tex_process_2.getUnit("gas to ht compressor"))

manifold_upstream_ht_injection_compressors.getUnit("manifold").setSplitFactors([input_parameters.injection_gas_rate_ht_split_to_train_A, -1])

print('start manifold_upstream_ht_injection_compressors process.....')

manifold_upstream_ht_injection_compressors.run()



if input_parameters.injection_gas_rate_ht <= 1.0e-12:

    print('HT injection rate is zero; bypassing HT injection compressor trains for this case.')

    ht_injection_process_A = create_zero_ht_injection_process(

        input_parameters, manifold_upstream_ht_injection_compressors.getUnit("manifold").getSplitStream(0))

    ht_injection_process_A.run()

    ht_injection_process_B = create_zero_ht_injection_process(

        input_parameters, manifold_upstream_ht_injection_compressors.getUnit("manifold").getSplitStream(1))

    ht_injection_process_B.run()

else:

    ht_injection_process_A = ht_injection_compressor_model(input_parameters, manifold_upstream_ht_injection_compressors.getUnit("manifold").getSplitStream(0))

    print('start ht_injection_process_A process.....')

    ht_injection_process_A.run()



    ht_injection_process_B = ht_injection_compressor_model(input_parameters, manifold_upstream_ht_injection_compressors.getUnit("manifold").getSplitStream(1))

    print('start ht_injection_process_B process.....')

    ht_injection_process_B.run()



manifold_upstream_compressors = manifold_model(

    input_parameters, tex_process_1.getUnit("gas to dx compressor"))

manifold_upstream_compressors.getUnit("manifold").addStream(

    tex_process_2.getUnit("gas to dx compressor"))

manifold_upstream_compressors.getUnit("manifold").setSplitFactors([0.5, 0.5])

print('start manifold_upstream_compressors process.....')

manifold_upstream_compressors.run()



exp_compressor_1 = export_compressor_model(

    input_parameters, manifold_upstream_compressors.getUnit("manifold").getSplitStream(0))

print('start exp_compressor_1 process.....')

exp_compressor_1.run()

stabilize_export_compressor_outlet(exp_compressor_1)



exp_compressor_2 = export_compressor_model(

    input_parameters, manifold_upstream_compressors.getUnit("manifold").getSplitStream(1))

print('start exp_compressor_2 process.....')

exp_compressor_2.run()

stabilize_export_compressor_outlet(exp_compressor_2)



exp_gas_process = exportgasprocess(input_parameters, exp_compressor_1,exp_compressor_2, offshore_asset_well_feed_model, ht_injection_process_A, ht_injection_process_B)

print('start exp_gas_process process.....')

exp_gas_process.run()

#clear_output(wait=True)

print("Calculation finished")

Code cell 27: 8. Export compressor model

Notebook cell 52. This code belongs to the 8. Export compressor model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

try:
    print('year ', input_parameters.Year)
    print('tex in ', tex_process_1.getUnit(
        "TEX").getInletStream().getTemperature('C'), ' C')
    print('tex out ', tex_process_1.getUnit(
        "TEX").getOutletStream().getTemperature('C'), ' C')
    print('tex in ', tex_process_1.getUnit(
        "TEX").getInletStream().getPressure('bara'), ' bara')
    print('feed gas to DPC A+B  ', tex_process_1.getUnit("dew point cooler").getInletStream().getFlowRate('MSm3/day') +
        tex_process_2.getUnit("dew point cooler").getInletStream().getFlowRate('MSm3/day'), ' MSm3/day')
except:
    print('tex in ', tex_process_1.getUnit(
        "TEX").getInletStream().getTemperature('C'), ' C')

Code cell 28: 9. Oil mixing with oil from FISCAL_AREA, Condensate Area and ThirdPartyFeed

Notebook cell 54. This code belongs to the 9. Oil mixing with oil from FISCAL_AREA, Condensate Area and ThirdPartyFeed section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case- specific result folders.

def export_oil_model(inp: ProcessInput, feed_A_oil_stab, feed_B_oil_stab, condensate_area_feed, third_party_feed_feed):
    oil_export_model = neqsim.process.processmodel.ProcessSystem()

    mixer_oil = neqsim.process.equipment.mixer.Mixer("inlet oil mixer")
    mixer_oil.addStream(feed_A_oil_stab)
    mixer_oil.addStream(feed_B_oil_stab)
    try:
        mixer_oil.run()
    except:
        print('error in inlet oil mixer')
    oil_export_model.add(mixer_oil)

    fiscal_area_oil = neqsim.process.equipment.stream.Stream("fiscal_area oil export", mixer_oil.getOutStream())
    fiscal_area_oil.run()
    oil_export_model.add(fiscal_area_oil)

    stable_oil_cooler = neqsim.process.equipment.heatexchanger.Cooler(
        "stable oil cooler", fiscal_area_oil)
    stable_oil_cooler.setOutTemperature(30.0, 'C')
    stable_oil_cooler.run()
    oil_export_model.add(stable_oil_cooler)

    oil_mixer = neqsim.process.equipment.mixer.Mixer("oil mixer")
    oil_mixer.addStream(stable_oil_cooler.getOutStream())
    oil_mixer.addStream(condensate_area_feed)
    oil_mixer.addStream(third_party_feed_feed)
    oil_mixer.run()
    oil_export_model.add(oil_mixer)

    oil_pump = neqsim.process.equipment.pump.Pump(
        "oil pump", oil_mixer.getOutStream())
    oil_pump.setOutletPressure(40.0, 'bara')
    try:
        oil_pump.run()
    except:
        print('error in oil pump')
    oil_export_model.add(oil_pump)

    return oil_export_model

Code cell 29: 9. Oil mixing with oil from FISCAL_AREA, Condensate Area and ThirdPartyFeed

Notebook cell 55. This code belongs to the 9. Oil mixing with oil from FISCAL_AREA, Condensate Area and ThirdPartyFeed section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case- specific result folders.

export_model = export_oil_model(input_parameters, separation_process_train_A.getUnit("NGL mixer").getOutStream(), separation_process_train_B.getUnit(
    "NGL mixer").getOutStream(), offshore_asset_well_feed_model.getUnit("Offshore Area C Feed"), offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed"))
#export_model.run()

clear_output(wait=True)
print('total oil flow ', export_model.getUnit('oil pump').getOutletStream().getFlowRate('m3/hr'), ' m3/hr')
print("Calculation finished")

Code cell 30: 10. Offshore Area combined full process model

Notebook cell 57. This code belongs to the 10. Offshore Area combined full process model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

offshore_asset_process = neqsim.process.processmodel.ProcessModel()
offshore_asset_process.add("well process", offshore_asset_well_feed_model)
offshore_asset_process.add("reference_stream_c calibration_stream process",reference_stream_c_sep_process)
offshore_asset_process.add("test separator process",test_sep_process)
offshore_asset_process.add("sep train A", separation_process_train_A)
offshore_asset_process.add("sep train B", separation_process_train_B)
offshore_asset_process.add("manifold TEX",manifold_upstream_TEX)
offshore_asset_process.add("TEX process A", tex_process_1)
offshore_asset_process.add("TEX process B", tex_process_2)
offshore_asset_process.add("column manifold",manifold_upstream_column)
offshore_asset_process.add("NGL column", column_model)
offshore_asset_process.add("ht injection compressor manifold", manifold_upstream_ht_injection_compressors)
offshore_asset_process.add("HT injection process A", ht_injection_process_A)
offshore_asset_process.add("HT injection process B", ht_injection_process_B)
offshore_asset_process.add("export compressor manifold", manifold_upstream_compressors)
offshore_asset_process.add("Export train A", exp_compressor_1)
offshore_asset_process.add("Export train B", exp_compressor_2)
offshore_asset_process.add("export gas", exp_gas_process)
offshore_asset_process.add("export oil", export_model)

#prothread = offshore_asset_process.runAsThread()
#prothread.join(5*60*1000)
offshore_asset_process.setRunStep(True)
#Run a number of times (run in steps)

for i in range(1, 10):
    print('run ', i)
    offshore_asset_process.run()

clear_output(wait=True)
print("Calculation finished")

Code cell 31: 11.1 General reporting

Notebook cell 60. This code belongs to the 11.1 General reporting section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

try:
    print('year ', input_parameters.Year)
    print('tex in ', tex_process_1.getUnit(
        "TEX").getInletStream().getTemperature('C'), ' C')
    print('tex out ', tex_process_1.getUnit(
        "TEX").getOutletStream().getTemperature('C'), ' C')
    print('tex in ', tex_process_1.getUnit(
        "TEX").getInletStream().getPressure('bara'), ' bara')
    print('feed gas to DPC A+B  ', tex_process_1.getUnit("dew point cooler").getInletStream().getFlowRate('MSm3/day') +
        tex_process_2.getUnit("dew point cooler").getInletStream().getFlowRate('MSm3/day'), ' MSm3/day')
    print('tex out ', tex_process_1.getUnit(
        "TEX").getOutletStream().getPressure('bara'), ' bara')
    print('expander energy ', tex_process_1.getUnit("TEX").getPower('MW'), ' MW')
    print('expander compressor energy ', tex_process_1.getUnit(
        "comp_export_booster_b").getPower('MW'), ' MW')
    print('tex in hot stream ', tex_process_1.getUnit(
        "HX_MULTI_STREAM").getInStream(0).getTemperature('C'), ' C')
    print('tex in  cold stream ', tex_process_1.getUnit(
        "HX_MULTI_STREAM").getInStream(1).getTemperature('C'), ' C')
    print('tex in  cold stream ', tex_process_1.getUnit(
        "HX_MULTI_STREAM").getInStream(2).getTemperature('C'), ' C')
    print('tex out hot stram out ', tex_process_1.getUnit(
        "HX_MULTI_STREAM").getOutStream(0).getTemperature('C'), ' C')
    print('tex out cold stream 2 ', tex_process_1.getUnit(
        "HX_MULTI_STREAM").getOutStream(1).getTemperature('C'), ' C')
    print('tex out cold stream 3 ', tex_process_1.getUnit(
        "HX_MULTI_STREAM").getOutStream(2).getTemperature('C'), ' C')
    print('gas export pressure ',  exp_compressor_1.getUnit(
        "compressor EXPORT_COMPRESSOR out stream").getPressure("bara"), ' bara')
    print('gas export 1 ',  exp_compressor_1.getUnit(
        "compressor EXPORT_COMPRESSOR out stream").getFlowRate("MSm3/day"), ' MSm3/day')
    print('gas export 2 ',  exp_compressor_2.getUnit(
        "compressor EXPORT_COMPRESSOR out stream").getFlowRate("MSm3/day"), ' MSm3/day')
    print('oil temperature 1st stage train A ',  separation_process_train_B.getUnit(
        "1st stage separator").getLiquidOutStream().getTemperature("C"), ' C')
    print('oil temperature 1st stage train B ',  separation_process_train_B.getUnit(
        "1st stage separator").getLiquidOutStream().getTemperature("C"), ' C')
    print('oil temperature 2nd stage train A ',  separation_process_train_B.getUnit(
        "2nd stage separator").getLiquidOutStream().getTemperature("C"), ' C')
    print('oil temperature 2nd stage train B ',  separation_process_train_B.getUnit(
        "2nd stage separator").getLiquidOutStream().getTemperature("C"), ' C')
    print('oil temperature 3rd stage train A ',  separation_process_train_B.getUnit(
        "3rd stage separator").getLiquidOutStream().getTemperature("C"), ' C')
    print('oil temperature 3rd stage train B ',  separation_process_train_B.getUnit(
        "3rd stage separator").getLiquidOutStream().getTemperature("C"), ' C')
    print('oil temperature 4th stage train A ',  separation_process_train_B.getUnit(
        "4th stage separator").getOilOutStream().getTemperature("C"), ' C')
    print('oil temperature 4th stage train B ',  separation_process_train_B.getUnit(
        "4th stage separator").getOilOutStream().getTemperature("C"), ' C')
    print('oil rate 4th and NGL Train A ',  separation_process_train_A.getUnit(
        "NGL mixer").getOutletStream().getFlowRate("idSm3/hr"), ' Sm3/hr')
    print('oil rate 4th and NGL Train B ',  separation_process_train_B.getUnit(
        "NGL mixer").getOutletStream().getFlowRate("idSm3/hr"), ' Sm3/hr')
    print('oil temperature 1st stage ',  separation_process_train_B.getUnit(
        "1st stage separator").getOilOutStream().getTemperature("C"), ' C')
    print('oil temperature 2nd stage ',  separation_process_train_B.getUnit(
        "2nd stage separator").getLiquidOutStream().getTemperature("C"), ' C')
    print('water from 2nd stage ',  separation_process_train_B.getUnit(
        "2nd stage separator").getWaterOutStream().getFlowRate("Sm3/day"), ' Sm3/day')
    print('water from 4th stage ',  separation_process_train_B.getUnit(
        "4th stage separator").getWaterOutStream().getFlowRate("Sm3/day"), ' Sm3/day')
    print('oil from 4th stage ',  separation_process_train_B.getUnit(
        "4th stage separator").getOilOutStream().getFlowRate("idSm3/hr"), ' Sm3/hr')
    print('WI ',  exp_compressor_1.getUnit("compressor EXPORT_COMPRESSOR out stream").getWI(
        "volume", 15.0, 25.0)/1e6, ' MJ/m3')
    print('compressor power ', exp_compressor_1.getUnit(
        'EXPORT_COMPRESSOR').getPower()/1e6, ' MW')
    #print('compressor power ', exp_compressor_1.getUnit(
    #    'EXPORT_COMPRESSOR').getPower()/1e6, ' MW')
    print('ethane  ',  separation_process_train_A.getUnit("NGL mixer").getOutletStream().getFluid().getComponent('ethane').getNumberOfMolesInPhase(
    )*3600.0*separation_process_train_A.getUnit("NGL mixer").getOutletStream().getFluid().getComponent('ethane').getMolarMass(), ' kg/hr')
    print('ethane  ',  export_model.getUnit("oil pump").getOutletStream().getFluid().getComponent('ethane').getNumberOfMolesInPhase() *
        3600.0*separation_process_train_A.getUnit("NGL mixer").getOutletStream().getFluid().getComponent('ethane').getMolarMass(), ' kg/hr')
    print('Condensate Area TVP 30C ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getTVP(30.0, "C", "bara"), 'bara')
    print('Condensate Area TVP 9C ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getTVP(9.0, "C", "bara"), 'bara')
    print('Condensate Area RVP 37.8C ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getRVP(37.8, "C", "bara"), 'bara')
    print('Condensate Area RVP 37.8C (RVP_ASTM_D6377)', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara')
    print('Condensate Area RVP 37.8C (RVP_ASTM_D323_82) ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getRVP(37.8, "C", "bara", "RVP_ASTM_D323_82"), 'bara')
    print('Condensate Area RVP 37.8C (RVP_ASTM_D323_82) ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getRVP(37.8, "C", "psia", "RVP_ASTM_D323_82"), 'psia')
    print('ThirdPartyFeed TVP 30C ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getTVP(30.0, "C", "bara"), 'bara')
    print('ThirdPartyFeed TVP 9C ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getTVP(9.0, "C", "bara"), 'bara')
    print('ThirdPartyFeed RVP 37.8C (VPCR4) ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "bara", "VPCR4"), 'bara')
    print('ThirdPartyFeed RVP 37.8C (VPCR4_no_water) ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "bara", "VPCR4_no_water"), 'bara')
    print('ThirdPartyFeed RVP 37.8C (RVP_ASTM_D6377)', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara')
    print('ThirdPartyFeed RVP 37.8C (RVP_ASTM_D323_82) ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "bara", "RVP_ASTM_D323_82"), 'bara')
    print('ThirdPartyFeed RVP 37.8C (RVP_ASTM_D323_82) ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "psia", "RVP_ASTM_D323_82"), 'psia')

    print('ThirdPartyFeed rate ',  offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getFlowRate("idSm3/hr"), ' Sm3/hr')
    print('Condensate Area rate ',  offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getFlowRate("idSm3/hr"), ' Sm3/hr')

    print('flow FISCAL_AREA  ',  separation_process_train_A.getUnit(
        "NGL mixer").getOutletStream().getFlowRate("idSm3/hr"), ' Sm3/hr')
    print('density oil FISCAL_AREA  ',  separation_process_train_A.getUnit(
        "NGL mixer").getOutletStream().getFluid().getDensity("kg/m3"), ' kg/m3')
    print('temperature oil FISCAL_AREA  ',  separation_process_train_A.getUnit(
        "NGL mixer").getOutletStream().getTemperature('C'), ' C')

    print('oil rate from 4th stage train B ',  separation_process_train_B.getUnit(
        "4th stage separator").getOilOutStream().getFlowRate("idSm3/hr"), ' Sm3/hr')
    print('TVP FISCAL_AREA oil (30C) ',  separation_process_train_A.getUnit(
        "NGL mixer").getOutletStream().TVP(30.0, "C"), ' bara')
    print('TVP FISCAL_AREA oil (9C) ',  separation_process_train_A.getUnit(
        "NGL mixer").getOutletStream().TVP(9.0, "C"), ' bara')
    print('RVP FISCAL_AREA oil (37.8C) ',  separation_process_train_A.getUnit(
        "NGL mixer").getOutletStream().getRVP(37.8, "C", "bara"), ' bara')
    print('RVP FISCAL_AREA oil (37.8C) (RVP_ASTM_D6377)', separation_process_train_A.getUnit(
        "NGL mixer").getOutletStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara')

    print('TVP NGL column oil (30C) ',  column_model.getUnit(
    "NGL column").getLiquidOutStream().TVP(30.0, "C"), ' bara')
    print('TVP NGL column (9C) ',  column_model.getUnit(
    "NGL column").getLiquidOutStream().TVP(9.0, "C"), ' bara')
    print('RVP NGL column (37.8C) ',  column_model.getUnit(
    "NGL column").getLiquidOutStream().getRVP(37.8, "C", "bara"), ' bara')
    print('RVP NGL column (37.8C) (RVP_ASTM_D6377)', column_model.getUnit(
    "NGL column").getLiquidOutStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara')

    print('NGL flow ', column_model.getUnit(
    "NGL column").getLiquidOutStream().getFlowRate("idSm3/hr"), ' Sm3/hr')
    print('NGL density ', column_model.getUnit(
    "NGL column").getLiquidOutStream().getFluid().getDensity("kg/m3"), ' kg/m3')

    print('oil rate from 4th stage train A ',  separation_process_train_A.getUnit(
        "4th stage separator").getOilOutStream().getFlowRate("idSm3/hr"), ' Sm3/hr')
    print('oil rate from 4th stage train B ',  separation_process_train_B.getUnit(
        "4th stage separator").getOilOutStream().getFlowRate("idSm3/hr"), ' Sm3/hr')
    print('TVP 4th stage (30C) ',  separation_process_train_A.getUnit(
    "4th stage separator").getOilOutStream().TVP(30.0, "C"), ' bara')
    print('TVP 4th stage (9C) ',  separation_process_train_A.getUnit(
    "4th stage separator").getOilOutStream().TVP(9.0, "C"), ' bara')
    print('RVP 4th stage (37.8C) ',  separation_process_train_A.getUnit(
    "4th stage separator").getOilOutStream().getRVP(37.8, "C", "bara"), ' bara')
    print('RVP 4th stage (37.8C) (RVP_ASTM_D6377)', separation_process_train_A.getUnit(
    "4th stage separator").getOilOutStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara')
    print('oill density 4th stage ',  separation_process_train_A.getUnit(
    "4th stage separator").getOilOutStream().getFluid().getDensity('kg/m3'), ' kg/m3')

    print('TVP FISCAL_AREA export oil (9C) ',  export_model.getUnit(
    "stable oil cooler").getOutletStream().TVP(9.0, "C"), ' bara')
    print('TVP FISCAL_AREA export oil (30C) ',  export_model.getUnit(
    "stable oil cooler").getOutletStream().TVP(30.0, "C"), ' bara')
    print('RVP FISCAL_AREA export oil (37.8C) (RVP_ASTM_D6377)', export_model.getUnit(
    "stable oil cooler").getOutletStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara')

    print('TVP export oil (30C) ',  export_model.getUnit(
    "oil pump").getOutletStream().TVP(30.0, "C"), ' bara')
    print('TVP export oil (9C) ',  export_model.getUnit(
    "oil pump").getOutletStream().TVP(9.0, "C"), ' bara')
    print('RVP export oil (37.8C) ',  export_model.getUnit(
    "oil pump").getOutletStream().getRVP(37.8, "C", "bara"), ' bara')
    print('RVP export oil (37.8C) (RVP_ASTM_D6377)', export_model.getUnit(
    "oil pump").getOutletStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara')

    print('total oil flow ', export_model.getUnit(
    "oil pump").getOutletStream().getFluid().getFlowRate("m3/hr"), ' m3/hr')
    print('total oil flow ', export_model.getUnit(
    "oil pump").getOutletStream().getFluid().getFlowRate("idSm3/hr"), ' idSm3/hr')

    print('wt frac ethane in oil mix to TerminalAsset ', export_model.getUnit(
        "oil pump").getOutletStream().getFluid().getPhase('oil').getWtFrac('ethane'))
    print('wt frac ethane in FISCAL_AREA oil ', export_model.getUnit(
        "stable oil cooler").getOutletStream().getFluid().getPhase('oil').getWtFrac('ethane'))
    print('wt frac propane in oil mix to TerminalAsset ', export_model.getUnit(
        "oil pump").getOutletStream().getFluid().getPhase('oil').getWtFrac('propane'))
    print('wt frac propane in FISCAL_AREA oil ', export_model.getUnit(
        "stable oil cooler").getOutletStream().getFluid().getPhase('oil').getWtFrac('propane'))

    print()
except:
    print('error in printing results')

Code cell 32: 11.2 Heaters and coolers

Notebook cell 62. This code belongs to the 11.2 Heaters and coolers section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

print('oil heater from first stage train A ',  separation_process_train_A.getUnit(
    "oil heater second stage").getDuty()/1e6, ' MW')
print('oil heater from first stage train B ',  separation_process_train_B.getUnit(
    "oil heater second stage").getDuty()/1e6, ' MW')

print('satellite heater ',  offshore_asset_well_feed_model.getUnit(
    "satellite heater").getDuty()/1e6, ' MW')

print('total oil flow ', export_model.getUnit(
    "oil pump").getOutletStream().getFluid().getFlowRate("m3/hr"))
print('TVP export oil (30C) ',  export_model.getUnit(
    "oil pump").getOutletStream().TVP(30.0, "C"), ' bara')
print('RVP export oil (37.8C) ',  export_model.getUnit(
    "oil pump").getOutletStream().getRVP(37.8, "C", "bara"), ' bara')
print('TVP export oil (9C) ',  export_model.getUnit(
    "oil pump").getOutletStream().TVP(9.0, "C"), ' bara')
# exp_compressor_1.getUnit("EXPORT_COMPRESSOR").getOutletStream().getFluid().prettyPrint()
print('ethane  ',  export_model.getUnit("oil pump").getOutletStream().getFluid().getComponent('ethane').getNumberOfMolesInPhase() *
      3600.0*separation_process_train_A.getUnit("NGL mixer").getOutletStream().getFluid().getComponent('ethane').getMolarMass(), ' kg/hr')
# print('oil heater  1 ',  separation_process_train_B.getUnit("oil heater second stage").getOutletStream().getFlowRate("idSm3/hr"), ' Sm3/hr')

Code cell 33: 11.3 Compressors

Notebook cell 64. This code belongs to the 11.3 Compressors section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

print('year ', input_parameters.Year)
# 1st stage
separation_process_train_A.getUnit("1st stage compressor").run()
print('1st stage compressor ',  separation_process_train_A.getUnit(
    "1st stage compressor").getInletStream().getPressure('bara'), ' bar')
print('1st stage compressor ',  separation_process_train_A.getUnit(
    "1st stage compressor").getOutletStream().getPressure('bara'), ' bar')
print('1st stage compressor ',  separation_process_train_A.getUnit(
    "1st stage compressor").getPower()/1e6, ' MW')
print('1st stage compressor ',  separation_process_train_A.getUnit(
    "1st stage compressor").getInletStream().getFlowRate("m3/hr"), ' m3/hr')
print('1st stage compressor ',  separation_process_train_A.getUnit(
    "1st stage compressor").getPolytropicFluidHead(), ' kJ/kg')

print('B train')
separation_process_train_B.getUnit("1st stage compressor").run()
print('1st stage compressor ',  separation_process_train_B.getUnit(
    "1st stage compressor").getInletStream().getPressure('bara'), ' bar')
print('1st stage compressor ',  separation_process_train_B.getUnit(
    "1st stage compressor").getOutletStream().getPressure('bara'), ' bar')
print('1st stage compressor ',  separation_process_train_B.getUnit(
    "1st stage compressor").getPower()/1e6, ' MW')
print('1st stage compressor ',  separation_process_train_B.getUnit(
    "1st stage compressor").getInletStream().getFlowRate("m3/hr"), ' m3/hr')
print('1st stage compressor ',  separation_process_train_B.getUnit(
    "1st stage compressor").getPolytropicFluidHead(), ' kJ/kg')

# 2nd stage
print('2nd stage compressor ',  separation_process_train_A.getUnit(
    "2nd stage compressor").getInletStream().getPressure('bara'), ' bar')
print('2nd stage compressor ',  separation_process_train_A.getUnit(
    "2nd stage compressor").getOutletStream().getPressure('bara'), ' bar')
print('2nd stage compressor ',  separation_process_train_A.getUnit(
    "2nd stage compressor").getPower()/1e6, ' MW')
print('2nd stage compressor ',  separation_process_train_A.getUnit(
    "2nd stage compressor").getInletStream().getFlowRate("m3/hr"), ' m3/hr')
print('2nd stage compressor ',  separation_process_train_A.getUnit(
    "2nd stage compressor").getPolytropicFluidHead(), ' kJ/kg')

# 3rd stage
print('3rd stage compressor ',  separation_process_train_A.getUnit(
    "3rd stage compressor").getInletStream().getPressure('bara'), ' bar')
print('3rd stage compressor ',  separation_process_train_A.getUnit(
    "3rd stage compressor").getOutletStream().getPressure('bara'), ' bar')
print('3rd stage compressor ',  separation_process_train_A.getUnit(
    "3rd stage compressor").getPower()/1e6, ' MW')
print('3rd stage compressor ',  separation_process_train_A.getUnit(
    "3rd stage compressor").getInletStream().getFlowRate("m3/hr"), ' m3/hr')
print('3rd stage compressor ',  separation_process_train_A.getUnit(
    "3rd stage compressor").getInletStream().getFlowRate("MSm3/day"), ' MSm3/day')
print('3rd stage compressor ',  separation_process_train_A.getUnit(
    "3rd stage compressor").getPolytropicFluidHead(), ' kJ/kg')

# new comp stage
if (input_parameters.Year >= input_parameters.year_pre_compression):
    print('new pre comp stage compressor ',  separation_process_train_A.getUnit(
        "new compressor").getPower()/1e6, ' MW')
    print('new pre comp  compressor ',  separation_process_train_A.getUnit(
        "new compressor").getInletStream().getFlowRate("m3/hr"), ' m3/hr')
    print('new pre comp  compressor ',  separation_process_train_A.getUnit(
        "new compressor").getInletStream().getFlowRate("MSm3/day"), ' MSm3/day')
    print('new pre comp  compressor ',  separation_process_train_A.getUnit(
        "new compressor").getPolytropicFluidHead(), ' kJ/kg')

print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
    "comp_export_booster_b").getInletStream().getPressure("bara"), ' bara')
print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
    "comp_export_booster_b").getOutletStream().getPressure("bara"), ' bara')
print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
    "comp_export_booster_b").getPower('MW'), ' MW')
print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
    "comp_export_booster_b").getOutletStream().getFlowRate("MSm3/day"), ' MSm3/day')
print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
    "comp_export_booster_b").getOutletStream().getFlowRate("m3/hr"), ' m3/hr')
print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
    "comp_export_booster_b").getPolytropicFluidHead(), ' kJ/kg')
print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit("comp_export_booster_b").getSpeed(), ' rpm')

print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getInletStream().getPressure("bara"), ' bara')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getOutletStream().getPressure("bara"), ' bara')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit("EXPORT_COMPRESSOR").getPower('MW'), ' MW')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getOutletStream().getFlowRate("MSm3/day"), ' MSm3/day')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getOutletStream().getFlowRate("m3/hr"), ' m3/hr')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getPolytropicFluidHead(), ' kJ/kg')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit("EXPORT_COMPRESSOR").getSpeed(), ' rpm')

print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getInletStream().getPressure("bara"), ' bara')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getOutletStream().getPressure("bara"), ' bara')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit("EXPORT_COMPRESSOR").getPower('MW'), ' MW')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getOutletStream().getFlowRate("MSm3/day"), ' MSm3/day')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getOutletStream().getFlowRate("m3/hr"), ' m3/hr')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getPolytropicFluidHead(), ' kJ/kg')
print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit("EXPORT_COMPRESSOR").getSpeed(), ' rpm')

print('injection compressor INJECTION_HUB ',  exp_gas_process.getUnit(
    "injection compressor INJECTION_HUB").getInletStream().getPressure("bara"), ' bara')
print('injection compressor INJECTION_HUB ',  exp_gas_process.getUnit(
    "injection compressor INJECTION_HUB").getOutletStream().getPressure("bara"), ' bara')
print('injection compressor INJECTION_HUB ',  exp_gas_process.getUnit("injection compressor INJECTION_HUB").getPower('MW'), ' MW')
print('injection compressor INJECTION_HUB ',  exp_gas_process.getUnit(
    "injection compressor INJECTION_HUB").getOutletStream().getFlowRate("MSm3/day"), ' MSm3/day')
print('injection compressor INJECTION_HUB ',  exp_gas_process.getUnit(
    "injection compressor INJECTION_HUB").getOutletStream().getFlowRate("m3/hr"), ' m3/hr')
print('injection compressor INJECTION_HUB ',  exp_gas_process.getUnit(
    "injection compressor INJECTION_HUB").getPolytropicFluidHead(), ' kJ/kg')
print('injection compressor INJECTION_HUB ',  exp_gas_process.getUnit("injection compressor INJECTION_HUB").getSpeed(), ' rpm')


print('HT injection process A ',  ht_injection_process_A.getUnit(
    "ht 1st stage compressor").getInletStream().getPressure("bara"), ' bara')
print('HT injection process A ',  ht_injection_process_A.getUnit(
    "ht 1st stage compressor").getOutletStream().getPressure("bara"), ' bara')
print('HT injection process A ',  ht_injection_process_A.getUnit("ht 1st stage compressor").getPower('MW'), ' MW')
print('HT injection process A ',  ht_injection_process_A.getUnit(
    "ht 1st stage compressor").getOutletStream().getFlowRate("MSm3/day"), ' MSm3/day')
print('HT injection process A ',  ht_injection_process_A.getUnit(
    "ht 1st stage compressor").getOutletStream().getFlowRate("m3/hr"), ' m3/hr')
print('HT injection process A',  ht_injection_process_A.getUnit(
    "ht 1st stage compressor").getPolytropicFluidHead(), ' kJ/kg')
print('HT injection process A ',  ht_injection_process_A.getUnit("ht 1st stage compressor").getSpeed(), ' rpm')

print('HT injection process B ',  ht_injection_process_B.getUnit(
    "ht 1st stage compressor").getInletStream().getPressure("bara"), ' bara')
print('HT injection process B ',  ht_injection_process_B.getUnit(
    "ht 1st stage compressor").getOutletStream().getPressure("bara"), ' bara')
print('HT injection process B ',  ht_injection_process_B.getUnit("ht 1st stage compressor").getPower('MW'), ' MW')
print('HT injection process B ',  ht_injection_process_B.getUnit(
    "ht 1st stage compressor").getOutletStream().getFlowRate("MSm3/day"), ' MSm3/day')
print('HT injection process B ',  ht_injection_process_B.getUnit(
    "ht 1st stage compressor").getOutletStream().getFlowRate("m3/hr"), ' m3/hr')
print('HT injection process B',  ht_injection_process_B.getUnit(
    "ht 1st stage compressor").getPolytropicFluidHead(), ' kJ/kg')
print('HT injection process B ',  ht_injection_process_B.getUnit("ht 1st stage compressor").getSpeed(), ' rpm')

Code cell 34: Mass balance check

Notebook cell 66. This code belongs to the Mass balance check section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

# Corrected feedflow calculation
feedflow = (
    offshore_asset_well_feed_model.getUnit('gas lift feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('main reference_stream_b hc feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('cluster_b hc feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('cluster_a hc feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('Offshore Area East Feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('calibration_stream hc feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('Offshore Area C Feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('reference_stream_c reference_stream_b hc flow').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('ThirdPartyFeed Feed').getFlowRate('kg/hr') +
    offshore_asset_well_feed_model.getUnit('Offshore Area South Feed').getFlowRate('kg/hr') +
    separation_process_train_A.getUnit('flare gas').getFlowRate('kg/hr') +
    separation_process_train_B.getUnit('flare gas').getFlowRate('kg/hr')
)

if input_parameters.simulation_case == 'high' or input_parameters.Year <= 100:
    feedflow += (
        offshore_asset_well_feed_model.getUnit('cluster_d hc flow').getFlowRate('kg/hr') +
        offshore_asset_well_feed_model.getUnit('cluster_c hc flow').getFlowRate('kg/hr') +
        offshore_asset_well_feed_model.getUnit('reference_stream_creference_stream_a hc flow').getFlowRate('kg/hr')
    )

print('Feed flow:', feedflow)

# Corrected outletflow calculation
outletflow = (
    exp_gas_process.getUnit("export gas stream").getFlowRate("kg/hr") +
    exp_gas_process.getUnit("gas lift stream").getFlowRate("kg/hr") +
    exp_gas_process.getUnit("gas injection stream").getFlowRate("kg/hr") +
    tex_process_1.getUnit("fuel gas splitter").getSplitStream(1).getFlowRate("kg/hr") +
    tex_process_2.getUnit("fuel gas splitter").getSplitStream(1).getFlowRate("kg/hr") +
    reference_stream_c_sep_process.getUnit("CALIB_STAGE gas_injection stream").getFlowRate("kg/hr") +
    export_model.getUnit('oil pump').getOutletStream().getFlowRate('kg/hr') +
    column_model.getUnit('lpg injection stream').getFlowRate('kg/hr')
)

print('Outlet flow:', outletflow)

# Mass balance calculation
mass_balance = (feedflow - outletflow) / feedflow * 100
print('Mass balance error:', mass_balance, '%')

Code cell 35: 11.4 Write results to file

Notebook cell 69. This code belongs to the 11.4 Write results to file section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

def write_simulation_results(input_parameters,
                             tex_process_1,
                             exp_compressor_1,
                             exp_compressor_2,
                             separation_process_train_A,
                             separation_process_train_B, exp_gas_process):
    """
    Writes all simulation results to a file named "results_<year>.txt".
    """
    case = input_parameters.simulation_case
    file_name = f"{input_parameters.results_path}/results_{input_parameters.Year}_{case}.txt"

    with open(file_name, "w") as f:
        print('year ', input_parameters.Year, file=f)
        print('mass_balance ', mass_balance, ' %', file=f)
        print('feed gas to DPC A+B  ', tex_process_1.getUnit("dew point cooler").getInletStream().getFlowRate('MSm3/day') +
              tex_process_2.getUnit("dew point cooler").getInletStream().getFlowRate('MSm3/day'), ' MSm3/day', file=f)
        print('export gas  ', exp_gas_process.getUnit("export gas stream").getFlowRate('MSm3/day') , ' MSm3/day', file=f)
        print('INJECTION_HUB injection gas  ', exp_gas_process.getUnit("gas injection stream").getFlowRate('MSm3/day') , ' MSm3/day', file=f)
        print('INJECTION_HUB lift gas  ', exp_gas_process.getUnit("gas lift stream").getFlowRate('MSm3/day') , ' MSm3/day', file=f)

        print('tex in ', tex_process_1.getUnit(
            "TEX").getInletStream().getTemperature('C'), ' C', file=f)
        print('tex out ', tex_process_1.getUnit(
            "TEX").getOutletStream().getTemperature('C'), ' C', file=f)
        print('tex in ', tex_process_1.getUnit(
            "TEX").getInletStream().getPressure('bara'), ' bara', file=f)
        print('tex out ', tex_process_1.getUnit(
            "TEX").getOutletStream().getPressure('bara'), ' bara', file=f)
        print('expander energy ', tex_process_1.getUnit(
            "TEX").getPower('MW'), ' MW', file=f)
        print('expanderpolytropic efficiency ',
              input_parameters.expander_efficiency, file=f)
        print('expander compressor energy ', tex_process_1.getUnit(
            "comp_export_booster_b").getPower('MW'), ' MW', file=f)
        print('tex in hot stream ', tex_process_1.getUnit(
            "HX_MULTI_STREAM").getInStream(0).getTemperature('C'), ' C', file=f)
        print('tex in  cold stream ', tex_process_1.getUnit(
            "HX_MULTI_STREAM").getInStream(1).getTemperature('C'), ' C', file=f)
        print('tex in  cold stream ', tex_process_1.getUnit(
            "HX_MULTI_STREAM").getInStream(2).getTemperature('C'), ' C', file=f)
        print('tex out hot stram out ', tex_process_1.getUnit(
            "HX_MULTI_STREAM").getOutStream(0).getTemperature('C'), ' C', file=f)
        print('tex out cold stream 2 ', tex_process_1.getUnit(
            "HX_MULTI_STREAM").getOutStream(1).getTemperature('C'), ' C', file=f)
        print('tex out cold stream 3 ', tex_process_1.getUnit(
            "HX_MULTI_STREAM").getOutStream(2).getTemperature('C'), ' C', file=f)
        print('gas export pressure ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getOutletStream().getPressure("bara"), ' bara', file=f)
        print('gas export 1 ',  exp_compressor_1.getUnit(
            "compressor EXPORT_COMPRESSOR out stream").getFlowRate("MSm3/day"), ' MSm3/day', file=f)
        print('gas export 2 ',  exp_compressor_2.getUnit(
            "compressor EXPORT_COMPRESSOR out stream").getFlowRate("MSm3/day"), ' MSm3/day', file=f)
        print('oil temperature 4th stage train A ',  separation_process_train_B.getUnit(
            "4th stage separator").getOilOutStream().getTemperature("C"), ' C', file=f)
        print('oil temperature 4th stage train B ',  separation_process_train_B.getUnit(
            "4th stage separator").getOilOutStream().getTemperature("C"), ' C', file=f)
        print('oil rate 4th and NGL Train A ',  separation_process_train_A.getUnit(
            "NGL mixer").getOutletStream().getFlowRate("idSm3/hr"), ' Sm3/hr', file=f)
        print('oil rate 4th and NGL Train B ',  separation_process_train_B.getUnit(
            "NGL mixer").getOutletStream().getFlowRate("idSm3/hr"), ' Sm3/hr', file=f)
        print('oil temperature 1st stage ',  separation_process_train_B.getUnit(
            "1st stage separator").getOilOutStream().getTemperature("C"), ' C', file=f)
        print('oil temperature 2nd stage ',  separation_process_train_B.getUnit(
            "2nd stage separator").getLiquidOutStream().getTemperature("C"), ' C', file=f)
        print('water from 2nd stage ',  separation_process_train_B.getUnit(
            "2nd stage separator").getWaterOutStream().getFlowRate("Sm3/day"), ' Sm3/day', file=f)
        print('water from 4th stage ',  separation_process_train_B.getUnit(
            "4th stage separator").getWaterOutStream().getFlowRate("Sm3/day"), ' Sm3/day', file=f)
        print('oil from 4th stage ',  separation_process_train_B.getUnit(
            "4th stage separator").getOilOutStream().getFlowRate("idSm3/hr"), ' Sm3/hr', file=f)

        print('WI ',  exp_compressor_1.getUnit("compressor EXPORT_COMPRESSOR out stream").getWI(
            "volume", 15.0, 25.0)/1e6, ' MJ/m3', file=f)
        print('TVP (30C) ',  separation_process_train_A.getUnit(
            "NGL mixer").getOutletStream().TVP(30.0, "C"), ' bara', file=f)
        print('RVP (37.8C) ',  separation_process_train_A.getUnit(
            "NGL mixer").getOutletStream().getRVP(37.8, "C", "bara"), ' bara', file=f)
        print('TVP (9C) ',  separation_process_train_A.getUnit(
            "NGL mixer").getOutletStream().TVP(9.0, "C"), ' bara', file=f)
        print('compressor power ', exp_compressor_1.getUnit(
            'EXPORT_COMPRESSOR').getPower()/1e6, ' MW', file=f)
        print('compressor power ', exp_compressor_1.getUnit(
            'EXPORT_COMPRESSOR').getPower()/1e6, ' MW', file=f)
        print('ethane  ',  separation_process_train_A.getUnit("NGL mixer").getOutletStream().getFluid().getComponent('ethane').getNumberOfMolesInPhase(
        )*3600.0*separation_process_train_A.getUnit("NGL mixer").getOutletStream().getFluid().getComponent('ethane').getMolarMass(), ' kg/hr', file=f)

        print('oil heater from first stage train A ',  separation_process_train_A.getUnit(
            "oil heater second stage").getDuty()/1e6, ' MW', file=f)
        print('oil heater from first stage train B ',  separation_process_train_B.getUnit(
            "oil heater second stage").getDuty()/1e6, ' MW', file=f)
        print('satellite heater ',  offshore_asset_well_feed_model.getUnit(
            "satellite heater").getDuty()/1e6, ' MW', file=f)

        print('year ', input_parameters.Year, file=f)

        # 1st stage
        separation_process_train_A.getUnit("1st stage compressor").run()
        print('1st stage compressor ',  separation_process_train_A.getUnit(
            "1st stage compressor").getInletStream().getPressure('bara'), ' bar', file=f)
        print('1st stage compressor ',  separation_process_train_A.getUnit(
            "1st stage compressor").getOutletStream().getPressure('bara'), ' bar', file=f)
        print('1st stage compressor ',  separation_process_train_A.getUnit(
            "1st stage compressor").getPower()/1e6, ' MW', file=f)
        print('1st stage compressor ',  separation_process_train_A.getUnit(
            "1st stage compressor").getInletStream().getFlowRate("m3/hr"), ' m3/hr', file=f)
        print('1st stage compressor ',  separation_process_train_A.getUnit(
            "1st stage compressor").getPolytropicFluidHead(), ' kJ/kg', file=f)

        # 2nd stage
        print('2nd stage compressor ',  separation_process_train_A.getUnit(
            "2nd stage compressor").getInletStream().getPressure('bara'), ' bar', file=f)
        print('2nd stage compressor ',  separation_process_train_A.getUnit(
            "2nd stage compressor").getOutletStream().getPressure('bara'), ' bar', file=f)
        print('2nd stage compressor ',  separation_process_train_A.getUnit(
            "2nd stage compressor").getPower()/1e6, ' MW', file=f)
        print('2nd stage compressor ',  separation_process_train_A.getUnit(
            "2nd stage compressor").getInletStream().getFlowRate("m3/hr"), ' m3/hr', file=f)
        print('2nd stage compressor ',  separation_process_train_A.getUnit(
            "2nd stage compressor").getPolytropicFluidHead(), ' kJ/kg', file=f)

        # 3rd stage
        print('3rd stage compressor ',  separation_process_train_A.getUnit(
            "3rd stage compressor").getInletStream().getPressure('bara'), ' bar', file=f)
        print('3rd stage compressor ',  separation_process_train_A.getUnit(
            "3rd stage compressor").getOutletStream().getPressure('bara'), ' bar', file=f)
        print('3rd stage compressor ',  separation_process_train_A.getUnit(
            "3rd stage compressor").getPower()/1e6, ' MW', file=f)
        print('3rd stage compressor ',  separation_process_train_A.getUnit(
            "3rd stage compressor").getInletStream().getFlowRate("m3/hr"), ' m3/hr', file=f)
        print('3rd stage compressor ',  separation_process_train_A.getUnit(
            "3rd stage compressor").getInletStream().getFlowRate("MSm3/day"), ' MSm3/day', file=f)
        print('3rd stage compressor ',  separation_process_train_A.getUnit(
            "3rd stage compressor").getPolytropicFluidHead(), ' kJ/kg', file=f)

        # new comp stage
        if input_parameters.Year >= input_parameters.year_pre_compression:
            print('new pre comp stage compressor ',  separation_process_train_A.getUnit(
                "new compressor").getPower()/1e6, ' MW', file=f)
            print('new pre comp  compressor ',  separation_process_train_A.getUnit(
                "new compressor").getInletStream().getFlowRate("m3/hr"), ' m3/hr', file=f)
            print('new pre comp  compressor ',  separation_process_train_A.getUnit(
                "new compressor").getInletStream().getFlowRate("MSm3/day"), ' MSm3/day', file=f)
            print('new pre comp  compressor ',  separation_process_train_A.getUnit(
                "new compressor").getPolytropicFluidHead(), ' kJ/kg', file=f)

        print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
            "comp_export_booster_b").getInletStream().getPressure("bara"), ' bara', file=f)
        print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
            "comp_export_booster_b").getOutletStream().getPressure("bara"), ' bara', file=f)
        print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
            "comp_export_booster_b").getPower('MW'), ' MW', file=f)
        print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
            "comp_export_booster_b").getOutletStream().getFlowRate("MSm3/day"), ' MSm3/day', file=f)
        print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
            "comp_export_booster_b").getOutletStream().getFlowRate("m3/hr"), ' m3/hr', file=f)
        print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
            "comp_export_booster_b").getPolytropicFluidHead(), ' kJ/kg', file=f)
        print('EXPORT_BOOSTER_B ',  tex_process_1.getUnit(
            "comp_export_booster_b").getSpeed(), ' rpm', file=f)

        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getInletStream().getPressure("bara"), ' bara', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getOutletStream().getPressure("bara"), ' bara', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getPower('MW'), ' MW', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getOutletStream().getFlowRate("MSm3/day"), ' MSm3/day', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getOutletStream().getFlowRate("m3/hr"), ' m3/hr', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getPolytropicFluidHead(), ' kJ/kg', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getSpeed(), ' rpm', file=f)

        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getInletStream().getPressure("bara"), ' bara', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getOutletStream().getPressure("bara"), ' bara', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getPower('MW'), ' MW', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getOutletStream().getFlowRate("MSm3/day"), ' MSm3/day', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getOutletStream().getFlowRate("m3/hr"), ' m3/hr', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getPolytropicFluidHead(), ' kJ/kg', file=f)
        print('EXPORT_COMPRESSOR ',  exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getSpeed(), ' rpm', file=f)
        # Include component names and molar compositions
        print('export gas composition ', file=f)
        component_names = exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getOutletStream().getFluid().getComponentNames()
        molar_compositions = exp_compressor_1.getUnit(
            "EXPORT_COMPRESSOR").getOutletStream().getFluid().getMolarComposition()
        print('Component Names: ', component_names, file=f)
        print('Molar Compositions: ', molar_compositions, file=f)

        print('oil rate from 4th stage train A ',  separation_process_train_A.getUnit(
        "4th stage separator").getOilOutStream().getFlowRate("idSm3/hr"), ' Sm3/hr', file=f)
        print('oil rate from 4th stage train B ',  separation_process_train_B.getUnit(
        "4th stage separator").getOilOutStream().getFlowRate("idSm3/hr"), ' Sm3/hr', file=f)

        component_names = separation_process_train_A.getUnit(
        "4th stage separator").getOilOutStream().getFluid().getComponentNames()
        molar_compositions = separation_process_train_A.getUnit(
        "4th stage separator").getOilOutStream().getFluid().getMolarComposition()
        print('Oil 4th stage component Names: ', component_names, file=f)
        print('Oil 4th stage Molar Compositions: ', molar_compositions, file=f)

        print('ngl column liquid flow ', column_model.getUnit(
            "NGL column").getLiquidOutStream().getFlowRate("m3/hr"), ' m3/hr', file=f)
        component_names = column_model.getUnit(
            "NGL column").getLiquidOutStream().getFluid().getComponentNames()
        molar_compositions = column_model.getUnit(
            "NGL column").getLiquidOutStream().getFluid().getMolarComposition()
        print('Oil Component Names: ', component_names, file=f)
        print('NGL column liquid Molar Compositions: ', molar_compositions, file=f)

        component_names = separation_process_train_B.getUnit(
            "NGL mixer").getOutletStream().getFluid().getComponentNames()
        molar_compositions = separation_process_train_B.getUnit(
            "NGL mixer").getOutletStream().getFluid().getMolarComposition()
        print('Oil Component Names: ', component_names, file=f)
        print('Oil Molar Compositions: ', molar_compositions, file=f)

        component_names = tex_process_1.getUnit(
            "fuel gas splitter").getSplitStream(1).getFluid().getComponentNames()
        molar_compositions = tex_process_1.getUnit(
            "fuel gas splitter").getSplitStream(1).getFluid().getMolarComposition()
        print('Fuel Gas Component Names: ', component_names, file=f)
        print('Fuel Gas Molar Compositions: ', molar_compositions, file=f)

        print('NGL column oil flow ', column_model.getUnit(
            "NGL column").getLiquidOutStream().getFluid().getFlowRate("m3/hr"), file=f)
        print('NGL column TVP (30C) ',  column_model.getUnit(
            "NGL column").getLiquidOutStream().TVP(30.0, "C"), ' bara', file=f)
        print('NGL column RVP (37.8C) ',  column_model.getUnit("NGL column").getLiquidOutStream().getRVP(37.8, "C", "bara"), ' bara', file=f)
        print('NGL column TVP (9C) ',  column_model.getUnit( "NGL column").getLiquidOutStream().TVP(9.0, "C"), ' bara', file=f)
        print('NGL column oil RVP 37.8C (RVP_ASTM_D6377)', column_model.getUnit( "NGL column").getLiquidOutStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara', file=f)
        print('NGL column oil RVP 37.8C (RVP_ASTM_D323_82) ', column_model.getUnit( "NGL column").getLiquidOutStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D323_82"), 'bara', file=f)
        print('NGL column oil RVP 37.8C (RVP_ASTM_D323_82) ', column_model.getUnit( "NGL column").getLiquidOutStream().getRVP(37.8, "C", "psia", "RVP_ASTM_D323_82"), 'psia', file=f)


        print('total oil flow ', export_model.getUnit(
            "oil pump").getOutletStream().getFluid().getFlowRate("m3/hr"), file=f)
        print('TVP (30C) ',  export_model.getUnit(
            "oil pump").getOutletStream().TVP(30.0, "C"), ' bara', file=f)
        print('RVP (37.8C) ',  export_model.getUnit("oil pump").getOutletStream().getRVP(37.8, "C", "bara"), ' bara', file=f)
        print('TVP (9C) ',  export_model.getUnit( "oil pump").getOutletStream().TVP(9.0, "C"), ' bara', file=f)
        print('export oil RVP 37.8C (RVP_ASTM_D6377)', export_model.getUnit( "oil pump").getOutletStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara', file=f)
        print('export oil RVP 37.8C (RVP_ASTM_D323_82) ', export_model.getUnit( "oil pump").getOutletStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D323_82"), 'bara', file=f)
        print('export oil RVP 37.8C (RVP_ASTM_D323_82) ', export_model.getUnit( "oil pump").getOutletStream().getRVP(37.8, "C", "psia", "RVP_ASTM_D323_82"), 'psia', file=f)

        print('ethane  ',  export_model.getUnit("oil pump").getOutletStream().getFluid().getComponent('ethane').getNumberOfMolesInPhase() *
              3600.0*separation_process_train_A.getUnit("NGL mixer").getOutletStream().getFluid().getComponent('ethane').getMolarMass(), ' kg/hr', file=f)

        print('Condensate Area TVP 30C ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getTVP(30.0, "C", "bara"), 'bara', file=f)
        print('Condensate Area TVP 9C ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getTVP(9.0, "C", "bara"), 'bara', file=f)
        print('Condensate Area RVP 37.8C ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getRVP(37.8, "C", "bara"), 'bara', file=f)
        print('Condensate Area RVP 37.8C (RVP_ASTM_D6377)', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara', file=f)
        print('Condensate Area RVP 37.8C (RVP_ASTM_D323_82) ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getRVP(37.8, "C", "bara", "RVP_ASTM_D323_82"), 'bara', file=f)
        print('Condensate Area RVP 37.8C (RVP_ASTM_D323_82) ', offshore_asset_well_feed_model.getUnit("Offshore Area C Feed").getRVP(37.8, "C", "psia", "RVP_ASTM_D323_82"), 'psia', file=f)

        print('ThirdPartyFeed TVP 30C ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getTVP(30.0, "C", "bara"), 'bara', file=f)
        print('ThirdPartyFeed TVP 9C ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getTVP(9.0, "C", "bara"), 'bara', file=f)
        print('ThirdPartyFeed RVP 37.8C (VPCR4) ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "bara", "VPCR4"), 'bara', file=f)
        print('ThirdPartyFeed RVP 37.8C (VPCR4_no_water) ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "bara", "VPCR4_no_water"), 'bara', file=f)
        print('ThirdPartyFeed RVP 37.8C (RVP_ASTM_D6377)', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "bara", "RVP_ASTM_D6377"), 'bara', file=f)
        print('ThirdPartyFeed RVP 37.8C (RVP_ASTM_D323_82) ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "bara", "RVP_ASTM_D323_82"), 'bara', file=f)
        print('ThirdPartyFeed RVP 37.8C (RVP_ASTM_D323_82) ', offshore_asset_well_feed_model.getUnit("ThirdPartyFeed Feed").getRVP(37.8, "C", "psia", "RVP_ASTM_D323_82"), 'psia', file=f)

    print(f"Results have been written to {file_name}.")


# Example usage
# Assuming the objects input_parameters, tex_process_1, etc. exist:
write_simulation_results(
    input_parameters, tex_process_1, exp_compressor_1, exp_compressor_2,
    separation_process_train_A, separation_process_train_B, exp_gas_process
)

Code cell 36: 11.4.2 Print to results/result_case.txt

Notebook cell 71. This code belongs to the 11.4.2 Print to results/result_case.txt section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

import os


def write_simulation_results(input_parameters,
                             tex_process_1,
                             tex_process_2,
                             exp_compressor_1,
                             exp_compressor_2,
                             separation_process_train_A,
                             separation_process_train_B, exp_gas_process):
    """
    Writes simulation results to a case-specific file, overwriting entries by year.
    """
    year = input_parameters.Year
    case = input_parameters.simulation_case
    file_path = f"{input_parameters.results_path}/results_{case}.txt"

    # Ensure results directory exists
    os.makedirs(os.path.dirname(file_path), exist_ok=True)

    # Read existing results
    results = {}
    header = "year oil_export oil_export_4th_stage gas_export lpg_export lpg_injected TVP9_OFC TVP30_OFC RVP37s_OFC rvp37terminal_asset tvp30terminal_asset tvp9terminal_asset WI N2 CO2 C1 C2 C3 iC4 nC4 iC5 nC5 CCB massbalance rich_gas_bypass rich_gas_bypass_pressure rich_gas_bypass_temperature"
    if os.path.exists(file_path):
        with open(file_path, "r", encoding="utf-8", errors="replace") as f:
            lines = f.readlines()
            if lines:
                header = lines[0].strip()
                for line in lines[1:]:
                    parts = line.strip().split()
                    if len(parts) >= 2:
                        try:
                            result_year = int(parts[0])
                            results[result_year] = line.strip()
                        except ValueError:
                            continue  # Skip malformed lines

    # Compute new results
    oil_export = (
        separation_process_train_A.getUnit("NGL mixer").getOutStream().getFlowRate('idSm3/hr') +
        separation_process_train_B.getUnit(
            "NGL mixer").getOutStream().getFlowRate('idSm3/hr')
    )

        # Compute new results
    oil_export_4th_stage = (
        separation_process_train_A.getUnit("4th stage oil pump").getOutStream().getFlowRate('idSm3/hr') +
        separation_process_train_B.getUnit("4th stage oil pump").getOutStream().getFlowRate('idSm3/hr')
    )
    lpg_export = (
        column_model.getUnit(
            "lpg production stream").getFlowRate('idSm3/hr')
    )
    lpg_injected = (
        column_model.getUnit(
            "lpg injection stream").getFlowRate('idSm3/hr')
    )
    rich_gas_bypass = tex_process_1.getUnit('gas to dx compressor').getFlowRate('MSm3/day') + tex_process_2.getUnit('gas to dx compressor').getFlowRate('MSm3/day')
    gas_export = exp_gas_process.getUnit("export gas stream").getFlowRate('MSm3/day')

    rich_gas_bypass_pressure = tex_process_1.getUnit("rich gas splitter").getSplitStream(1).getPressure('bara')
    rich_gas_bypass_temperature = tex_process_1.getUnit("rich gas splitter").getSplitStream(1).getTemperature('C')

    tvp9 = (
        separation_process_train_A.getUnit(
            "NGL mixer").getOutletStream().TVP(9.0, "C")
    )

    tvp30 = (
        separation_process_train_A.getUnit(
            "NGL mixer").getOutletStream().TVP(30.0, "C")
    )

    rvp37 = (
        separation_process_train_A.getUnit(
            "NGL mixer").getOutletStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D6377")
    )

    rvp37oilmix = export_model.getUnit( "oil pump").getOutletStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D6377")

    tvp30oilmix = export_model.getUnit( "oil pump").getOutletStream().TVP(30.0, "C")

    tvp9oilmix = export_model.getUnit( "oil pump").getOutletStream().TVP(9.0, "C")

    wi = (
        exp_gas_process.getUnit("export gas stream").getWI(
            "volume", 15.0, 25.0)/1e6
    )

    component_names = exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getOutletStream().getFluid().getComponentNames()
    molar_compositions = exp_compressor_1.getUnit(
    "EXPORT_COMPRESSOR").getOutletStream().getFluid().getMolarComposition()

    ccb_value = exp_gas_process.getUnit("export gas stream").CCB('bara')

    new_result_line = f"{year} {oil_export:.2f} {oil_export_4th_stage:.2f} {lpg_export:.2f} {lpg_injected:.2f} {gas_export:.2f} {tvp9:.2f} {tvp30:.2f} {rvp37:.2f} {rvp37oilmix:.2f} {tvp30oilmix:.2f} {tvp9oilmix:.2f} {wi:.4f} {molar_compositions[0]:.4f} {molar_compositions[1]:.4f} {molar_compositions[2]:.4f} {molar_compositions[3]:.4f} {molar_compositions[4]:.4f} {molar_compositions[5]:.4f} {molar_compositions[6]:.4f} {molar_compositions[7]:.4f} {molar_compositions[8]:.4f}  {ccb_value:.4f} {mass_balance:.4f}  {rich_gas_bypass:.2f} {rich_gas_bypass_pressure:.2f} {rich_gas_bypass_temperature:.2f}"

    results[year] = new_result_line

    # Write updated results sorted by year
    with open(file_path, "w", encoding="utf-8") as f:
        f.write(header + "\n")
        for result_year in sorted(results):
            f.write(results[result_year] + "\n")

    print(
        f"Results have been successfully written to {file_path} for year {year}.")


write_simulation_results(
    input_parameters, tex_process_1, tex_process_2, exp_compressor_1, exp_compressor_2,
    separation_process_train_A, separation_process_train_B, exp_gas_process)

Code cell 37: 12. Oil pipeline to TerminalAsset

Notebook cell 73. This code belongs to the 12. Oil pipeline to TerminalAsset section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

def pipeline(inp: ProcessInput, feed_stream):
    pipeline_process = neqsim.process.processmodel.ProcessSystem()

    pipe = neqsim.process.equipment.pipeline.PipeBeggsAndBrills(
        'OS transport', feed_stream)
    pipe.setDiameter(inp.offshore_asset_transport_diameter)
    pipe.setPipeWallRoughness(50.0e-6)
    pipe.setLength(inp.offshore_asset_transport_length)
    pipe.setElevation(0.0)
    #pipe.setConstantSurfaceTemperature(9.0, "C")
    #pipe.setHeatTransferCoefficient(10.0)
    #pipe.setNumberOfIncrements(10)
    #pipe.setRunIsothermal(False)
    try:
        pipe.run()
    except:
        print("Error in pipeline calculation")

    pipeline_process.add(pipe)

    return pipeline_process

Code cell 38: 12.1 Test the OST pipeline model

Notebook cell 75. This code belongs to the 12.1 Test the OST pipeline model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

#%%script false --no-raise-error uncomment if model should be saved to file
export_pipe = pipeline(input_parameters, export_model.getUnit(
    "oil pump").getOutletStream())

try:
    export_pipe.run()
    export_pipe.getUnit("OS transport").getOutStream(
    ).getFluid().getFlowRate("m3/hr")
    print('TerminalAsset arrival pressure ', export_pipe.getUnit(
    "OS transport").getOutStream().getPressure("bara"), ' bara')
    print('TerminalAsset arrival temperature ', export_pipe.getUnit(
    "OS transport").getOutStream().getTemperature("C"), ' C')
    print('oil velocity ', export_pipe.getUnit(
    "OS transport").getOutletSuperficialVelocity(), ' m/sec')
    export_pipe.getUnit("OS transport").getOutStream().getFluid().prettyPrint()
except:
    print('error in pipeline')

#print('transport time ', input_parameters.offshore_asset_transport_length/export_pipe.getUnit(
#    "OS transport").getOutletSuperficialVelocity()/3600/24, 'days')

print('reynolds number ', export_pipe.getUnit(
    "OS transport").getMixtureReynoldsNumber()[-1], ' - ')

print('viscosity  ', export_pipe.getUnit(
    "OS transport").getOutletStream().getFluid().getViscosity('kg/msec'), ' - ')

print('density  ', export_pipe.getUnit(
    "OS transport").getOutletStream().getFluid().getDensity('kg/m3'), ' - ')

print('flow ', export_pipe.getUnit(
    "OS transport").getOutletStream().getFlowRate('m3/hr'), ' m3/hr')

print('flow ', export_pipe.getUnit(
    "OS transport").getOutletStream().getFlowRate('kg/hr'), ' kg/hr')


#re = export_pipe.getUnit(
#    "OS transport").getOutletSuperficialVelocity()*input_parameters.offshore_asset_transport_diameter*export_pipe.getUnit(
#    "OS transport").getOutletStream().getFluid().getDensity('kg/m3')/export_pipe.getUnit(
#    "OS transport").getOutletStream().getFluid().getViscosity('kg/msec')

#print('reynolds number ', re, ' - ')
#print('diameter ', input_parameters.offshore_asset_transport_diameter)

Code cell 39: 13. TerminalAsset process model

Notebook cell 77. This code belongs to the 13. TerminalAsset process model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

from dataclasses import dataclass, field
from typing import List

@dataclass
class TerminalAssetProcessInput:
    year: int = 2025  # Year of the simulation
    cavern_temperature: float = 9.0  # Temperature in the cavern (°C)
    water_wash_rate: float = 1.0  # Water wash rate (m3/hr)
    cavern_pressure: float = 3.0  # Pressure in the cavern (bara)
    heated_oil_separator_pressure: float = 3.0  # Heated oil separator pressure (bara)
    heated_oil_separator_temperature: float = 100.0  # Heated oil separator temperature (°C)
    compressor_pressure: float = 13.0  # Compressor pressure (bara)
    condenser_temperature: float = 35.0  # Condenser temperature (°C)
    de_ethanizer_pressure: float = 14.8  # De-ethanizer pressure (bara)
    de_ethanizer_reboiler_temperature: float = 70.0  # De-ethanizer reboiler temperature (°C)
    de_ethanizer_gas_cooler_temperature: float = 35.0  # De-ethanizer gas cooler temperature (°C)
    de_butanizer_pressure: float = 8.4  # De-butanizer pressure (bara)
    de_butanizer_reboiler_temperature: float = 130.0  # De-butanizer reboiler temperature (°C)
    de_butanizer_reflux_ratio: float = 0.5  # De-butanizer reflux ratio
    naphta_rate_to_de_ethanizer_reflux: float = 100.0  # Naphta rate to de-ethanizer reflux (kg/hr)
    naphta_product_split: float = 0.5  # Naphta product split ratio
    pump_unstable_oil_pressure: float = 9.5  # Pump unstable oil pressure (bara)
    lpg_to_naphta_split: float = 0.5  # LPG to Naphta split ratio

input_terminal_asset = TerminalAssetProcessInput()

Code cell 40: 13. TerminalAsset process model

Notebook cell 78. This code belongs to the 13. TerminalAsset process model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

#%%script false --no-raise-error uncomment if model should be saved to file
import pandas as pd

def update_terminal_asset_input_from_excel(file_path: str, year: int, input_terminal_asset: TerminalAssetProcessInput):
    """
    Update the input_terminal_asset object with data from a given year in an Excel sheet.

    Parameters:
    - file_path (str): Path to the Excel file.
    - year (int): The year for which data should be extracted.
    - input_terminal_asset (TerminalAssetProcessInput): The object to update.
    """
    try:
        # Read the Excel file
        df = pd.read_excel(file_path, sheet_name=0, header=0)

        # Filter the data for the given year
        row = df.loc[df['Year'] == year]
        if row.empty:
            raise ValueError(f"No data found for year {year} in {file_path}.")

        # Update the input_terminal_asset object with values from the row
        row = row.iloc[0]  # Get the first matching row
        input_terminal_asset.cavern_temperature = row['cavern_temperature']
        input_terminal_asset.cavern_pressure = row['cavern_pressure']
        input_terminal_asset.pump_unstable_oil_pressure = row['pump_unstable_oil_pressure']
        input_terminal_asset.water_wash_rate = row['water_wash_rate']
        input_terminal_asset.heated_oil_separator_temperature = row['heated_oil_separator_temperature']
        input_terminal_asset.heated_oil_separator_temperature = row['heated_oil_separator_temperature']
        input_terminal_asset.compressor_pressure = row['compressor_pressure']
        input_terminal_asset.condenser_temperature = row['condenser_temperature']
        input_terminal_asset.de_ethanizer_pressure = row['de_ethanizer_pressure']
        input_terminal_asset.de_ethanizer_reboiler_temperature = row['de_ethanizer_reboiler_temperature']
        input_terminal_asset.de_ethanizer_gas_cooler_temperature = row['de_ethanizer_gas_cooler_temperature']
        input_terminal_asset.de_butanizer_pressure = row['de_butanizer_pressure']
        input_terminal_asset.de_butanizer_reboiler_temperature = row['de_butanizer_reboiler_temperature']
        input_terminal_asset.de_butanizer_reflux_ratio = row['de_butanizer_reflux_ratio']
        input_terminal_asset.naphta_rate_to_de_ethanizer_reflux = row['naphta_rate_to_de_ethanizer_reflux']
        input_terminal_asset.naphta_product_split = row['naphta_product_split']
        input_terminal_asset.lpg_to_naphta_split = row['lpg_to_naphta_split']

        print(f"TerminalAsset input updated for year {year}.")
    except Exception as e:
        print(f"Error updating TerminalAsset input: {e}")

file_path = "./parameters_terminal_asset.xlsx"

update_terminal_asset_input_from_excel(file_path, input_parameters.Year, input_terminal_asset)

Code cell 41: 13. TerminalAsset process model

Notebook cell 79. This code belongs to the 13. TerminalAsset process model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

def get_terminal_asset_process(inp: TerminalAssetProcessInput, terminal_asset_oil_feed):
    terminal_assetprocess = neqsim.process.processmodel.ProcessSystem()
    """
    The method creates the TerminalAsset SCUP process model using neqsim
    """
    cavernfeed = neqsim.process.equipment.heatexchanger.Heater(
        "oil cavern feed", terminal_asset_oil_feed)
    cavernfeed.setOutTemperature(inp.cavern_temperature, 'C')
    cavernfeed.setOutPressure(inp.cavern_pressure, 'bara')
    cavernfeed.run()
    terminal_assetprocess.add(cavernfeed)

    oil_cavern = neqsim.process.equipment.separator.ThreePhaseSeparator(
        "oil cavern", cavernfeed.getOutStream())
    oil_cavern.run()
    terminal_assetprocess.add(oil_cavern)

    oil_pump = neqsim.process.equipment.pump.Pump(
        "oil pump", oil_cavern.getOilOutStream())
    oil_pump.setOutletPressure(inp.pump_unstable_oil_pressure, 'bara')
    oil_pump.run()
    terminal_assetprocess.add(oil_pump)

    water_wash_stream = create_water_stream('water wash stream')
    water_wash_stream.setFlowRate(inp.water_wash_rate*1000.0, 'kg/hr')
    water_wash_stream.setTemperature(inp.cavern_temperature, 'C')
    water_wash_stream.setPressure(inp.pump_unstable_oil_pressure, 'bara')
    water_wash_stream.run()
    terminal_assetprocess.add(water_wash_stream)

    oil_water_mixer = neqsim.process.equipment.mixer.Mixer(
        "oil water mixer")
    oil_water_mixer.addStream(oil_pump.getOutStream())
    oil_water_mixer.addStream(water_wash_stream)
    oil_water_mixer.run()
    terminal_assetprocess.add(oil_water_mixer)

    gasrecyl = create_stream('res 0')
    gasrecyl.setFlowRate(20000.0, 'kg/hr')
    gasrecyl.setTemperature(inp.heated_oil_separator_temperature, 'C')
    gasrecyl.setPressure(inp.heated_oil_separator_pressure, 'bara')
    gasrecyl.run()
    terminal_assetprocess.add(gasrecyl)

    inlet_TP_setter = neqsim.process.equipment.heatexchanger.Heater(
    "gas valve dp and cooling", gasrecyl.getOutletStream())
    inlet_TP_setter.setOutTemperature(inp.heated_oil_separator_temperature-5.0, 'C')
    inlet_TP_setter.run()
    terminal_assetprocess.add(inlet_TP_setter)

    hx1 = neqsim.process.equipment.heatexchanger.HeatExchanger(
        "1st oil heater", oil_water_mixer.getOutletStream())
    hx1.setFeedStream(1, inlet_TP_setter.getOutletStream())
    hx1.setGuessOutTemperature(273.15 + 35.0)
    hx1.setUAvalue(300000.2)
    try:
        hx1.run()
    except:
        print('error in 1st oil heater')
    terminal_assetprocess.add(hx1)

    oilrecyl = create_stream('res 1')
    oilrecyl.setFlowRate(terminal_asset_oil_feed.getFlowRate('kg/hr')*0.9, 'kg/hr')
    oilrecyl.setTemperature(inp.heated_oil_separator_temperature, 'C')
    oilrecyl.setPressure(inp.heated_oil_separator_pressure, 'bara')
    oilrecyl.run()
    terminal_assetprocess.add(oilrecyl)

    hx2 = neqsim.process.equipment.heatexchanger.HeatExchanger(
        "2nd oil heater", hx1.getOutStream(0))
    hx2.setFeedStream(1, oilrecyl.getOutletStream())
    hx2.setGuessOutTemperature(273.15 + 75.0)
    hx2.setUAvalue(1100000.0)
    try:
        hx2.run()
    except:
        print('error in 2nd oil heater')
    terminal_assetprocess.add(hx2)

    oilvalve = neqsim.process.equipment.valve.ThrottlingValve(
        'oil valve', hx2.getOutStream(0))
    oilvalve.setOutletPressure(inp.heated_oil_separator_pressure, 'bara')
    oilvalve.run()
    terminal_assetprocess.add(oilvalve)

    hotoil_heater = neqsim.process.equipment.heatexchanger.Heater(
        "hot oil heater", oilvalve.getOutStream())
    hotoil_heater.setOutTemperature(inp.heated_oil_separator_temperature, 'C')
    hotoil_heater.run()
    terminal_assetprocess.add(hotoil_heater)

    stabilized_oil_separator = neqsim.process.equipment.separator.ThreePhaseSeparator(
        "heated oil separator", hotoil_heater.getOutStream())
    try:
        stabilized_oil_separator.run()
    except:
        print('error in heated oil separator')
    terminal_assetprocess.add(stabilized_oil_separator)

    gas_resycle = neqsim.process.equipment.util.Recycle("gas resycle")
    gas_resycle.addStream(stabilized_oil_separator.getGasOutStream())
    gas_resycle.setOutletStream(gasrecyl)
    gas_resycle.setTolerance(1e-2)
    gas_resycle.run()
    terminal_assetprocess.add(gas_resycle)

    oil_resycle = neqsim.process.equipment.util.Recycle("oil resycle")
    oil_resycle.addStream(stabilized_oil_separator.getOilOutStream())
    oil_resycle.setOutletStream(oilrecyl)
    oil_resycle.setTolerance(1e-2)
    oil_resycle.run()
    terminal_assetprocess.add(oil_resycle)

    separato1 = neqsim.process.equipment.separator.ThreePhaseSeparator(
        "sep1 cavernsep", hx1.getOutStream(1))
    separato1.run()
    terminal_assetprocess.add(separato1)

    pump1 = neqsim.process.equipment.pump.Pump(
        "pump1", separato1.getOilOutStream())
    pump1.setOutletPressure(inp.compressor_pressure, 'bara')
    try:
        pump1.run()
    except:
        print('error in pump1 run')
    terminal_assetprocess.add(pump1)

    compressor_gas_to_gas_colummn = neqsim.process.equipment.compressor.Compressor(
        "compressor gas to gas column", separato1.getGasOutStream())
    compressor_gas_to_gas_colummn.setUsePolytropicCalc(True)
    compressor_gas_to_gas_colummn.setPolytropicEfficiency(0.8)
    compressor_gas_to_gas_colummn.setOutletPressure(inp.compressor_pressure, 'bara')
    try:
        compressor_gas_to_gas_colummn.run()
    except:
        print('error in compressor gas to gas column')
    terminal_assetprocess.add(compressor_gas_to_gas_colummn)

    mixer = neqsim.process.equipment.mixer.Mixer(
        'mixer gas to gas column')
    mixer.addStream(compressor_gas_to_gas_colummn.getOutStream())
    mixer.addStream(pump1.getOutStream())
    mixer.run()
    terminal_assetprocess.add(mixer)

    feed_to_fuel_gas_column_bublepoint =  neqsim.process.equipment.stream.Stream('gas to fuel condesation stream', mixer.getOutStream())
    feed_to_fuel_gas_column_bublepoint.setSpecification("bubP");
    feed_to_fuel_gas_column_bublepoint.run()
    terminal_assetprocess.add(feed_to_fuel_gas_column_bublepoint)

    cooler_1 = neqsim.process.equipment.heatexchanger.Cooler('cooler 1', mixer.getOutStream())
    cooler_1.setOutTemperature(inp.condenser_temperature, 'C')
    cooler_1.run()
    terminal_assetprocess.add(cooler_1)

    feed_to_fuel_gas_column =  neqsim.process.equipment.stream.Stream('stream to fuel gas column', feed_to_fuel_gas_column_bublepoint)
    #feed_to_fuel_gas_column =  neqsim.process.equipment.stream.Stream('stream to fuel gas column', cooler_1.getOutStream())
    feed_to_fuel_gas_column.run()
    terminal_assetprocess.add(feed_to_fuel_gas_column)

    separato2 = neqsim.process.equipment.separator.ThreePhaseSeparator(
    "sep1 gas fule", feed_to_fuel_gas_column)
    separato2.run()
    terminal_assetprocess.add(separato2)

    extra_gas_to_fuel = neqsim.process.equipment.stream.Stream(
    'extra gas to fuel', separato2.getGasOutStream())
    extra_gas_to_fuel.run()
    terminal_assetprocess.add(extra_gas_to_fuel)

    pump2 = neqsim.process.equipment.pump.Pump(
    "feed pump 2", separato2.getOilOutStream())
    pump2.setOutletPressure(inp.de_ethanizer_pressure, 'bara')
    pump2.run()
    terminal_assetprocess.add(pump2)

    water_dehydration = neqsim.process.equipment.splitter.ComponentSplitter(
    "molsieve dehydration", pump2.getOutStream())
    complen = pump2.getOutStream().getFluid().getNumberOfComponents()
    water_dehydration.setSplitFactors([1.0] * (complen - 1) + [0.0])
    try:
        water_dehydration.run()
    except:
        print('error in water dehydration')
    terminal_assetprocess.add(water_dehydration)

    feedHeater = neqsim.process.equipment.heatexchanger.Heater("deethanizer feed heater", water_dehydration.getSplitStream(0))
    feedHeater.setdT(0.0)
    feedHeater.run()
    terminal_assetprocess.add(feedHeater)

    tempfluid = feedHeater.getOutStream().getFluid().clone()
    tempfluid.setMolarComposition([1.1269232486923688e-06, 0.002642638817095049, 0.015237623814512286,
        0.09479920295855006, 0.2664367133684378, 0.072638890369372, 0.18433074090670493,
        0.05893425834431258, 0.07525119431180687, 0.07925100506320992, 0.0814576540555948,
        0.04665775189490658, 0.01708982141273816, 0.004685723238493833, 5.666335741724731e-06,
        2.608641697723448e-12, 0.0])

    lqiuidrefluc = neqsim.process.equipment.stream.Stream("recycle", tempfluid.clone())
    lqiuidrefluc.setFlowRate(20000.0, "kg/hr")
    lqiuidrefluc.setTemperature(30.0, "C")
    lqiuidrefluc.setPressure(inp.de_ethanizer_pressure, "bara")
    lqiuidrefluc.run()
    terminal_assetprocess.add(lqiuidrefluc)

    deethanizer = neqsim.process.equipment.distillation.DistillationColumn(
        'de ethanizer column', 7, True, False)
    deethanizer.addFeedStream(feedHeater.getOutletStream(), 3)
    deethanizer.addFeedStream(lqiuidrefluc, 7)
    deethanizer.getReboiler().setOutTemperature(273.15 + float(inp.de_ethanizer_reboiler_temperature))
    deethanizer.setTopPressure(inp.de_ethanizer_pressure)
    deethanizer.setBottomPressure(inp.de_ethanizer_pressure)
    deethanizer.run()
    terminal_assetprocess.add(deethanizer)

    naphta_recyl = neqsim.process.equipment.stream.Stream('recycle napht',tempfluid.clone())
    naphta_recyl.setFlowRate(8000.0, 'kg/hr')
    naphta_recyl.setTemperature(30.0, 'C')
    naphta_recyl.setPressure(inp.de_ethanizer_pressure, 'bara')
    naphta_recyl.run()
    terminal_assetprocess.add(naphta_recyl)

    gasfrom_deethanizer_mixer = neqsim.process.equipment.mixer.Mixer(
        'gas from deethanizer mixer')
    gasfrom_deethanizer_mixer.addStream(deethanizer.getGasOutStream())
    gasfrom_deethanizer_mixer.addStream(naphta_recyl)
    gasfrom_deethanizer_mixer.run()
    terminal_assetprocess.add(gasfrom_deethanizer_mixer)

    gasfrom_deethanizer_cooler = neqsim.process.equipment.heatexchanger.Cooler(
        'gas from deethanizer cooler', gasfrom_deethanizer_mixer.getOutStream())
    gasfrom_deethanizer_cooler.setOutTemperature(inp.de_ethanizer_gas_cooler_temperature, 'C')
    gasfrom_deethanizer_cooler.run()
    terminal_assetprocess.add(gasfrom_deethanizer_cooler)

    deethanizer_separator = neqsim.process.equipment.separator.Separator(
        'deethanizer gas separator', gasfrom_deethanizer_cooler.getOutStream())
    deethanizer_separator.run()
    terminal_assetprocess.add(deethanizer_separator)

    gasfrom_deethanizer_separator = neqsim.process.equipment.stream.Stream(
        'gas from deethanizer separator', deethanizer_separator.getGasOutStream())
    gasfrom_deethanizer_separator.run()
    terminal_assetprocess.add(gasfrom_deethanizer_separator)

    liquid_from_deethanizer_separator = neqsim.process.equipment.stream.Stream(
        'liquid from deethanizer separator', deethanizer_separator.getLiquidOutStream())
    liquid_from_deethanizer_separator.run()
    terminal_assetprocess.add(liquid_from_deethanizer_separator)

    liquid_from_deethanizer = neqsim.process.equipment.stream.Stream(
        'liquid from deethanizer', deethanizer.getLiquidOutStream())
    liquid_from_deethanizer.run()
    terminal_assetprocess.add(liquid_from_deethanizer)

    deethanizerRecycle = neqsim.process.equipment.util.Recycle("ethane liquid to deethanizer recycle")
    deethanizerRecycle.addStream(liquid_from_deethanizer_separator)
    deethanizerRecycle.setOutletStream(lqiuidrefluc)
    deethanizerRecycle.setTolerance(1e-2)
    deethanizerRecycle.run()
    terminal_assetprocess.add(deethanizerRecycle)

    valve_debutanizer = neqsim.process.equipment.valve.ThrottlingValve(
        'debutanizer valve', liquid_from_deethanizer)
    valve_debutanizer.setOutletPressure(inp.de_butanizer_pressure, 'bara')
    valve_debutanizer.run()
    terminal_assetprocess.add(valve_debutanizer)

    #heater_debutanizer = neqsim.process.equipment.heatexchanger.Heater('heater debutanizer', valve_debutanizer.getOutStream())
    #heater_debutanizer.setOutTemperature(73.0, 'C')
    #heater_debutanizer.run()
    #terminal_assetprocess.add(heater_debutanizer)

    oilrecyhx = create_stream('res oil resycl')
    oilrecyhx.setFlowRate(200.0, 'kg/hr')
    oilrecyhx.setTemperature(125.0, 'C')
    oilrecyhx.setPressure(inp.de_butanizer_pressure, 'bara')
    oilrecyhx.run()
    terminal_assetprocess.add(oilrecyhx)

    hx22 = neqsim.process.equipment.heatexchanger.HeatExchanger(
        "2nd oil heater debut", valve_debutanizer.getOutStream())
    hx22.setFeedStream(1, oilrecyhx.getOutletStream())
    hx22.setGuessOutTemperature(273.15 + 50.0)
    hx22.setUAvalue(1100000.0)
    try:
        hx22.run()
    except:
        print('error in 2nd oil heater')
    terminal_assetprocess.add(hx22)

    debutanizer = neqsim.process.equipment.distillation.DistillationColumn(
        'de butanizer column', 4, True, True)
    debutanizer.addFeedStream(hx22.getOutStream(0), 1)
    debutanizer.getReboiler().setOutTemperature(273.15 + inp.de_butanizer_reboiler_temperature)
    debutanizer.getCondenser().setRefluxRatio(inp.de_butanizer_reflux_ratio)
    debutanizer.getCondenser().setTotalCondenser(True)
    debutanizer.setTopPressure(inp.de_butanizer_pressure)
    debutanizer.setBottomPressure(inp.de_butanizer_pressure)
    debutanizer.setSolverType(neqsim.process.equipment.distillation.DistillationColumn.SolverType.DAMPED_SUBSTITUTION)
    try:
        debutanizer.run()
    except:
        print('error in debutanizer')
    terminal_assetprocess.add(debutanizer)

    liquid_from_debutanizer = neqsim.process.equipment.stream.Stream(
        'liquid from butinizer', debutanizer.getLiquidOutStream())
    liquid_from_debutanizer.run()
    terminal_assetprocess.add(liquid_from_debutanizer)

    liquid_from_debutanizer_recycle = neqsim.process.equipment.util.Recycle(
        'liquid_from_debutanizer recycle')
    liquid_from_debutanizer_recycle.addStream(liquid_from_debutanizer)
    liquid_from_debutanizer_recycle.setOutletStream(oilrecyhx)
    liquid_from_debutanizer_recycle.setTolerance(1e-2)
    liquid_from_debutanizer_recycle.run()
    terminal_assetprocess.add(liquid_from_debutanizer_recycle)

    naptha_liquid_to_deethanizer_pump = neqsim.process.equipment.pump.Pump(
        'naphta liquid to deethanizer pump', hx22.getOutStream(1))
    naptha_liquid_to_deethanizer_pump.setOutletPressure(inp.de_ethanizer_pressure, 'bara')
    naptha_liquid_to_deethanizer_pump.run()
    terminal_assetprocess.add(naptha_liquid_to_deethanizer_pump)

    naptha_liquid_to_deethanizer_cooler = neqsim.process.equipment.heatexchanger.Cooler(
        'naphta liquid to deethanizer cooler', naptha_liquid_to_deethanizer_pump.getOutStream())
    naptha_liquid_to_deethanizer_cooler.setOutTemperature(273.15 + 40.0)
    naptha_liquid_to_deethanizer_cooler.run()
    terminal_assetprocess.add(naptha_liquid_to_deethanizer_cooler)

    naphta_liquid_splitter = neqsim.process.equipment.splitter.Splitter(
        'butane liquid splitter', naptha_liquid_to_deethanizer_cooler.getOutStream())
    naphta_liquid_splitter.setFlowRates([-1, inp.naphta_rate_to_de_ethanizer_reflux], 'kg/hr')
    #naphta_liquid_splitter.setFlowRates([-1, pump2.getOutStream().getFlowRate('kg/hr')*0.1470636], 'kg/hr')
    #print('naphta rate to deethanizer reflux ', feedHeater.getOutStream().getFlowRate('kg/hr')*0.1470636, ' kg/hr')
    #naphta_liquid_splitter.setSplitF([0.8, 0.2])
    try:
        naphta_liquid_splitter.run()
    except:
        print('error in butane liquid splitter')
    terminal_assetprocess.add(naphta_liquid_splitter)

    naphta_liquid_product = neqsim.process.equipment.stream.Stream(
        'naphta liquid product', naphta_liquid_splitter.getSplitStream(0))
    naphta_liquid_product.run()
    terminal_assetprocess.add(naphta_liquid_product)

    naptha_liquid_to_deethanizer = neqsim.process.equipment.stream.Stream(
        'naphta liquid to deethanizer', naphta_liquid_splitter.getSplitStream(1))
    naptha_liquid_to_deethanizer.run()
    terminal_assetprocess.add(naptha_liquid_to_deethanizer)

    naptha_liquid_to_deethanizer_recycle = neqsim.process.equipment.util.Recycle(
        'naphta liquid to deethanizer recycle')
    naptha_liquid_to_deethanizer_recycle.addStream(naptha_liquid_to_deethanizer)
    naptha_liquid_to_deethanizer_recycle.setOutletStream(naphta_recyl)
    naptha_liquid_to_deethanizer_recycle.setTolerance(1e-2)
    naptha_liquid_to_deethanizer_recycle.run()
    terminal_assetprocess.add(naptha_liquid_to_deethanizer_recycle)

    gas_for_fuel_mixer = neqsim.process.equipment.mixer.Mixer(
        'mixer gas for fuel gas column')
    gas_for_fuel_mixer.addStream(gasfrom_deethanizer_separator)
    #gas_for_fuel_mixer.addStream(extra_gas_to_fuel)
    gas_for_fuel_mixer.run()
    terminal_assetprocess.add(gas_for_fuel_mixer)

    gas_for_fuel = neqsim.process.equipment.stream.Stream(
        'gas for fuel', gas_for_fuel_mixer.getOutStream())
    gas_for_fuel.run()
    terminal_assetprocess.add(gas_for_fuel)

    #air = neqsim.thermo.system.SystemSrkEos(298.15, 20.0)
    #air.addComponent("nitrogen", 79.0)
    #air.addComponent("oxygen", 21.0)

    #airstream = neqsim.process.equipment.stream.Stream("air stream", air)
    #airstream.setTemperature(15.0, "C")
    #airstream.setPressure(1.0, "bara")
    #airstream.setFlowRate(5000.0, "kg/hr")
    #airstream.run()
    #terminal_assetprocess.add(airstream)

    #flare_burner = neqsim.process.equipment.reactor.FurnaceBurner(
    #    "terminal_asset burner")
    #flare_burner.setFuelInlet(gas_for_fuel)
    #flare_burner.setAirInlet(airstream)
    #flare_burner.setExcessAirFraction(0.4)
    #flare_burner.run()
    #terminal_assetprocess.add(flare_burner)

    lpg_stream = neqsim.process.equipment.stream.Stream(
        'lpg stream', debutanizer.getGasOutStream())
    lpg_stream.run()
    terminal_assetprocess.add(lpg_stream)

    lpg_product_splitter = neqsim.process.equipment.splitter.Splitter(
        'lpg product splitter', lpg_stream)
    lpg_product_splitter.setSplitFactors([inp.lpg_to_naphta_split, 1.0-inp.lpg_to_naphta_split])
    try:
        lpg_product_splitter.run()
    except:
        print('error in lpg_product_splitter')
    terminal_assetprocess.add(lpg_product_splitter)

    lpg_stream_storage = neqsim.process.equipment.stream.Stream(
        'lpg stream to lpg storage', lpg_product_splitter.getSplitStream(1))
    lpg_stream_storage.run()
    terminal_assetprocess.add(lpg_stream_storage)

    naphta_product_splitter = neqsim.process.equipment.splitter.Splitter(
        'butane product splitter', naphta_liquid_product)
    naphta_product_splitter.setSplitFactors([inp.naphta_product_split,1-inp.naphta_product_split])
    try:
        naphta_product_splitter.run()
    except:
        print('error in naphta_product_splitter')
    terminal_assetprocess.add(naphta_product_splitter)

    naptha_vestProcess_mixer = neqsim.process.equipment.mixer.Mixer(
        'naphta to vestprocess mixer')
    naptha_vestProcess_mixer.addStream(lpg_product_splitter.getSplitStream(0))
    naptha_vestProcess_mixer.addStream(naphta_product_splitter.getSplitStream(0))
    naptha_vestProcess_mixer.run()
    terminal_assetprocess.add(naptha_vestProcess_mixer)

    naphta_product_vest_process = neqsim.process.equipment.stream.Stream(
        'naphta product to vestprocess', naptha_vestProcess_mixer.getOutStream())
    naphta_product_vest_process.run()
    terminal_assetprocess.add(naphta_product_vest_process)

    naphta_product_to_oil = neqsim.process.equipment.stream.Stream(
        'naphta product to oil', naphta_product_splitter.getSplitStream(1))
    naphta_product_to_oil.run()
    terminal_assetprocess.add(naphta_product_to_oil)

    oil_to_cavern_mixer = neqsim.process.equipment.mixer.Mixer(
        'oil to cavern mixer')
    oil_to_cavern_mixer.addStream(hx2.getOutStream(1))
    oil_to_cavern_mixer.addStream(naphta_product_to_oil)
    oil_to_cavern_mixer.run()
    terminal_assetprocess.add(oil_to_cavern_mixer)

    water_removal_oil_to_cavern  = neqsim.process.equipment.splitter.ComponentSplitter(
    "dehydration oil to cavern", oil_to_cavern_mixer.getOutStream())
    complen = oil_to_cavern_mixer.getOutStream().getFluid().getNumberOfComponents()
    water_removal_oil_to_cavern.setSplitFactors([1.0] * (complen - 1) + [0.0])
    try:
        water_removal_oil_to_cavern.run()
    except:
        print('error in water dehydration of oil')
    terminal_assetprocess.add(water_removal_oil_to_cavern)

    oil_to_cavern_stream = neqsim.process.equipment.stream.Stream(
        'oil to cavern stream', water_removal_oil_to_cavern.getSplitStream(0))
    oil_to_cavern_stream.run()
    terminal_assetprocess.add(oil_to_cavern_stream)


    return terminal_assetprocess

Code cell 42: 13. TerminalAsset process model

Notebook cell 81. This code belongs to the 13. TerminalAsset process model section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

#%%script false --no-raise-error uncomment if model should be saved to file
input_terminal_asset.de_ethanizer_pressure = 13.8
input_terminal_asset.naphta_rate_to_de_ethanizer_reflux = 9000.0
input_terminal_asset.de_ethanizer_gas_cooler_temperature = 30
input_terminal_asset.de_butanizer_reboiler_temperature = 125
input_terminal_asset.de_butanizer_reflux_ratio = 0.2
input_terminal_asset.de_butanizer_pressure = 8.4
input_terminal_asset.heated_oil_separator_temperature = 98
terminal_asset = get_terminal_asset_process(
    input_terminal_asset, export_pipe.getUnit("OS transport").getOutStream())
try:
    for i in range(10):
        terminal_asset.run_step()
except:
    print('error in terminal_asset run')
clear_output(wait=True)
print("Calculation finished")

totalPower = terminal_asset.getUnit("hot oil heater").getDuty()+ terminal_asset.getUnit("de ethanizer column").getReboiler().getDuty() + terminal_asset.getUnit("de butanizer column").getReboiler().getDuty()
totalFuelPower = terminal_asset.getUnit("gas for fuel").LCV()*terminal_asset.getUnit("gas for fuel").getFlowRate("Sm3/sec")*0.8

error = totalFuelPower - totalPower

print('hot oil heater duty (W): ', terminal_asset.getUnit("hot oil heater").getDuty()/1e6)
print('deethanizer reboiler duty (W): ', terminal_asset.getUnit("de ethanizer column").getReboiler().getDuty()/1e6)
print('debutanizer reboiler duty (W): ', terminal_asset.getUnit("de butanizer column").getReboiler().getDuty()/1e6)

print('Total power needed (W): ', totalPower/1e6)
print('Total fuel power (W): ', totalFuelPower/1e6)
print('Energy balance (W): ', error/1e6)

Code cell 43: 14. Report TerminalAsset process results

Notebook cell 83. This code belongs to the 14. Report TerminalAsset process results section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

#emissions = terminal_asset.getUnit("terminal_asset burner").getEmissionRatesKgPerHr()
#print('emissions terminal_asset stack ', emissions)
totalPower = terminal_asset.getUnit("hot oil heater").getDuty()+ terminal_asset.getUnit("de ethanizer column").getReboiler().getDuty() + terminal_asset.getUnit("de butanizer column").getReboiler().getDuty()
totalFuelPower = terminal_asset.getUnit("gas for fuel").LCV()*terminal_asset.getUnit("gas for fuel").getFlowRate("Sm3/sec")
temperaturegasforfuel = terminal_asset.getUnit("gas for fuel").getTemperature('C')
print('temperature gas for fuel ', temperaturegasforfuel, ' C')
print('total power consumption ', totalPower/1e6, ' MW')
print('total fuel power ', totalFuelPower/1e6, ' MW')
#print(terminal_asset.getUnit("feed pump 2").getFluid().getMolarComposition())
print(terminal_asset.getUnit("2nd oil heater").getOutStream(0).getFlowRate('m3/hr'))
print(terminal_asset.getUnit("feed pump 2").getOutStream().getFlowRate('kg/hr'))
print(terminal_asset.getUnit("hot oil heater").getDuty('MW'), ' MW')
print(terminal_asset.getUnit("de ethanizer column").getReboiler().getDuty()/1e6, ' MW')
print(terminal_asset.getUnit("de butanizer column").getReboiler().getDuty()/1e6, ' MW')
print('fuel ', terminal_asset.getUnit("gas for fuel").getFlowRate("Sm3/hr"), ' Sm3/hr')
print('fuel ', terminal_asset.getUnit("gas for fuel").LCV()*terminal_asset.getUnit("gas for fuel").getFlowRate("Sm3/sec")/1e6, ' MW')

print('fuel gas composition ', terminal_asset.getUnit("gas for fuel").getFluid().getMolarComposition())
print('fuel gas composition wt ', terminal_asset.getUnit("gas for fuel").getFluid().getPhase(0).getComposition('wtfraction'))
print('lpg composition wt ', terminal_asset.getUnit("lpg stream").getFluid().getPhase(0).getComposition('wtfraction'))
print('lpg density ', terminal_asset.getUnit("lpg stream").getFluid().getPhase(0).getDensity('kg/m3'))
print('naphta composition wt ', terminal_asset.getUnit("naphta product to vestprocess").getFluid().getPhase(0).getComposition('wtfraction'))
print('naphta density ', terminal_asset.getUnit("naphta liquid product").getFluid().getPhase(0).getDensity('kg/m3'))
print('naphta flow  ', terminal_asset.getUnit("naphta liquid product").getFluid().getFlowRate('idSm3/hr') , ' Sm3/hr')
print('flow rate ', terminal_asset.getUnit("gas from deethanizer separator").getFlowRate('kg/hr'), ' kg/hr')
print('density vest process', terminal_asset.getUnit("naphta product to vestprocess").getFluid().getPhase(0).getDensity('kg/m3'))
print('flow vest process ', terminal_asset.getUnit("naphta product to vestprocess").getFluid().getFlowRate('idSm3/hr') , ' Sm3/hr')
print('naphta product to oil ', terminal_asset.getUnit("naphta product to oil").getFluid().getFlowRate('idSm3/hr') , ' Sm3/hr')
print('feed to fuel gas column ', terminal_asset.getUnit("deethanizer feed heater").getOutletStream().getFlowRate('idSm3/hr') , ' Sm3/hr')
#printFrame(terminal_asset.getUnit("molsieve dehydration").getSplitStream(0).getFluid())
print(terminal_asset.getUnit("molsieve dehydration").getSplitStream(0).getFluid().getMolarComposition())
terminal_asset.getUnit("molsieve dehydration").getSplitStream(0).setTemperature(60.0,'C')
terminal_asset.getUnit("molsieve dehydration").getSplitStream(0).run()
#printFrame(terminal_asset.getUnit("molsieve dehydration").getSplitStream(0).getFluid())

print('feed to fuel gas column ', terminal_asset.getUnit("deethanizer feed heater").getOutletStream().getFlowRate('kg/sec') , ' kg/sec')
print('naphta product to oil ', terminal_asset.getUnit("naphta product to oil").getFluid().getFlowRate('kg/sec') , ' kg/sec')
print('fuel gas ', terminal_asset.getUnit("gas for fuel").getFlowRate("kg/sec"), ' kg/sec')
print('flow vest process ', terminal_asset.getUnit("naphta product to vestprocess").getFluid().getFlowRate('kg/sec') , ' kg/sec')
print('flow lpg storage ', terminal_asset.getUnit("lpg stream to lpg storage").getFluid().getFlowRate('kg/sec') , ' kg/sec')

Code cell 44: 14. Report TerminalAsset process results

Notebook cell 84. This code belongs to the 14. Report TerminalAsset process results section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

#%%script false --no-raise-error uncomment if model should be saved to file
print('year ', input_parameters.Year)

print()

print('total oil to TerminalAsset ', export_model.getUnit(
    "oil pump").getOutletStream().getFlowRate("m3/hr"), ' m3/hr')

print()
print('TerminalAsset results')
print('cavern pressure TVP 9) ', export_model.getUnit(
    "oil pump").getOutStream().getTVP(9.0, 'C', 'bara'), ' bara')
print('tvp feed oil ', export_model.getUnit(
    "oil pump").getOutStream().getTVP(30.0, 'C', 'bara'), ' bara')
print('rvp feed oil ', export_model.getUnit(
    "oil pump").getOutStream().getRVP(37.8, "C", "bara", "RVP_ASTM_D323_82"), 'bara')
print('tvp stable oil (30C) ', terminal_asset.getUnit(
    "2nd oil heater").getOutStream(1).getTVP(30.0, 'C', 'bara'), ' bara')
print('tvp stable oil (9C) ', terminal_asset.getUnit(
    "2nd oil heater").getOutStream(1).getTVP(9.0, 'C', 'bara'), ' bara')
print('1st oil heater out temperature ', terminal_asset.getUnit(
    "1st oil heater").getOutStream(0).getTemperature('C'), ' C')
print('1st oil heater gas out temperature ', terminal_asset.getUnit(
    "1st oil heater").getOutStream(1).getTemperature('C'), ' C')

print('gas heat loss  ', terminal_asset.getUnit(
    "gas valve dp and cooling").getDuty()/1e6, ' MW')



print('heat balance heated/cooled error ', terminal_asset.getUnit(
    "1st oil heater").getHotColdDutyBalance()-1, ' [-]')
print('2nd oil heater out temperature ', terminal_asset.getUnit(
    "2nd oil heater").getOutStream(0).getTemperature('C'), ' C')
print('2nd oil heater out temperature cooled oil ', terminal_asset.getUnit(
    "2nd oil heater").getOutStream(1).getTemperature('C'), ' C')
print('tvp stable oil ', terminal_asset.getUnit("2nd oil heater").getOutStream(
    1).getTVP(30.0, 'C', 'bara'), ' bara')
print('gas from de-ethanizer ', terminal_asset.getUnit('de ethanizer column').getGasOutStream().getFlowRate('kg/hr'), ' kg/hr')
print('energy in gas from de-ethanizer ', terminal_asset.getUnit('gas for fuel').getFlowRate('MSm3/day') * terminal_asset.getUnit('gas for fuel').getGCV("volume", 15.0, 25.0)/3600.0/24, ' MW')
print('ethane in gas from de-ethanizer ', terminal_asset.getUnit('de ethanizer column').getGasOutStream().getFluid().getComponent('ethane').getz()*100, ' mol%')

print('de ethanizer top temperature ', terminal_asset.getUnit('de ethanizer column').getTray(2).getTemperature() - 273.15, 'C')
print('inlet hot oil heater temperature ', terminal_asset.getUnit('hot oil heater').getInletStream().getTemperature('C'), ' C')
print('hot oil heater duty ', terminal_asset.getUnit('hot oil heater').getDuty()/1e6, ' MW')
print('de ethanizer duty ', terminal_asset.getUnit('de ethanizer column').getReboiler().getDuty()/1e6, 'MW')
print('de butanizer duty ', terminal_asset.getUnit('de butanizer column').getReboiler().getDuty()/1e6, 'MW')
print('de butanizer top temperature ', terminal_asset.getUnit('de butanizer column').getCondenser().getGasOutStream().getTemperature('C'), 'C')

print('propane in gas from de-ethanizer ', terminal_asset.getUnit('de ethanizer column').getGasOutStream().getFluid().getComponent('propane').getz()*100, ' mol%')
print('gas from de-butanizer ', terminal_asset.getUnit('de butanizer column').getGasOutStream().getFlowRate('kg/hr'), ' kg/hr')
print('liquid from de-butanizer ', terminal_asset.getUnit('de butanizer column').getLiquidOutStream().getFlowRate('kg/hr'), ' kg/hr')
print('temperature in condenser ', terminal_asset.getUnit('stream to fuel gas column').getTemperature('C'), ' C')

print('gas for fuels ', terminal_asset.getUnit('gas for fuel').getFlowRate('kg/hr'), ' kg/hr')

print('lpg to vestprosess ', terminal_asset.getUnit('lpg stream').getFlowRate('kg/hr'), ' kg/hr')

print('naphtpa to vestprosess ', terminal_asset.getUnit('naphta product to vestprocess').getFlowRate('kg/hr'), ' kg/hr')
print('naphtpa to oil ', terminal_asset.getUnit('naphta product to oil').getFlowRate('kg/hr'), ' kg/hr')
print('oil to cavern ', terminal_asset.getUnit('oil to cavern stream').getFlowRate('kg/hr'), ' kg/hr')

print('total oil to TerminalAsset ', export_model.getUnit(
    "oil pump").getOutletStream().getFlowRate("kg/hr"), ' kg/hr')

mass_balance = (export_model.getUnit(
    "oil pump").getOutletStream().getFlowRate("kg/hr") - terminal_asset.getUnit('oil to cavern stream').getFlowRate('kg/hr') - terminal_asset.getUnit('naphta product to vestprocess').getFlowRate('kg/hr') - terminal_asset.getUnit('gas for fuel').getFlowRate('kg/hr')
    - terminal_asset.getUnit('oil cavern').getWaterOutStream().getFlowRate('kg/hr')-terminal_asset.getUnit("lpg stream to lpg storage").getFluid().getFlowRate('kg/hr')

    )/export_model.getUnit(
    "oil pump").getOutletStream().getFlowRate("kg/hr")*100
print('mass balance ', mass_balance, ' %')


print('to ethane column ', terminal_asset.getUnit(
    "feed pump 2").getOutletStream().getFlowRate("kg/hr"), ' kg/hr')
print('total oil to TerminalAsset ', terminal_asset.getUnit(
    "feed pump 2").getOutletStream().getFlowRate("kg/hr"), ' kg/hr')

print('to ethane column ', terminal_asset.getUnit(
    "liquid from butinizer").getFlowRate("kg/hr"), ' kg/hr')


print('condensing temperature ', terminal_asset.getUnit('gas to fuel condesation stream').getTemperature('C'), ' C')

from neqsim.thermo import printFrame
#printFrame(terminal_asset.getUnit(
#    "heater debutanizer").getOutStream().getFluid())
# MSm3/day * MJ/Sm3 = MJ/day/3600/24 = MW

# evne tilå få kondensert blandingen (trykk og temperatur som kreves for å få kondensert blandingen)
# Varmebehov (20 MW - 10 5 MW)
# Lave trykk som kompressor kan)
# neste ikke fritt vann i olje

Code cell 45: 15. Save model to file

Notebook cell 86. This code belongs to the 15. Save model to file section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

#%%script false --no-raise-error uncomment if model should be saved to file

offshore_asset_terminal_asset_process = neqsim.process.processmodel.ProcessModel()
offshore_asset_terminal_asset_process.add("well process", offshore_asset_well_feed_model)
offshore_asset_terminal_asset_process.add("reference_stream_c calibration_stream process",reference_stream_c_sep_process)
offshore_asset_terminal_asset_process.add("test separator process",test_sep_process)
offshore_asset_terminal_asset_process.add("sep train A", separation_process_train_A)
offshore_asset_terminal_asset_process.add("sep train B", separation_process_train_B)
offshore_asset_terminal_asset_process.add("manifold TEX",manifold_upstream_TEX)
offshore_asset_terminal_asset_process.add("TEX process A", tex_process_1)
offshore_asset_terminal_asset_process.add("TEX process B", tex_process_2)
offshore_asset_terminal_asset_process.add("ht 3rd stage compressor manifold", manifold_upstream_ht_injection_compressors)
offshore_asset_terminal_asset_process.add("HT injection process A", ht_injection_process_A)
offshore_asset_terminal_asset_process.add("HT injection process B", ht_injection_process_B)
offshore_asset_terminal_asset_process.add("column manifold",manifold_upstream_column)
offshore_asset_terminal_asset_process.add("NGL column", column_model)
offshore_asset_terminal_asset_process.add("export compressor manifold", manifold_upstream_compressors)
offshore_asset_terminal_asset_process.add("Export train A", exp_compressor_1)
offshore_asset_terminal_asset_process.add("Export train B", exp_compressor_2)
offshore_asset_terminal_asset_process.add("export gas", exp_gas_process)
offshore_asset_terminal_asset_process.add("export oil", export_model)
offshore_asset_terminal_asset_process.add("export pipeline", export_pipe)
offshore_asset_terminal_asset_process.add("terminal_asset", terminal_asset)
offshore_asset_terminal_asset_process.setRunStep(True)

Code cell 46: 15. Save model to file

Notebook cell 87. This code belongs to the 15. Save model to file section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

#%%script false --no-raise-error uncomment if model should be saved to file
offshore_asset_terminal_asset_process.get("TEX process A").getUnit("feed stream turbo expander").run()
offshore_asset_terminal_asset_process.get("TEX process A").getUnit("feed stream turbo expander").getFluid().prettyPrint()
print('mass flow ', offshore_asset_terminal_asset_process.get("TEX process A").getUnit("feed stream turbo expander").getFlowRate('kg/hr'), ' kg/hr')
print('mass flow ', offshore_asset_terminal_asset_process.get("TEX process A").getUnit("TurboExpanderCompressor").getCompressorFeedStream().getFlowRate('kg/hr'), ' kg/hr')
print('expander out temperature ',offshore_asset_terminal_asset_process.get("TEX process A").getUnit("TurboExpanderCompressor").getExpanderOutletStream().getTemperature('C'), ' C')
print('compressor out pressure ',offshore_asset_terminal_asset_process.get("TEX process A").getUnit("TurboExpanderCompressor").getCompressorOutletStream().getPressure('bara'), ' bara')
print('expander power ',offshore_asset_terminal_asset_process.get("TEX process A").getUnit("TurboExpanderCompressor").getPowerExpander()/1e6, ' MW')
print('expander isentropic efficiency ',offshore_asset_terminal_asset_process.get("TEX process A").getUnit("TurboExpanderCompressor").getExpanderIsentropicEfficiency(), ' -')
print('compressor polytropic efficiency ',offshore_asset_terminal_asset_process.get("TEX process A").getUnit("TurboExpanderCompressor").getCompressorPolytropicEfficiency(), ' -')

Code cell 47: 15. Save model to file

Notebook cell 89. This code belongs to the 15. Save model to file section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

#%%script false --no-raise-error uncomment if model should be saved to file
offshore_asset_terminal_asset_process.get('sep train A').getUnit('1st stage separator').setTagName('V-GEN-101A')
offshore_asset_terminal_asset_process.get('sep train B').getUnit('1st stage separator').setTagName('V-GEN-101B')

offshore_asset_terminal_asset_process.get('sep train A').getUnit('2nd stage separator').setTagName('V-GEN-102A')
offshore_asset_terminal_asset_process.get('sep train B').getUnit('2nd stage separator').setTagName('V-GEN-102B')

offshore_asset_terminal_asset_process.get('sep train A').getUnit('3rd stage separator').setTagName('V-GEN-103A')
offshore_asset_terminal_asset_process.get('sep train B').getUnit('3rd stage separator').setTagName('V-GEN-103B')

offshore_asset_terminal_asset_process.get('sep train A').getUnit('4th stage separator').setTagName('V-GEN-104A')
offshore_asset_terminal_asset_process.get('sep train B').getUnit('3rd stage separator').setTagName('V-GEN-104B')

Code cell 48: 15. Save model to file

Notebook cell 90. This code belongs to the 15. Save model to file section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid- characterization files, and case-specific result folders.

#%%script false --no-raise-error uncomment if model should be saved to file

from neqsim import save_neqsim, save_xml
from neqsim.process import results_json

year = input_parameters.Year
case = input_parameters.simulation_case

file_path = f"{results_path}/neqsim_model_{case}_{year}.neqsim"
save_neqsim(offshore_asset_terminal_asset_process, file_path)

output_file_path = f"{input_parameters.results_path}/neqsim_model_{case}_{year}.json"

try:
    output_offshore_asset_process = results_json(offshore_asset_terminal_asset_process, output_file_path)
except:
    print('error in offshore_asset process json export')

print(f"\nOutput saved to {input_parameters.results_path}")

Code cell 49: Mass Balance Check for Unit Operations

Notebook cell 92. This code belongs to the Mass Balance Check for Unit Operations section and is included to preserve the full model implementation. It is intentionally not executed during book builds because the full model requires the project input workbook, fluid-characterization files, and case-specific result folders.

# Mass balance check for all init operations in offshore_asset_process
print("=" * 80)
print("MASS BALANCE CHECK FOR INIT OPERATIONS")
print("=" * 80)

# Check mass balance for each process module
# Returns: Map<String, Map<String, ProcessSystem.MassBalanceResult>>
# Structure: {process_name: {unit_name: MassBalanceResult}}
all_mass_balance_results = offshore_asset_terminal_asset_process.checkMassBalance("kg/hr")

# Display results for each process
total_units = 0
total_failed = 0

for process_name, unit_results in all_mass_balance_results.items():
    print(f"\n{process_name}:")
    print("-" * 80)

    if not unit_results:
        print("  No unit operations found")
        continue

    failed_count = 0
    for unit_name, result in unit_results.items():
        total_units += 1
        abs_error = result.getAbsoluteError()
        percent_error = result.getPercentError()

        # Check if unit failed (>0.1% error)
        if abs(percent_error) > 0.1:
            failed_count += 1
            total_failed += 1
            status = "✗"
        else:
            status = "✓"

        print(f"  {status} {unit_name}: {abs_error:.6f} {result.getUnit()} ({percent_error:.4f}%)")

    if failed_count > 0:
        print(f"  → {failed_count} unit(s) failed in this process")

# Check for failed units across all processes
print("\n" + "=" * 80)
print("FAILED MASS BALANCE UNITS (>0.1% error)")
print("=" * 80)

failed_results = offshore_asset_process.getFailedMassBalance("kg/hr", 0.1)

if not failed_results:
    print("\n✓ All processes and units passed mass balance check!")
else:
    print(f"\n✗ Found {total_failed} unit(s) with mass balance errors:\n")
    for process_name, failed_units in failed_results.items():
        print(f"\n  Process: {process_name}")
        for unit_name, result in failed_units.items():
            print(f"    - {unit_name}:")
            print(f"      Absolute Error: {result.getAbsoluteError():.6f} {result.getUnit()}")
            print(f"      Percent Error: {result.getPercentError():.4f}%")

print("\n" + "=" * 80)
print(f"SUMMARY: {total_units} total units checked, {total_failed} failed")
print("=" * 80)

Capstone Portfolio and Self-Assessment

The best way to finish this book is to package one reproducible study. It can be small: a separator train, compressor case, pipeline check, PVT report, dynamic example, or optimization study. What matters is that the work is complete enough for another engineer to rerun and review.

Minimum Portfolio

A complete portfolio contains eight artifacts:

1. Problem statement. One page describing the engineering question, operating envelope, assumptions, and acceptance criteria.
2. Fluid definition. Components, EOS, mixing rule, plus-fraction or electrolyte choices, and at least one reference or sanity check.
3. Runnable notebook. A notebook that builds the case from inputs and runs without private files or hidden local state.
4. Validation evidence. Mass balance, unit checks, convergence status, and a comparison against a benchmark, simple estimate, plant value, or published result.
5. Figures and tables. At least two figures or tables with units and short interpretation paragraphs.
6. Machine-readable output. A results.json file or equivalent dictionary containing key results, validation flags, assumptions, and figure captions.
7. Saved model state. A .neqsim archive, lifecycle-state JSON, or another reproducible state file.
8. Decision memo. A short conclusion that states what you would do next and what evidence would change the decision.

Quality Rubric

Aim for Practitioner on your first pass. Aim for Lead engineer when the study will be shared, reused, or used for a design or operating decision.

Capstone Project Ideas

1. Gas export compressor screening. Vary inlet flow and discharge pressure, calculate power and discharge temperature, identify the feasible envelope, and export the selected case.
2. Compressor map and anti-surge envelope. Attach generated or vendor curves, vary flow and speed, report surge margin, stonewall margin, driver margin, and the minimum recycle needed for turndown.
3. Three-stage separation study. Vary separator pressures, track oil, gas, water, and compression power, and recommend a pressure set with mass-balance evidence.
4. Distillation column diagnostic study. Build a deethanizer or debutanizer, compare solvers, log residuals, add a product specification, and produce a tray-temperature and product-composition report.
5. PVT characterization report. Build a characterized fluid, run CME or CVD calculations, compare against reference data, and explain deviations.
6. TEG dehydration sensitivity. Vary lean glycol circulation or contactor conditions, calculate water content or dew point, and produce a design table.
7. Dynamic control example. Add a measurement device and controller to a simple process, run a transient disturbance, and interpret the response.
8. Parallel scenario batch. Build independent process cases, run them using managed runAsTask() execution, collect a scenario table, and discuss speed, failures, and resource limits.
9. API-ready model. Wrap a process model behind a structured input/output function, save a lifecycle state, and sketch the FastAPI endpoint contract.

Reviewer Checklist

Before calling the portfolio finished, ask:

• Can a reviewer rerun the notebook from a clean environment?
• Does the code-block or notebook verification report show zero failed runnable examples?
• Are all temperatures, pressures, flows, and powers labelled with units?
• Is every major result traceable to an input, a model option, and a code cell?
• Is the fluid basis ledger complete: component source, database mode, EOS, mixing rule, and validation point?
• Did the model converge, and is convergence checked explicitly?
• Is there at least one independent sanity check?
• Are figures discussed with observation, mechanism, implication, and recommendation?
• Are uncertainty, operating envelope, or residual risk stated honestly?
• Is the final recommendation specific enough to act on?

If the answer to any of these is no, the next improvement is clear.

Author Biography

Even Solbraa is a process engineer and the original architect of NeqSim. He has led NeqSim's development for more than two decades, growing it from a thermodynamics research code into a production-grade open-source toolkit for the international oil & gas industry. He holds a PhD in chemical engineering from NTNU on equation-of-state modelling of natural gas systems, and has authored or co-authored more than a hundred publications on thermodynamic property prediction, gas processing, CO₂ capture and transport, hydrate inhibition, and digital twin technology.

His current focus is on the integration of high-fidelity process models with AI agents and operational data — making rigorous thermodynamics and process simulation directly usable by domain engineers, data scientists, and intelligent systems.

NeqSim is publicly available at https://github.com/equinor/neqsim and the Python bindings at https://github.com/equinor/neqsim-python.

References

1. Solbraa, "Equilibrium and non-equilibrium thermodynamics of natural gas processing — Measurements and modelling of {CO2," PhD Thesis, NTNU, 2002.