Power Generation Equipment

Documentation for power generation equipment in NeqSim, including gas turbines, steam turbines, HRSG, combined-cycle systems, fuel cells, wind turbines, and solar panels.

Table of Contents

Overview

Location: neqsim.process.equipment.powergeneration

The power generation package provides equipment models for converting chemical and renewable energy sources into electrical power:

Equipment Energy Source Output
GasTurbine Fuel gas combustion Electricity + heat
SteamTurbine High-pressure steam Electricity
HRSG Gas turbine exhaust Steam
CombinedCycleSystem Fuel gas (GT + HRSG + ST) Electricity (high efficiency)
FuelCell Hydrogen + oxygen Electricity + water
WindTurbine Wind Electricity
SolarPanel Solar radiation Electricity
BatteryStorage Stored electricity Electricity

Gas Turbine

The GasTurbine class models a simple cycle gas turbine with integrated air compression, combustion, and expansion.

Class Hierarchy

TwoPortEquipment
└── GasTurbine

Constructor

import neqsim.process.equipment.powergeneration.GasTurbine;
import neqsim.process.equipment.stream.Stream;

// Basic constructor
GasTurbine turbine = new GasTurbine("GT-101");

// Constructor with fuel stream
GasTurbine turbine = new GasTurbine("GT-101", fuelGasStream);

Key Properties

Property Description Unit
combustionPressure Combustor pressure bara
airGasRatio Air to fuel ratio -
power Net electrical power output W
heat Heat output W
compressorPower Air compressor power W
expanderPower Expander power W

Example Usage

import neqsim.process.equipment.powergeneration.GasTurbine;
import neqsim.process.equipment.stream.Stream;
import neqsim.thermo.system.SystemSrkEos;

// Create fuel gas
SystemInterface fuelGas = new SystemSrkEos(288.15, 25.0);
fuelGas.addComponent("methane", 0.90);
fuelGas.addComponent("ethane", 0.05);
fuelGas.addComponent("propane", 0.03);
fuelGas.addComponent("nitrogen", 0.02);
fuelGas.setMixingRule("classic");

Stream fuelStream = new Stream("Fuel Gas", fuelGas);
fuelStream.setFlowRate(1000.0, "kg/hr");

// Create gas turbine
GasTurbine turbine = new GasTurbine("Power Turbine", fuelStream);
turbine.combustionpressure = 15.0;  // bara (public field)

// Run simulation
turbine.run();

// Results
System.out.println("Net power: " + turbine.getPower() / 1e6 + " MW");
System.out.println("Heat output: " + turbine.getHeat() / 1e6 + " MW");
System.out.println("Ideal air/fuel ratio: " + turbine.calcIdealAirFuelRatio());

Steam Turbine

The SteamTurbine class models isentropic expansion of high-pressure steam to produce power. Outlet conditions are computed via PS-flash (isentropic) followed by PH-flash (actual) using the specified isentropic efficiency.

Class Hierarchy

TwoPortEquipment
└── SteamTurbine

Constructor

import neqsim.process.equipment.powergeneration.SteamTurbine;

// Basic constructor
SteamTurbine st = new SteamTurbine("ST-100");

// Constructor with inlet steam stream
SteamTurbine st = new SteamTurbine("ST-100", steamStream);

Key Properties

Property Setter Default Unit
outletPressure setOutletPressure(p) / setOutletPressure(p, "bara") 1.01325 bara
isentropicEfficiency setIsentropicEfficiency(e) 0.85 0-1
numberOfStages setNumberOfStages(n) 1 -
power (result) - W

Example Usage

import neqsim.process.equipment.powergeneration.SteamTurbine;
import neqsim.process.equipment.stream.Stream;
import neqsim.thermo.system.SystemSrkEos;

// Create superheated steam
SystemInterface steam = new SystemSrkEos(273.15 + 450.0, 40.0);
steam.addComponent("water", 1.0);
steam.setMixingRule("classic");

Stream steamFeed = new Stream("HP Steam", steam);
steamFeed.setFlowRate(50000.0, "kg/hr");

// Create steam turbine
SteamTurbine turbine = new SteamTurbine("ST-100", steamFeed);
turbine.setOutletPressure(0.05, "bara");
turbine.setIsentropicEfficiency(0.88);
turbine.run();

System.out.println("Power output: " + turbine.getPower("MW") + " MW");

HRSG

The HRSG (Heat Recovery Steam Generator) class models counter-current heat exchange between hot gas turbine exhaust and a water/steam loop. It calculates the heat transferred and the steam production rate for given steam conditions.

Class Hierarchy

TwoPortEquipment
└── HRSG

Constructor

import neqsim.process.equipment.powergeneration.HRSG;

// Basic constructor
HRSG hrsg = new HRSG("HRSG-1");

// Constructor with hot gas inlet (gas turbine exhaust)
HRSG hrsg = new HRSG("HRSG-1", gasTurbineExhaust);

Key Properties

Property Setter Default Unit
steamPressure setSteamPressure(p) 40.0 bara
steamTemperature setSteamTemperature(t) / setSteamTemperature(t, "C") 400 C K
feedWaterTemperature setFeedWaterTemperature(t) / setFeedWaterTemperature(t, "C") 60 C K
approachTemperature setApproachTemperature(dT) 15.0 K
effectiveness setEffectiveness(e) 0.85 0-1

Results

Method Returns Unit
getHeatTransferred() / getHeatTransferred("MW") Heat to steam W / MW
getSteamFlowRate() / getSteamFlowRate("kg/hr") Steam production kg/s / kg/hr
getGasOutletTemperature() Gas stack temperature K

Example Usage

HRSG hrsg = new HRSG("HRSG-1", turbine.getOutletStream());
hrsg.setSteamPressure(40.0);
hrsg.setSteamTemperature(400.0, "C");
hrsg.setApproachTemperature(15.0);
hrsg.run();

System.out.println("Heat recovered: " + hrsg.getHeatTransferred("MW") + " MW");
System.out.println("Steam production: " + hrsg.getSteamFlowRate("kg/hr") + " kg/hr");

Combined Cycle System

The CombinedCycleSystem class integrates a GasTurbine, HRSG, and SteamTurbine into a single equipment unit. It models the full gas turbine combined cycle (GTCC) workflow:

  1. Fuel gas combustion in the gas turbine
  2. Exhaust heat recovery in the HRSG to produce steam
  3. Steam expansion through the steam turbine

Class Hierarchy

TwoPortEquipment
└── CombinedCycleSystem  (composes GasTurbine + HRSG + SteamTurbine)

Constructor

import neqsim.process.equipment.powergeneration.CombinedCycleSystem;

CombinedCycleSystem cc = new CombinedCycleSystem("CC-Plant");
CombinedCycleSystem cc = new CombinedCycleSystem("CC-Plant", fuelGasStream);

Key Properties

Property Setter Default Unit
combustionPressure combustionpressure (public field) 2.5 bara
steamPressure setSteamPressure(p) 40.0 bara
steamTemperature setSteamTemperature(t, "C") 400.0 C
steamTurbineEfficiency setSteamTurbineEfficiency(e) 0.85 0-1
steamCondensorPressure setSteamCondensorPressure(p) 0.05 bara
hrsgApproachTemperature setHrsgApproachTemperature(dT) 15.0 K
hrsgEffectiveness setHrsgEffectiveness(e) 0.85 0-1

Results

Method Returns Unit
getTotalPower() / getTotalPower("MW") Combined GT + ST power W / MW
getGasTurbinePower() GT contribution W
getSteamTurbinePower() ST contribution W
getOverallEfficiency() LHV thermal efficiency 0-1
getFuelEnergyInput() Fuel energy (LHV) W
toJson() Full results JSON String

Example Usage

CombinedCycleSystem cc = new CombinedCycleSystem("CC-1", fuelStream);
cc.setCombustionPressure(15.0);
cc.setSteamPressure(40.0);
cc.setSteamTemperature(400.0, "C");
cc.setSteamTurbineEfficiency(0.85);
cc.run();

System.out.println("Total power: " + cc.getTotalPower("MW") + " MW");
System.out.println("GT power: " + cc.getGasTurbinePower() / 1e6 + " MW");
System.out.println("ST power: " + cc.getSteamTurbinePower() / 1e6 + " MW");
System.out.println("Efficiency: " + cc.getOverallEfficiency() * 100 + "%");
System.out.println(cc.toJson());

Fuel Cell

Class Hierarchy

TwoPortEquipment
└── FuelCell

Constructor

import neqsim.process.equipment.powergeneration.FuelCell;

// Basic constructor
FuelCell cell = new FuelCell("FC-101");

// Constructor with fuel and oxidant streams
FuelCell cell = new FuelCell("FC-101", hydrogenStream, airStream);

Key Properties

Property Description Unit
efficiency Electrical efficiency 0-1
power Electrical power output W
heatLoss Heat loss to environment W

Example Usage

import neqsim.process.equipment.powergeneration.FuelCell;
import neqsim.process.equipment.stream.Stream;
import neqsim.thermo.system.SystemSrkEos;

// Create hydrogen fuel stream
SystemInterface h2Fluid = new SystemSrkEos(298.15, 5.0);
h2Fluid.addComponent("hydrogen", 1.0);
h2Fluid.setMixingRule("classic");

Stream hydrogenFeed = new Stream("Hydrogen", h2Fluid);
hydrogenFeed.setFlowRate(10.0, "kg/hr");

// Create air stream
SystemInterface airFluid = new SystemSrkEos(298.15, 1.01325);
airFluid.addComponent("nitrogen", 0.79);
airFluid.addComponent("oxygen", 0.21);
airFluid.setMixingRule("classic");

Stream airFeed = new Stream("Air", airFluid);
airFeed.setFlowRate(100.0, "kg/hr");

// Create fuel cell
FuelCell fuelCell = new FuelCell("SOFC", hydrogenFeed, airFeed);
fuelCell.setEfficiency(0.55);

// Run simulation
fuelCell.run();

// Results
System.out.println("Electrical power: " + fuelCell.getPower() / 1000 + " kW");
System.out.println("Heat loss: " + fuelCell.getHeatLoss() / 1000 + " kW");

Wind Turbine

The WindTurbine class models wind power generation based on wind speed and turbine characteristics.

Constructor

import neqsim.process.equipment.powergeneration.WindTurbine;

WindTurbine turbine = new WindTurbine("WT-01");
turbine.setWindSpeed(12.0);          // m/s
turbine.setRotorArea(11310.0);       // m² (e.g. pi * 60² for 120m diameter)
turbine.setPowerCoefficient(0.45);   // Betz limit max ~0.593

Key Properties

Property Description Unit
windSpeed Wind velocity m/s
rotorArea Rotor swept area m²
powerCoefficient Aerodynamic efficiency (Cp) 0-0.593 (Betz limit)
airDensity Air density kg/m³
power Electrical power output W

Solar Panel

The SolarPanel class models photovoltaic power generation.

Constructor

import neqsim.process.equipment.powergeneration.SolarPanel;

SolarPanel panel = new SolarPanel("PV-Array");
panel.setPanelArea(1000.0);        // m²
panel.setIrradiance(800.0);        // W/m²
panel.setEfficiency(0.20);

Key Properties

Property Description Unit
panelArea Total panel area m²
irradiance Solar radiation W/m²
efficiency Panel efficiency 0-1
power Electrical power output W

Battery Storage

Location: neqsim.process.equipment.battery

The BatteryStorage class models electrical energy storage systems.

Constructor

import neqsim.process.equipment.battery.BatteryStorage;

BatteryStorage battery = new BatteryStorage("BESS-01");
battery.setCapacity(3.6e11);         // Joules (= 100 MWh)
// Note: charge/discharge efficiencies are internal (default 0.95 each)

Key Properties

Property Description Unit
capacity Total energy capacity J
stateOfCharge Current energy level J
stateOfChargeFraction SOC as fraction 0-1

Operations

battery.charge(25e6, 2.0);         // charge at 25 MW for 2 hours
double delivered = battery.discharge(25e6, 1.0);  // discharge at 25 MW for 1 hour
double soc = battery.getStateOfChargeFraction();   // 0-1

Right-Sizing, Dispatch & Retrofit (gasturbine sub-package)

For late-life turndown, fleet right-sizing, dispatch with N+1 reserve, and retrofit NPV / CO₂-avoided studies, use the catalog-driven classes under neqsim.process.equipment.powergeneration.gasturbine. These complement the legacy GasTurbine class above: use the legacy class when you need full thermodynamic GT + HRSG integration; use this sub-package when the question is “which turbines, how many, and at what load over 20 years?”

Class Purpose
GasTurbineCatalog Bundled gas_turbine_catalog.csv (14 aero + industrial models: LM2500, LM2500PLUS_G4, LM6000PF/PG, RB211_6562, Trent 60, SGT-700/750, Centaur 50, Taurus 60/70, Mars 100, Titan 130/250)
GasTurbineSpec Immutable rating point (rated MW, ISO heat rate, exhaust flow/T, NOx, mass)
GasTurbinePerformanceMap Part-load + ambient correction (aero vs industrial polynomials, min-load fraction)
GasTurbineDegradation Recoverable + non-recoverable fouling vs fired hours, water-wash and overhaul reset
GasTurbineEmissions Full-carbon-balance CO₂, NOx, methane slip from fuel composition
CO2TaxSchedule Loads co2_tax_norway.csv (2020–2040 NOK/tonne, CO₂ tax + EU ETS), linear interpolation
GasTurbineUnit TwoPortEquipment — runs inside a ProcessSystem, accepts fuel Stream, aggregates Compressor shaft load via addPowerConsumer
TurbineDispatchOptimizer Picks the cheapest feasible on/off combination (brute-force ≤8 units, merit-order above) with N+1 reserve
LateLifeRetrofitStudy Year-by-year NPV / CO₂-avoided / payback for baseline vs retrofit fleet over a declining demand profile

Catalog & site-corrected available power

import neqsim.process.equipment.powergeneration.gasturbine.GasTurbineCatalog;
import neqsim.process.equipment.powergeneration.gasturbine.GasTurbineSpec;
import neqsim.process.equipment.powergeneration.gasturbine.GasTurbineUnit;

GasTurbineSpec spec = GasTurbineCatalog.get("LM2500");
GasTurbineUnit gt = new GasTurbineUnit("GT-A", fuelStream, spec);
gt.setAmbientTemperatureK(273.15 + 30.0);   // hot-day derate
gt.setDemandedPower(15.0e6);                 // 15 MW shaft
gt.run(UUID.randomUUID());
double availMW = gt.getAvailablePowerW() / 1.0e6;
double load    = gt.getLoadFraction();
double co2Tph  = gt.getCO2EmissionKgPerS() * 3.6;

Linking turbine shaft to compressor demand

Each GasTurbineUnit sums the live shaft demand from any number of Compressor objects in the same flowsheet — the dispatcher reads it on every run():

ProcessSystem plant = new ProcessSystem();
plant.add(exportCompressor);     // existing Compressor
plant.add(injectionCompressor);
GasTurbineUnit gt = new GasTurbineUnit("GT-A", fuelStream,
        GasTurbineCatalog.get("LM2500"));
gt.addPowerConsumer(exportCompressor);
gt.addPowerConsumer(injectionCompressor);
plant.add(gt);
plant.run();   // gt aggregates Compressor.getPower() automatically

Fleet dispatch with N+1 redundancy

import neqsim.process.equipment.powergeneration.gasturbine.TurbineDispatchOptimizer;

List<GasTurbineUnit> fleet = Arrays.asList(gt1, gt2, gt3);
TurbineDispatchOptimizer disp = new TurbineDispatchOptimizer(
        /*fuelPriceNOKPerKg*/ 4.5,
        /*co2CostNOKPerTonne*/ 1500.0);
disp.setRequireNplusOne(true);
TurbineDispatchOptimizer.DispatchResult r = disp.dispatch(fleet, 18.0e6);
if (r.feasible) {
    System.out.println(r.summary());   // running units, load, NOK/hr
}

Retrofit NPV vs baseline

import neqsim.process.equipment.powergeneration.gasturbine.CO2TaxSchedule;
import neqsim.process.equipment.powergeneration.gasturbine.LateLifeRetrofitStudy;

double[] demandMW = new double[20];
for (int i = 0; i < 20; i++) demandMW[i] = Math.max(8.0, 56.0 - i * 2.0);

LateLifeRetrofitStudy study = new LateLifeRetrofitStudy(
        baselineFleet,    // e.g. 2x LM6000PF
        retrofitFleet,    // e.g. 3x SGT-700
        demandMW,
        /*startYear*/ 2026,
        CO2TaxSchedule.loadDefault(),
        /*fuelPriceNOKPerKg*/ 4.5);
study.setRetrofitCapexMNOK(800.0);
study.setDiscountRate(0.08);
study.setAnnualOperatingHours(8000);
LateLifeRetrofitStudy.RetrofitResult res = study.run();
System.out.println("NPV (MNOK):      " + res.npvMNOK);
System.out.println("CO2 avoided (t): " + res.totalCO2AvoidedTonne);
System.out.println("Payback (yr):    " + res.simplePaybackYear);

End-to-end notebook

The Gas Turbine 20-Year Right-Sizing and Retrofit notebook walks through a complete late-life study:

  1. Build a 50 MMSCFD export-compression train and link it to a GasTurbineUnit.
  2. Sweep ambient temperature × load to map site-corrected available power.
  3. Apply GasTurbineDegradation over fired hours and overhauls.
  4. Dispatch a 3-unit fleet with TurbineDispatchOptimizer against an annual load-duration curve.
  5. Run LateLifeRetrofitStudy with CO2TaxSchedule.loadDefault() to compare baseline (2 × LM6000PF) vs retrofit (3 × SGT-700) on NPV, payback, and CO₂ avoided.
  6. Layer an HRSG + steam-turbine bottoming cycle on the retrofit fleet to evaluate a combined-cycle alternative.
  7. Replace the synthetic decline with a reservoir + Beggs-Brills riser + flowline model so the compressor suction — and therefore the shaft demand — is driven by reservoir physics.

The full skill reference lives at .github/skills/neqsim-power-generation/SKILL.md.

Usage Examples

Combined Heat and Power (CHP) System

import neqsim.process.processmodel.ProcessSystem;
import neqsim.process.equipment.powergeneration.GasTurbine;
import neqsim.process.equipment.powergeneration.HRSG;

ProcessSystem chpSystem = new ProcessSystem("CHP Plant");

// Create fuel gas stream
Stream fuelGas = new Stream("Fuel", fuelFluid);
fuelGas.setFlowRate(500.0, "kg/hr");
chpSystem.add(fuelGas);

// Gas turbine
GasTurbine turbine = new GasTurbine("GT", fuelGas);
turbine.combustionpressure = 12.0;
chpSystem.add(turbine);

// Heat recovery steam generator
HRSG hrsg = new HRSG("HRSG", turbine.getOutletStream());
hrsg.setSteamPressure(20.0);
hrsg.setSteamTemperature(250.0, "C");
hrsg.setApproachTemperature(15.0);
chpSystem.add(hrsg);

// Run
chpSystem.run();

// Calculate efficiency
double electricalPower = turbine.getPower();
double thermalPower = hrsg.getHeatTransferred();
double fuelInput = fuelGas.getFlowRate("kg/hr") * 50e6 / 3600;  // LHV ~ 50 MJ/kg

double electricalEff = electricalPower / fuelInput;
double totalEff = (electricalPower + thermalPower) / fuelInput;

System.out.println("Electrical efficiency: " + electricalEff * 100 + "%");
System.out.println("Total CHP efficiency: " + totalEff * 100 + "%");
System.out.println("Steam production: " + hrsg.getSteamFlowRate("kg/hr") + " kg/hr");

Combined Cycle Power Plant

import neqsim.process.equipment.powergeneration.CombinedCycleSystem;

// One-call combined cycle with internal GT + HRSG + ST
CombinedCycleSystem ccPlant = new CombinedCycleSystem("GTCC", fuelGasStream);
ccPlant.setCombustionPressure(15.0);
ccPlant.setSteamPressure(40.0);
ccPlant.setSteamTemperature(400.0, "C");
ccPlant.setSteamTurbineEfficiency(0.85);
ccPlant.run();

System.out.println("Total power: " + ccPlant.getTotalPower("MW") + " MW");
System.out.println("GT power: " + ccPlant.getGasTurbinePower() / 1e6 + " MW");
System.out.println("ST power: " + ccPlant.getSteamTurbinePower() / 1e6 + " MW");
System.out.println("Overall efficiency: " + ccPlant.getOverallEfficiency() * 100 + "%");

Hybrid Renewable System

// Solar + Wind + Battery system
SolarPanel solar = new SolarPanel("PV");
solar.setPanelArea(5000.0);
solar.setIrradiance(600.0);
solar.setEfficiency(0.18);

WindTurbine wind = new WindTurbine("Wind");
wind.setWindSpeed(8.0);
wind.setRotorArea(5027.0);  // ~80m diameter

BatteryStorage battery = new BatteryStorage("Battery");
battery.setCapacity(3.6e10);  // 10 MWh in Joules

// Calculate total renewable generation
solar.run();
wind.run();

double totalGeneration = solar.getPower() + wind.getPower();
System.out.println("Total renewable power: " + totalGeneration / 1e6 + " MW");

Capacity Constraints and Optimization

All four core power generation equipment types (GasTurbine, SteamTurbine, HRSG, CombinedCycleSystem) implement the CapacityConstrainedEquipment and AutoSizeable interfaces. This enables rated-capacity tracking, bottleneck detection, and integration with the plant-wide ProcessOptimizationEngine.

Interfaces

Interface Purpose
CapacityConstrainedEquipment Tracks operating point vs rated capacity, detects violations
AutoSizeable Sets rated capacity from current operating point with a safety factor

Setting Rated Capacity

Each equipment type has a rated capacity field that defines its design limit:

// Gas turbine — rated power
GasTurbine gt = new GasTurbine("GT-1", fuelStream);
gt.setRatedPower(30.0, "MW");  // 30 MW design rating

// Steam turbine — rated power
SteamTurbine st = new SteamTurbine("ST-1", steamStream);
st.setRatedPower(15.0, "MW");

// HRSG — design heat duty
HRSG hrsg = new HRSG("HRSG-1", gt.getOutletStream());
hrsg.setDesignHeatDuty(50.0, "MW");

// Combined cycle — rated total power
CombinedCycleSystem cc = new CombinedCycleSystem("CC-1", fuelStream);
cc.setRatedTotalPower(45.0, "MW");

Auto-Sizing

When design ratings are not known, auto-size from the current operating point:

// Run the process first to establish operating conditions
process.run();

// Auto-size with a 20% safety margin (factor = 1.2)
gt.autoSize(1.2);
st.autoSize(1.2);
hrsg.autoSize(1.2);
cc.autoSize(1.2);

// Check sizing results
System.out.println(gt.getSizingReport());
System.out.println(gt.isAutoSized());  // true

Querying Capacity

After running and setting rated capacity (manually or via auto-size), query the operating margin:

// Current operating duty vs maximum
double duty = gt.getCapacityDuty();  // current power output (W)
double max = gt.getCapacityMax();    // rated power (W)

// Utilization fraction (0-1, where 1.0 = at capacity)
double utilization = gt.getMaxUtilization();

// Check if any constraint is violated
boolean exceeded = gt.isCapacityExceeded();    // soft or hard limit
boolean hardTrip = gt.isHardLimitExceeded();   // hard limit only

// Get the most-loaded constraint
CapacityConstraint bottleneck = gt.getBottleneckConstraint();
if (bottleneck != null) {
    System.out.println(bottleneck.getName() + ": " + bottleneck.getUtilization());
}

// Iterate all constraints
for (Map.Entry<String, CapacityConstraint> entry :
        gt.getCapacityConstraints().entrySet()) {
    System.out.println(entry.getKey() + " -> " + entry.getValue().getUtilization());
}

Adding Custom Constraints

The built-in constraint (power or heat duty) covers the primary capacity limit. Add additional constraints for operational envelopes:

import neqsim.process.equipment.capacity.CapacityConstraint;

// Add an exhaust temperature limit to the gas turbine
gt.addCapacityConstraint(
    new CapacityConstraint("exhaustTemp", "C", CapacityConstraint.ConstraintType.HARD)
        .setDesignValue(550.0)
        .setMaxValue(600.0)
        .setWarningThreshold(0.90)
        .setDescription("Exhaust gas temperature limit")
        .setValueSupplier(() -> gt.getOutletStream().getTemperature("C")));

// Remove a constraint by name
gt.removeCapacityConstraint("exhaustTemp");

// Clear all constraints
gt.clearCapacityConstraints();

Integration with ProcessOptimizationEngine

The ProcessOptimizationEngine reads capacity constraints from all equipment in a ProcessSystem to find the plant-wide maximum throughput and identify bottlenecks.

Bottleneck Detection

import neqsim.process.util.optimizer.ProcessOptimizationEngine;

// Build a combined heat and power system
ProcessSystem chp = new ProcessSystem();
chp.add(fuelStream);
chp.add(gt);
chp.add(hrsg);
chp.run();

// Set rated capacities
gt.setRatedPower(30.0, "MW");
hrsg.setDesignHeatDuty(50.0, "MW");

// Evaluate constraints across the entire process
ProcessOptimizationEngine engine = new ProcessOptimizationEngine(chp);
ProcessOptimizationEngine.ConstraintReport report = engine.evaluateAllConstraints();

for (ProcessOptimizationEngine.EquipmentConstraintStatus status :
        report.getEquipmentStatuses()) {
    System.out.printf("%s %s: %.1f%% utilization%n",
        status.isWithinLimits() ? "OK" : "!!",
        status.getEquipmentName(),
        status.getMaxUtilization() * 100);
}

Maximum Throughput Optimization

Find how much fuel gas the system can handle before hitting a capacity limit:

ProcessOptimizationEngine.OptimizationResult result =
    engine.findMaximumThroughput(
        25.0,       // inlet pressure (bara)
        25.0,       // outlet pressure (bara — no compression)
        100.0,      // min fuel flow (kg/hr)
        10000.0     // max fuel flow (kg/hr)
    );

System.out.println("Max fuel rate: " + result.getOptimalFlowRate() + " kg/hr");
System.out.println("Bottleneck: " + result.getBottleneckEquipment());
System.out.println("Total power at max: " + result.getTotalPower() + " kW");

Capacity Utilization Summary

For a quick overview of all equipment headroom in the process:

Map<String, Double> utilization = chp.getCapacityUtilizationSummary();
for (Map.Entry<String, Double> entry : utilization.entrySet()) {
    System.out.printf("%-25s %.1f%%%n", entry.getKey(), entry.getValue() * 100);
}
// Example output:
// GT-1                      72.3%
// HRSG-1                    65.8%

Python (Jupyter) Example

from neqsim import jneqsim

# Create fuel gas
gas = jneqsim.thermo.system.SystemSrkEos(288.15, 25.0)
gas.addComponent("methane", 0.90)
gas.addComponent("ethane", 0.05)
gas.addComponent("propane", 0.03)
gas.addComponent("nitrogen", 0.02)
gas.setMixingRule("classic")

Stream = jneqsim.process.equipment.stream.Stream
GasTurbine = jneqsim.process.equipment.powergeneration.GasTurbine
HRSG = jneqsim.process.equipment.powergeneration.HRSG
ProcessSystem = jneqsim.process.processmodel.ProcessSystem

fuel = Stream("Fuel Gas", gas)
fuel.setFlowRate(1000.0, "kg/hr")

gt = GasTurbine("GT-1", fuel)
hrsg = HRSG("HRSG-1", gt.getOutletStream())
hrsg.setSteamPressure(40.0)

process = ProcessSystem()
process.add(fuel)
process.add(gt)
process.add(hrsg)
process.run()

# Auto-size with 20% margin
gt.autoSize(1.2)
hrsg.autoSize(1.2)

# Check utilization
print(f"GT utilization:   {gt.getMaxUtilization() * 100:.1f}%")
print(f"HRSG utilization: {hrsg.getMaxUtilization() * 100:.1f}%")
print(f"GT capacity exceeded: {gt.isCapacityExceeded()}")

# Sizing report
print(gt.getSizingReport())