Class PinchAnalyzer

java.lang.Object
neqsim.process.util.heatintegration.PinchAnalyzer
All Implemented Interfaces:
Serializable
public class PinchAnalyzer extends Object implements Serializable
Performs pinch analysis (heat integration) on a process system.

Identifies hot and cold streams from process equipment, builds composite curves, calculates minimum approach temperature, and recommends heat exchanger matches for energy recovery.

Based on Linnhoff & Hindmarsh (1983) pinch technology methodology.

Usage example: 


PinchAnalyzer analyzer = new PinchAnalyzer(process);
analyzer.setMinApproachTemperature(10.0); // 10 K
analyzer.analyze();
double pinchT = analyzer.getPinchTemperature();
double minHotUtility = analyzer.getMinHotUtilityDuty();
double minColdUtility = analyzer.getMinColdUtilityDuty();
String json = analyzer.toJson();
Version:
1.0
Author:
ESOL
See Also:

  • Field Details

    • serialVersionUID

      private static final long serialVersionUID
      See Also:

    • processSystem

      private final ProcessSystem processSystem

    • minApproachTemperature

      private double minApproachTemperature

    • hotStreams

      private final List<PinchAnalyzer.HeatStream> hotStreams

    • coldStreams

      private final List<PinchAnalyzer.HeatStream> coldStreams

    • pinchTemperature

      private double pinchTemperature

    • minHotUtilityDuty

      private double minHotUtilityDuty

    • minColdUtilityDuty

      private double minColdUtilityDuty

    • hotCompositeCurve

      private final List<double[]> hotCompositeCurve

    • coldCompositeCurve

      private final List<double[]> coldCompositeCurve

    • grandCompositeCurve

      private final List<double[]> grandCompositeCurve

    • matches

      private final List<PinchAnalyzer.HeatExchangerMatch> matches

    • analyzed

      private boolean analyzed

  • Constructor Details

    • PinchAnalyzer

      public PinchAnalyzer(ProcessSystem processSystem)
      Creates a pinch analyzer for the given process system.
      Parameters:
      processSystem - the process system to analyze

  • Method Details

    • setMinApproachTemperature

      public void setMinApproachTemperature(double deltaT)
      Sets the minimum approach temperature (delta T_min).
      Parameters:
      deltaT - minimum approach temperature in K (default 10.0)

    • getMinApproachTemperature

      public double getMinApproachTemperature()
      Gets the minimum approach temperature.
      Returns:
      minimum approach temperature in K

    • addHotStream

      public void addHotStream(String name, double supplyTempK, double targetTempK, double dutyW)
      Manually adds a hot stream to the analysis.
      Parameters:
      name - stream name
      supplyTempK - supply temperature in K
      targetTempK - target temperature in K
      dutyW - heat duty in W

    • addColdStream

      public void addColdStream(String name, double supplyTempK, double targetTempK, double dutyW)
      Manually adds a cold stream to the analysis.
      Parameters:
      name - stream name
      supplyTempK - supply temperature in K
      targetTempK - target temperature in K
      dutyW - heat duty in W

    • extractStreams

      public void extractStreams()
      Extracts hot and cold streams automatically from the process system.

    • analyze

      public void analyze()
      Runs the pinch analysis. Extracts streams if none are present, then calculates composite curves, pinch point, utility duties, and matching.

    • buildCompositeCurves

      private void buildCompositeCurves()
      Builds temperature-enthalpy composite curves for hot and cold streams.

    • buildSingleComposite

      private void buildSingleComposite(List<PinchAnalyzer.HeatStream> streams, List<double[]> composite, boolean isHot)
      Builds a single composite curve from a list of heat streams.
      Parameters:
      streams - list of heat streams
      composite - output composite curve as list of [Q, T] pairs
      isHot - true for hot composite, false for cold composite

    • calculatePinchAndUtilities

      private void calculatePinchAndUtilities()
      Calculates pinch temperature and minimum utility duties using the problem table algorithm.

    • generateMatches

      private void generateMatches()
      Generates heat exchanger match suggestions using the pinch design method.

    • containsDouble

      private boolean containsDouble(List<Double> list, double value)
      Helper to check if a double list contains a value within tolerance.
      Parameters:
      list - the list to search
      value - the value to find
      Returns:
      true if found within 0.001

    • getPinchTemperature

      public double getPinchTemperature()
      Gets the pinch temperature (shifted).
      Returns:
      pinch temperature in K

    • getMinHotUtilityDuty

      public double getMinHotUtilityDuty()
      Gets the minimum hot utility duty.
      Returns:
      minimum hot utility in W

    • getMinColdUtilityDuty

      public double getMinColdUtilityDuty()
      Gets the minimum cold utility duty.
      Returns:
      minimum cold utility in W

    • getHotStreams

      public List<PinchAnalyzer.HeatStream> getHotStreams()
      Gets the list of hot streams identified.
      Returns:
      list of hot HeatStream objects

    • getColdStreams

      public List<PinchAnalyzer.HeatStream> getColdStreams()
      Gets the list of cold streams identified.
      Returns:
      list of cold HeatStream objects

    • getHotCompositeCurve

      public List<double[]> getHotCompositeCurve()
      Gets the hot composite curve as list of [Q(W), T(K)] pairs.
      Returns:
      hot composite curve data points

    • getColdCompositeCurve

      public List<double[]> getColdCompositeCurve()
      Gets the cold composite curve as list of [Q(W), T(K)] pairs.
      Returns:
      cold composite curve data points

    • getGrandCompositeCurve

      public List<double[]> getGrandCompositeCurve()
      Gets the grand composite curve as list of [Q(W), T(K)] pairs.
      Returns:
      grand composite curve data points

    • getMatches

      public List<PinchAnalyzer.HeatExchangerMatch> getMatches()
      Gets the suggested heat exchanger matches.
      Returns:
      list of HeatExchangerMatch suggestions

    • getTotalRecoverableEnergy

      public double getTotalRecoverableEnergy()
      Gets the total recoverable energy from all suggested matches.
      Returns:
      total recoverable energy in W

    • getEnergyRecoveryFraction

      public double getEnergyRecoveryFraction()
      Gets the energy recovery percentage relative to total heating/cooling duty.
      Returns:
      energy recovery as a fraction (0.0 to 1.0)

    • toJson

      public String toJson()
      Returns the analysis results as a JSON string.
      Returns:
      JSON representation of pinch analysis results