liquid_load_charge_material.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include "load_charge_material.h"
 
class LiquidLoadChargeMaterial {
 
  public:
    LiquidLoadChargeMaterial(const LoadChargeMaterial::ThermicReactionType thermicReactionType,
                             const double specificHeatLiquid, const double vaporizingTemperature,
                             const double latentHeat, const double specificHeatVapor, const double chargeFeedRate,
                             const double initialTemperature, const double dischargeTemperature,
                             const double percentVaporized, const double percentReacted, const double reactionHeat,
                             const double additionalHeat)
        : thermicReactionType(thermicReactionType), specificHeatLiquid(specificHeatLiquid),
          vaporizingTemperature(vaporizingTemperature), latentHeat(latentHeat), specificHeatVapor(specificHeatVapor),
          chargeFeedRate(chargeFeedRate), initialTemperature(initialTemperature),
          dischargeTemperature(dischargeTemperature), percentVaporized(percentVaporized / 100.0),
          percentReacted(percentReacted / 100.0), reactionHeat(reactionHeat), additionalHeat(additionalHeat) {}
 
    LiquidLoadChargeMaterial() = default;
 
    LoadChargeMaterial::ThermicReactionType getThermicReactionType() const { return thermicReactionType; }
 
    void setThermicReactionType(LoadChargeMaterial::ThermicReactionType thermicReactionType) {
        this->thermicReactionType = thermicReactionType;
    }
 
    double getSpecificHeatLiquid() const { return specificHeatLiquid; }
 
    void setSpecificHeatLiquid(const double specificHeatLiquid) { this->specificHeatLiquid = specificHeatLiquid; }
 
    double getVaporizingTemperature() const { return vaporizingTemperature; }
 
    void setVaporizingTemperature(const double vaporizingTemperature) {
        this->vaporizingTemperature = vaporizingTemperature;
    }
 
    double getLatentHeat() const { return latentHeat; }
 
    void setLatentHeat(const double latentHeat) { this->latentHeat = latentHeat; }
 
    double getSpecificHeatVapor() const { return specificHeatVapor; }
 
    void setSpecificHeatVapor(const double specificHeatVapor) { this->specificHeatVapor = specificHeatVapor; }
 
    double getChargeFeedRate() const { return chargeFeedRate; }
 
    void setChargeFeedRate(const double chargeFeedRate) { this->chargeFeedRate = chargeFeedRate; }
 
    double getInitialTemperature() const { return initialTemperature; }
 
    void setInitialTemperature(const double initialTemperature) { this->initialTemperature = initialTemperature; }
 
    double getDischargeTemperature() const { return dischargeTemperature; }
 
    void setDischargeTemperature(const double dischargeTemperature) {
        this->dischargeTemperature = dischargeTemperature;
    }
 
    double getPercentVaporized() const { return percentVaporized * 100.0; }
 
    void setPercentVaporized(const double percentVaporized) { this->percentVaporized = percentVaporized / 100.0; }
 
    double getPercentReacted() const { return percentReacted * 100.0; }
 
    void setPercentReacted(const double percentReacted) { this->percentReacted = percentReacted / 100.0; }
 
    double getReactionHeat() const { return reactionHeat; }
 
    void setReactionHeat(const double reactionHeat) { this->reactionHeat = reactionHeat; }
 
    double getAdditionalHeat() const { return additionalHeat; }
 
    void setAdditionalHeat(const double additionalHeat) { this->additionalHeat = additionalHeat; }
 
    std::string getSubstance() const { return substance; }
 
    void setSubstance(std::string const& substance) { this->substance = substance; }
 
    int getID() const { return id; }
 
    void setID(int const id) { this->id = id; }
 
    double getTotalHeat() {
        double hliq;
        if (dischargeTemperature < vaporizingTemperature) {
            // H_liq=m_li×C_pl×(t_lo-t_li )
            hliq = chargeFeedRate * specificHeatLiquid * (dischargeTemperature - initialTemperature);
        }
        else {
            // H_liq=m_li×C_pl×(t_lv-t_li )+%lv×m_lt×[h_lv+C_pv  (t_lo-T_lv )]+(1-%lv)×C_pl (t_lo-t_lv)
            hliq =
                chargeFeedRate *
                (specificHeatLiquid * (vaporizingTemperature - initialTemperature) +
                 percentVaporized * (latentHeat + specificHeatVapor * (dischargeTemperature - vaporizingTemperature)) +
                 (1 - percentVaporized) * specificHeatLiquid * (dischargeTemperature - vaporizingTemperature));
        }
 
        double heatReacted = 0.0;
        if (thermicReactionType == LoadChargeMaterial::ThermicReactionType::ENDOTHERMIC) {
            heatReacted = chargeFeedRate * percentReacted * reactionHeat;
        }
        totalHeat = hliq + heatReacted + additionalHeat;
        return totalHeat;
    }
 
    bool operator==(const LiquidLoadChargeMaterial& rhs) const {
        return specificHeatLiquid == rhs.specificHeatLiquid && latentHeat == rhs.latentHeat &&
               specificHeatVapor == rhs.specificHeatVapor && vaporizingTemperature == rhs.vaporizingTemperature &&
               substance == rhs.substance && id == rhs.id;
    }
 
    bool operator!=(const LiquidLoadChargeMaterial& rhs) const { return !(*this == rhs); }
 
  private:
    // In values
    LoadChargeMaterial::ThermicReactionType thermicReactionType   = LoadChargeMaterial::ThermicReactionType::NONE;
    double                                  specificHeatLiquid    = 0.0;
    double                                  vaporizingTemperature = 0.0;
    double                                  latentHeat            = 0.0;
    double                                  specificHeatVapor     = 0.0;
    double                                  chargeFeedRate        = 0.0;
    double                                  initialTemperature    = 0.0;
    double                                  dischargeTemperature  = 0.0;
    double                                  percentVaporized      = 0.0;
    double                                  percentReacted        = 0.0;
    double                                  reactionHeat          = 0.0;
    double                                  additionalHeat        = 0.0;
    std::string                             substance             = "Unknown";
    int                                     id                    = 0;
    // Out value
    double totalHeat = 0.0;
 
    friend class DefaultData;
 
    LiquidLoadChargeMaterial(std::string substance, double specificHeatLiquid, double latentHeat,
                             double specificHeatVapor, double vaporizingTemperature)
        : specificHeatLiquid(specificHeatLiquid), vaporizingTemperature(vaporizingTemperature), latentHeat(latentHeat),
          specificHeatVapor(specificHeatVapor), substance(std::move(substance)) {}
};