Class PackedColumn

java.lang.Object
neqsim.util.NamedBaseClass
neqsim.process.SimulationBaseClass
neqsim.process.equipment.ProcessEquipmentBaseClass
neqsim.process.equipment.distillation.DistillationColumn
neqsim.process.equipment.distillation.PackedColumn
All Implemented Interfaces:
Serializable, Runnable, DistillationInterface, ProcessEquipmentInterface, ProcessElementInterface, SimulationInterface, NamedInterface
public class PackedColumn extends DistillationColumn
Packed column (contactor/absorber/stripper) using packing internals with HETP-based staging.

Models a packed column for gas absorption (amine, TEG, water wash) or stripping applications. Internally wraps a DistillationColumn and adds packing-specific functionality: HETP calculation, packing hydraulics (flooding, pressure drop, mass transfer), and packing selection.

The number of theoretical stages is determined from packed bed height and HETP. The underlying DistillationColumn provides the rigorous VLE calculations, while the PackingHydraulicsCalculator provides the hydraulic design evaluation.

Usage example: 

PackedColumn contactor = new PackedColumn("TEG Contactor", gasStream);
contactor.setPackedHeight(6.0);
contactor.setPackingType("Mellapak-250Y");
contactor.setStructuredPacking(true);
contactor.setDesignFloodFraction(0.70);
contactor.addSolventStream(leanTEGStream);
contactor.run();

StreamInterface dryGas = contactor.getGasOutStream();
StreamInterface richSolvent = contactor.getLiquidOutStream();
double hetp = contactor.getHETP();
double percentFlood = contactor.getPercentFlood();
String report = contactor.toJson();
Version:
1.0
Author:
NeqSim
See Also:

  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      Serialization version UID.
      See Also:

    • logger

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

    • packedHeight

      private double packedHeight
      Packed bed height [m].

    • packingType

      private String packingType
      Packing type name.

    • structuredPacking

      private boolean structuredPacking
      Whether packing is structured (true) or random (false).

    • designFloodFraction

      private double designFloodFraction
      Design flood fraction (0-1). Typical 0.65-0.75 for packed columns.

    • columnDiameter

      private double columnDiameter
      Column internal diameter [m]. If <= 0, auto-sized from hydraulics.

    • hydraulics

      private transient PackingHydraulicsCalculator hydraulics
      Packing hydraulics calculator (populated after run).

    • hetp

      private double hetp
      HETP from hydraulics calculation [m].

    • theoreticalStages

      private double theoreticalStages
      Number of theoretical stages from HETP (packed_height / HETP).

    • percentFlood

      private double percentFlood
      Percent flooding at operating conditions.

    • packingPressureDrop

      private double packingPressureDrop
      Total packing pressure drop [Pa].

    • floodingVelocity

      private double floodingVelocity
      Flooding velocity [m/s].

    • hydraulicsOk

      private boolean hydraulicsOk
      Whether hydraulics design is feasible.

  • Constructor Details

    • PackedColumn

      public PackedColumn(String name, boolean hasCondenser, boolean hasReboiler)
      Create a packed column with a given number of stages (from HETP).

      The default HETP of ~0.5 m is used initially. After running, HETP is recalculated from packing correlations and the internal stage count is updated.

      Parameters:
      name - equipment name
      hasCondenser - true to include a condenser
      hasReboiler - true to include a reboiler

    • PackedColumn

      public PackedColumn(String name, StreamInterface gasInStream)
      Create a packed column for absorber/contactor use (no condenser, no reboiler).
      Parameters:
      name - equipment name
      gasInStream - the gas inlet stream (bottom)

    • PackedColumn

      public PackedColumn(String name, double packedHeight, String packingType, boolean hasCondenser, boolean hasReboiler)
      Create a packed column with specified packed height and packing type.
      Parameters:
      name - equipment name
      packedHeight - packed bed height [m]
      packingType - packing name (e.g., "Pall-Ring-50", "Mellapak-250Y")
      hasCondenser - true for condenser
      hasReboiler - true for reboiler

  • Method Details

    • estimateStages

      private static int estimateStages(double height, double hetpGuess)
      Estimate the number of theoretical stages from packed height and an initial HETP guess.
      Parameters:
      height - packed bed height [m]
      hetpGuess - initial HETP guess [m]
      Returns:
      estimated stage count (at least 2)

    • setPackedHeight

      public void setPackedHeight(double height)
      Set packed bed height [m].
      Parameters:
      height - packed bed height

    • getPackedHeight

      public double getPackedHeight()
      Get packed bed height [m].
      Returns:
      packed bed height

    • setPackingType

      public void setPackingType(String packingType)
      Set packing type by name.
      Parameters:
      packingType - packing name (e.g., "Pall-Ring-50", "Mellapak-250Y")

    • getPackingType

      public String getPackingType()
      Get packing type name.
      Returns:
      packing name

    • setStructuredPacking

      public void setStructuredPacking(boolean structured)
      Set whether packing is structured or random.
      Parameters:
      structured - true for structured (e.g., Mellapak), false for random (e.g., Pall Ring)

    • isStructuredPacking

      public boolean isStructuredPacking()
      Check if packing is structured.
      Returns:
      true for structured packing

    • setDesignFloodFraction

      public void setDesignFloodFraction(double fraction)
      Set design flood fraction (typical 0.65-0.75).
      Parameters:
      fraction - flood fraction

    • getDesignFloodFraction

      public double getDesignFloodFraction()
      Get design flood fraction.
      Returns:
      flood fraction

    • setColumnDiameter

      public void setColumnDiameter(double diameter)
      Override column diameter [m]. Set to <= 0 for auto-sizing.
      Parameters:
      diameter - column diameter

    • addSolventStream

      public void addSolventStream(StreamInterface solventStream)
      Add the solvent (lean amine/TEG) stream to the top of the column.
      Parameters:
      solventStream - the lean solvent stream

    • getHETP

      public double getHETP()
      Get the calculated HETP [m].
      Returns:
      HETP

    • getTheoreticalStages

      public double getTheoreticalStages()
      Get the number of theoretical stages.
      Returns:
      theoretical stages

    • getPercentFlood

      public double getPercentFlood()
      Get percent flooding at operating conditions.
      Returns:
      percent flood

    • getPackingPressureDrop

      public double getPackingPressureDrop()
      Get packing pressure drop [Pa].
      Returns:
      pressure drop

    • getPackingPressureDrop

      public double getPackingPressureDrop(String unit)
      Get packing pressure drop with unit.
      Parameters:
      unit - "Pa", "mbar", "bar"
      Returns:
      pressure drop in specified unit

    • getFloodingVelocity

      public double getFloodingVelocity()
      Get flooding velocity [m/s].
      Returns:
      flooding velocity

    • isHydraulicsOk

      public boolean isHydraulicsOk()
      Check if the hydraulic design is feasible.
      Returns:
      true if all hydraulic checks pass

    • getHydraulics

      public PackingHydraulicsCalculator getHydraulics()
      Get the packing hydraulics calculator (null before run).
      Returns:
      hydraulics calculator

    • run

      public void run(UUID id)

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

      Solve the column until tray temperatures converge. The method applies sequential substitution with an adaptive relaxation controller. Pressures are set linearly between bottom and top. Each iteration performs an upward sweep where liquid flows downward followed by a downward sweep where vapour flows upward. Tray temperatures and inter-tray stream flow rates are relaxed if the combined temperature, mass and energy residuals grow, providing basic line-search behaviour.

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

    • calcPackingHydraulics

      private void calcPackingHydraulics()
      Calculate packing hydraulics after the column has converged.

    • toJson

      public String toJson()
      Generate a JSON report including both column results and packing hydraulics.
      Specified by:
      toJson in interface ProcessEquipmentInterface
      Overrides:
      toJson in class DistillationColumn
      Returns:
      comprehensive JSON report