SteamReduction.h

#pragma once
 
#include <exception>
#include <stdexcept>
#include <utility>
#include <vector>
 
#include "steamModeler/SaturatedProperties.h"
#include "steamModeler/SteamProperties.h"
#include "steamModeler/SteamSystemModelerTool.h"
 
class SteamFlowMeterMethodData {
  public:
    explicit SteamFlowMeterMethodData(const double flowRate) : flowRate(flowRate) {}
 
    double getFlowRate() const { return flowRate; }
 
  private:
    double flowRate;
};
 
class SteamMassFlowNameplateData {
  public:
    explicit SteamMassFlowNameplateData(const double flowRate) : flowRate(flowRate) {}
 
    double getFlowRate() const { return flowRate; }
 
  private:
    double flowRate;
};
 
class SteamMassFlowMeasuredData {
  public:
    SteamMassFlowMeasuredData(const double areaOfDuct, const double airVelocity)
        : areaOfDuct(areaOfDuct), airVelocity(airVelocity) {}
 
    double getAreaOfDuct() const { return areaOfDuct; }
    double getAirVelocity() const { return airVelocity; }
 
  private:
    double areaOfDuct, airVelocity;
};
 
class SteamMassFlowMethodData {
  public:
    SteamMassFlowMethodData(const bool isNameplate, const SteamMassFlowMeasuredData massFlowMeasuredData,
                            const SteamMassFlowNameplateData massFlowNameplateData, const double inletTemperature,
                            const double outletTemperature)
        : isNameplate(isNameplate), massFlowMeasuredData(massFlowMeasuredData),
          massFlowNameplateData(massFlowNameplateData), inletTemperature(inletTemperature),
          outletTemperature(outletTemperature) {}
 
    bool                       getIsNameplate() const { return isNameplate; }
    SteamMassFlowMeasuredData  getMassFlowMeasuredData() { return massFlowMeasuredData; }
    SteamMassFlowNameplateData getMassFlowNameplateData() { return massFlowNameplateData; }
    double                     getInletTemperature() const { return inletTemperature; }
    double                     getOutletTemperature() const { return outletTemperature; }
 
  private:
    bool                       isNameplate;
    SteamMassFlowMeasuredData  massFlowMeasuredData;
    SteamMassFlowNameplateData massFlowNameplateData;
    double                     inletTemperature, outletTemperature;
};
 
class SteamOffsheetMethodData {
  public:
    explicit SteamOffsheetMethodData(const double consumption) : consumption(consumption) {}
 
    double getConsumption() const { return consumption; }
 
  private:
    double consumption;
};
 
class SteamReductionInput {
  public:
    SteamReductionInput(const int hoursPerYear, const int utilityType, const double utilityCost,
                        const int measurementMethod, const double systemEfficiency, const double pressure,
                        const SteamFlowMeterMethodData flowMeterMethodData,
                        const SteamMassFlowMethodData  airMassFlowMethodData,
                        const SteamMassFlowMethodData  waterMassFlowMethodData,
                        const SteamOffsheetMethodData offsheetMethodData, const int units,
                        const double boilerEfficiency, const SteamProperties::ThermodynamicQuantity steamVariableOption,
                        const double steamVariable, const double feedWaterTemperature)
        : hoursPerYear(hoursPerYear), utilityType(utilityType), utilityCost(utilityCost),
          measurementMethod(measurementMethod), systemEfficiency(systemEfficiency), pressure(pressure),
          flowMeterMethodData(flowMeterMethodData), airMassFlowMethodData(airMassFlowMethodData),
          waterMassFlowMethodData(waterMassFlowMethodData), offsheetMethodData(offsheetMethodData), units(units),
          boilerEfficiency(boilerEfficiency), steamVariableOption(steamVariableOption), steamVariable(steamVariable),
          feedWaterTemperature(feedWaterTemperature) {}
 
    int                                    getHoursPerYear() const { return hoursPerYear; }
    int                                    getUtilityType() const { return utilityType; }
    int                                    getMeasurementMethod() const { return measurementMethod; }
    int                                    getUnits() const { return units; }
    double                                 getUtilityCost() const { return utilityCost; }
    double                                 getSystemEfficiency() const { return systemEfficiency; }
    double                                 getPressure() const { return pressure; }
    SteamFlowMeterMethodData               getFlowMeterMethodData() const { return flowMeterMethodData; }
    SteamMassFlowMethodData                getAirMassFlowMethodData() const { return airMassFlowMethodData; }
    SteamMassFlowMethodData                getWaterMassFlowMethodData() const { return waterMassFlowMethodData; }
    SteamOffsheetMethodData                getOffsheetMethodData() const { return offsheetMethodData; }
    double                                 getBoilerEfficiency() const { return boilerEfficiency; }
    double                                 getFeedWaterTemperature() const { return feedWaterTemperature; }
    double                                 getSteamVariable() const { return steamVariable; }
    SteamProperties::ThermodynamicQuantity getSteamVariableOption() const { return steamVariableOption; }
 
  private:
    int                                    hoursPerYear, utilityType;
    double                                 utilityCost;
    int                                    measurementMethod;
    double                                 systemEfficiency, pressure;
    SteamFlowMeterMethodData               flowMeterMethodData;
    SteamMassFlowMethodData                airMassFlowMethodData;
    SteamMassFlowMethodData                waterMassFlowMethodData;
    SteamOffsheetMethodData                offsheetMethodData;
    int                                    units;
    double                                 boilerEfficiency;
    SteamProperties::ThermodynamicQuantity steamVariableOption;
    double                                 steamVariable;
    double                                 feedWaterTemperature;
};
 
class SteamReduction {
  public:
    struct Output {
        Output(double steamUse, double energyUse, double energyCost)
            : steamUse(steamUse), energyUse(energyUse), energyCost(energyCost) {}
 
        Output() = default;
 
        double steamUse = 0, energyUse = 0, energyCost = 0;
    };
 
    explicit SteamReduction(std::vector<SteamReductionInput> steamReductionInputVec)
        : steamReductionInputVec(std::move(steamReductionInputVec)) {}
 
    SteamReduction::Output calculate();
 
  private:
    std::vector<SteamReductionInput> steamReductionInputVec;
    SteamReduction::Output           output;
};