solid_load_charge_material.h

Go to the documentation of this file.

 
#ifndef TOOLS_SUITE_SOLIDLOADCHARGEMATERIAL_H
#define TOOLS_SUITE_SOLIDLOADCHARGEMATERIAL_H
 
#include <string>
 
#include "load_charge_material.h"
 
class SolidLoadChargeMaterial {
  public:
    SolidLoadChargeMaterial(const LoadChargeMaterial::ThermicReactionType thermicReactionType,
                            const double specificHeatSolid, const double latentHeat, const double specificHeatLiquid,
                            const double meltingPoint, const double chargeFeedRate, const double waterContentCharged,
                            const double waterContentDischarged, const double initialTemperature,
                            const double dischargeTemperature, const double waterVaporDischargeTemperature,
                            const double chargeMelted, const double chargeReacted, const double reactionHeat,
                            const double additionalHeat)
        : thermicReactionType(thermicReactionType), specificHeatSolid(specificHeatSolid), latentHeat(latentHeat),
          specificHeatLiquid(specificHeatLiquid), meltingPoint(meltingPoint), chargeFeedRate(chargeFeedRate),
          waterContentCharged(waterContentCharged / 100.0), waterContentDischarged(waterContentDischarged / 100.0),
          initialTemperature(initialTemperature), dischargeTemperature(dischargeTemperature),
          waterVaporDischargeTemperature(waterVaporDischargeTemperature), chargeMelted(chargeMelted / 100.0),
          chargeReacted(chargeReacted / 100.0), reactionHeat(reactionHeat), additionalHeat(additionalHeat) {}
 
    SolidLoadChargeMaterial() = default;
 
    LoadChargeMaterial::ThermicReactionType getThermicReactionType() const { return thermicReactionType; }
 
    void setThermicReactionType(LoadChargeMaterial::ThermicReactionType thermicReactionType) {
        this->thermicReactionType = thermicReactionType;
    }
 
    double getSpecificHeatSolid() const { return specificHeatSolid; }
 
    void setSpecificHeatSolid(const double specificHeatSolid) { this->specificHeatSolid = specificHeatSolid; }
 
    double getLatentHeat() const { return latentHeat; }
 
    void setLatentHeat(const double latentHeat) { this->latentHeat = latentHeat; }
 
    double getSpecificHeatLiquid() const { return specificHeatLiquid; }
 
    void setSpecificHeatLiquid(const double specificHeatLiquid) { this->specificHeatLiquid = specificHeatLiquid; }
 
    double getMeltingPoint() const { return meltingPoint; }
 
    int getID() const { return this->id; }
 
    void setID(const int id) { this->id = id; }
 
    void setMeltingPoint(const double meltingPoint) { this->meltingPoint = meltingPoint; }
 
    double getChargeFeedRate() const { return chargeFeedRate; }
 
    void setChargeFeedRate(const double chargeFeedRate) { this->chargeFeedRate = chargeFeedRate; }
 
    double getWaterContentCharged() const { return waterContentCharged * 100.0; }
 
    void setWaterContentCharged(const double waterContentCharged) {
        this->waterContentCharged = waterContentCharged / 100.0;
    }
 
    double getWaterContentDischarged() const { return waterContentDischarged * 100.0; }
 
    void setWaterContentDischarged(const double waterContentDischarged) {
        this->waterContentDischarged = waterContentDischarged / 100.0;
    }
 
    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 getWaterVaporDischargeTemperature() const { return waterVaporDischargeTemperature; }
 
    void setWaterVaporDischargeTemperature(const double waterVaporDischargeTemperature) {
        this->waterVaporDischargeTemperature = waterVaporDischargeTemperature;
    }
 
    double getChargeMelted() const { return chargeMelted * 100.0; }
 
    void setChargeMelted(const double chargeMelted) { this->chargeMelted = chargeMelted / 100.0; }
 
    double getChargedReacted() const { return chargeReacted * 100.0; }
 
    void setChargedReacted(const double chargedReacted) { this->chargeReacted = chargedReacted / 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; }
 
    bool operator==(const SolidLoadChargeMaterial& rhs) const {
        return specificHeatSolid == rhs.specificHeatSolid && latentHeat == rhs.latentHeat &&
               specificHeatLiquid == rhs.specificHeatLiquid && meltingPoint == rhs.meltingPoint &&
               substance == rhs.substance && id == rhs.id;
    }
 
    double getTotalHeat() {
        double const waterBoilTemp = 212.0; // Heat required temperature is 212.0°F
 
        // Heat required for removal of moisture
        double hmv;
        if (waterVaporDischargeTemperature < waterBoilTemp) {
            //   (H_mv )=m_st×(%w_i )×〖(t〗_wo-t_si)
            hmv = chargeFeedRate * waterContentCharged * (waterVaporDischargeTemperature - initialTemperature);
        }
        else {
            double const specificHeatWaterVapor = 0.481;
            double const waterEvaporation       = 970.0; // Latent heat of evaporation for water is 970 Btu/lb
            // (H_mv )=m_st×(%w_i )×(212-t_si )+m_st×(%w_i-%w_o )  ×[970+0.481×〖(t〗_wo-212)]
            hmv = (chargeFeedRate * waterContentCharged * (waterBoilTemp - initialTemperature)) +
                  chargeFeedRate * (waterContentCharged - waterContentDischarged) *
                      (waterEvaporation + specificHeatWaterVapor * (waterVaporDischargeTemperature - waterBoilTemp));
        }
        // (H_mr )=m_st×(%w_0 )×〖(t〗_wo-t_si)
        double hmr = chargeFeedRate * waterContentDischarged * (waterVaporDischargeTemperature - waterBoilTemp);
 
        // Heat required for solid
        double hs;
        if (dischargeTemperature < meltingPoint) {
            // (H_s)=m_st×(1-%w_i )×C_ps×(t_so-t_si)
            hs = chargeFeedRate * (1.0 - waterContentCharged) * specificHeatSolid *
                 (dischargeTemperature - initialTemperature);
        }
        else {
            // (H_s )=m_st×(1-%w_i )×C_ps×(T_sm-t_si )+h_m+C_(pl ×) (t_so-T_sm)
            hs = chargeFeedRate * (1.0 - waterContentCharged) *
                 (specificHeatSolid * (meltingPoint - initialTemperature) + (latentHeat * chargeMelted) +
                  specificHeatLiquid * (dischargeTemperature - meltingPoint) * (chargeMelted) +
                  (specificHeatSolid * (1 - chargeMelted) * (dischargeTemperature - meltingPoint)));
        }
 
        double heatReaction = 0.0;
        if (thermicReactionType == LoadChargeMaterial::ThermicReactionType::ENDOTHERMIC) {
            heatReaction = chargeFeedRate * (1.0 - waterContentCharged) * chargeReacted * reactionHeat;
        }
 
        // H_t=H_mv+H_mr+H_s±H_r
        totalHeat = hmv + hmr + hs + heatReaction + additionalHeat;
        return totalHeat;
    }
 
  private:
    // In/Out values
    std::string substance = "Unknown";
    // In values
    LoadChargeMaterial::ThermicReactionType thermicReactionType    = LoadChargeMaterial::ThermicReactionType::NONE;
    double                                  specificHeatSolid      = 0.0;
    double                                  latentHeat             = 0.0;
    double                                  specificHeatLiquid     = 0.0;
    double                                  meltingPoint           = 0.0;
    double                                  chargeFeedRate         = 0.0;
    double                                  waterContentCharged    = 0.0;
    double                                  waterContentDischarged = 0.0;
    double                                  initialTemperature     = 0.0;
    double                                  dischargeTemperature   = 0.0;
    double                                  waterVaporDischargeTemperature = 0.0;
    double                                  chargeMelted                   = 0.0;
    double                                  chargeReacted                  = 0.0;
    double                                  reactionHeat                   = 0.0;
    double                                  additionalHeat                 = 0.0;
    int                                     id                             = 0;
    // Out values
    double totalHeat = 0.0;
 
    friend class DefaultData;
 
    SolidLoadChargeMaterial(std::string substance, double specificHeatSolid, double latentHeat,
                            double specificHeatLiquid, double meltingPoint)
        : substance(std::move(substance)), specificHeatSolid(specificHeatSolid), latentHeat(latentHeat),
          specificHeatLiquid(specificHeatLiquid), meltingPoint(meltingPoint) {}
};
 
#endif // TOOLS_SUITE_SOLIDLOADCHARGEMATERIAL_H