Add get_BIP function for multiparameter models

Closes #84
usnistgov · Jan 12, 2024 · 2001c17 · 2001c17
1 parent a129dd2
commit 2001c17
Show file tree

Hide file tree

Showing 4 changed files with 62 additions and 0 deletions.
diff --git a/include/teqp/models/multifluid.hpp b/include/teqp/models/multifluid.hpp
@@ -85,6 +85,8 @@ class DepartureContribution {
     const DepartureFunctionCollection funcs;
 public:
     DepartureContribution(FCollection&& F, DepartureFunctionCollection&& funcs) : F(F), funcs(funcs) {};
+
+    const auto& get_F() const { return F; }
 
     template<typename TauType, typename DeltaType, typename MoleFractions>
     auto alphar(const TauType& tau, const DeltaType& delta, const MoleFractions& molefracs) const {
@@ -134,6 +136,16 @@ class MultiFluid {
     void set_meta(const std::string& m) { meta = m; }
     /// Get the metadata stored in string form
     auto get_meta() const { return meta; }
+    /// Return a binary interaction parameter
+    const std::variant<double, std::string> get_BIP(const std::size_t &i, const std::size_t &j, const std::string& key) const{
+        if (key == "F" || key == "Fij"){
+            auto F = dep.get_F();
+            if (0 <= i && i < F.rows() && 0 <= j && j < F.cols()){
+                return F(i,j);
+            }
+        }
+        return redfunc.get_BIP(i, j, key);
+    }
 
     MultiFluid(ReducingFunctions&& redfunc, CorrespondingTerm&& corr, DepartureTerm&& dep, GasConstantCalculator&& Rcalc) : redfunc(redfunc), corr(corr), dep(dep), Rcalc(Rcalc) {};
 

diff --git a/include/teqp/models/multifluid_mutant.hpp b/include/teqp/models/multifluid_mutant.hpp
@@ -28,6 +28,16 @@ namespace teqp {
         void set_meta(const std::string& m) { meta = m; }
         /// Get the metadata stored in string form
         auto get_meta() const { return meta; }
+        /// Return a binary interaction parameter
+        const std::variant<double, std::string> get_BIP(const std::size_t &i, const std::size_t &j, const std::string& key) const{
+            if (key == "F" || key == "Fij"){
+                auto F = dep.get_F();
+                if (0 <= i && i < F.rows() && 0 <= j && j < F.cols()){
+                    return F(i,j);
+                }
+            }
+            return redfunc.get_BIP(i, j, key);
+        }
 
         template<typename TType, typename RhoType, typename MoleFracType>
         auto alphar(const TType& T,

diff --git a/include/teqp/models/multifluid_reducing.hpp b/include/teqp/models/multifluid_reducing.hpp
@@ -221,6 +221,24 @@ namespace teqp {
 
         template<typename MoleFractions> auto get_Tr(const MoleFractions& molefracs) const { return Y(molefracs, Tc, betaT, YT); }
         template<typename MoleFractions> auto get_rhor(const MoleFractions& molefracs) const { return 1.0 / Y(molefracs, vc, betaV, Yv); }
+
+        const auto& get_mat(const std::string& key) const {
+            if (key == "betaT"){ return betaT; }
+            if (key == "gammaT"){ return gammaT; }
+            if (key == "betaV"){ return betaV; }
+            if (key == "gammaV"){ return gammaV; }
+            throw std::invalid_argument("variable is not understood: " + key);
+        }
+        auto get_BIP(const std::size_t& i, const std::size_t& j, const std::string& key) const {
+            const auto& mat = get_mat(key);
+            if (i < mat.rows() && j < mat.cols()){
+                return mat(i,j);
+            }
+            else{
+                throw std::invalid_argument("Indices are out of bounds");
+            }
+        }
+
     };
 
     class MultiFluidInvariantReducingFunction {
@@ -265,6 +283,23 @@ namespace teqp {
         }
         template<typename MoleFractions> auto get_Tr(const MoleFractions& molefracs) const { return Y(molefracs, phiT, lambdaT, YT); }
         template<typename MoleFractions> auto get_rhor(const MoleFractions& molefracs) const { return 1.0 / Y(molefracs, phiV, lambdaV, Yv); }
+
+        const auto& get_mat(const std::string& key) const {
+            if (key == "phiT"){ return phiT; }
+            if (key == "lambdaT"){ return lambdaT; }
+            if (key == "phiV"){ return phiV; }
+            if (key == "lambdaV"){ return lambdaV; }
+            throw std::invalid_argument("variable is not understood: " + key);
+        }
+        auto get_BIP(const std::size_t& i, const std::size_t& j, const std::string& key) const {
+            const auto& mat = get_mat(key);
+            if (i < mat.rows() && j < mat.cols()){
+                return mat(i,j);
+            }
+            else{
+                throw std::invalid_argument("Indices are out of bounds");
+            }
+        }
     };
 
 
@@ -289,6 +324,10 @@ namespace teqp {
         auto get_rhor(const MoleFractions& molefracs) const {
             return std::visit([&](auto& t) { return t.get_rhor(molefracs); }, term);
         }
+
+        auto get_BIP(const std::size_t& i, const std::size_t& j, const std::string& key) const {
+            return std::visit([&](auto& t) { return t.get_BIP(i, j, key); }, term);
+        }
     };
 
     using ReducingFunctions = ReducingTermContainer<MultiFluidReducingFunction, MultiFluidInvariantReducingFunction>;

diff --git a/interface/pybind11_wrapper.cpp b/interface/pybind11_wrapper.cpp
@@ -94,6 +94,7 @@ void attach_multifluid_methods(py::object&obj){
     setattr("get_meta", MethodType(py::cpp_function([](py::object& o){ return get_typed<TYPE>(o).get_meta(); }), obj));
     setattr("set_meta", MethodType(py::cpp_function([](py::object& o, const std::string& s){ return get_mutable_typed<TYPE>(o).set_meta(s); }, "self"_a, "s"_a), obj));
     setattr("get_alpharij", MethodType(py::cpp_function([](py::object& o, const int i, const int j, const double tau, const double delta){ return get_typed<TYPE>(o).dep.get_alpharij(i,j,tau,delta); }, "self"_a, "i"_a, "j"_a, "tau"_a, "delta"_a), obj));
+    setattr("get_BIP", MethodType(py::cpp_function([](py::object& o, const std::size_t& i, const std::size_t& j, const std::string& key){ return get_typed<TYPE>(o).get_BIP(i,j,key); }, "self"_a, "i"_a, "j"_a, "key"_a), obj));
 }
 template<typename TYPE>
 void attach_GERG_methods(py::object&obj){