IncompBase.h

Go to the documentation of this file.

#ifndef INCOMPRESSIBLE_BASE_H
#define INCOMPRESSIBLE_BASE_H

#include <string>
#include <vector>
#include <math.h>
#include "FluidClass.h"
#include "GlobalConstants.h"
#include "CPExceptions.h"
#include "CoolPropTools.h"
#include "MatrixMath.h"


class IncompressibleClass{
        
protected:
        std::string name;
        std::string description;
        std::string reference;
        double Tmin;
        double TminPsat;
        double Tmax;
        double Tref;

        bool DEBUG;

public:
        std::string getDescription() const {return description;}
        std::string getName() const {return name;}
        // For backwards-compatibility.
        std::string get_name() const {return getName();}
        std::string getReference() const {return reference;}
        double getTmax() const {return Tmax;}
        double getTmin() const {return Tmin;}
        double getTminPsat() const {return TminPsat;}
        double getTref() const {return Tref;}

        void setDebug(bool debug) {this->DEBUG = debug;}

public:
        // Constructor
        IncompressibleClass(){
                name = "";
                description = "";
                reference = "";
                Tmin = -1.;
                Tmax = -1.;
                TminPsat = -1.;
                Tref = 273.15 + 25. ;
                DEBUG = false;
        };

        // Destructor.  No implementation
        virtual ~IncompressibleClass(){};


protected:

        bool checkCoefficients(std::vector<double> const& coefficients, unsigned int n);
        bool checkCoefficients(std::vector< std::vector<double> > const& coefficients, unsigned int rows, unsigned int columns);

private:

        DEPRECATED(double simplePolynomial(std::vector<double> const& coefficients, double T));
        DEPRECATED(double simplePolynomial(std::vector<std::vector<double> > const& coefficients, double x, double T));


        double simplePolynomialInt(std::vector<double> const& coefficients, double T);
        double simplePolynomialInt(std::vector<double> const& coefficients, double T1, double T0);
        double simplePolynomialInt(std::vector<std::vector<double> > const& coefficients, double x, double T);
        double simplePolynomialInt(std::vector<std::vector<double> > const& coefficients, double x, double T1, double T0);


        double simpleFracInt(std::vector<double> const& coefficients, double T);
        double simpleFracInt(std::vector<double> const& coefficients, double T1, double T0);
        double simpleFracInt(std::vector<std::vector<double> > const& coefficients, double x, double T);
        double simpleFracInt(std::vector<std::vector<double> > const& coefficients, double x, double T1, double T0);


        double factorial(double nValue);
        double binom(double nValue, double nValue2);
        std::vector<double> fracIntCentralDvector(int m, double T, double Tbase);
        std::vector<double> fracIntCentralDvector(int m, double T1, double T0, double Tbase);
        double fracIntCentral(std::vector<double> const& coefficients, double T, double Tbase);
        double fracIntCentral(std::vector<double> const& coefficients, double T1, double T0, double Tbase);



        double baseHorner(std::vector<double> const& coefficients, double T);
        double baseHorner(std::vector< std::vector<double> > const& coefficients, double x, double T);
        double baseHornerInt(std::vector<double> const& coefficients, double T);
        double baseHornerInt(std::vector<double> const& coefficients, double T1, double T0);
        double baseHornerInt(std::vector<std::vector<double> > const& coefficients, double x, double T);
        double baseHornerInt(std::vector<std::vector<double> > const& coefficients, double x, double T1, double T0);
        double baseHornerFra(std::vector<double> const& coefficients, double T);
        double baseHornerFra(std::vector<double> const& coefficients, double T1, double T0);
        double baseHornerFra(std::vector<std::vector<double> > const& coefficients, double x, double T);
        double baseHornerFra(std::vector<std::vector<double> > const& coefficients, double x, double T1, double T0);


        std::vector<double> integrateCoeffs(std::vector<double> const& coefficients);
        std::vector< std::vector<double> > integrateCoeffs(std::vector< std::vector<double> > const& coefficients, bool axis);

        DEPRECATED(std::vector<double> deriveCoeffs(std::vector<double> const& coefficients));
        DEPRECATED(std::vector< std::vector<double> > deriveCoeffs(std::vector< std::vector<double> > const& coefficients, unsigned int axis));

        double integrateIn2Steps(std::vector<double> const& coefficients, double T);
        double integrateIn2Steps(std::vector<double> const& coefficients, double T1, double T0);
        double integrateIn2Steps(std::vector< std::vector<double> > const& coefficients, double x, double T, bool axis);
        double integrateIn2Steps(std::vector< std::vector<double> > const& coefficients, double x, double T1, double T0);
        double fracIntIn2Steps(std::vector<double> const& coefficients, double T);
        double fracIntIn2Steps(std::vector<double> const& coefficients, double T1, double T0);
        double fracIntIn2Steps(std::vector<std::vector<double> > const& coefficients, double x, double T);
        double fracIntIn2Steps(std::vector<std::vector<double> > const& coefficients, double x, double T1, double T0);
        double fracIntCentral2Steps(std::vector<std::vector<double> > const& coefficients, double x, double T, double Tbase);
        double fracIntCentral2Steps(std::vector<std::vector<double> > const& coefficients, double x, double T1, double T0, double Tbase);

public:
        double polyval(std::vector<double> const& coefficients, double x){
                //return simplePolynomial(coefficients,x);
                return baseHorner(coefficients,x);
        }

        double polyval(std::vector< std::vector<double> > const& coefficients, double x, double y){
                //return simplePolynomial(coefficients,x,y);
                return baseHorner(coefficients,x,y);
        }

        double polyint(std::vector<double> const& coefficients, double T){
                //return simplePolynomialInt(coefficients,T);
                return baseHornerInt(coefficients,T);
                //return integrateIn2Steps(coefficients,T);
        }

        double polyint(std::vector<double> const& coefficients, double T1, double T0){
                //return simplePolynomialInt(coefficients,T1,T0);
                return baseHornerInt(coefficients,T1,T0);
                //return integrateIn2Steps(coefficients,T1,T0);
        }

        double polyint(std::vector< std::vector<double> > const& coefficients, double x, double T){
                //return simplePolynomialInt(coefficients,x,T);
                return baseHornerInt(coefficients,x,T);
                //return integrateIn2Steps(coefficients,x,T,false);
        }

        double polyint(std::vector< std::vector<double> > const& coefficients, double x, double T1, double T0){
                //return simplePolynomialInt(coefficients,x,T1,T0);
                return baseHornerInt(coefficients,x,T1,T0);
                //return integrateIn2Steps(coefficients,x,T1,T0);
        }

        double polyfracint(std::vector<double> const& coefficients, double T){
                //return simpleFracInt(coefficients,T);
                return baseHornerFra(coefficients,T);
                //return fracIntIn2Steps(coefficients,T);
        }

        double polyfracint(std::vector<double> const& coefficients, double T1, double T0){
                //return simpleFracInt(coefficients,T1,T0);
                //return baseHornerFracInt(coefficients,T1,T0);
                return fracIntIn2Steps(coefficients,T1,T0);
        }

        double polyfracint(std::vector< std::vector<double> > const& coefficients, double x, double T){
                //return simpleFracInt(coefficients,x,T);
                return baseHornerFra(coefficients,x,T);
                //return fracIntIn2Steps(coefficients,x,T);
        }

        double polyfracint(std::vector< std::vector<double> > const& coefficients, double x, double T1, double T0){ //TODO compare speed
                //return simpleFracInt(coefficients,x,T1,T0);
                return baseHornerFra(coefficients,x,T1,T0);
                //return fracIntIn2Steps(coefficients,x,T1,T0);
        }

        double polyfracintcentral(std::vector<double> const& coefficients, double T, double Tbase){
                return fracIntCentral(coefficients,T,Tbase);
        }

        double polyfracintcentral(std::vector<double> const& coefficients, double T1, double T0, double Tbase){
                return fracIntCentral(coefficients,T1,T0,Tbase);
        }

        double polyfracintcentral(std::vector< std::vector<double> > const& coefficients, double x, double T, double Tbase){
                return fracIntCentral2Steps(coefficients,x,T,Tbase);
        }

        double polyfracintcentral(std::vector< std::vector<double> > const& coefficients, double x, double T1, double T0, double Tbase){
                return fracIntCentral2Steps(coefficients,x,T1,T0,Tbase);
        }



        double expval(std::vector<double> const& coefficients, double T, int n);

        double expval(std::vector< std::vector<double> > const& coefficients, double x, double T, int n);
};


class IncompressibleFluid : public Fluid, public IncompressibleClass {
public:
        IncompressibleFluid(){};
    ~IncompressibleFluid(){};
    // Some functions need top be overwritten!
};


#endif