PRV.h

Go to the documentation of this file.

#include "SteamProperties.h"

#ifndef AMO_TOOLS_SUITE_PRV_H
#define AMO_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; };

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;
};

#endif //AMO_TOOLS_SUITE_PRV_H