Class TwoFluidPipe

java.lang.Object
neqsim.util.NamedBaseClass
neqsim.process.SimulationBaseClass
neqsim.process.equipment.ProcessEquipmentBaseClass
neqsim.process.equipment.TwoPortEquipment
neqsim.process.equipment.pipeline.Pipeline
neqsim.process.equipment.pipeline.TwoFluidPipe
All Implemented Interfaces:
Serializable, Runnable, CapacityConstrainedEquipment, PipeLineInterface, ProcessEquipmentInterface, TwoPortInterface, SimulationInterface, NamedInterface
public class TwoFluidPipe extends Pipeline
Two-fluid transient multiphase pipe model.

Implements a full two-fluid model for 1D transient multiphase pipeline flow. Unlike the drift-flux based TransientPipe, this model solves separate momentum equations for each phase, providing more accurate predictions for:

  • Countercurrent flow
  • Slug flow dynamics
  • Terrain-induced liquid accumulation
  • Transient pressure waves

Conservation Equations

  • Gas Mass: ∂/∂t(α_g·ρ_g·A) + ∂/∂x(α_g·ρ_g·v_g·A) = Γ_g
  • Liquid Mass: ∂/∂t(α_L·ρ_L·A) + ∂/∂x(α_L·ρ_L·v_L·A) = Γ_L
  • Gas Momentum: ∂/∂t(α_g·ρ_g·v_g·A) + ∂/∂x(α_g·ρ_g·v_g²·A + α_g·P·A) = S_g
  • Liquid Momentum: ∂/∂t(α_L·ρ_L·v_L·A) + ∂/∂x(α_L·ρ_L·v_L²·A + α_L·P·A) = S_L
  • Mixture Energy: (optional)

Usage Example

// Create two-phase fluid
SystemInterface fluid = new SystemSrkEos(300, 50);
fluid.addComponent("methane", 0.85);
fluid.addComponent("n-pentane", 0.15);
fluid.setMixingRule("classic");
fluid.setMultiPhaseCheck(true);

// Create inlet stream
Stream inlet = new Stream("inlet", fluid);
inlet.setFlowRate(10, "kg/sec");
inlet.run();

// Create two-fluid pipe
TwoFluidPipe pipe = new TwoFluidPipe("Pipeline", inlet);
pipe.setLength(5000); // 5 km
pipe.setDiameter(0.3); // 300 mm
pipe.setNumberOfSections(100);

// Set terrain profile
double[] elevations = new double[100];
for (int i = 0; i < 100; i++) {
  elevations[i] = 50.0 * Math.sin(i * Math.PI / 50); // Undulating terrain
}
pipe.setElevationProfile(elevations);

// Initialize steady state
pipe.run();

// Transient simulation
UUID id = UUID.randomUUID();
for (int step = 0; step < 1000; step++) {
  pipe.runTransient(0.1, id); // 0.1 second steps
}

// Get results
double[] pressures = pipe.getPressureProfile();
double[] holdups = pipe.getLiquidHoldupProfile();
double liquidInventory = pipe.getLiquidInventory("m3");

References

  • Bendiksen, K.H. et al. (1991) - The Dynamic Two-Fluid Model OLGA
  • Taitel, Y. and Dukler, A.E. (1976) - Flow regime transitions
  • Issa, R.I. and Kempf, M.H.W. (2003) - Simulation of slug flow
Version:
1.0
Author:
Even Solbraa
See Also:

  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      See Also:

    • logger

      private static final org.apache.logging.log4j.Logger logger

    • length

      private double length
      Total pipe length (m).

    • diameter

      private double diameter
      Pipe inner diameter (m).

    • roughness

      private double roughness
      Pipe wall roughness (m).

    • numberOfSections

      private int numberOfSections
      Number of computational cells.

    • elevationProfile

      private double[] elevationProfile
      Elevation profile at each section (m).

    • sections

      private TwoFluidSection[] sections
      Pipe sections with state.

    • dx

      private double dx
      Spatial step size (m).

    • simulationTime

      private double simulationTime
      Current simulation time (s).

    • maxSimulationTime

      private double maxSimulationTime
      Maximum simulation time (s).

    • cflNumber

      private double cflNumber
      CFL number for time stepping (0 < CFL < 1).

    • equations

      private TwoFluidConservationEquations equations
      Conservation equations solver.

    • timeIntegrator

      private TimeIntegrator timeIntegrator
      Time integrator.

    • flowRegimeDetector

      private FlowRegimeDetector flowRegimeDetector
      Flow regime detector.

    • accumulationTracker

      private LiquidAccumulationTracker accumulationTracker
      Liquid accumulation tracker.

    • slugTracker

      private SlugTracker slugTracker
      Slug tracker (simplified model).

    • lagrangianSlugTracker

      private LagrangianSlugTracker lagrangianSlugTracker
      Lagrangian slug tracker (OLGA-style full tracking).

    • slugTrackingMode

      private TwoFluidPipe.SlugTrackingMode slugTrackingMode
      Current slug tracking mode.

    • inletBCType

      private TwoFluidPipe.BoundaryCondition inletBCType
      Inlet boundary condition type.

    • outletBCType

      private TwoFluidPipe.BoundaryCondition outletBCType
      Outlet boundary condition type.

    • outletPressure

      private double outletPressure
      Outlet pressure (Pa).

    • outletPressureSet

      private boolean outletPressureSet
      Flag indicating if outlet pressure was explicitly set.

    • includeEnergyEquation

      private boolean includeEnergyEquation
      Include energy equation.

    • includeMassTransfer

      private boolean includeMassTransfer
      Include mass transfer (flash/condensation).

    • enableHeatTransfer

      private boolean enableHeatTransfer
      Enable heat transfer from surroundings.

    • surfaceTemperature

      private double surfaceTemperature
      Surface temperature for heat transfer (K).

    • heatTransferCoefficient

      private double heatTransferCoefficient
      Heat transfer coefficient (W/(m²·K)).

    • heatTransferProfile

      private double[] heatTransferProfile
      Heat transfer coefficient profile along pipe (W/(m²·K)).

    • surfaceTemperatureProfile

      private double[] surfaceTemperatureProfile
      Surface temperature profile along pipe (K).

    • wallThickness

      private double wallThickness
      Pipe wall thickness (m).

    • wallDensity

      private double wallDensity
      Pipe wall density (kg/m³) - steel default.

    • wallHeatCapacity

      private double wallHeatCapacity
      Pipe wall specific heat capacity (J/(kg·K)) - steel default.

    • wallTemperatureProfile

      private double[] wallTemperatureProfile
      Pipe wall temperature profile (K).

    • soilThermalResistance

      private double soilThermalResistance
      Soil/burial thermal resistance (m²·K/W).

    • thermalCalculator

      private MultilayerThermalCalculator thermalCalculator
      Multi-layer thermal calculator for OLGA-style radial heat transfer.

    • useMultilayerThermalModel

      private boolean useMultilayerThermalModel
      Enable multi-layer thermal model (vs simple U-value).

    • enableJouleThomson

      private boolean enableJouleThomson
      Enable Joule-Thomson effect.

    • hydrateFormationTemperature

      private double hydrateFormationTemperature
      Hydrate formation temperature (K).

    • waxAppearanceTemperature

      private double waxAppearanceTemperature
      Wax appearance temperature (K).

    • hydrateRiskSections

      private boolean[] hydrateRiskSections
      Sections flagged for hydrate risk.

    • waxRiskSections

      private boolean[] waxRiskSections
      Sections flagged for wax risk.

    • insulationType

      private TwoFluidPipe.InsulationType insulationType
      Current insulation type.

    • enableSlugTracking

      private boolean enableSlugTracking
      Enable slug tracking.

    • outletSlugCount

      private int outletSlugCount
      Outlet slug statistics.

    • totalSlugVolumeAtOutlet

      private double totalSlugVolumeAtOutlet

    • lastSlugArrivalTime

      private double lastSlugArrivalTime

    • maxSlugLengthAtOutlet

      private double maxSlugLengthAtOutlet

    • maxSlugVolumeAtOutlet

      private double maxSlugVolumeAtOutlet

    • countedOutletSlugs

      private Set<Integer> countedOutletSlugs
      Track which slugs have already been counted at outlet (by slug ID).

    • olgaModelType

      private TwoFluidPipe.OLGAModelType olgaModelType
      Current OLGA model type. Default is FULL for best accuracy.

    • minimumLiquidHoldup

      private double minimumLiquidHoldup
      Base minimum liquid holdup for stratified flow (OLGA-style constraint).

      OLGA enforces a minimum holdup to prevent unrealistically low values at high gas velocities. This is based on the observation that even at high velocities, a thin liquid film remains on the pipe wall in stratified/annular flow.

      The actual minimum applied is the maximum of:

      • This base value (default 1%)
      • A multiple of the no-slip holdup (lambdaL * minimumSlipFactor)

      This ensures the minimum is physically reasonable for both lean gas (low liquid loading) and rich gas condensate (high liquid loading) systems.

      Reference: Bendiksen et al. (1991) "The Dynamic Two-Fluid Model OLGA" - SPE Production Engineering

    • minimumSlipFactor

      private double minimumSlipFactor
      Slip factor applied to no-slip holdup to calculate adaptive minimum.

      The adaptive minimum holdup is calculated as: lambdaL * minimumSlipFactor. For gas-dominant systems, typical slip ratios range from 1.5-3.0. Default value of 2.0 means minimum holdup is twice the no-slip value, which accounts for liquid accumulation due to slip. This prevents the minimum from being unrealistically high for lean gas systems with very low liquid loading.

    • useAdaptiveMinimumOnly

      private boolean useAdaptiveMinimumOnly
      Use only adaptive (correlation-based) minimum, without absolute floor.

      When true, the minimum holdup is calculated purely from flow correlations (Beggs-Brill type) without enforcing the absolute minimumLiquidHoldup floor. This allows the model to predict very low holdups for lean gas systems where the physical holdup may be below 1%.

      Default is true for better handling of lean gas systems.

    • enforceMinimumSlip

      private boolean enforceMinimumSlip
      Enable OLGA-style minimum slip constraint.

      When enabled (default), enforces a minimum liquid holdup in gas-dominant stratified flow, matching OLGA behavior. When disabled, holdup can approach no-slip values at high velocities (Beggs-Brill style).

    • minimumFilmThickness

      private double minimumFilmThickness
      Minimum film thickness for annular flow (m).

      In high gas velocity annular flow, OLGA maintains a minimum liquid film on the pipe wall. This prevents unrealistically low holdup predictions. Default 0.1mm based on typical measurements.

    • annularEntrainmentFraction

      private double annularEntrainmentFraction
      Entrainment fraction in annular flow.

      Fraction of liquid entrained as droplets in the gas core. Affects the distribution between film flow and droplet flow in annular regime. OLGA uses Ishii-Mishima correlation.

    • enableAnnularFilmModel

      private boolean enableAnnularFilmModel
      Enable OLGA-style annular film model.

      When enabled, uses OLGA's annular film model which accounts for: - Minimum film thickness on pipe wall - Liquid entrainment in gas core - Wave formation and droplet deposition

    • enableTerrainTracking

      private boolean enableTerrainTracking
      Enable full OLGA-style terrain tracking.

      When enabled, uses OLGA's terrain tracking algorithm which: - Identifies all low points and high points - Tracks liquid accumulation in valleys - Models terrain-induced slugging - Handles severe slugging in risers

    • terrainSlugCriticalHoldup

      private double terrainSlugCriticalHoldup
      Critical holdup for terrain-induced slug initiation.

      When liquid holdup in a low point exceeds this value, a terrain-induced slug is initiated. Default 0.6 based on OLGA recommendations.

    • liquidFallbackCoefficient

      private double liquidFallbackCoefficient
      Liquid fallback coefficient for uphill sections.

      Controls how much liquid falls back in uphill sections when gas velocity is insufficient to carry liquid upward. Higher values mean more liquid accumulation. OLGA default ~0.3.

    • enableSevereSlugModel

      private boolean enableSevereSlugModel
      Enable severe slugging detection and modeling.

      Severe slugging occurs at riser bases when liquid periodically blocks gas flow. This cyclic phenomenon can cause large pressure and flow oscillations.

    • useOLGAFlowRegimeMap

      private boolean useOLGAFlowRegimeMap
      Use OLGA flow regime map instead of Taitel-Dukler.

      OLGA's flow regime map differs from Taitel-Dukler in several ways: - Different transition criteria for stratified wavy to slug - Accounts for pipe roughness effects - Better handling of inclined flow - Hysteresis in regime transitions

    • flowRegimeHysteresis

      private double flowRegimeHysteresis
      Flow regime transition hysteresis factor.

      OLGA uses hysteresis to prevent rapid switching between flow regimes. A value of 0.1 means 10% hysteresis band around transition boundaries.

    • thermodynamicUpdateInterval

      private int thermodynamicUpdateInterval
      Update thermodynamics every N steps.

    • currentStep

      private int currentStep
      Current step count.

    • pressureProfile

      private double[] pressureProfile
      Pressure profile (Pa).

    • temperatureProfile

      private double[] temperatureProfile
      Temperature profile (K).

    • liquidHoldupProfile

      private double[] liquidHoldupProfile
      Liquid holdup profile.

    • gasVelocityProfile

      private double[] gasVelocityProfile
      Gas velocity profile (m/s).

    • liquidVelocityProfile

      private double[] liquidVelocityProfile
      Liquid velocity profile (m/s).

    • referenceFluid

      private SystemInterface referenceFluid
      Reference fluid for flash calculations.

  • Constructor Details

    • TwoFluidPipe

      public TwoFluidPipe(String name)
      Constructor with name only.
      Parameters:
      name - Equipment name

    • TwoFluidPipe

      public TwoFluidPipe(String name, StreamInterface inStream)
      Constructor with inlet stream.
      Parameters:
      name - Equipment name
      inStream - Inlet stream

  • Method Details

    • initSubModels

      private void initSubModels()
      Initialize sub-models.

    • initializeSections

      private void initializeSections()
      Initialize pipe sections with inlet conditions.

    • runSteadyState

      private void runSteadyState()
      Run steady-state initialization.

    • updateThermodynamicsWithCondensation

      private void updateThermodynamicsWithCondensation(double massFlow, double[] localMDotGas, double[] localMDotLiq)
      Update thermodynamics along pipe with condensation tracking.

      Performs TP-flash at each section to determine local phase fractions accounting for condensation/vaporization. This is critical for gas systems with water where liquid may condense as pressure drops and temperature decreases along the pipeline.

      Parameters:
      massFlow - Total mass flow rate [kg/s]
      localMDotGas - Array to store local gas mass flow rates [kg/s]
      localMDotLiq - Array to store local liquid mass flow rates [kg/s]

    • updateTemperatureProfile

      private void updateTemperatureProfile(double massFlow, double area)
      Update temperature profile along the pipe accounting for heat transfer.

      Steady-state energy balance: m_dot * Cp * dT/dx = -h * π * D * (T - T_surface) - μ_JT * dP/dx

      Parameters:
      massFlow - Total mass flow rate [kg/s]
      area - Pipe cross-sectional area [m²]

    • updateTransientTemperature

      private void updateTransientTemperature(double massFlow, double area, double dt)
      Update temperature profile for transient simulation including pipe wall thermal mass.

      Solves coupled fluid-wall energy equations:

      • Fluid: ρ_f * Cp_f * A * dT_f/dt = -m_dot * Cp_f * dT_f/dx - h_i * π * D * (T_f - T_w)
      • Wall: ρ_w * Cp_w * A_w * dT_w/dt = h_i * π * D * (T_f - T_w) - h_o * π * D_o * (T_w - T_amb)

      If multi-layer thermal model is enabled, uses MultilayerThermalCalculator for accurate radial heat transfer through multiple layers (steel, insulation, coatings, etc.).

      Parameters:
      massFlow - Total mass flow rate [kg/s]
      area - Pipe cross-sectional area [m²]
      dt - Time step [s]

    • updateTransientTemperatureMultilayer

      private void updateTransientTemperatureMultilayer(double massFlow, double area, double dt, double Cp, double muJT)
      Update temperature using multi-layer thermal model.

      This method implements OLGA-style radial heat transfer through multiple concentric layers. The heat transfer calculation uses:

      • Inner convective resistance from fluid to pipe wall
      • Conductive resistance through each layer
      • Thermal mass storage in each layer for transient response
      • Outer convective/conductive resistance to ambient
      Parameters:
      massFlow - Total mass flow rate [kg/s]
      area - Pipe cross-sectional area [m²]
      dt - Time step [s]
      Cp - Fluid heat capacity [J/(kg·K)]
      muJT - Joule-Thomson coefficient [K/Pa]

    • calculateInnerHTC

      private double calculateInnerHTC(double massFlow, double area)
      Calculate inner (fluid-side) heat transfer coefficient based on flow conditions.

      Uses Dittus-Boelter correlation for turbulent flow, constant Nusselt for laminar.

      Parameters:
      massFlow - Mass flow rate [kg/s]
      area - Pipe cross-sectional area [m²]
      Returns:
      Inner HTC in W/(m²·K)

    • calculateLocalHoldup

      private double[] calculateLocalHoldup(TwoFluidSection sec, TwoFluidSection prev, double mDotGas, double mDotLiq, double area)
      Calculate local liquid holdup using OLGA-style models with terrain effects.

      Supports multiple model types:

      • FULL OLGA: Momentum balance for stratified, film model for annular, Dukler for slug
      • SIMPLIFIED OLGA: Empirical correlations with minimum slip constraint
      • DRIFT_FLUX: Original NeqSim drift-flux model
      Parameters:
      sec - Current section
      prev - Previous section (upstream)
      mDotGas - Gas mass flow rate [kg/s]
      mDotLiq - Liquid mass flow rate [kg/s]
      area - Pipe cross-sectional area [m²]
      Returns:
      Array with [liquidHoldup, gasHoldup]

    • calculateDriftFluxHoldup

      private double calculateDriftFluxHoldup(double vsG, double vsL, double rhoG, double rhoL, double sigma, double inclination)
      Calculate holdup using original drift-flux model.

      Uses the drift-flux model: v_G = C_0 * v_m + v_gj where:

      • C_0 = distribution coefficient (~1.0-1.2 for pipe flow)
      • v_gj = drift velocity (gas rises relative to mixture)
      Parameters:
      vsG - Gas superficial velocity [m/s]
      vsL - Liquid superficial velocity [m/s]
      rhoG - Gas density [kg/m³]
      rhoL - Liquid density [kg/m³]
      sigma - Surface tension [N/m]
      inclination - Pipe inclination [radians]
      Returns:
      Liquid holdup [-]

    • calculateStratifiedHoldupOLGA

      private double calculateStratifiedHoldupOLGA(double vsG, double vsL, double rhoG, double rhoL, double muG, double muL, double sigma, double D, double theta)
      Calculate stratified flow liquid holdup using OLGA-style momentum balance.

      This method implements the OLGA approach for stratified flow, where the liquid level is determined by a momentum balance between the phases. The key principle is that at equilibrium, the pressure gradient must be equal in both phases.

      The momentum balance accounts for:

      • Wall friction in each phase (τ_wG, τ_wL)
      • Interfacial friction between phases (τ_i)
      • Gravity component for inclined pipes

      Uses exact circular segment geometry for wetted perimeters and areas, which is critical for accurate holdup prediction at low liquid fractions (lean gas systems).

      Reference: Bendiksen et al. (1991) "The Dynamic Two-Fluid Model OLGA: Theory and Application" SPE Production Engineering, May 1991, pp. 171-180

      Parameters:
      vsG - Gas superficial velocity [m/s]
      vsL - Liquid superficial velocity [m/s]
      rhoG - Gas density [kg/m³]
      rhoL - Liquid density [kg/m³]
      muG - Gas dynamic viscosity [Pa·s]
      muL - Liquid dynamic viscosity [Pa·s]
      sigma - Surface tension [N/m]
      D - Pipe diameter [m]
      theta - Pipe inclination [radians]
      Returns:
      Equilibrium liquid holdup [-]

    • calculateAnnularHoldupOLGA

      private double[] calculateAnnularHoldupOLGA(double vsG, double vsL, double rhoG, double rhoL, double muG, double muL, double sigma, double D, double theta)
      Calculate liquid holdup for annular flow using OLGA-style film model.

      In annular flow, liquid exists as a thin film on the pipe wall and as entrained droplets in the gas core. OLGA models this using:

      • Film flow momentum balance
      • Entrainment/deposition equilibrium
      • Minimum film thickness constraint

      Reference: Bendiksen et al. (1991) and OLGA Technical Manual

      Parameters:
      vsG - Gas superficial velocity [m/s]
      vsL - Liquid superficial velocity [m/s]
      rhoG - Gas density [kg/m³]
      rhoL - Liquid density [kg/m³]
      muG - Gas dynamic viscosity [Pa·s]
      muL - Liquid dynamic viscosity [Pa·s]
      sigma - Surface tension [N/m]
      D - Pipe diameter [m]
      theta - Pipe inclination [radians]
      Returns:
      Array with [total liquid holdup, film holdup, entrained fraction]

    • calculateSlugHoldupOLGA

      private double calculateSlugHoldupOLGA(double vsG, double vsL, double rhoG, double rhoL, double muL, double sigma, double D, double theta)
      Calculate liquid holdup for slug flow using OLGA model.

      OLGA models slug flow as a sequence of liquid slugs separated by gas bubbles (Taylor bubbles). The average holdup is determined by:

      • Slug body holdup (typically 0.7-1.0)
      • Film holdup under Taylor bubble
      • Slug frequency and length
      Parameters:
      vsG - Gas superficial velocity [m/s]
      vsL - Liquid superficial velocity [m/s]
      rhoG - Gas density [kg/m³]
      rhoL - Liquid density [kg/m³]
      muL - Liquid dynamic viscosity [Pa·s]
      sigma - Surface tension [N/m]
      D - Pipe diameter [m]
      theta - Pipe inclination [radians]
      Returns:
      Slug flow average liquid holdup [-]

    • applyTerrainAccumulation

      private double applyTerrainAccumulation(TwoFluidSection sec, TwoFluidSection prev, double baseHoldup)
      Calculate terrain-induced liquid accumulation enhancement using OLGA methodology.

      This implements the full OLGA terrain tracking algorithm which accounts for:

      • Low Point Accumulation: Liquid pools in valleys due to gravity. The volume of accumulated liquid depends on the depth of the valley and gas carrying capacity.
      • Uphill Liquid Fallback: When gas velocity is below critical velocity, liquid falls back. The critical velocity is based on Taitel-Dukler flooding criterion.
      • Downhill Drainage: Liquid accelerates on downhill sections, reducing holdup.
      • Riser Base Accumulation: Special treatment for transition from horizontal/downhill to steep uphill (severe slugging potential).
      • Terrain-Induced Slugging: When low-point holdup exceeds critical value, slugs form and surge out.

      Reference: Bendiksen et al. (1991) "The Dynamic Two-Fluid Model OLGA: Theory and Application" SPE Production Engineering, May 1991, pp. 171-180

      Parameters:
      sec - Current pipe section
      prev - Previous pipe section
      baseHoldup - Base holdup from flow regime correlation
      Returns:
      Enhanced holdup accounting for terrain effects

    • checkTerrainSlugEvents

      private void checkTerrainSlugEvents(double dt)
      Check for and handle terrain-induced slug events.

      Called during transient simulation to detect when accumulated liquid in low points reaches critical level and triggers a terrain-induced slug.

      Parameters:
      dt - Time step (s)

    • estimatePressureGradient

      private double estimatePressureGradient(TwoFluidSection sec)
      Estimate pressure gradient for steady-state initialization.

      Uses Haaland equation (explicit approximation to Colebrook-White) for friction factor, consistent with AdiabaticPipe and PipeBeggsAndBrills.

      Parameters:
      sec - Current pipe section
      Returns:
      Pressure gradient estimate (Pa/m)

    • updateWaterOilHoldups

      private void updateWaterOilHoldups(TwoFluidSection sec, TwoFluidSection prev, double alphaL, double area)
      Update water and oil holdups for three-phase flow with terrain effects.

      Water is denser than oil, so it tends to accumulate in valleys (low spots) more than oil. This method calculates the local water cut which can vary along the pipe based on:

      • Gravity segregation: water settles faster in low-velocity regions
      • Terrain effects: water accumulates more in valleys
      • Slip between oil and water phases
      Parameters:
      sec - Current section
      prev - Previous section (upstream)
      alphaL - Total liquid holdup
      area - Pipe cross-sectional area

    • run

      public void run(UUID id)
      Description copied from class: Pipeline

      In this method all thermodynamic and unit operations will be calculated in a steady state calculation.

      Specified by:
      run in interface SimulationInterface
      Overrides:
      run in class Pipeline
      Parameters:
      id - UUID

    • runTransient

      public void runTransient(double dt, UUID id)
      Run transient simulation for specified time step.
      Specified by:
      runTransient in interface SimulationInterface
      Overrides:
      runTransient in class Pipeline
      Parameters:
      dt - Requested time step (s)
      id - Calculation identifier

    • validateAndCorrectState

      private void validateAndCorrectState(double[][] U_new, double[][] U_prev)
      Validate and correct state vector to prevent numerical instabilities.
      Parameters:
      U_new - New state to validate
      U_prev - Previous state for fallback

    • validateSectionStates

      private void validateSectionStates()
      Validate section states and fix any numerical issues.

    • calcStableTimeStep

      private double calcStableTimeStep()
      Calculate stable time step using CFL condition.
      Returns:
      stable time step [s]

    • updateThermodynamics

      private void updateThermodynamics()
      Update thermodynamic properties using flash calculations.

    • applyBoundaryConditions

      private void applyBoundaryConditions()
      Apply boundary conditions.

    • updateOutletStream

      private void updateOutletStream()
      Update outlet stream with current outlet conditions.

    • updateResultArrays

      private void updateResultArrays()
      Update result arrays from section states.

      Array length equals numberOfSections, with each element representing the section midpoint values.

    • getLiquidInventory

      public double getLiquidInventory(String unit)
      Get total liquid inventory in the pipe.

      Calculates inventory from conservative mass per length, converted to volume using local liquid density. This ensures consistency with the solver's mass tracking.

      Parameters:
      unit - Volume unit ("m3", "bbl", "L")
      Returns:
      Liquid volume

    • getPressureProfile

      public double[] getPressureProfile()
      Get pressure profile.
      Specified by:
      getPressureProfile in interface PipeLineInterface
      Overrides:
      getPressureProfile in class Pipeline
      Returns:
      Pressure at each section (Pa)

    • getTemperatureProfile

      public double[] getTemperatureProfile()
      Get temperature profile.
      Specified by:
      getTemperatureProfile in interface PipeLineInterface
      Overrides:
      getTemperatureProfile in class Pipeline
      Returns:
      Temperature at each section (K)

    • getLiquidHoldupProfile

      public double[] getLiquidHoldupProfile()
      Get liquid holdup profile.

      For consistency with oil and water holdups, the liquid holdup is calculated as the sum of oil and water holdups.

      Specified by:
      getLiquidHoldupProfile in interface PipeLineInterface
      Overrides:
      getLiquidHoldupProfile in class Pipeline
      Returns:
      Holdup at each section (0-1)

    • getWaterCutProfile

      public double[] getWaterCutProfile()
      Get water cut profile along the pipeline.

      For three-phase flow, water cut can vary along the pipeline as water accumulates in low spots (valleys) due to its higher density compared to oil.

      Returns:
      Water cut at each section (0-1, fraction of liquid that is water)

    • getWaterHoldupProfile

      public double[] getWaterHoldupProfile()
      Get water holdup profile along the pipeline.
      Returns:
      Water holdup at each section (0-1, fraction of pipe area occupied by water)

    • getOilHoldupProfile

      public double[] getOilHoldupProfile()
      Get oil holdup profile along the pipeline.
      Returns:
      Oil holdup at each section (0-1, fraction of pipe area occupied by oil)

    • getGasVelocityProfile

      public double[] getGasVelocityProfile()
      Get gas velocity profile.
      Returns:
      Gas velocity at each section (m/s)

    • getLiquidVelocityProfile

      public double[] getLiquidVelocityProfile()
      Get liquid velocity profile.
      Returns:
      Liquid velocity at each section (m/s)

    • getOilVelocityProfile

      public double[] getOilVelocityProfile()
      Get oil velocity profile along the pipeline.

      When water-oil slip is enabled, this returns the independent oil velocity. Otherwise, it returns the combined liquid velocity.

      Returns:
      Oil velocity at each section (m/s)

    • getWaterVelocityProfile

      public double[] getWaterVelocityProfile()
      Get water velocity profile along the pipeline.

      When water-oil slip is enabled, this returns the independent water velocity. Otherwise, it returns the combined liquid velocity.

      Returns:
      Water velocity at each section (m/s)

    • getOilWaterSlipProfile

      public double[] getOilWaterSlipProfile()
      Get oil-water velocity slip profile along the pipeline.

      Returns the difference between oil and water velocities (vOil - vWater). Positive values indicate oil is flowing faster than water.

      Returns:
      Oil-water slip velocity at each section (m/s)

    • getFlowRegimeProfile

      public PipeSection.FlowRegime[] getFlowRegimeProfile()
      Get flow regime at each section.
      Returns:
      Array of flow regimes

    • getPositionProfile

      public double[] getPositionProfile()
      Get position array for plotting.
      Returns:
      Position along pipe (m), one value per section at section midpoint

    • getSimulationTime

      public double getSimulationTime()
      Get current simulation time.
      Returns:
      Time (s)

    • getAccumulationTracker

      public LiquidAccumulationTracker getAccumulationTracker()
      Get accumulation tracker for detailed analysis.
      Returns:
      Accumulation tracker

    • getSlugTracker

      public SlugTracker getSlugTracker()
      Get slug tracker for slug statistics (simplified model).
      Returns:
      Slug tracker

    • getLagrangianSlugTracker

      public LagrangianSlugTracker getLagrangianSlugTracker()
      Get Lagrangian slug tracker for OLGA-style slug tracking.
      Returns:
      Lagrangian slug tracker

    • getSlugTrackingMode

      public TwoFluidPipe.SlugTrackingMode getSlugTrackingMode()
      Get current slug tracking mode.
      Returns:
      slug tracking mode

    • setSlugTrackingMode

      public void setSlugTrackingMode(TwoFluidPipe.SlugTrackingMode mode)
      Set slug tracking mode.

      Available modes:

      • SIMPLIFIED: Simple slug unit model with basic tracking
      • LAGRANGIAN: Full OLGA-style Lagrangian tracking with wake effects, frequency-based initiation, and detailed statistics
      • DISABLED: No slug tracking
      Parameters:
      mode - slug tracking mode

    • configureLagrangianSlugTracking

      public void configureLagrangianSlugTracking(boolean enableInletGeneration, boolean enableTerrainGeneration, boolean enableWakeEffects)
      Configure Lagrangian slug tracker parameters.

      This method provides access to advanced slug tracking configuration for the OLGA-style Lagrangian model.

      Parameters:
      enableInletGeneration - enable hydrodynamic slug generation at inlet
      enableTerrainGeneration - enable terrain-induced slug generation
      enableWakeEffects - enable wake interaction between slugs

    • getSlugTrackingStatisticsJson

      public String getSlugTrackingStatisticsJson()
      Get slug tracking statistics as JSON string.
      Returns:
      JSON string with slug statistics

    • trackOutletSlugs

      private void trackOutletSlugs()
      Track slugs arriving at outlet and collect statistics. Each slug is only counted once when it first reaches the outlet region.

    • trackOutletSlugsLagrangian

      private void trackOutletSlugsLagrangian()
      Track slugs arriving at outlet using Lagrangian tracker.

    • getOutletSlugCount

      public int getOutletSlugCount()
      Get number of slugs that have arrived at outlet.
      Returns:
      Outlet slug count

    • getTotalSlugVolumeAtOutlet

      public double getTotalSlugVolumeAtOutlet()
      Get total liquid volume delivered by slugs at outlet.
      Returns:
      Total slug volume (m³)

    • getLastSlugArrivalTime

      public double getLastSlugArrivalTime()
      Get time of last slug arrival at outlet.
      Returns:
      Time (s)

    • getMaxSlugLengthAtOutlet

      public double getMaxSlugLengthAtOutlet()
      Get maximum slug length observed at outlet.
      Returns:
      Max length (m)

    • getMaxSlugVolumeAtOutlet

      public double getMaxSlugVolumeAtOutlet()
      Get maximum slug volume observed at outlet.
      Returns:
      Max volume (m³)

    • getSlugStatisticsSummary

      public String getSlugStatisticsSummary()
      Get slug statistics summary string.
      Returns:
      Statistics summary

    • setLength

      public void setLength(double length)
      Set pipe length.
      Specified by:
      setLength in interface PipeLineInterface
      Overrides:
      setLength in class Pipeline
      Parameters:
      length - Length (m)

    • getLength

      public double getLength()
      Get pipe length.
      Specified by:
      getLength in interface PipeLineInterface
      Overrides:
      getLength in class Pipeline
      Returns:
      Length (m)

    • setDiameter

      public void setDiameter(double diameter)
      Set pipe diameter.
      Specified by:
      setDiameter in interface PipeLineInterface
      Overrides:
      setDiameter in class Pipeline
      Parameters:
      diameter - Diameter (m)

    • getDiameter

      public double getDiameter()
      Get pipe diameter.
      Specified by:
      getDiameter in interface PipeLineInterface
      Overrides:
      getDiameter in class Pipeline
      Returns:
      Diameter (m)

    • setRoughness

      public void setRoughness(double roughness)
      Set pipe wall roughness.
      Parameters:
      roughness - Roughness (m)

    • getRoughness

      public double getRoughness()
      Get pipe wall roughness.
      Returns:
      Roughness (m)

    • setNumberOfSections

      public void setNumberOfSections(int numberOfSections)
      Set number of computational sections.
      Parameters:
      numberOfSections - Number of sections

    • getNumberOfSections

      public int getNumberOfSections()
      Get number of sections.
      Returns:
      Number of sections

    • setElevationProfile

      public void setElevationProfile(double[] elevations)
      Set elevation profile.
      Parameters:
      elevations - Elevation at each section (m)

    • setOutletPressure

      public void setOutletPressure(double pressure)
      Set outlet pressure.
      Specified by:
      setOutletPressure in interface PipeLineInterface
      Specified by:
      setOutletPressure in interface TwoPortInterface
      Overrides:
      setOutletPressure in class Pipeline
      Parameters:
      pressure - Pressure (Pa)

    • setOutletPressure

      public void setOutletPressure(double pressure, String unit)
      Set outlet pressure with unit.
      Specified by:
      setOutletPressure in interface TwoPortInterface
      Overrides:
      setOutletPressure in class TwoPortEquipment
      Parameters:
      pressure - Pressure value
      unit - Pressure unit ("Pa", "bara", "barg", "psia")

    • setCflNumber

      public void setCflNumber(double cfl)
      Set CFL number for time stepping.
      Parameters:
      cfl - CFL number (0 < cfl < 1)

    • setMaxSimulationTime

      public void setMaxSimulationTime(double time)
      Set maximum simulation time for transient calculations.
      Parameters:
      time - Maximum simulation time in seconds

    • getMaxSimulationTime

      public double getMaxSimulationTime()
      Get maximum simulation time.
      Returns:
      Maximum simulation time in seconds

    • setIncludeEnergyEquation

      public void setIncludeEnergyEquation(boolean include)
      Enable/disable energy equation.
      Parameters:
      include - true to include energy equation

    • setSurfaceTemperature

      public void setSurfaceTemperature(double temperature, String unit)
      Set surface temperature for heat transfer calculations.

      Enables heat transfer modeling. The pipe loses/gains heat to reach this temperature.

      Parameters:
      temperature - Surface temperature in the specified unit
      unit - Temperature unit ("K" or "C")

    • setHeatTransferCoefficient

      public void setHeatTransferCoefficient(double heatTransferCoefficient)
      Set heat transfer coefficient for convective heat transfer.

      Heat transfer rate: Q = h * A * (T_pipe - T_surface)
      where h = heat transfer coefficient (W/(m²·K))
      A = pipe surface area (m²)
      T_pipe = bulk fluid temperature (K)
      T_surface = surrounding surface temperature (K)

      Typical values:

      • Insulated subsea pipe: 5-15 W/(m²·K)
      • Uninsulated subsea pipe: 20-30 W/(m²·K)
      • Exposed/above-ground pipe: 50-100 W/(m²·K)
      Specified by:
      setHeatTransferCoefficient in interface PipeLineInterface
      Overrides:
      setHeatTransferCoefficient in class Pipeline
      Parameters:
      heatTransferCoefficient - Heat transfer coefficient in W/(m²·K)

    • getSurfaceTemperature

      public double getSurfaceTemperature()
      Get the surface temperature used for heat transfer calculations.
      Returns:
      Surface temperature in Kelvin

    • getHeatTransferCoefficient

      public double getHeatTransferCoefficient()
      Get the heat transfer coefficient.
      Specified by:
      getHeatTransferCoefficient in interface PipeLineInterface
      Overrides:
      getHeatTransferCoefficient in class Pipeline
      Returns:
      Heat transfer coefficient in W/(m²·K)

    • isHeatTransferEnabled

      public boolean isHeatTransferEnabled()
      Check if heat transfer is enabled.
      Returns:
      true if heat transfer modeling is active

    • setIncludeMassTransfer

      public void setIncludeMassTransfer(boolean include)
      Enable/disable mass transfer (flashing/condensation).
      Parameters:
      include - true to include mass transfer

    • setEnableSlugTracking

      public void setEnableSlugTracking(boolean enable)
      Enable/disable slug tracking.
      Parameters:
      enable - true to enable slug tracking

    • setEnableWaterOilSlip

      public void setEnableWaterOilSlip(boolean enable)
      Enable water-oil velocity slip modeling.

      When enabled, uses 7-equation model with separate oil and water momentum equations, allowing water and oil phases to flow at different velocities. This is important for:

      • Uphill flow: water slips back relative to oil due to higher density
      • Downhill flow: water accelerates relative to oil
      • Stratified oil-water flow with shear at interface
      Parameters:
      enable - true to enable 7-equation model with oil-water slip

    • isWaterOilSlipEnabled

      public boolean isWaterOilSlipEnabled()
      Check if water-oil velocity slip modeling is enabled.
      Returns:
      true if 7-equation model is enabled

    • setThermodynamicUpdateInterval

      public void setThermodynamicUpdateInterval(int interval)
      Set thermodynamic update interval.
      Parameters:
      interval - Update every N time steps

    • setMinimumLiquidHoldup

      public void setMinimumLiquidHoldup(double minHoldup)
      Set minimum liquid holdup for stratified flow (OLGA-style constraint).

      This parameter enforces a minimum liquid holdup in gas-dominant stratified flow, preventing unrealistically low values at high gas velocities. OLGA uses a similar approach based on the observation that a thin liquid film always remains on the pipe wall.

      Typical values:

      • 0.005 (0.5%) - Default, suitable for gas-condensate systems
      • 0.01 (1%) - Conservative estimate for wet gas
      • 0.02 (2%) - High liquid loading or wavy stratified flow
      Parameters:
      minHoldup - Base minimum liquid holdup fraction (0-1), default 0.01

    • getMinimumLiquidHoldup

      public double getMinimumLiquidHoldup()
      Get base minimum liquid holdup for stratified flow.
      Returns:
      Base minimum liquid holdup fraction (0-1)

    • setMinimumSlipFactor

      public void setMinimumSlipFactor(double slipFactor)
      Set the slip factor used for adaptive minimum holdup calculation.

      The adaptive minimum holdup is calculated as: lambdaL * minimumSlipFactor, where lambdaL is the no-slip (input) liquid fraction. This ensures physically reasonable minimum holdup for systems with varying liquid loading.

      Example: For a lean gas with 0.5% liquid loading and slipFactor=2.0:

      • adaptiveMin = 0.005 * 2.0 = 1% holdup
      • This is more reasonable than a fixed 5% minimum
      Parameters:
      slipFactor - Multiplier for no-slip holdup (1.0-5.0), default 2.0

    • getMinimumSlipFactor

      public double getMinimumSlipFactor()
      Get the slip factor used for adaptive minimum holdup calculation.
      Returns:
      Slip factor (multiplier for no-slip holdup)

    • setEnforceMinimumSlip

      public void setEnforceMinimumSlip(boolean enforce)
      Enable or disable OLGA-style minimum slip constraint.

      When enabled (default), enforces a minimum liquid holdup in gas-dominant stratified flow. This matches OLGA behavior and prevents unrealistically low holdup at high velocities.

      When disabled, holdup can approach no-slip values at high Froude numbers, similar to the original Beggs-Brill correlation behavior.

      Parameters:
      enforce - true to enforce minimum slip (OLGA-style, default), false for Beggs-Brill style

    • isEnforceMinimumSlip

      public boolean isEnforceMinimumSlip()
      Check if OLGA-style minimum slip constraint is enabled.
      Returns:
      true if minimum slip is enforced (OLGA-style)

    • setUseAdaptiveMinimumOnly

      public void setUseAdaptiveMinimumOnly(boolean useAdaptive)
      Set whether to use adaptive-only minimum holdup (no absolute floor).

      When true (default), the minimum holdup is calculated purely from flow correlations (Beggs-Brill type) scaled by the no-slip holdup, without enforcing an absolute floor. This allows the model to predict very low holdups for lean gas systems where the physical holdup may be well below 1%.

      When false, an absolute minimum (minimumLiquidHoldup, default 0.1%) is enforced in addition to the correlation-based minimum. This is more conservative but may overpredict holdup for very lean gas systems.

      Parameters:
      useAdaptive - true to use correlation-only minimum (recommended for lean gas), false to also enforce absolute floor

    • isUseAdaptiveMinimumOnly

      public boolean isUseAdaptiveMinimumOnly()
      Check if adaptive-only minimum holdup mode is enabled.
      Returns:
      true if using correlation-based minimum only (no absolute floor)

    • setOLGAModelType

      public void setOLGAModelType(TwoFluidPipe.OLGAModelType modelType)
      Set the OLGA model type for holdup and flow regime calculations.

      Available model types:

      • FULL - Full OLGA model with momentum balance for all flow regimes (most accurate)
      • SIMPLIFIED - Simplified OLGA model with empirical correlations (faster)
      • DRIFT_FLUX - Original NeqSim drift-flux model (for backward compatibility)
      Parameters:
      modelType - the OLGA model type to use

    • getOLGAModelType

      public TwoFluidPipe.OLGAModelType getOLGAModelType()
      Get the current OLGA model type.
      Returns:
      the current OLGA model type

    • setMinimumFilmThickness

      public void setMinimumFilmThickness(double thickness)
      Set minimum film thickness for annular flow model.
      Parameters:
      thickness - minimum film thickness in meters (default 0.0001 m = 0.1 mm)

    • getMinimumFilmThickness

      public double getMinimumFilmThickness()
      Get minimum film thickness for annular flow model.
      Returns:
      minimum film thickness in meters

    • setEnableAnnularFilmModel

      public void setEnableAnnularFilmModel(boolean enable)
      Enable or disable OLGA-style annular film model.
      Parameters:
      enable - true to enable annular film model

    • isEnableAnnularFilmModel

      public boolean isEnableAnnularFilmModel()
      Check if annular film model is enabled.
      Returns:
      true if annular film model is enabled

    • setEnableTerrainTracking

      public void setEnableTerrainTracking(boolean enable)
      Enable or disable full terrain tracking.

      Terrain tracking identifies low points and models liquid accumulation in valleys. Required for accurate liquid inventory prediction in undulating pipelines.

      Parameters:
      enable - true to enable terrain tracking (default true)

    • isEnableTerrainTracking

      public boolean isEnableTerrainTracking()
      Check if terrain tracking is enabled.
      Returns:
      true if terrain tracking is enabled

    • setTerrainSlugCriticalHoldup

      public void setTerrainSlugCriticalHoldup(double criticalHoldup)
      Set the critical holdup for terrain-induced slug initiation.
      Parameters:
      criticalHoldup - holdup fraction (0-1) at which terrain slug initiates (default 0.6)

    • getTerrainSlugCriticalHoldup

      public double getTerrainSlugCriticalHoldup()
      Get the critical holdup for terrain-induced slug initiation.
      Returns:
      critical holdup fraction

    • setLiquidFallbackCoefficient

      public void setLiquidFallbackCoefficient(double coefficient)
      Set the liquid fallback coefficient for uphill sections.

      Controls liquid accumulation in uphill sections. Higher values mean more liquid falls back and accumulates. OLGA default is approximately 0.3.

      Parameters:
      coefficient - fallback coefficient (0-1), default 0.3

    • getLiquidFallbackCoefficient

      public double getLiquidFallbackCoefficient()
      Get the liquid fallback coefficient.
      Returns:
      liquid fallback coefficient

    • setEnableSevereSlugModel

      public void setEnableSevereSlugModel(boolean enable)
      Enable or disable severe slugging model for risers.
      Parameters:
      enable - true to enable severe slugging detection (default true)

    • isEnableSevereSlugModel

      public boolean isEnableSevereSlugModel()
      Check if severe slugging model is enabled.
      Returns:
      true if severe slugging model is enabled

    • setUseOLGAFlowRegimeMap

      public void setUseOLGAFlowRegimeMap(boolean enable)
      Enable or disable OLGA flow regime map.

      When enabled, uses OLGA's flow regime transition criteria instead of Taitel-Dukler. OLGA's criteria include roughness effects and better inclined flow handling.

      Parameters:
      enable - true to use OLGA flow regime map (default true)

    • isUseOLGAFlowRegimeMap

      public boolean isUseOLGAFlowRegimeMap()
      Check if OLGA flow regime map is used.
      Returns:
      true if OLGA flow regime map is enabled

    • setFlowRegimeHysteresis

      public void setFlowRegimeHysteresis(double hysteresis)
      Set flow regime transition hysteresis factor.

      Prevents rapid switching between flow regimes near transition boundaries. A value of 0.1 means 10% hysteresis band.

      Parameters:
      hysteresis - hysteresis factor (0-0.5), default 0.1

    • getFlowRegimeHysteresis

      public double getFlowRegimeHysteresis()
      Get flow regime transition hysteresis factor.
      Returns:
      hysteresis factor

    • setInsulationType

      public void setInsulationType(TwoFluidPipe.InsulationType type)
      Set insulation type using predefined U-values.

      This is a convenience method that sets appropriate heat transfer coefficient based on insulation type. Automatically enables heat transfer modeling.

      Parameters:
      type - Insulation type preset

    • getInsulationTypeEnum

      public TwoFluidPipe.InsulationType getInsulationTypeEnum()
      Get the current insulation type.
      Returns:
      Current insulation type

    • getInsulationType

      public String getInsulationType()
      Get the insulation type/material.
      Specified by:
      getInsulationType in interface PipeLineInterface
      Overrides:
      getInsulationType in class Pipeline
      Returns:
      insulation type

    • setInsulationType

      public void setInsulationType(String type)
      Set the insulation type/material.
      Specified by:
      setInsulationType in interface PipeLineInterface
      Overrides:
      setInsulationType in class Pipeline
      Parameters:
      type - insulation type (e.g., "polyurethane", "mineral wool", "aerogel")

    • setHeatTransferProfile

      public void setHeatTransferProfile(double[] profile)
      Set heat transfer coefficient profile along the pipe.

      Allows different U-values at different positions (e.g., buried vs exposed sections).

      Parameters:
      profile - Array of U-values [W/(m²·K)], one per section

    • getHeatTransferProfile

      public double[] getHeatTransferProfile()
      Get the heat transfer coefficient profile.
      Returns:
      Array of U-values or null if constant

    • setSurfaceTemperatureProfile

      public void setSurfaceTemperatureProfile(double[] profile)
      Set surface temperature profile along the pipe.

      Allows different ambient temperatures at different positions (e.g., varying seabed depth).

      Parameters:
      profile - Array of surface temperatures [K], one per section

    • getSurfaceTemperatureProfile

      public double[] getSurfaceTemperatureProfile()
      Get the surface temperature profile.
      Returns:
      Array of surface temperatures or null if constant

    • setWallProperties

      public void setWallProperties(double thickness, double density, double heatCapacity)
      Set pipe wall properties for transient thermal calculations.
      Parameters:
      thickness - Wall thickness [m]
      density - Wall material density [kg/m³]
      heatCapacity - Wall specific heat capacity [J/(kg·K)]

    • getWallThickness

      public double getWallThickness()
      Get pipe wall thickness.
      Specified by:
      getWallThickness in interface PipeLineInterface
      Overrides:
      getWallThickness in class Pipeline
      Returns:
      Wall thickness [m]

    • setSoilThermalResistance

      public void setSoilThermalResistance(double resistance)
      Set soil/burial thermal resistance.

      For buried pipelines, this adds thermal resistance between pipe outer wall and ambient. The effective U-value becomes: U_eff = 1 / (1/U + R_soil)

      Parameters:
      resistance - Soil thermal resistance [m²·K/W]

    • getSoilThermalResistance

      public double getSoilThermalResistance()
      Get soil thermal resistance.
      Returns:
      Soil thermal resistance [m²·K/W]

    • getThermalCalculator

      public MultilayerThermalCalculator getThermalCalculator()
      Get or create the multi-layer thermal calculator.

      If not yet created, initializes with current pipe geometry. The calculator allows defining multiple radial thermal layers (steel wall, insulation, coatings, etc.) for accurate heat transfer calculations.

      Returns:
      MultilayerThermalCalculator instance

    • setThermalCalculator

      public void setThermalCalculator(MultilayerThermalCalculator calculator)
      Set a pre-configured thermal calculator.
      Parameters:
      calculator - Configured MultilayerThermalCalculator

    • setUseMultilayerThermalModel

      public void setUseMultilayerThermalModel(boolean enable)
      Enable multi-layer thermal model for OLGA-style radial heat transfer.

      When enabled, uses the MultilayerThermalCalculator for accurate heat transfer with proper modeling of:

      • Steel pipe wall thermal mass and conductivity
      • Insulation layers (PU foam, syntactic, aerogel, etc.)
      • Coating layers (FBE, 3LPE, etc.)
      • Concrete weight coating
      • Burial/soil effects
      Parameters:
      enable - true to use multi-layer model, false to use simple U-value

    • isUseMultilayerThermalModel

      public boolean isUseMultilayerThermalModel()
      Check if multi-layer thermal model is enabled.
      Returns:
      true if using multi-layer thermal model

    • configureSubseaThermalModel

      public void configureSubseaThermalModel(double insulationThickness, double concreteThickness, RadialThermalLayer.MaterialType insulationMaterial)
      Configure standard subsea pipe thermal model.

      Creates a typical subsea configuration with:

      1. Steel wall
      2. FBE corrosion coating
      3. Insulation (optional)
      4. Concrete weight coating (optional)
      Parameters:
      insulationThickness - Insulation thickness [m], 0 for uninsulated
      concreteThickness - Concrete coating thickness [m], 0 for none
      insulationMaterial - Type of insulation material

    • configureBuriedThermalModel

      public void configureBuriedThermalModel(double burialDepth, boolean wetSoil)
      Configure buried onshore pipe thermal model.
      Parameters:
      burialDepth - Depth of cover [m]
      wetSoil - true for wet soil, false for dry

    • calculateCooldownTime

      public double calculateCooldownTime(double targetTemperature, String unit)
      Calculate cooldown time from current state to a target temperature.

      Estimates shutdown cooldown time, useful for hydrate prevention planning.

      Parameters:
      targetTemperature - Target temperature
      unit - Temperature unit ("K" or "C")
      Returns:
      Cooldown time in hours

    • calculateHydrateCooldownTime

      public double calculateHydrateCooldownTime()
      Calculate cooldown time to hydrate formation temperature.
      Returns:
      Cooldown time in hours, or infinity if hydrate temp not set

    • getThermalSummary

      public String getThermalSummary()
      Get thermal summary including U-value and layer details.
      Returns:
      Formatted thermal summary string

    • setEnableJouleThomson

      public void setEnableJouleThomson(boolean enable)
      Enable or disable Joule-Thomson effect.

      When enabled, temperature drops due to pressure reduction are calculated. This is important for gas pipelines with significant pressure drop.

      Parameters:
      enable - true to enable J-T effect

    • isJouleThomsonEnabled

      public boolean isJouleThomsonEnabled()
      Check if Joule-Thomson effect is enabled.
      Returns:
      true if J-T effect is modeled

    • setHydrateFormationTemperature

      public void setHydrateFormationTemperature(double temperature, String unit)
      Set hydrate formation temperature for risk monitoring.
      Parameters:
      temperature - Hydrate formation temperature
      unit - Temperature unit ("K" or "C")

    • getHydrateFormationTemperature

      public double getHydrateFormationTemperature()
      Get hydrate formation temperature.
      Returns:
      Hydrate formation temperature [K], or 0 if not set

    • setWaxAppearanceTemperature

      public void setWaxAppearanceTemperature(double temperature, String unit)
      Set wax appearance temperature for risk monitoring.
      Parameters:
      temperature - Wax appearance temperature
      unit - Temperature unit ("K" or "C")

    • getWaxAppearanceTemperature

      public double getWaxAppearanceTemperature()
      Get wax appearance temperature.
      Returns:
      Wax appearance temperature [K], or 0 if not set

    • getHydrateRiskSections

      public boolean[] getHydrateRiskSections()
      Get sections with hydrate formation risk.
      Returns:
      Array of booleans, true where temperature is below hydrate formation temperature

    • getWaxRiskSections

      public boolean[] getWaxRiskSections()
      Get sections with wax deposition risk.
      Returns:
      Array of booleans, true where temperature is below wax appearance temperature

    • hasHydrateRisk

      public boolean hasHydrateRisk()
      Check if any section has hydrate risk.
      Returns:
      true if any section temperature is below hydrate formation temperature

    • hasWaxRisk

      public boolean hasWaxRisk()
      Check if any section has wax risk.
      Returns:
      true if any section temperature is below wax appearance temperature

    • getTemperatureProfile

      public double[] getTemperatureProfile(String unit)
      Get temperature profile with specified unit.
      Parameters:
      unit - Temperature unit ("K", "C", or "F")
      Returns:
      Temperature profile in the specified unit

    • getWallTemperatureProfile

      public double[] getWallTemperatureProfile()
      Get the pipe wall temperature profile.
      Returns:
      Wall temperature profile [K], or null if not calculated

    • getHydrateRiskSectionCount

      public int getHydrateRiskSectionCount()
      Get number of sections with hydrate risk.
      Returns:
      Count of sections below hydrate formation temperature

    • getFirstHydrateRiskSection

      public int getFirstHydrateRiskSection()
      Get first section index with hydrate risk.
      Returns:
      Section index where hydrate risk first occurs, or -1 if no risk

    • getDistanceToHydrateRisk

      public double getDistanceToHydrateRisk()
      Get distance to first hydrate risk location.
      Returns:
      Distance [m] from inlet to first hydrate risk, or -1 if no risk