TTSE.h

Go to the documentation of this file.

#ifndef TTSE_H
#define TTSE_H

#include "FluidClass.h"

class Fluid;

enum TTSE_MODES{ TTSE_MODE_TTSE,TTSE_MODE_BICUBIC};

class BiCubicCellClass
{
public:
        std::vector<double> alpha_s_hp, alpha_rho_hp, alpha_T_hp, alpha_s_Trho, alpha_h_Trho, alpha_p_Trho, alpha_mu_Trho, alpha_k_Trho;
        bool valid_hp,valid_Trho;
        BiCubicCellClass(){valid_hp = false; valid_Trho = false;};
};

class BiCubicCellsContainerClass
{
public:
        std::vector< std::vector<BiCubicCellClass> > cells;
};

class TTSETwoPhaseTableClass
{
protected:
        unsigned int N;
        Fluid *pFluid;
        double dh,dp;
        double pratio,logpratio;
public:
        TTSETwoPhaseTableClass(){};
        TTSETwoPhaseTableClass(Fluid *pFluid, double Q);
        ~TTSETwoPhaseTableClass(){};

        void set_size(unsigned int N);

        double pmin,pmax,Q,logpmin,logpmax;

        // Variables with h, p
        std::vector<double> T,dTdp,d2Tdp2;
        std::vector<double> rho,drhodp,d2rhodp2,logrho;
        std::vector<double> s,dsdp,d2sdp2;
        std::vector<double> h,dhdp,d2hdp2;
        std::vector<double> p,logp;

        double build(double pmin, double pmax, TTSETwoPhaseTableClass *other = NULL);
        
        double evaluate(long iParam, double p);

        double evaluate_T(double T);

        double evaluate_sat_derivative(long iParam, double p);

        double evaluate_randomly(long iParam, unsigned int N);

        double check_randomly(long iParam, unsigned int N, std::vector<double> *p, std::vector<double> *EOSv, std::vector<double> *TTSE);
};

class TTSESinglePhaseTableClass
{
protected:
        unsigned int Nh, Np,NT,Nrho;
        Fluid *pFluid;
        double pratio,logpratio,logpmin;
        double rhoratio,logrhoratio,logrhomin;
        int jpcrit_floor, jpcrit_ceil;
        int mode;
public:
        TTSESinglePhaseTableClass();
        TTSESinglePhaseTableClass(Fluid *pFluid);
        TTSETwoPhaseTableClass *SatL, *SatV;
        
        std::string root_path;
        std::vector<double> TL,SL,DL,TV,SV,DV;

        double hmin,hmax,pmin,pmax,Tmin,Tmax,rhomin,rhomax;
        bool enable_writing_tables_to_files;
        bool enable_transport;

        // Storage vectors for bicubic to keep from having to remake them every time (SLOW!)
        std::vector<double> alpha_bicubic, z_bicubic;

        BiCubicCellsContainerClass bicubic_cells;

        // Variables with h, p as inputs
        std::vector<std::vector<double> > T,dTdh,dTdp,d2Tdh2,d2Tdp2,d2Tdhdp;
        std::vector<std::vector<double> > rho,drhodh,drhodp,d2rhodh2,d2rhodp2,d2rhodhdp;
        std::vector<std::vector<double> > s,dsdh,dsdp,d2sdh2,d2sdp2,d2sdhdp;
        std::vector<double> h, p;

        // Variables with T, rho as inputs
        std::vector<std::vector<double> > s_Trho, dsdT_Trho, dsdrho_Trho, d2sdT2_Trho, d2sdrho2_Trho, d2sdTdrho_Trho;
        std::vector<std::vector<double> > p_Trho, dpdT_Trho, dpdrho_Trho, d2pdT2_Trho, d2pdrho2_Trho, d2pdTdrho_Trho;
        std::vector<std::vector<double> > h_Trho, dhdT_Trho, dhdrho_Trho, d2hdT2_Trho, d2hdrho2_Trho, d2hdTdrho_Trho;
        std::vector<std::vector<double> > mu_Trho, dmudT_Trho, dmudrho_Trho, d2mudT2_Trho, d2mudrho2_Trho, d2mudTdrho_Trho;
        std::vector<std::vector<double> > k_Trho, dkdT_Trho, dkdrho_Trho, d2kdT2_Trho, d2kdrho2_Trho, d2kdTdrho_Trho;
        std::vector<double> T_Trho, rho_Trho;

        std::vector<int> IL, IV;

        int set_mode(int mode);
        int get_mode();
        bool read_all_from_file(std::string root_path);
        void write_all_to_file(std::string root_path = std::string());
        void matrix_to_file(std::string fName, std::vector< std::vector<double> > *A);
        void vector_to_file(std::string fName, std::vector<double> *A);
        void vector_from_file(std::string fName, int N, std::vector<double> *A);
        void matrix_from_file(std::string fName, std::vector< std::vector<double> > *A);

        void set_size_ph(unsigned int Np = 100, unsigned int Nh = 100);
        void set_size_Trho(unsigned int NT = 100, unsigned int Nrho = 100);

        void update_saturation_boundary_indices();

        void update_cell_validity();

        double build_ph(double hmin, double hmax, double pmin, double pmax, TTSETwoPhaseTableClass *SatL = NULL, TTSETwoPhaseTableClass *SatV = NULL);

        double build_Trho(double Tmin, double Tmax, double rhomin, double rhomax, TTSETwoPhaseTableClass *SatL, TTSETwoPhaseTableClass *SatV);
        
        double evaluate(long iParam, double p, double logp, double h);

        double evaluate_one_other_input(long iInput1, double Param1, long iOther, double Other);
        
        bool within_range(long iInput1, double Input1, long iInput2, double Input2);
protected:
        bool within_range_one_other_input(long iInput1, double Input1, long iOther, double Other, int buf);
public:
        double evaluate_Trho(long iOutput, double T, double rho, double logrho);

        double interpolate_bicubic_Trho(long iParam, double T, double rho, double logrho);

        double evaluate_randomly(long iParam, unsigned int N);

        double interpolate_bicubic_ph(long iParam, double p, double logp, double h);

        void bicubic_cell_coordinates_Trho(double Tval, double rho, double logrhoval, int *i, int *j);
        void bicubic_cell_coordinates_ph(double hval, double p, double logpval, int *i, int *j);
        std::vector<double> * bicubic_cell_coeffs_Trho(long iParam, int i, int j);
        std::vector<double> * bicubic_cell_coeffs_ph(long iParam, int i, int j);
        double bicubic_evaluate_first_derivative_ph(long iOF, long iWRT, long iCONSTANT, double p, double logp, double h);
        double bicubic_evaluate_one_other_input(long iInput1, double Input1, long iOther, double Other);

        double check_randomly(long iParam, unsigned int N, std::vector<double> *h, std::vector<double> *p, std::vector<double> *EOSv, std::vector<double> *TTSE);

        void write_dotdrawing_tofile(char fName[]);

        void nearest_neighbor_ph(int i, int j, double *T0, double *rho0);

        void nearest_good_neighbor(int *i, int *j);

        void nearest_good_neighbor_Trho(int *i, int *j);

        void nearest_good_neighbor_ph_interpolate(int *i, int *j);

        void nearest_good_neighbor_Trho_interpolate(int *i, int *j);

        double evaluate_first_derivative(long iOF, long iWRT, long iCONSTANT, double p, double logp, double h);

};

double matrix_vector_product(std::vector<double> *x, std::vector<double> *y, double yy);

#endif