steam_leak_survey.h

Go to the documentation of this file.

#pragma once
 
#include <cmath>
#include <stdexcept>
#include <string>
 
#include "quantify_steam_leak_by_plume_length.h"
#include "physics/constants.h"
#include "steamModeler/SteamProperties.h"
 
class SteamLeakSurvey {
public:
    enum class UtilityType { steam, electric, natural_gas };
 
    struct SteamLeakSurveyResults {
        SteamLeakSurveyResults(const double leakRate, const double steamLoss, const double energyLoss, const double leakCost)
            : leakRate(leakRate), steamLoss(steamLoss), energyLoss(energyLoss), leakCost(leakCost) {}
 
        const double leakRate, steamLoss, energyLoss, leakCost;
    };
 
    SteamLeakSurvey(const double operatingTime, const double steamTemp, const double steamPressure, const double costOfElectricity,
        const double leakPressure, const double leakTemp, const double feedwaterTemp,
        const double steamCost) :
            SteamLeakSurvey(operatingTime, steamTemp, steamPressure, costOfElectricity,
                leakPressure, leakTemp, feedwaterTemp,
                0, 0, UtilityType::steam, 0, 1, steamCost) {}
 
    SteamLeakSurvey(const double operatingTime, const double steamTemp, const double steamPressure, const double costOfElectricity,
        const double leakPressure, const double leakTemp, const double feedwaterTemp,
        const double boilerEfficiency, const double systemEfficiency) :
            SteamLeakSurvey(operatingTime, steamTemp, steamPressure, costOfElectricity,
                leakPressure, leakTemp, feedwaterTemp,
                boilerEfficiency, systemEfficiency, UtilityType::electric){}
 
    SteamLeakSurvey(const double operatingTime, const double steamTemp, const double steamPressure, const double costOfElectricity,
        const double leakPressure, const double leakTemp, const double feedwaterTemp,
        const double boilerEfficiency, const double systemEfficiency,
        const double fuelCost, const double fuelEnergyFactor = 1) :
            SteamLeakSurvey(operatingTime, steamTemp, steamPressure, costOfElectricity,
                leakPressure, leakTemp, feedwaterTemp,
                boilerEfficiency, systemEfficiency, UtilityType::natural_gas, fuelCost, fuelEnergyFactor){}
 
    SteamLeakSurvey(const double operatingTime, const double steamTemp, const double steamPressure, const double costOfElectricity,
        const double leakPressure, const double leakTemp, const double feedwaterTemp,
        const double boilerEfficiency, const double systemEfficiency, const UtilityType utilityType,
        const double fuelCost = 0, const double fuelEnergyFactor = 1, const double steamCost = 0) :
    operatingTime(operatingTime), steamPressure(steamPressure), leakPressure(leakPressure), costOfElectricity(costOfElectricity) {
        constexpr auto feedWaterPressureMPa = physics::conversions::psigToMPa(physics::conversions::kWaterSurfacePressure);
        const auto steamPressureMPa = physics::conversions::psigToMPa(steamPressure);
        const auto leakPressureMPa = physics::conversions::psigToMPa(leakPressure);
        const auto steamTempK = physics::conversions::fahrenheitToKelvin(steamTemp);
        const auto leakTempK = physics::conversions::fahrenheitToKelvin(leakTemp);
        const auto feedwaterTempK = physics::conversions::fahrenheitToKelvin(feedwaterTemp);
 
        const auto steamProperties = SteamProperties(steamPressureMPa, SteamProperties::ThermodynamicQuantity::TEMPERATURE, steamTempK).calculate();
        specificHeatRatio = steamProperties.isentropicExponent;
        steamSpecificEnthalpy = steamProperties.specificEnthalpy;
        isentropicEnthalpy = SteamProperties(leakPressureMPa, SteamProperties::ThermodynamicQuantity::ENTROPY,steamProperties.specificEntropy).calculate().specificEnthalpy;
        leakEnthalpy = SteamProperties(leakPressureMPa, SteamProperties::ThermodynamicQuantity::TEMPERATURE,leakTempK).calculate().specificEnthalpy;
        feedwaterEnthalpy = SteamProperties(feedWaterPressureMPa, SteamProperties::ThermodynamicQuantity::TEMPERATURE, feedwaterTempK).calculate().specificEnthalpy;
 
        double leakSpecificVolume = SteamProperties(leakPressureMPa, SteamProperties::ThermodynamicQuantity::TEMPERATURE, leakTempK).calculate().specificVolume;
        leakSpecificVolume *= physics::conversions::kM3PerKgToFt3PerLb;
        leakSpecificVolume *= physics::conversions::kFt3ToIn3;
 
        feedwaterEnthalpy *= physics::conversions::kKJPerKgToBtuPerLb;
        steamSpecificEnthalpy *= physics::conversions::kKJPerKgToBtuPerLb;
        isentropicEnthalpy *= physics::conversions::kKJPerKgToBtuPerLb;
        leakEnthalpy *= physics::conversions::kKJPerKgToBtuPerLb;
        leakDensity = 1 / leakSpecificVolume;  // lb/in3
 
        switch (utilityType) {
            case UtilityType::natural_gas:
                this->steamCost = fuelCost * fuelEnergyFactor * (steamSpecificEnthalpy - feedwaterEnthalpy) / 1000000 / (boilerEfficiency/100) / (systemEfficiency/100);
                break;
            case UtilityType::electric:
                this->steamCost = costOfElectricity * 293.071 * (steamSpecificEnthalpy - feedwaterEnthalpy) / 1000000 / (boilerEfficiency/100) / (systemEfficiency/100);
                break;
            case UtilityType::steam :
                this->steamCost = steamCost;
                break;
        }
    }
 
    SteamLeakSurveyResults estimateMethodPRVCalc(const double leakRate) const {
        return calculate(leakRate);
    }
 
    SteamLeakSurveyResults estimateMethodTurbineCalc(const double turbineEfficiency, const double leakRate) const {
        return calculate(leakRate, turbineEfficiency);
    }
 
    SteamLeakSurveyResults orificeMethodCalc(const double turbineEfficiency, const double holeSize, const double dischargeCoef, const double atmPressure) const {
        const double criticalPressureRatio = std::pow(2 / (specificHeatRatio+1), (specificHeatRatio+1) / (specificHeatRatio-1));
        const double pressureRatio = atmPressure / (leakPressure + atmPressure);
        const double minPressure = atmPressure / (criticalPressureRatio - atmPressure);
 
        if (criticalPressureRatio <= pressureRatio) {
            throw std::runtime_error("Steam Leak with Orifice method, Leak pressure (" + std::to_string(leakPressure) +
                ") must be at least minimum pressure (" + std::to_string(minPressure) + ")");
        }
 
        const double leakRate = dischargeCoef * M_PI / 4 * holeSize * holeSize *
            std::sqrt(specificHeatRatio * leakDensity * (leakPressure + atmPressure) * 32.2 * 12 * criticalPressureRatio) * 3600;
 
        return calculate(leakRate, turbineEfficiency);
    }
 
    SteamLeakSurveyResults plumeMethodCalc(const double turbineEfficiency, const double plumeLength, const double ambTemp) const {
        const double leakRate = QuantifySteamLeakByPlumeLength::estimate(steamPressure, plumeLength, ambTemp);    // lb/hr
 
        return calculate(leakRate, turbineEfficiency);
    }
 
    double costOfSteam(const double turbineEfficiency) const {
        if (turbineEfficiency != 0) {
            return steamCost - costOfElectricity * 293.071 * (steamSpecificEnthalpy - isentropicEnthalpy) / 1000000 * (turbineEfficiency/100);
        }
 
        return steamCost;
    }
 
    double costOfSteam() const {
        return costOfSteam(0);
    }
 
  private:
    SteamLeakSurveyResults calculate(const double leakRate, const double turbineEfficiency = 0) const {
        const double steamLoss  = operatingTime * leakRate / 1000;
        const double energyLoss = leakEnthalpy * steamLoss / 1000;
 
        const double leakCost = steamLoss * costOfSteam(turbineEfficiency) * 1000 *
            (leakEnthalpy - feedwaterEnthalpy) / (steamSpecificEnthalpy - feedwaterEnthalpy);
 
        return {leakRate, steamLoss, energyLoss, leakCost};
    }
 
    double operatingTime = 0, steamPressure = 0, leakPressure = 0, costOfElectricity = 0, steamCost = 0;
    double steamSpecificEnthalpy = 1256.12;        // btu/lb
    double isentropicEnthalpy = 1220.35;           // btu/lb
    double feedwaterEnthalpy = 38.16;              // btu/lb
    double leakEnthalpy = 1208.07;                 // btu/lb
    double leakDensity = 0;                        // lb/in3
    double specificHeatRatio = 1.3;
};