steamcalculator.h

Go to the documentation of this file.

/*

freesteam - IAPWS-IF97 steam tables library
Copyright (C) 2004-2006  John Pye

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
#ifndef STEAMCALCULATOR_H
#define STEAMCALCULATOR_H

#ifdef FREESTEAM_SWIG
# include "measurement.h"
# define Density Measurement
# define Pressure Measurement
# define Temperature Measurement
# define SpecificEnergy Measurement
# define SpecificEntropy Measurement
# define DynamicViscosity Measurement
# define ThermalConductivity Measurement
# define SpecHeatCap Measurement
# define SpecificVolume Measurement
# define SurfaceTension Measurement
# define Num double
#else
# include "designbycontract.h"
# include "steamcalculatorexception.h"
# include "boundaries.h"
# include "state.h"
# include "zeroin.h"
#endif

typedef enum { STEAM_SUBCOOLED =
                   0, STEAM_SUPERHEATED, STEAM_SATURATED, STEAM_SUPERCRITICAL,
               STEAM_STATE_UNKNOWN = -1 } SteamStateCode;

typedef enum { STEAM_TEMPERATURE =
                   0, STEAM_PRESSURE, STEAM_VOLUME, STEAM_INTERNAL_ENERGY,
               STEAM_ENTHALPY, STEAM_ENTROPY } SteamPropertyCode;



class SteamCalculator:public DesignByContract {

        public:

                SteamCalculator();

                SteamCalculator(const SteamCalculator & original);

                SteamCalculator const &operator=(SteamCalculator const &original);

                // Destructor
                virtual ~SteamCalculator();

                // Defining state, simple methods

                void set_pT(const Pressure &p, const Temperature &T, double x = 1.0);   // pressure [MPa]

                template<class F,class S>
                inline void set(const F &f, const S &s);

                void setSatSteam_p(const Pressure &p);  // p Pressure [MPa]
                void setSatWater_p(const Pressure &p);  // p Pressure [MPa]
                void setSatWater_T(const Temperature &T);       // T Temperature [K]
                void setSatSteam_T(const Temperature &T);       // T Temperature [K]

                void setB23_T(const Temperature &T);
                void setB23_p(const Pressure &p);

                void setRegion1_pT(const Pressure &p, const Temperature &T);
                void setRegion2_pT(const Pressure &p, const Temperature &T);
                void setRegion4_Tx(const Temperature &T, const Num &x);
                void setRegion3_rhoT(const Density &rho, const Temperature &T);

                bool isSet(void) const;

                // Methods to return properties and state

                int whichRegion(void) const;
                const SteamCalculator &getGasPart() const;
                const SteamCalculator &getLiquidPart() const;

                SteamStateCode whichState(void);
                const char *whichStateStr(void);

                Temperature temp() const;               // Temperature
                Pressure pres() const;                  // Pressure
                Density dens() const;                   // Density

                SpecificVolume specvol() const;         // Specific volume
                SpecificEnergy specienergy() const;     // Specific internal energy
                SpecificEntropy specentropy() const;    // Specific entropy
                SpecificEnergy specenthalpy() const;    // Specific entropy
                SpecHeatCap speccp() const;             // Specific isobaric heat capacity  [kJ/kgK]
                SpecHeatCap speccv() const;             // Specific isochoric heat capacity [kJ/kgK]
                Num quality() const;                    // Steam quality
                DynamicViscosity dynvisc() const;       // Dynamic viscosity, mu            [Pa.s]
                ThermalConductivity conductivity() const;// Conductivity
                SurfaceTension surftens() const;                // Surface tension

                // Design by contract stuff...
                virtual bool isValid(void) const;

                virtual void copy(const SteamCalculator & original);

        protected:

                Num tau_iaps85() const;
                Num del_iaps85() const;
                Num pi_iaps85() const;
                Num delpi_iaps85() const;
                Num pitau_iaps85() const;

                // reduced thermal conductivity correlations
                Num lam(const Num &Tbar, const Num &rhobar) const;
                Num lam0(const Num &Tbar) const;
                Num lam1(const Num &rhobar) const;
                Num lam2(const Num &Tbar, const Num &rhobar) const;

                Num mu() const;
                Num mu0() const;
                Num mu1() const;
                Num mu2() const;

                Pressure getRegion3PressureError(const Density &test_rho);

                // All the intrinsic properties must be stored here because the states are singletons to save memory.

                Temperature T;                              
                Pressure p;                                     
                Density rho;                            
                Num x;                                  

                Num tau;                                
                Num pi;                                 
                Num del;                                    
                Pressure reg3_target_pressure;      

        private:
                friend class SteamState;
                friend class Region1;
                friend class Region2;
                friend class Region3;
                friend class Region4;
                friend class ZeroIn<SteamCalculator, Pressure, Density>;

                bool isset;             

                void changeState(SteamState * state);

                void destroy();

                SteamState *_state;

                SteamCalculator *gas;   // for use in two-phase calcs
                SteamCalculator *liq;   // for use in two-phase calcs

};

template<>
inline void
SteamCalculator::set<Pressure,Temperature>(const Pressure &p, const Temperature &T){
        set_pT(p,T);
}

template<>
inline void
SteamCalculator::set<Temperature,Pressure>(const Temperature &T, const Pressure &p){
        set_pT(p,T);
}

#endif

---