git:20260924.2a17c33 to git:20261004.fc23e28

---

name: neqsim-lng-liquefaction

description: LNG liquefaction modelling in NeqSim. USE WHEN: building or sizing a liquefaction plant (SMR, DMR, C3MR, cascade, nitrogen expander), calibrating a mixed refrigerant, computing liquefaction specific energy or power, scaling to trains, choosing gas-turbine against electric drive and the resulting carbon intensity, or sizing LNG storage and cargo loading. Covers LNGProcessBuilder, LNGProcessModel, the mandatory specific-energy benchmark gate, and the LNG bubble-point trap.

---

# LNG liquefaction with NeqSim

## When to use this

Any task that turns a treated gas stream into LNG and needs a defensible power, specific energy,

train count, storage volume or carbon intensity. Pair with `neqsim-process-modeling` for the

upstream treatment train and `neqsim-equipment-cost-estimation` for the cost side.

## The one thing that will bite you

**A shipped mixed-refrigerant inventory is not a design.** Liquefaction specific energy is a

strong function of refrigerant composition and circulation ratio — those *are* the cycle design.

A builder with a fixed default inventory will return whatever that inventory gives, which can be

two to three times outside the published band for the cycle, with no warning.

**Therefore: calibrating the refrigerant and passing the specific-energy benchmark is a mandatory

gate, not a refinement.** Never scale an uncalibrated train to plant size.

Reference bands (specific energy on the feed-to-LNG basis):

| Cycle | kWh/kg LNG | Notes |

|---|---|---|

| Single mixed refrigerant (SMR) | 0.19 – 0.43 | Typical reference ~0.26 |

| Dual mixed refrigerant (DMR) | 0.25 – 0.35 | |

| Propane-precooled MR (C3MR) | 0.27 – 0.35 | Baseload workhorse |

| Cascade | 0.30 – 0.38 | |

| Nitrogen expander | 0.45 – 0.70 | Small scale / FLNG, simplicity over efficiency |

Source: Pereira et al., *Energy Conversion and Management* 272 (2022) 116364, and the open

liquefaction literature. Always cite the band you validate against.

## Core API

```java

LNGProcessBuilder builder = new LNGProcessBuilder("SMR train");

builder.setFeedStream(treatedGas);

builder.setLngTemperature(-160.0); // degC

builder.setLngPressure(1.08); // bara

// Refrigerant is configurable — set it, do not accept the default

builder.setRefrigerantComposition(

new String[] {"nitrogen", "methane", "ethane", "propane", "i-butane"},

new double[] {0.08, 0.34, 0.34, 0.12, 0.12});

builder.setRefrigerantCirculationRatio(2.5); // kmol refrigerant per kmol feed

builder.setRefrigerantSuctionPressure(4.0); // bara

builder.setRefrigerantDischargePressure(45.0); // bara

builder.setRefrigerantCoolingTemperature(30.0);// degC after the aftercooler

ProcessSystem train = builder.buildSMR();

train.run();

```

Other cycles: `buildDMR()`, `buildC3MR()`, `buildCascade()`, `buildNitrogenExpander()`.

## The calibration workflow (do this every time)

```python

def specific_energy(comp, fractions, ratio, suction, discharge):

b = LNGProcessBuilder("cal")

b.setFeedStream(feed)

b.setRefrigerantComposition(comp, fractions)

b.setRefrigerantCirculationRatio(ratio)

b.setRefrigerantSuctionPressure(suction)

b.setRefrigerantDischargePressure(discharge)

p = b.buildSMR()

p.run()

power_kW = sum(u.getPower("kW") for u in compressors_in(p))

lng_kg_per_h = lng_stream.getFlowRate("kg/hr")

return power_kW / lng_kg_per_h

# 1. Sweep circulation ratio and discharge pressure

# 2. Accept the first combination inside the published band

# 3. ASSERT it is inside the band before going further

assert 0.19 <= se <= 0.43, "SMR train outside the published specific-energy band"

```

Circulation ratio is the strongest single lever; discharge pressure is the second. Suction

pressure mainly sets the cold-end approach.

## Scaling to a plant

Scale on **specific energy**, not by multiplying a single train's absolute power, so the train

count and the plant rate stay consistent:

```python

train_mtpa = lng_kg_per_h * 8766 * availability / 1e9

n_trains = ceil(plant_mtpa / train_mtpa)

plant_power = specific_energy * plant_mtpa * 1e9 / (8766 * availability) # kW

```

Then add, as separate items:

- **End-flash and BOG compression**: typically 5–8 % of refrigeration power.

- **Utilities** (cooling pumps, air, N2, instrument): typically 8–10 %.

A common sanity number: total FLNG/plant power lands near **0.35–0.40 kWh/kg** once end-flash and

utilities are included, against 0.26–0.32 for the refrigeration cycle alone.

## The LNG bubble-point trap

Flashing an LNG composition at its storage temperature and pressure with `TPflash` frequently

returns **vapour**, giving a density near 2 kg/m³ instead of 430–460 kg/m³ — and the error then

propagates silently into cargo size, storage volume and cargo count.

```python

# WRONG — may land on the vapour side

fluid.setTemperature(-160.0, "C"); fluid.setPressure(1.08, "bara")

ops.TPflash(); rho = fluid.getDensity("kg/m3") # 1.9 kg/m3 !

# RIGHT — put the fluid on the saturation line first

fluid.setPressure(1.08, "bara")

ops.bubblePointTemperatureFlash()

fluid.initProperties()

rho = fluid.getPhase("oil").getDensity("kg/m3") # ~440 kg/m3

```

Always cross-check LNG density against a reference equation (CoolProp methane saturated liquid is

close enough for a screening study; expect SRK to sit within ~4 %).

## Driver selection and carbon intensity

This is usually the largest ESG lever in an LNG study and is cheap to compute:

```python

# Gas-turbine drive

fuel_kg_per_h = power_kW / (gt_efficiency * LHV_kWh_per_kg)

co2_kg_per_h = fuel_kg_per_h * 2.72 # kg CO2 per kg of natural gas

intensity = co2_kg_per_h / lng_kg_per_h * 1000.0 # kg CO2 per tonne LNG

# Electric drive

co2_kg_per_h = power_kW * grid_intensity_kg_per_kWh

```

Typical outcomes: gas-turbine drive ~180–220 kg CO2 per tonne of LNG; electric drive from a

low-carbon grid ~5–15 kg CO2/t. Electric drive also **releases the fuel gas back into production**

— quantify that, because it extends plateau life and is often worth more than the emission saving.

## Storage and marine sizing

```python

cargo_m3 = carrier_size_m3 * 0.985 # allow for heel and trim

cargo_t = cargo_m3 * lng_density / 1000.0

cargoes_per_y = plant_mtpa * 1e6 / cargo_t

days_between = 365.25 / cargoes_per_y

berth_occupancy = cargoes_per_y * turnaround_hours / (365.25 * 24)

loading_rate = cargo_m3 / loading_hours # m3/h -> number of arms

```

Rules of thumb: one berth serves up to ~50 % occupancy comfortably; storage of 1.5–2 cargo

volumes (roughly 5 days of production) is the usual minimum; 16-inch arms carry ~3000–4000 m³/h

each.

## Validation gate for any LNG deliverable

1. Specific energy inside the published band for the chosen cycle — **assert it**.

2. LNG density cross-checked against a reference equation.

3. Feed-to-LNG mass balance closes (account for NGL extraction, fuel and end-flash).

4. Feed rate cross-checked against a published plant of similar capacity

(~160–170 MMscfd per MTPA for a lean feed; higher for a rich feed with NGL extraction).

## Related skills

- `neqsim-process-modeling` — building the treatment train that feeds the liquefier

- `neqsim-water-dewpoint-dehydration-screening` — molecular-sieve specification upstream

- `neqsim-equipment-cost-estimation` — costing the trains (watch the correlation validity range)

- `neqsim-ccs-hydrogen` — if the CO2 removed upstream is captured rather than vented

- `neqsim-benchmark-reference-data` — the reference-data comparison layer for the validation gate