gas_load_charge_material.h

Go to the documentation of this file.

#pragma once
 
#include <string>
 
#include "load_charge_material.h"
 
class GasLoadChargeMaterial {
  public:
    GasLoadChargeMaterial(const LoadChargeMaterial::ThermicReactionType thermicReactionType,
                          const double specificHeatGas, const double feedRate, const double percentVapor,
                          const double initialTemperature, const double dischargeTemperature,
                          const double specificHeatVapor, const double percentReacted, const double reactionHeat,
                          const double additionalHeat)
        : thermicReactionType(thermicReactionType), specificHeatGas(specificHeatGas), feedRate(feedRate),
          percentVapor(percentVapor / 100.0), initialTemperature(initialTemperature),
          dischargeTemperature(dischargeTemperature), specificHeatVapor(specificHeatVapor),
          percentReacted(percentReacted / 100.0), reactionHeat(reactionHeat), additionalHeat(additionalHeat) {}
 
    GasLoadChargeMaterial() = default;
 
    LoadChargeMaterial::ThermicReactionType getThermicReactionType() const { return thermicReactionType; }
 
    void setThermicReactionType(LoadChargeMaterial::ThermicReactionType thermicReactionType) {
        this->thermicReactionType = thermicReactionType;
    }
 
    double getSpecificHeatGas() const { return specificHeatGas; }
 
    void setSpecificHeatGas(double specificHeatGas) { this->specificHeatGas = specificHeatGas; }
 
    double getFeedRate() const { return feedRate; }
 
    void setFeedRate(double feedRate) { this->feedRate = feedRate; }
 
    double getInitialTemperature() const { return initialTemperature; }
 
    void setInitialTemperature(double initialTemperature) { this->initialTemperature = initialTemperature; }
 
    double getDischargeTemperature() const { return dischargeTemperature; }
 
    void setDischargeTemperature(double dischargeTemperature) { this->dischargeTemperature = dischargeTemperature; }
 
    double getSpecificHeatVapor() const { return specificHeatVapor; }
 
    void setSpecificHeatVapor(double specificHeatVapor) { this->specificHeatVapor = specificHeatVapor; }
 
    double getPercentReacted() const { return percentReacted * 100.0; }
 
    void setPercentReacted(double percentReacted) { percentReacted = percentReacted / 100.0; }
 
    double getReactionHeat() const { return reactionHeat; }
 
    void setReactionHeat(double reactionHeat) { this->reactionHeat = reactionHeat; }
 
    double getAdditionalHeat() const { return additionalHeat; }
 
    void setAdditionalHeat(double additionalHeat) { this->additionalHeat = additionalHeat; }
 
    double getPercentVapor() const { return percentVapor * 100.0; }
 
    void setPercentVapor(double percentVapor) { percentVapor = percentVapor / 100.0; }
 
    std::string getSubstance() const { return substance; }
 
    void setSubstance(std::string substance) { this->substance = std::move(substance); }
 
    int getID() const { return this->id; }
 
    void setID(const int id) { this->id = id; }
 
    double getTotalHeat() {
        const double tempDiff = dischargeTemperature - initialTemperature;
        const double hgas     = (1.0 - percentVapor) * feedRate * specificHeatGas * tempDiff;
        const double hvapor   = percentVapor * feedRate * specificHeatVapor * tempDiff;
 
        // heatReact ignored when exothermic
        double heatReact = 0.0;
        if (thermicReactionType == LoadChargeMaterial::ThermicReactionType::ENDOTHERMIC) {
            heatReact = feedRate * percentReacted * reactionHeat;
        }
 
        totalHeat = hgas + hvapor + heatReact + additionalHeat;
        return totalHeat;
    }
 
    bool operator==(const GasLoadChargeMaterial& rhs) const {
        return specificHeatVapor == rhs.specificHeatVapor && substance == rhs.substance && id == rhs.id;
    }
 
    bool operator!=(const GasLoadChargeMaterial& rhs) const { return !(*this == rhs); }
 
  private:
    LoadChargeMaterial::ThermicReactionType thermicReactionType  = LoadChargeMaterial::ThermicReactionType::NONE;
    double                                  specificHeatGas      = 0.0;
    double                                  feedRate             = 0.0;
    double                                  percentVapor         = 0.0;
    double                                  initialTemperature   = 0.0;
    double                                  dischargeTemperature = 0.0;
    double                                  specificHeatVapor    = 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;
 
    GasLoadChargeMaterial(std::string substance, double specificHeatVapor)
        : specificHeatVapor(specificHeatVapor), substance(std::move(substance)) {}
};