BicubicBackend.h

Go to the documentation of this file.

#ifndef BICUBICBACKEND_H
#define BICUBICBACKEND_H
 
#include "TabularBackends.h"
#include "Exceptions.h"
#include "DataStructures.h"
#include "Eigen/Core"
 
namespace CoolProp {
 
typedef std::vector<std::vector<double>> mat;
class BicubicBackend : public TabularBackend
{
   public:
    BicubicBackend(shared_ptr<CoolProp::AbstractState> AS) : TabularBackend(AS) {
        imposed_phase_index = iphase_not_imposed;
        // If a pure fluid or a predefined mixture, don't need to set fractions, go ahead and build
        if (!this->AS->get_mole_fractions().empty()) {
            check_tables();
            SinglePhaseGriddedTableData& single_phase_logph = dataset->single_phase_logph;
            SinglePhaseGriddedTableData& single_phase_logpT = dataset->single_phase_logpT;
            dataset->build_coeffs(single_phase_logph, dataset->coeffs_ph);
            dataset->build_coeffs(single_phase_logpT, dataset->coeffs_pT);
            is_mixture = (this->AS->get_mole_fractions().size() > 1);
        }
    };
    void set_mole_fractions(const std::vector<CoolPropDbl>& mole_fractions) {
        this->AS->set_mole_fractions(mole_fractions);
        is_mixture = true;
        // Check the tables and build if necessary
        check_tables();
        // For mixtures, the construction of the coefficients is delayed until this
        // function so that the set_mole_fractions function can be called
        SinglePhaseGriddedTableData& single_phase_logph = dataset->single_phase_logph;
        SinglePhaseGriddedTableData& single_phase_logpT = dataset->single_phase_logpT;
        dataset->build_coeffs(single_phase_logph, dataset->coeffs_ph);
        dataset->build_coeffs(single_phase_logpT, dataset->coeffs_pT);
    };
    std::string backend_name(void) {
        return get_backend_string(BICUBIC_BACKEND);
    }
 
    double evaluate_single_phase_derivative(SinglePhaseGriddedTableData& table, std::vector<std::vector<CellCoeffs>>& coeffs, parameters output,
                                            double x, double y, std::size_t i, std::size_t j, std::size_t Nx, std::size_t Ny);
    double evaluate_single_phase_phmolar_derivative(parameters output, std::size_t i, std::size_t j, std::size_t Nx, std::size_t Ny) {
        return evaluate_single_phase_derivative(dataset->single_phase_logph, dataset->coeffs_ph, output, _hmolar, _p, i, j, Nx, Ny);
    };
    double evaluate_single_phase_pT_derivative(parameters output, std::size_t i, std::size_t j, std::size_t Nx, std::size_t Ny) {
        return evaluate_single_phase_derivative(dataset->single_phase_logpT, dataset->coeffs_pT, output, _T, _p, i, j, Nx, Ny);
    };
 
    double evaluate_single_phase(const SinglePhaseGriddedTableData& table, const std::vector<std::vector<CellCoeffs>>& coeffs,
                                 const parameters output, const double x, const double y, const std::size_t i, const std::size_t j);
    double evaluate_single_phase_phmolar(parameters output, std::size_t i, std::size_t j) {
        return evaluate_single_phase(dataset->single_phase_logph, dataset->coeffs_ph, output, _hmolar, _p, i, j);
    };
    double evaluate_single_phase_pT(parameters output, std::size_t i, std::size_t j) {
        return evaluate_single_phase(dataset->single_phase_logpT, dataset->coeffs_pT, output, _T, _p, i, j);
    };
 
    virtual void find_native_nearest_good_indices(SinglePhaseGriddedTableData& table, const std::vector<std::vector<CellCoeffs>>& coeffs, double x,
                                                  double y, std::size_t& i, std::size_t& j);
 
    virtual void find_nearest_neighbor(SinglePhaseGriddedTableData& table, const std::vector<std::vector<CellCoeffs>>& coeffs,
                                       const parameters variable1, const double value1, const parameters otherkey, const double otherval,
                                       std::size_t& i, std::size_t& j);
 
    double evaluate_single_phase_transport(SinglePhaseGriddedTableData& table, parameters output, double x, double y, std::size_t i, std::size_t j);
 
    double evaluate_single_phase_phmolar_transport(parameters output, std::size_t i, std::size_t j) {
        return evaluate_single_phase_transport(dataset->single_phase_logph, output, _hmolar, _p, i, j);
    };
    double evaluate_single_phase_pT_transport(parameters output, std::size_t i, std::size_t j) {
        return evaluate_single_phase_transport(dataset->single_phase_logpT, output, _T, _p, i, j);
    };
 
    void invert_single_phase_x(const SinglePhaseGriddedTableData& table, const std::vector<std::vector<CellCoeffs>>& coeffs, parameters other_key,
                               double other, double y, std::size_t i, std::size_t j);
    void invert_single_phase_y(const SinglePhaseGriddedTableData& table, const std::vector<std::vector<CellCoeffs>>& coeffs, parameters other_key,
                               double other, double x, std::size_t i, std::size_t j);
};
 
}  // namespace CoolProp
 
#endif  // BICUBICBACKEND_H