BicubicBackend.h

Go to the documentation of this file.

#ifndef BICUBICBACKEND_H
#define BICUBICBACKEND_H
 
#include <utility>
 
#include "TabularBackends.h"
#include "CoolProp/Exceptions.h"
#include "CoolProp/DataStructures.h"
#include "Eigen/Core"
 
namespace CoolProp {
 
using mat = std::vector<std::vector<double>>;
class BicubicBackend : public TabularBackend
{
   public:
    BicubicBackend(shared_ptr<CoolProp::AbstractState> AS) : TabularBackend(std::move(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) override {
        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() override {
        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) override {
        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) override {
        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) override {
        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) override {
        return evaluate_single_phase(dataset->single_phase_logpT, dataset->coeffs_pT, output, _T, _p, i, j);
    };
 
    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) override;
 
    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) override;
 
    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) override {
        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) override {
        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) override;
    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) override;
};
 
}  // namespace CoolProp
 
#endif  // BICUBICBACKEND_H