SteamSystemModelerTool.h

#pragma once
 
#include <cmath>
#include <iostream>
#include <memory>
#include <string>
 
class Point {
  public:
    Point(double x, double y) : x_(x), y_(y) {}
 
    double getX() const { return x_; }
 
    double getY() const { return y_; }
 
  private:
    double x_, y_;
};
 
class SteamSystemModelerTool {
  public:
    struct SteamPropertiesOutput {
        SteamPropertiesOutput(const double temperature, const double pressure, const double quality,
                              const double specificVolume, const double density, const double specificEnthalpy,
                              const double specificEntropy, const double internalEnergy = 0,
                              const double specificIsobaricHeatCapacity_cp = 0, const double specificIsochoricHeatCapacity_cv = 0,
                              const double speedOfSound_w = 0, const double isentropicExponent = 0)
            : temperature(temperature), pressure(pressure), quality(quality), specificVolume(specificVolume),
              density(density), specificEnthalpy(specificEnthalpy), specificEntropy(specificEntropy),
              internalEnergy(internalEnergy),
              specificIsobaricHeatCapacity_cp(specificIsobaricHeatCapacity_cp), specificIsochoricHeatCapacity_cv(specificIsochoricHeatCapacity_cv),
              speedOfSound_w(speedOfSound_w), isentropicExponent(isentropicExponent){}
 
        friend std::ostream& operator<<(std::ostream& stream, const SteamPropertiesOutput& props);
 
        SteamPropertiesOutput() = default;
 
        double temperature = 0, pressure = 0, quality = 0, specificVolume = 0, density = 0;
        double specificEnthalpy = 0, specificEntropy = 0, internalEnergy = 0;
        double specificIsobaricHeatCapacity_cp = 0, specificIsochoricHeatCapacity_cv = 0, speedOfSound_w = 0, isentropicExponent = 0;
    };
 
    struct SaturatedPropertiesOutput {
        SaturatedPropertiesOutput(const double temperature, const double pressure, const double gasSpecificVolume,
                                  const double gasSpecificEnthalpy, const double gasSpecificEntropy,
                                  const double liquidSpecificVolume, const double liquidSpecificEnthalpy,
                                  const double liquidSpecificEntropy, const double evaporationSpecificVolume,
                                  const double evaporationSpecificEnthalpy, const double evaporationSpecificEntropy)
            : temperature(temperature), pressure(pressure), gasSpecificVolume(gasSpecificVolume),
              gasSpecificEnthalpy(gasSpecificEnthalpy), gasSpecificEntropy(gasSpecificEntropy),
              liquidSpecificVolume(liquidSpecificVolume), liquidSpecificEnthalpy(liquidSpecificEnthalpy),
              liquidSpecificEntropy(liquidSpecificEntropy), evaporationSpecificVolume(evaporationSpecificVolume),
              evaporationSpecificEnthalpy(evaporationSpecificEnthalpy),
              evaporationSpecificEntropy(evaporationSpecificEntropy) {}
 
        SaturatedPropertiesOutput() = default;
 
        double temperature = 0, pressure = 0;
        double gasSpecificVolume = 0, gasSpecificEnthalpy = 0, gasSpecificEntropy = 0;
        double liquidSpecificVolume = 0, liquidSpecificEnthalpy = 0, liquidSpecificEntropy = 0;
        double evaporationSpecificVolume = 0, evaporationSpecificEnthalpy = 0, evaporationSpecificEntropy = 0;
    };
 
    struct FluidProperties : public SteamPropertiesOutput {
        FluidProperties(const double massFlow, const double energyFlow, const double temperature, const double pressure,
                        const double quality, const double specificVolume, const double density,
                        const double specificEnthalpy, const double specificEntropy, const double internalEnergy = 0)
            : SteamPropertiesOutput(temperature, pressure, quality, specificVolume, density, specificEnthalpy,
                                    specificEntropy, internalEnergy),
              massFlow(massFlow), energyFlow(energyFlow) {}
 
        FluidProperties(const double massFlow, const double energyFlow, SteamPropertiesOutput const& sp)
            : SteamPropertiesOutput(sp.temperature, sp.pressure, sp.quality, sp.specificVolume, sp.density,
                                    sp.specificEnthalpy, sp.specificEntropy, sp.internalEnergy),
              massFlow(massFlow), energyFlow(energyFlow) {}
 
        friend std::ostream& operator<<(std::ostream& stream, const FluidProperties& props);
        friend std::ostream& operator<<(std::ostream& stream, const std::shared_ptr<FluidProperties>& props);
 
        FluidProperties() = default;
 
        double massFlow = 0, energyFlow = 0;
    };
 
    enum class Key { ENTHALPY, ENTROPY };
 
    enum class Region { REGION1, REGION2A, REGION2B, REGION2C };
 
  private:
    static void checkIsentropicExponentLimits(double& k);
 
    static int regionSelect(double pressure, double temperature);
 
    static SteamPropertiesOutput region1(double temperature, double pressure);
 
    static SteamPropertiesOutput region2(double temperature, double pressure);
 
    static SteamPropertiesOutput region3(double temperature, double pressure);
 
    static SteamPropertiesOutput region3Density(double density, double temperature);
 
    static double region4(double temperature);
 
    static double backwardPressureEnthalpyRegion1(double pressure, double enthalpy);
 
    static double backwardPressureEnthalpyRegion2A(double pressure, double enthalpy);
 
    static double backwardPressureEnthalpyRegion2B(double pressure, double enthalpy);
 
    static double backwardPressureEnthalpyRegion2C(double pressure, double enthalpy);
 
    static double backwardPressureEntropyRegion2A(double pressure, double entropy);
 
    static double backwardPressureEntropyRegion2B(double pressure, double entropy);
 
    static double backwardPressureEntropyRegion2C(double pressure, double entropy);
 
    static double backwardPressureEntropyRegion1(double pressure, double entropy);
 
    static Point generatePoint(int region, SteamSystemModelerTool::Key key, double var1, double var2);
 
    static double linearTestPoint(double X, Point point1, Point point2);
 
    static double backwardRegion3Exact(double pressure, double X, SteamSystemModelerTool::Key key);
 
    static double backwardPressureEnthalpyRegion3(double pressure, double enthalpy);
 
    static double backwardPressureEntropyRegion3(double pressure, double entropy);
 
    static double backwardPressureEnthalpyRegion1Exact(double pressure, double enthalpy);
 
    static double backwardPressureEntropyRegion1Exact(double pressure, double entropy);
 
    static double backwardPressureEnthalpyRegion2AExact(double pressure, double enthalpy);
 
    static double backwardPressureEntropyRegion2AExact(double pressure, double entropy);
 
    static double backwardPressureEnthalpyRegion2BExact(double pressure, double enthalpy);
 
    static double backwardPressureEntropyRegion2BExact(double pressure, double entropy);
 
    static double backwardPressureEnthalpyRegion2CExact(double pressure, double enthalpy);
 
    static double backwardPressureEntropyRegion2CExact(double pressure, double entropy);
 
    static double backwardExact(int region, SteamSystemModelerTool::Key key,
                                SteamSystemModelerTool::Region regionFunction, double pressure, double var2);
 
    // constants
 
    static constexpr double PRESSURE_MIN = 0.01;
    static constexpr double TEMPERATURE_MIN = 273.15;
    static constexpr double PRESSURE_Tp = 16.5291643;
 
    static constexpr double TEMPERATURE_Tp = 623.15;
 
    static constexpr double PRESSURE_CRIT = 22.064;
 
    static constexpr double TEMPERATURE_CRIT = 647.096;
 
    static constexpr double PRESSURE_MAX = 100;
 
    static constexpr double TEMPERATURE_MAX = 1073.15;
 
    static constexpr double TEMPERATURE_REGION3_MAX = 863.15;
 
    static inline double boundaryByTemperatureRegion3to2(const double t) {
        return 0.34805185628969E+03 - 0.11671859879975E+01 * t + 0.10192970039326E-02 * std::pow(t, 2.0);
    }
 
    static inline double boundaryByPressureRegion3to2(const double p) {
        return 0.57254459862746E+03 + std::pow((p - 0.13918839778870E+02) / 0.10192970039326E-02, 0.5);
    }
 
    friend class SteamProperties;
    friend class SaturatedProperties;
};