NeqSim’s Pump models a liquid pump from a process inlet stream. Use either a specified discharge pressure and isentropic efficiency, a vendor head/efficiency curve, or a specified discharge temperature. PumpMechanicalDesign adds preliminary mechanical-design calculations and an auditable API 610 screening result.

Packages

Class Package Purpose
Pump neqsim.process.equipment.pump Steady-state and transient process calculation
PumpChartInterface neqsim.process.equipment.pump Vendor head, efficiency, and NPSHr curves
PumpMechanicalDesign neqsim.process.mechanicaldesign.pump Preliminary sizing and design outputs
PumpApi610DesignCalculator neqsim.process.mechanicaldesign.pump Structured API 610 screening checks

Calculation modes

Specified discharge pressure

Set the discharge pressure and isentropic efficiency before calling run():

pump.setOutletPressure(15.0, "bara");
pump.setIsentropicEfficiency(0.78);
pump.run();

The absorbed shaft power is based on the isentropic enthalpy rise divided by the specified efficiency:

\[P = \frac{\dot m\left(h_{2s}-h_1\right)}{\eta_s}\]

Here $P$ is shaft power, $\dot m$ is mass flow, $h_1$ is inlet specific enthalpy, $h_{2s}$ is the isentropic discharge enthalpy, and $\eta_s$ is isentropic efficiency.

Vendor performance curves

Supply one row per speed to PumpChartInterface.setCurves(...). Flow is in m³/h, efficiency is supplied in percent, and the head unit is set separately. The NPSHr array must have the same speed/flow layout.

double[] speed = new double[] { 1000.0 };
double[][] flow = new double[][] { { 50.0, 75.0, 100.0, 125.0, 150.0 } };
double[][] head = new double[][] { { 120.0, 115.0, 105.0, 90.0, 70.0 } };
double[][] efficiency = new double[][] { { 65.0, 75.0, 82.0, 78.0, 68.0 } };
double[][] npshRequired = new double[][] { { 2.0, 2.4, 3.0, 4.0, 5.5 } };

pump.getPumpChart().setCurves(new double[] {}, speed, flow, head, efficiency);
pump.getPumpChart().setHeadUnit("meter");
pump.getPumpChart().setNPSHCurve(npshRequired);
pump.setSpeed(1000.0);
pump.run();

Do not use setHeadCurve, setEfficiencyCurve, or setNPSHRequiredCurve; those convenience methods are not part of the current Pump API.

The default PumpChart evaluates operating status in the same reduced-flow coordinate ($Q/N$) as its head and efficiency curves. The positive-head-slope check, high-flow boundary and best-efficiency-point comparison therefore follow the requested speed, not the reference-speed absolute flow. checkSurge1(flow, head) retains its legacy reference-speed interpretation; use checkSurge2(flow, speed) for a speed-specific check. These are curve-based diagnostics: the SURGE and STONEWALL labels are heuristics, not measured stability limits or an OEM-approved operating envelope. They neither prohibit speed extrapolation nor replace minimum stable flow, NPSH or driver constraints. This reduced-curve behavior does not change the alternative spline-map implementation. PumpOperatingStatusTest checks synthetic speed similarity, and NetworkPumpOperatingStatusTest exercises migration and restoration on one canonical network with mass balance, head, power and host-power checks.

The alternative PumpChartAlternativeMapLookupExtrapolate uses a different formalism: efficiency is interpolated between speed curves at the same absolute flow, and outside the supplied speed range it uses the nearest curve’s efficiency without flow scaling. Its speed-aware BEP and OPTIMAL diagnostic therefore scan that requested-speed efficiency surface, not an affinity-scaled first-curve BEP. The no-speed BEP remains the first supplied curve’s reference diagnostic. Both use the existing bounded 51-point scan over the global tabulated flow range; the result is approximate and can include extrapolation from individual curves with narrower ranges. It is not an exact maximum or a qualified operating boundary. The scan is recomputed so replacing curves, adding curves or editing the existing mutable curve data cannot reuse a stale BEP. Head/efficiency interpolation, viscosity/NPSH formulas and the existing global-flow SURGE/STONEWALL heuristics are unchanged. PumpChartAlternativeMapLookupExtrapolateTest covers non-affine speed slices and curve updates; NetworkPumpOperatingStatusTest checks same-graph migration and restoration for both chart formalisms. Neither test establishes vendor-map or speed-range qualification.

The alternative-map network regression uses pure water (SRK, classic mixing, 298.15 K, 5 bara suction) and two synthetic speed curves with linear head and non-affine efficiency peaks. These asserted points retain the same pump and host; returning to the first point restores pressure and shaft power. Head is in metres and flow is actual inlet volume.

Speed (rpm) Flow (m3/hr) Head (m) Diagnostic
1000 40 160 OPTIMAL
2000 40 360 NORMAL
2000 60 340 OPTIMAL
1500 50 250 OPTIMAL

The test also checks mass balance, positive pressure/work, finite outlet temperature, hydraulic work divided by efficiency, and equality of edge demand and host shaft power. These are analytical/same-model consistency checks, not independent pump performance data.

Specified discharge temperature

Calling setOutletTemperature(...) selects the fixed-temperature mode. NeqSim performs a TP flash at the specified discharge temperature and pressure and back-calculates power from the inlet/outlet enthalpy difference. This mode represents a measured or externally specified discharge state; it does not evaluate a vendor performance curve.

pump.setOutletPressure(15.0, "bara");
pump.setOutletTemperature(35.0, "C");
pump.run();

setOutTemperature(double) is deprecated. Use setOutletTemperature(double) for kelvin or setOutletTemperature(double, String) for an explicit unit.

Numerical bypass versus stable operating flow

Pump.setMinimumFlow(double) sets a numerical low-flow bypass threshold in kg/hr, consistent with the process-equipment base contract. Below that threshold the standalone pump is inactive and reports zero shaft work; this is not a physical operating point or a minimum-flow recirculation model. The explicit-unit overload inherited from the base class may be used when configuring the threshold in another supported mass-flow unit.

In a canonical LoopedPipeNetwork, NetworkPipe.setPumpMinimumFlowKgS is a separate minimum stable operating limit in kg/s. It produces an operating-limit residual, not a bypass command. Network evaluation preserves the backing pump’s numerical threshold and rejects bypassed positive-flow results rather than accepting zero-power pressure rise. A stable-limit violation requires an explicit operating constraint even when the network converges. See the SURF network guide and NetworkPumpMinimumFlowTest for tested limit, bypass and recovery behavior.

NPSH screening

getNPSHAvailable() returns metres of liquid head. It clones the inlet fluid, calculates its bubble-point pressure at the inlet temperature, and evaluates the pressure head. The current implementation assumes zero velocity-head contribution and expects static elevation effects to already be represented in the suction system:

\[NPSH_A = \frac{P_s-P_v}{\rho g}\]

where $P_s$ is absolute suction pressure, $P_v$ is bubble-point pressure, $\rho$ is inlet-fluid density, and $g$ is gravitational acceleration. A failed bubble-point calculation returns Double.NaN; it is not interpreted as a large safe margin.

getNPSHRequired() returns the interpolated vendor NPSHr when a chart is present. Without a vendor NPSHr curve it returns a coarse flow-based screening estimate. Treat that fallback as a data gap, not as vendor qualification.

double npshAvailableM = pump.getNPSHAvailable();
double npshRequiredM = pump.getNPSHRequired();
pump.setCheckNPSH(true);
pump.setNPSHMargin(1.15);
boolean cavitationRisk = pump.isCavitating();

The getter methods do not accept unit strings; both values are returned in metres.

API 610 mechanical-design screening

PumpMechanicalDesign combines the simulated duty with purchaser inputs and vendor curve data. Its PumpApi610DesignCalculator reports each check as PASS, WARNING, FAIL, or NOT_EVALUATED, and combines them into PASS, PASS_WITH_WARNINGS, FAIL, or NOT_EVALUATED.

The screen covers:

Missing purchaser or vendor values remain NOT_EVALUATED. NeqSim does not certify casing, rotor, bearing, nozzle, seal, baseplate, material, inspection, or test compliance. Use the purchased standard edition, project specification, and vendor documentation for final design.

Complete Java example

This Java 8 example runs a single-phase liquid pump with a vendor curve, checks NPSH, performs the API 610 screen, and exports the structured mechanical-design response. The inlet uses n-hexane so the actual-volume flow conversion is based on one stable liquid phase at the stated temperature and pressure. The example is silent and returns four finite, positive operating metrics so the published source can be executed as a documentation contract.

import neqsim.process.equipment.pump.Pump;
import neqsim.process.equipment.stream.Stream;
import neqsim.process.mechanicaldesign.pump.PumpApi610DesignCalculator;
import neqsim.process.mechanicaldesign.pump.PumpMechanicalDesign;
import neqsim.thermo.system.SystemInterface;
import neqsim.thermo.system.SystemSrkEos;

public final class PumpDesignExample {
  private PumpDesignExample() {}

  public static double[] run() {
    SystemInterface fluid = new SystemSrkEos(298.15, 5.0);
    fluid.addComponent("n-hexane", 1.0);
    fluid.setMixingRule("classic");

    Stream feed = new Stream("pump feed", fluid);
    feed.setFlowRate(100.0, "m3/hr");
    feed.run();

    Pump pump = new Pump("P-100", feed);
    double[] speed = new double[] { 1000.0 };
    double[][] flow = new double[][] { { 50.0, 75.0, 100.0, 125.0, 150.0 } };
    double[][] head = new double[][] { { 120.0, 115.0, 105.0, 90.0, 70.0 } };
    double[][] efficiency = new double[][] { { 65.0, 75.0, 82.0, 78.0, 68.0 } };
    double[][] npshRequired = new double[][] { { 2.0, 2.4, 3.0, 4.0, 5.5 } };

    pump.getPumpChart().setCurves(new double[] {}, speed, flow, head, efficiency);
    pump.getPumpChart().setHeadUnit("meter");
    pump.getPumpChart().setNPSHCurve(npshRequired);
    pump.setSpeed(1000.0);
    pump.setCheckNPSH(true);
    pump.setNPSHMargin(1.15);
    pump.run();

    double powerKw = pump.getPower("kW");
    double vendorHeadM = pump.getPumpChart().getHead(feed.getFlowRate("m3/hr"), pump.getSpeed());
    double npshAvailableM = pump.getNPSHAvailable();
    double npshRequiredM = pump.getNPSHRequired();

    PumpMechanicalDesign design = pump.getMechanicalDesign();
    design.setApi610PumpType(PumpApi610DesignCalculator.Api610PumpType.OH2);
    design.setMaximumSuctionPressure(8.0);
    design.setFurnishedCasingMawp(25.0);
    design.calcDesign();

    PumpApi610DesignCalculator assessment = design.getApi610Assessment();
    PumpApi610DesignCalculator.AssessmentStatus status = assessment.getAssessmentStatus();
    String responseJson = design.getResponse().toJson();

    double[] metrics = {powerKw, vendorHeadM, npshAvailableM, npshRequiredM};
    for (double value : metrics) {
      if (!Double.isFinite(value) || value <= 0.0) {
        throw new IllegalStateException("Pump metric is not finite and positive");
      }
    }
    if (status == null || responseJson == null || responseJson.trim().isEmpty()) {
      throw new IllegalStateException("API 610 screening result is incomplete");
    }
    return metrics;
  }

  public static void main(String[] args) {
    run();
  }
}

Interpreting results

Result Interpretation
pump.getPower("kW") Absorbed shaft power calculated by the process model
pump.getPumpChart().getHead(flow, speed) Vendor-curve head in the configured head unit
pump.getNPSHAvailable() Process-side NPSHa in metres, or NaN if unavailable
pump.getNPSHRequired() Fitted vendor-curve value or coarse fallback estimate in metres
assessment.getOperatingRegion() Rated-point classification relative to vendor BEP
assessment.getSelectedDriverPowerKw() First configured rating meeting the required driver power
assessment.getRequiredCasingPressureBara() Screening casing-pressure requirement in bara
assessment.getChecks() Immutable list of individual checks and missing-evidence findings

Limitations