adding new fucntions and test to the python interface

Author: BBArrosDias

interface/python/src/pyMixture.cpp

@@ -20,6 +20,50 @@ void py_export_Mixture(py::module &m) {
   py::class_<Mutation::Mixture>(m, "Mixture")
       .def(py::init<Mutation::MixtureOptions>())
       .def(py::init<std::string &>())
+
+     .def("NA", 
+          [](const Mutation::Mixture &self) {
+               return Mutation::NA;
+          },
+           "Returns the Avogadro's number (molecule/mol)."
+           )
+
+     .def("KB", 
+          [](const Mutation::Mixture &self) {
+               return Mutation::KB;
+          },    
+           "Returns the Boltzmann's constant (J/molecule-K)")
+
+     .def("RU", 
+          [](const Mutation::Mixture &self) {
+               return Mutation::RU;
+          },
+           "Returns the Universal Gas constant (J/mole-K)")            
+
+     .def("HP", 
+          [](const Mutation::Mixture &self) {
+               return Mutation::HP;
+          },
+           "Returns the Planck's constant (J-s)")
+     
+     .def("C0", 
+          [](const Mutation::Mixture &self) {
+               return Mutation::C0;
+          },
+           "Returns the Speed of light in vacuum (m/s)")
+
+     .def("ONEATM", 
+          [](const Mutation::Mixture &self) {
+               return Mutation::ONEATM;
+          },
+           "Returns the 1 atm in Pa")   
+
+     .def("SB", 
+          [](const Mutation::Mixture &self) {
+               return Mutation::SB;
+          },
+           "Returns the Stefan-Boltzmann constant (W/m^2-K^4)")  
+
       .def("nElements", &Mutation::Mixture::nElements,
            "Returns the number of elements considered in the mixture.")
 
@@ -380,7 +424,7 @@ void py_export_Mixture(py::module &m) {
           "elemental mole fractions. "
           "If the mole fractions are not given, then the default fractions are "
           "used.")
-           .def(
+     .def(
           "speciesHOverRT",
           [](const Mutation::Mixture &self) {
             std::vector<double> h_i(self.nSpecies());
@@ -400,16 +444,6 @@ void py_export_Mixture(py::module &m) {
           "Returns the unitless vector of species enthalpies \f$ H_i / R_u T "
           "\f$.")
 
-      .def(
-          "speciesCpOverR",
-          [](const Mutation::Mixture &self) {
-            std::vector<double> h_i(self.nSpecies());
-            self.speciesCpOverR(h_i.data());
-            return py::array(py::cast(h_i));
-          },
-          "Returns the unitless vector of species specific heat at constant pressure \f$ Cp_i / R_u "
-          "\f$.")
-
       .def("mixtureHMole",
            static_cast<double (Mutation::Mixture::*)(void) const>(
                &Mutation::Mixture::mixtureHMole),
@@ -508,6 +542,26 @@ void py_export_Mixture(py::module &m) {
           },
           "Converts species mass to elemental mass fraction.")
 
+           .def(
+          "convert_xe_to_ye",
+          [](const Mutation::Mixture &self, std::vector<double> x) {
+            std::vector<double> y(self.nElements());
+            self.Mutation::Mixture::Thermodynamics::convert<
+                Mutation::Thermodynamics::XE_TO_YE>(x.data(), y.data());
+            return py::array(py::cast(y));
+          },
+          "Converts elemental mole fraction to elemental mass fractions.")
+
+      .def(
+          "convert_ye_to_xe",
+          [](const Mutation::Mixture &self, std::vector<double> x) {
+            std::vector<double> y(self.nElements());
+            self.Mutation::Mixture::Thermodynamics::convert<
+                Mutation::Thermodynamics::YE_TO_XE>(x.data(), y.data());
+            return py::array(py::cast(y));
+          },
+          "Converts elemental mass fraction to elemental mole fractions.")     
+
       .def("dRhodP", &Mutation::Mixture::dRhodP,
            "Returns the density derivative with respect to pressure for the "
            "current equilibrium state.")
@@ -810,5 +864,38 @@ void py_export_Mixture(py::module &m) {
             return py::array(py::cast(cv_i));
           },
           "Fills the constant volume specific heat according to the used "
-          "StateModel");
+          "StateModel") 
+
+     
+     .def(
+          "getGibbsMass",
+          [](const Mutation::Mixture &self) {
+            Eigen::ArrayXd gibbs_i(self.nSpecies());
+            self.Mutation::Mixture::speciesGOverRT(gibbs_i.data());
+            gibbs_i*=self.T()* Mutation::RU/self.speciesMw();
+            return py::array(py::cast(gibbs_i));;
+          },
+          "Return an array of gibbs free energy for each species per unit mass")       
+
+     .def(
+          "getGibbsMass",
+          [](const Mutation::Mixture &self, double T, double P) {
+            Eigen::ArrayXd gibbs_i(self.nSpecies());
+            self.Mutation::Mixture::speciesGOverRT(T, P, gibbs_i.data());
+            gibbs_i*=T* Mutation::RU/self.speciesMw();
+            return py::array(py::cast(gibbs_i));;
+          },
+          "Return an array of gibbs free energy for each species per unit mass")      
+
+     .def(
+          "getSTGibbsMass",
+          [](const Mutation::Mixture &self, double T) {
+            Eigen::ArrayXd gibbs_i(self.nSpecies());
+            self.Mutation::Mixture::speciesSTGOverRT(T, gibbs_i.data());
+            gibbs_i*=T* Mutation::RU/self.speciesMw();
+            return py::array(py::cast(gibbs_i));;
+          },
+          "Return an array of gibbs free energy for each species per unit mass at standard pressure")     
+          
+          ;
 }

tests/python/test_mutation.py

@@ -1,5 +1,6 @@
 #!/usr/bin/env python
 
+import numpy as np
 import mutationpp as mpp
 import pytest
 
@@ -319,3 +320,91 @@ def test_speciesHOverRT():
         3.34133823e-02,
     ]
     assert np.allclose(mixture.speciesHOverRT(301), expected)    
+    
+def test_getEnergiesMass():
+    
+    expected = mixture.getEnthalpiesMass() -  mixture.T()*mixture.RU()/mixture.speciesMw()
+    
+    assert mixture.getEnergiesMass() == pytest.approx(expected)    
+    
+    
+def test_getEnthalpiesMass():
+    
+    expected = [
+        7.0098139454e+07,
+        1.3436541662e+08,
+        9.8062005405e+07,
+        3.3017452040e+07,
+        5.3888226083e+07,
+        3.6610342011e+07,
+        3.3732317707e+07,
+        1.5579800144e+07,
+        3.0374812162e+06,
+        1.9226029990e+03,
+        1.6962169231e+03
+    ]
+    
+    assert mixture.getEnthalpiesMass() == pytest.approx(expected)  
+     
+def test_getCpsMass():
+    
+    expected = [
+        3.7890886192e+07,
+        1.5192147894e+03,
+        1.2992294338e+03,
+        9.7019017139e+02,
+        1.0395135823e+03,
+        9.1103684272e+02,
+        1.4840168399e+03,
+        1.2991848864e+03,
+        9.7219901895e+02,
+        1.0392575435e+03,
+        9.1700386827e+02
+    ]
+    
+    assert mixture.getCpsMass() == pytest.approx(expected)  
+    
+    
+def test_getGibbsMass():
+    
+    expected = [
+        -3.2412103851e+10,
+        1.3011972425e+08,
+        9.4435909312e+07,
+        3.0651845001e+07,
+        5.1361201327e+07,
+        3.4318319525e+07,
+        2.9626009866e+07,
+        1.1827394569e+07,
+        5.4328552314e+05,
+        -2.4612058750e+06,
+        -2.2814767433e+06
+    ]
+    
+    assert mixture.getGibbsMass() == pytest.approx(expected)      
+        
+def test_getCvsMass():
+    
+    expected = mixture.getCpsMass()- mixture.RU()/mixture.speciesMw()
+    assert mixture.getCvsMass() == pytest.approx(expected)              
+
+def test_mixtureSMass():
+    assert mixture.mixtureSMass() == pytest.approx(8218.83)  
+    
+def test_NA():
+    assert mixture.NA() == pytest.approx(6.0221415E23)       
+    
+def test_KB():
+    assert mixture.KB() == pytest.approx(1.3806503E-23)  
+    
+def test_RU():
+    assert mixture.RU() == pytest.approx(mixture.KB()* mixture.NA()) 
+    
+def test_HP():
+    assert mixture.HP() == pytest.approx(6.626068E-34)      
+    
+def test_C0():
+    assert mixture.C0() == pytest.approx(299792458.0)     
+    
+def test_ONEATM():
+    assert mixture.ONEATM() == pytest.approx(101325.0)