PRV.h

Go to the documentation of this file.

 
#include "SteamProperties.h"
 
#ifndef TOOLS_SUITE_PRV_H
    #define TOOLS_SUITE_PRV_H
 
class PrvWithoutDesuperheating {
  public:
    PrvWithoutDesuperheating(double inletPressure, SteamProperties::ThermodynamicQuantity quantityType,
                             double quantityValue, double inletMassFlow, double outletPressure);
 
    friend std::ostream& operator<<(std::ostream& stream, const PrvWithoutDesuperheating& prv);
    friend std::ostream& operator<<(std::ostream& stream, const std::shared_ptr<PrvWithoutDesuperheating>& prv);
 
    virtual bool isWithDesuperheating() const { return false; }
 
    double getInletPressure() const { return inletPressure; }
 
    SteamProperties::ThermodynamicQuantity getQuantityType() const { return quantityType; }
 
    double getQuantityValue() const { return quantityValue; }
 
    double getInletMassFlow() const { return inletMassFlow; }
 
    double getOutletPressure() const { return outletPressure; }
 
    SteamSystemModelerTool::SteamPropertiesOutput const& getInletProperties() const { return inletProperties; };
 
    SteamSystemModelerTool::SteamPropertiesOutput const& getOutletProperties() const { return outletProperties; };
 
    double getInletEnergyFlow() const { return inletEnergyFlow; }
 
    virtual double getOutletMassFlow() const { return inletMassFlow; }
 
    virtual double getOutletEnergyFlow() const { return inletEnergyFlow; }
 
    void setInletPressure(double inletPressure) {
        this->inletPressure = inletPressure;
        calculateProperties();
    }
 
    void setQuantityType(SteamProperties::ThermodynamicQuantity quantityType) {
        this->quantityType = quantityType;
        calculateProperties();
    }
    void setQuantityValue(double quantityValue) {
        this->quantityValue = quantityValue;
        calculateProperties();
    }
 
    void setInletMassFlow(double inletMassFlow) {
        this->inletMassFlow = inletMassFlow;
        calculateProperties();
    }
 
    void setOutletPressure(double outletPressure) {
        this->outletPressure = outletPressure;
        calculateProperties();
    }
 
  protected:
    virtual void calculateProperties();
 
    double                                        inletPressure, quantityValue, inletMassFlow, outletPressure;
    SteamSystemModelerTool::SteamPropertiesOutput inletProperties, outletProperties;
    SteamProperties::ThermodynamicQuantity        quantityType;
 
  private:
    double inletEnergyFlow;
};
 
class PrvWithDesuperheating : public PrvWithoutDesuperheating {
  public:
    PrvWithDesuperheating(double inletPressure, SteamProperties::ThermodynamicQuantity quantityType,
                          double quantityValue, double inletMassFlow, double outletPressure, double feedwaterPressure,
                          SteamProperties::ThermodynamicQuantity feedwaterQuantityType, double feedwaterQuantityValue,
                          double desuperheatingTemp);
 
    friend std::ostream& operator<<(std::ostream& stream, const PrvWithDesuperheating& prv);
    friend std::ostream& operator<<(std::ostream& stream, const std::shared_ptr<PrvWithDesuperheating>& prv);
 
    bool isWithDesuperheating() const override { return true; }
 
    void setFeedwaterPressure(double feedwaterPressure) {
        this->feedwaterPressure = feedwaterPressure;
        calculateProperties();
    }
 
    double getFeedwaterPressure() const { return feedwaterPressure; }
 
    void setFeedwaterQuantityType(SteamProperties::ThermodynamicQuantity feedwaterQuantityType) {
        this->feedwaterQuantityType = feedwaterQuantityType;
        calculateProperties();
    }
 
    SteamProperties::ThermodynamicQuantity getFeedwaterQuantityType() const { return feedwaterQuantityType; }
 
    void setFeedwaterQuantityValue(double feedwaterQuantityValue) {
        this->feedwaterQuantityValue = feedwaterQuantityValue;
        calculateProperties();
    }
 
    double getFeedwaterQuantityValue() const { return feedwaterQuantityValue; }
 
    void setDesuperheatingTemp(double desuperheatingTemp) {
        this->desuperheatingTemp = desuperheatingTemp;
        calculateProperties();
    }
 
    double getDesuperheatingTemp() const { return desuperheatingTemp; }
 
    SteamSystemModelerTool::SteamPropertiesOutput const& getFeedwaterProperties() const { return feedwaterProperties; };
 
    double getOutletMassFlow() const override { return outletMassFlow; };
 
    double getOutletEnergyFlow() const override { return outletEnergyFlow; };
 
    double getFeedwaterMassFlow() const { return feedwaterMassFlow; };
 
    double getFeedwaterEnergyFlow() const { return feedwaterEnergyFlow; };
 
    SteamSystemModelerTool::SteamPropertiesOutput const& getInletProperties() const { return inletProperties; };
 
    SteamSystemModelerTool::SteamPropertiesOutput const& getOutletProperties() const { return outletProperties; };
 
    double getInletEnergyFlow() const { return inletEnergyFlow; }
 
    double getInletMassFlow() const { return inletMassFlow; }
 
  protected:
    void calculateProperties() override;
 
  private:
    // In values
    double                                 feedwaterPressure, feedwaterQuantityValue, desuperheatingTemp;
    SteamProperties::ThermodynamicQuantity feedwaterQuantityType;
 
    // Out values
    SteamSystemModelerTool::SteamPropertiesOutput feedwaterProperties;
    double inletEnergyFlow, outletMassFlow, outletEnergyFlow, feedwaterMassFlow, feedwaterEnergyFlow;
};
 
class PrvCastDesuperheating {
  public:
    PrvCastDesuperheating() {}
    std::shared_ptr<PrvWithDesuperheating> Cast(std::shared_ptr<PrvWithoutDesuperheating> prvWithout) {
        return std::static_pointer_cast<PrvWithDesuperheating>(prvWithout);
    }
};
 
#endif // TOOLS_SUITE_PRV_H