754 lines
22 KiB
Python
754 lines
22 KiB
Python
import os
|
|
import ctypes
|
|
import numpy as np
|
|
import pandas as pd
|
|
from ctypes import POINTER, c_double, CFUNCTYPE, c_char_p, c_void_p, Structure
|
|
# @CFUNCTYPE(None)
|
|
# def modelica_print(a):
|
|
# print(a)
|
|
|
|
# @CFUNCTYPE(None)
|
|
# def modelica_error(a):
|
|
# print(f"Modelica Error: {a}")
|
|
|
|
# util_function_ptr = ctypes.CFUNCTYPE(None)
|
|
# class ModelicaUtilsWrapper(Structure):
|
|
# _fields_ = [('print_message', POINTER(util_function_ptr)),
|
|
# ('print_error', POINTER(util_function_ptr))]
|
|
|
|
|
|
class GenRefPropertiesPipev2(Structure):
|
|
"""
|
|
struct GenRefPropertiesPipev2
|
|
{
|
|
double T;
|
|
double Ts;
|
|
double rho;
|
|
double Cp;
|
|
double mu;
|
|
double lambda;
|
|
};
|
|
"""
|
|
_fields_ = [('T', c_double),
|
|
('Ts', c_double),
|
|
('rho', c_double),
|
|
('Cp', c_double),
|
|
('mu', c_double),
|
|
('lambda', c_double)]
|
|
|
|
|
|
class SatRefPropertiesPipe(Structure):
|
|
"""
|
|
struct SatRefPropertiesPipe
|
|
{
|
|
double rhosl; //liquid specific volume
|
|
double rhosv;
|
|
double hsl;
|
|
double hsv;
|
|
double Cpsl;
|
|
double Cpsv;
|
|
double musl;
|
|
double musv;
|
|
double lambdasl;
|
|
double lambdasv;
|
|
double sigma;
|
|
};
|
|
|
|
"""
|
|
_fields_ = [('rhosl', c_double),
|
|
('rhosv', c_double),
|
|
('hsl', c_double),
|
|
('hsv', c_double),
|
|
('Cpsl', c_double),
|
|
('Cpsv', c_double),
|
|
('musl', c_double),
|
|
('musv', c_double),
|
|
('lambdasl', c_double),
|
|
('lambdasv', c_double),
|
|
('sigma', c_double)]
|
|
|
|
|
|
class GenRefProperties(Structure):
|
|
"""
|
|
struct GenRefProperties
|
|
{
|
|
double T;
|
|
double Ts;
|
|
double v;
|
|
double h;
|
|
double s;
|
|
double Cp;
|
|
double mu;
|
|
double lambda;
|
|
double CpCv;
|
|
double n_is;
|
|
double c;
|
|
double dTglide;
|
|
};
|
|
"""
|
|
_fields_ = [('T', c_double),
|
|
('Ts', c_double),
|
|
('v', c_double),
|
|
('h', c_double),
|
|
('s', c_double),
|
|
('Cp', c_double),
|
|
('mu', c_double),
|
|
('lambda', c_double),
|
|
('CpCv', c_double),
|
|
('n_is', c_double),
|
|
('c', c_double),
|
|
('dTglide', c_double)]
|
|
|
|
|
|
if os.name == 'nt':
|
|
REFIFC_LIB_NAME = "refifc"
|
|
else: # 'posix'
|
|
REFIFC_LIB_NAME = "librefifc.so"
|
|
|
|
|
|
class Refifc(object):
|
|
|
|
def __init__(self, refrig_name):
|
|
|
|
# Sauvegardez le répertoire courant pour pouvoir y revenir plus tard
|
|
self.original_directory = os.getcwd()
|
|
# Determine candidate directories for the native library.
|
|
# Prefer central repo-level folders:
|
|
# <repo_root>/libs/dll (Windows)
|
|
# <repo_root>/libs/so (Linux)
|
|
# Fall back to package-local `app/ipm/lib/<platform>` or the package dir.
|
|
package_dir = os.path.dirname(os.path.abspath(__file__))
|
|
# repo root is two levels above app/ipm
|
|
repo_root = os.path.abspath(os.path.join(package_dir, '..', '..'))
|
|
preferred_windows = os.path.join(repo_root, 'libs', 'dll')
|
|
preferred_linux = os.path.join(repo_root, 'libs', 'so')
|
|
|
|
if os.name == 'nt':
|
|
candidate_dirs = [preferred_windows]
|
|
else:
|
|
candidate_dirs = [preferred_linux]
|
|
|
|
# also consider the package-local lib/<platform> layout as fallback
|
|
candidate_dirs.append(os.path.join(package_dir, 'lib', 'windows' if os.name == 'nt' else 'linux'))
|
|
candidate_dirs.append(package_dir)
|
|
|
|
# Try each candidate directory in order until we can load the library.
|
|
load_exc = None
|
|
for dll_directory in candidate_dirs:
|
|
if not dll_directory:
|
|
continue
|
|
try:
|
|
if os.path.isdir(dll_directory):
|
|
# temporarily change cwd to help some LoadLibrary behaviors
|
|
os.chdir(dll_directory)
|
|
self.lib = ctypes.cdll.LoadLibrary(os.path.join(dll_directory, REFIFC_LIB_NAME))
|
|
else:
|
|
# attempt to load directly by path anyway
|
|
self.lib = ctypes.cdll.LoadLibrary(os.path.join(dll_directory, REFIFC_LIB_NAME))
|
|
load_exc = None
|
|
break
|
|
except OSError as e:
|
|
load_exc = e
|
|
# try next candidate
|
|
continue
|
|
|
|
# if we failed to load from candidates, try loading by name (system path)
|
|
if load_exc is not None:
|
|
try:
|
|
self.lib = ctypes.cdll.LoadLibrary(REFIFC_LIB_NAME)
|
|
load_exc = None
|
|
except Exception:
|
|
# restore cwd before raising
|
|
os.chdir(self.original_directory)
|
|
raise load_exc
|
|
|
|
ctypes_refrig_name = refrig_name
|
|
if os.name == 'posix':
|
|
if not ctypes_refrig_name.lower().endswith("so"):
|
|
ctypes_refrig_name = ctypes_refrig_name + ".so"
|
|
if not ctypes_refrig_name.lower().startswith("lib"):
|
|
ctypes_refrig_name = "lib" + ctypes_refrig_name
|
|
|
|
try:
|
|
ctypes.CDLL(os.path.join(dll_directory, REFIFC_LIB_NAME))
|
|
except OSError:
|
|
# don't raise here; letting the subsequent load/check handle missing refrigerant libs
|
|
print(f"Refrig {refrig_name} not found in {dll_directory}, please check!")
|
|
|
|
func = self.lib.refdll_load
|
|
func.restype = POINTER(c_void_p)
|
|
func.argtypes = [c_char_p, c_void_p]
|
|
self.handle = func(c_char_p(refrig_name.encode('utf-8')), c_void_p())
|
|
|
|
# def __del__(self):
|
|
|
|
# func = self.lib.refdll_unload
|
|
# func.restype = None
|
|
# func.argtypes = [c_void_p]
|
|
# func(self.handle)
|
|
|
|
def func_0_f(self, func_name):
|
|
func = self.lib[func_name]
|
|
func.restype = c_double
|
|
func.argtypes = [c_void_p]
|
|
return func(self.handle)
|
|
|
|
def func_f_f(self, func_name, f_arg):
|
|
func = self.lib[func_name]
|
|
func.restype = c_double
|
|
func.argtypes = [c_void_p, c_double]
|
|
return func(self.handle, f_arg)
|
|
|
|
def func_f_2f(self, func_name, f_arg_1, f_arg_2):
|
|
func = self.lib[func_name]
|
|
func.restype = c_double
|
|
func.argtypes = [c_void_p, c_double, c_double]
|
|
return func(self.handle, f_arg_1, f_arg_2)
|
|
|
|
def func_f_4f(self, func_name, f_arg_1, f_arg_2, f_arg_3, f_arg_4):
|
|
func = self.lib[func_name]
|
|
func.restype = c_double
|
|
func.argtypes = [c_void_p, c_double, c_double, c_double, c_double]
|
|
return func(self.handle, f_arg_1, f_arg_2, f_arg_3, f_arg_4)
|
|
|
|
def p_begin(self):
|
|
return self.func_0_f('pbegin')
|
|
|
|
def p_end(self):
|
|
return self.func_0_f('pend')
|
|
|
|
def x_begin(self):
|
|
return self.func_0_f('qbegin')
|
|
|
|
def x_end(self):
|
|
return self.func_0_f('qend')
|
|
|
|
"""
|
|
Define the AD functions
|
|
"""
|
|
|
|
def computeDpGenValuesPipev2_px(self, p, x):
|
|
func = self.lib.computeDpGenValuesPipev2_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, POINTER(GenRefPropertiesPipev2)]
|
|
gen_prop_pipe = GenRefPropertiesPipev2()
|
|
|
|
func(self.handle, p, x, gen_prop_pipe)
|
|
res = np.ctypeslib.as_array(gen_prop_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
return res
|
|
|
|
def computeDxGenValuesPipev2_px(self, p, x):
|
|
func = self.lib.computeDxGenValuesPipev2_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, POINTER(GenRefPropertiesPipev2)]
|
|
gen_prop_pipe = GenRefPropertiesPipev2()
|
|
|
|
func(self.handle, p, x, gen_prop_pipe)
|
|
|
|
res = np.ctypeslib.as_array(gen_prop_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
return res
|
|
|
|
def computeDpSatValuesPipe_px(self, p, x):
|
|
func = self.lib.computeDpSatValuesPipe_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, POINTER(SatRefPropertiesPipe)]
|
|
sat_pro_pipe = SatRefPropertiesPipe()
|
|
|
|
func(self.handle, p, x, sat_pro_pipe)
|
|
res = np.ctypeslib.as_array(sat_pro_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
return res
|
|
|
|
def computeDxSatValuesPipe_px(self, p, x):
|
|
func = self.lib.computeDxSatValuesPipe_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, POINTER(SatRefPropertiesPipe)]
|
|
sat_pro_pipe = SatRefPropertiesPipe()
|
|
|
|
func(self.handle, p, x, sat_pro_pipe)
|
|
res = np.ctypeslib.as_array(sat_pro_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
return res
|
|
|
|
def computeGenValuesPipev2_px(self, p, x):
|
|
func = self.lib.computeGenValuesPipev2_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, POINTER(GenRefPropertiesPipev2)]
|
|
gen_prop_pipe = GenRefPropertiesPipev2()
|
|
|
|
func(self.handle, p, x, gen_prop_pipe)
|
|
|
|
res = np.ctypeslib.as_array(gen_prop_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
return res
|
|
|
|
def computeSatValuesPipe_px(self, p, x):
|
|
func = self.lib.computeSatValuesPipe_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, POINTER(SatRefPropertiesPipe)]
|
|
sat_pro_pipe = SatRefPropertiesPipe()
|
|
|
|
func(self.handle, p, x, sat_pro_pipe)
|
|
res = np.ctypeslib.as_array(sat_pro_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
return res
|
|
|
|
def computeGenDxValues_px(self, p, x):
|
|
func = self.lib.computeGenDxValues_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, POINTER(GenRefProperties)]
|
|
gen_prop_pipe = GenRefProperties()
|
|
|
|
func(self.handle, p, x, gen_prop_pipe)
|
|
|
|
res = np.ctypeslib.as_array(gen_prop_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
return res
|
|
|
|
def computeGenDpValues_px(self, p, x):
|
|
func = self.lib.computeGenDpValues_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, POINTER(GenRefProperties)]
|
|
gen_prop_pipe = GenRefProperties()
|
|
|
|
func(self.handle, p, x, gen_prop_pipe)
|
|
res = np.ctypeslib.as_array(gen_prop_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
return res
|
|
|
|
def ComputeDFGenValuesPipev2_px(self, p, x, dp, dx):
|
|
func = self.lib.ComputeDFGenValuesPipev2_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, c_double, c_double, POINTER(GenRefPropertiesPipev2)]
|
|
gen_prop_pipe = GenRefPropertiesPipev2()
|
|
|
|
func(self.handle, p, x, dp, dx, gen_prop_pipe)
|
|
|
|
res = np.ctypeslib.as_array(gen_prop_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
res['dp'] = dp
|
|
res['dx'] = dx
|
|
return res
|
|
|
|
def ComputeDFSatValuesPipe_px(self, p, x, dp, dx):
|
|
func = self.lib.ComputeDFSatValuesPipe_px
|
|
func.restype = c_void_p
|
|
func.argtypes = [c_void_p, c_double, c_double, c_double, c_double, POINTER(SatRefPropertiesPipe)]
|
|
sat_pro_pipe = SatRefPropertiesPipe()
|
|
|
|
func(self.handle, p, x, dp, dx, sat_pro_pipe)
|
|
res = np.ctypeslib.as_array(sat_pro_pipe)
|
|
res = pd.Series(res.tolist(), index=res.dtype.names)
|
|
res['p'] = p
|
|
res['x'] = x
|
|
res['dp'] = dp
|
|
res['dx'] = dx
|
|
return res
|
|
|
|
def dTglide_p(self, p):
|
|
return self.func_f_f('dTglide_p', p)
|
|
|
|
def dvxdp_px(self, p, x):
|
|
return self.func_f_2f('dvxdp_px', p, x)
|
|
|
|
def dvpdp_px(self, p, x):
|
|
return self.func_f_2f('dvpdp_px', p, x)
|
|
|
|
def T_px(self, p, x):
|
|
return self.func_f_2f('T_px', p, x)
|
|
|
|
def dCpsldx_px(self, p, x):
|
|
return self.func_f_2f('dCpsldx_px', p, x)
|
|
|
|
def dCpsldp_px(self, p, x):
|
|
return self.func_f_2f('dCpsldp_px', p, x)
|
|
|
|
def dCpdx_px(self, p, x):
|
|
return self.func_f_2f('dCpdx_px', p, x)
|
|
|
|
def dCpdp_px(self, p, x):
|
|
return self.func_f_2f('dCpdp_px', p, x)
|
|
|
|
def dssvdx_px(self, p, x):
|
|
return self.func_f_2f('dssvdx_px', p, x)
|
|
|
|
def dssvdp_px(self, p, x):
|
|
return self.func_f_2f('dssvdp_px', p, x)
|
|
|
|
def dssldx_px(self, p, x):
|
|
return self.func_f_2f('dssldx_px', p, x)
|
|
|
|
def dssldp_px(self, p, x):
|
|
return self.func_f_2f('dssldp_px', p, x)
|
|
|
|
def dhsvdx_px(self, p, x):
|
|
return self.func_f_2f('dhsvdx_px', p, x)
|
|
|
|
def dhsvdp_px(self, p, x):
|
|
return self.func_f_2f('dhsvdp_px', p, x)
|
|
|
|
def dTsdp_px(self, p, x):
|
|
return self.func_f_2f('dTsdp_px', p, x)
|
|
|
|
def dTdp_px(self, p, x):
|
|
return self.func_f_2f('dTdp_px', p, x)
|
|
|
|
def dvp_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dvp_px', p, x, dp, dx)
|
|
|
|
def dhxdx_px(self, p, x):
|
|
return self.func_f_2f('dhxdx_px', p, x)
|
|
|
|
def dhxdp_px(self, p, x):
|
|
return self.func_f_2f('dhxdp_px', p, x)
|
|
|
|
def dhx_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dhx_px', p, x, dp, dx)
|
|
|
|
def dhpdx_px(self, p, x):
|
|
return self.func_f_2f('dhpdx_px', p, x)
|
|
|
|
def dhpdp_px(self, p, x):
|
|
return self.func_f_2f('dhpdp_px', p, x)
|
|
|
|
def dhp_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dhp_px', p, x, dp, dx)
|
|
|
|
def dlambdasvdx_px(self, p, x):
|
|
return self.func_f_2f('dlambdasvdx_px', p, x)
|
|
|
|
def dlambdasvdp_px(self, p, x):
|
|
return self.func_f_2f('dlambdasvdp_px', p, x)
|
|
|
|
def dlambdasldx_px(self, p, x):
|
|
return self.func_f_2f('dlambdasldx_px', p, x)
|
|
|
|
def dlambdasldp_px(self, p, x):
|
|
return self.func_f_2f('dlambdasldp_px', p, x)
|
|
|
|
def dlambdadx_px(self, p, x):
|
|
return self.func_f_2f('dlambdadx_px', p, x)
|
|
|
|
def dlambdadp_px(self, p, x):
|
|
return self.func_f_2f('dlambdadp_px', p, x)
|
|
|
|
def dmusvdx_px(self, p, x):
|
|
return self.func_f_2f('dmusvdx_px', p, x)
|
|
|
|
def dmusvdp_px(self, p, x):
|
|
return self.func_f_2f('dmusvdp_px', p, x)
|
|
|
|
def dmusldx_px(self, p, x):
|
|
return self.func_f_2f('dmusldx_px', p, x)
|
|
|
|
def dmusldp_px(self, p, x):
|
|
return self.func_f_2f('dmusldp_px', p, x)
|
|
|
|
def dsdx_px(self, p, x):
|
|
return self.func_f_2f('dsdx_px', p, x)
|
|
|
|
def dsdp_px(self, p, x):
|
|
return self.func_f_2f('dsdp_px', p, x)
|
|
|
|
def dhsldx_px(self, p, x):
|
|
return self.func_f_2f('dhsldx_px', p, x)
|
|
|
|
def dhsldp_px(self, p, x):
|
|
return self.func_f_2f('dhsldp_px', p, x)
|
|
|
|
def hx_px(self, p, x):
|
|
return self.func_f_2f('hx_px', p, x)
|
|
|
|
def hp_px(self, p, x):
|
|
return self.func_f_2f('hp_px', p, x)
|
|
|
|
def dhdx_px(self, p, x):
|
|
return self.func_f_2f('dhdx_px', p, x)
|
|
|
|
def dhdp_px(self, p, x):
|
|
return self.func_f_2f('dhdp_px', p, x)
|
|
|
|
def vx_px(self, p, x):
|
|
return self.func_f_2f('vx_px', p, x)
|
|
|
|
def vp_px(self, p, x):
|
|
return self.func_f_2f('vp_px', p, x)
|
|
|
|
def drhosvdx_px(self, p, x):
|
|
return self.func_f_2f('drhosvdx_px', p, x)
|
|
|
|
def drhosvdp_px(self, p, x):
|
|
return self.func_f_2f('drhosvdp_px', p, x)
|
|
|
|
def drhosldx_px(self, p, x):
|
|
return self.func_f_2f('drhosldx_px', p, x)
|
|
|
|
def drhosldp_px(self, p, x):
|
|
return self.func_f_2f('drhosldp_px', p, x)
|
|
|
|
def drhodh_px(self, p, x):
|
|
return self.func_f_2f('drhodh_px', p, x)
|
|
|
|
def drhodp_px(self, p, x):
|
|
return self.func_f_2f('drhodp_px', p, x)
|
|
|
|
def dTs_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dTs_px', p, x, dp, dx)
|
|
|
|
def dT_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dT_px', p, x, dp, dx)
|
|
|
|
def dc_ph(self, p, h, dp, dh):
|
|
return self.func_f_4f('dc_ph', p, h, dp, dh)
|
|
|
|
def dlambda_ph(self, p, h, dp, dh):
|
|
return self.func_f_4f('dlambda_ph', p, h, dp, dh)
|
|
|
|
def dmu_ph(self, p, h, dp, dh):
|
|
return self.func_f_4f('dmu_ph', p, h, dp, dh)
|
|
|
|
def dCpCv_ph(self, p, h, dp, dh):
|
|
return self.func_f_4f('dCpCv_ph', p, h, dp, dh)
|
|
|
|
def dh_ps(self, p, s, dp, ds):
|
|
return self.func_f_4f('dh_ps', p, s, dp, ds)
|
|
|
|
def dh_pT(self, p, T, dp, dT):
|
|
return self.func_f_4f('dh_pT', p, T, dp, dT)
|
|
|
|
def drhodh_ph(self, p, h):
|
|
return self.func_f_2f('drhodh_ph', p, h)
|
|
|
|
def drhodp_ph(self, p, h):
|
|
return self.func_f_2f('drhodp_ph', p, h)
|
|
|
|
def drho_ph(self, p, h, dp, dh):
|
|
return self.func_f_4f('drho_ph', p, h, dp, dh)
|
|
|
|
def h_pT(self, p, T):
|
|
return self.func_f_2f('h_pT', p, T)
|
|
|
|
def x_ph(self, p, h):
|
|
return self.func_f_2f('x_ph', p, h)
|
|
|
|
def c_ph(self, p, h):
|
|
return self.func_f_2f('c_ph', p, h)
|
|
|
|
def lambda_ph(self, p, h):
|
|
return self.func_f_2f('lambda_ph', p, h)
|
|
|
|
def mu_ph(self, p, h):
|
|
return self.func_f_2f('mu_ph', p, h)
|
|
|
|
def CpCv_ph(self, p, h):
|
|
return self.func_f_2f('CpCv_ph', p, h)
|
|
|
|
def Cp_ph(self, p, h):
|
|
return self.func_f_2f('Cp_ph', p, h)
|
|
|
|
def s_ph(self, p, h):
|
|
return self.func_f_2f('s_ph', p, h)
|
|
|
|
def rho_ph(self, p, h):
|
|
return self.func_f_2f('rho_ph', p, h)
|
|
|
|
def Ts_ph(self, p, h):
|
|
return self.func_f_2f('Ts_ph', p, h)
|
|
|
|
def T_ph(self, p, h):
|
|
return self.func_f_2f('T_ph', p, h)
|
|
|
|
def dp_Tx(self, T, x, dT, dx):
|
|
return self.func_f_4f('dp_Tx', T, x, dT, dx)
|
|
|
|
def dx_ph(self, p, h, dp, dh):
|
|
return self.func_f_4f('dx_ph', p, h, dp, dh)
|
|
|
|
def dCp_ph(self, p, h, dp, dh):
|
|
return self.func_f_4f('dCp_ph', p, h, dp, dh)
|
|
|
|
def dvxdx_px(self, p, x):
|
|
return self.func_f_2f('dvxdx_px', p, x)
|
|
|
|
def dvx_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dvx_px', p, x, dp, dx)
|
|
|
|
def dsigmadx_px(self, p, x):
|
|
return self.func_f_2f('dsigmadx_px', p, x)
|
|
|
|
def dsigmadp_px(self, p, x):
|
|
return self.func_f_2f('dsigmadp_px', p, x)
|
|
|
|
def dcsvdx_px(self, p, x):
|
|
return self.func_f_2f('dcsvdx_px', p, x)
|
|
|
|
def dcsvdp_px(self, p, x):
|
|
return self.func_f_2f('dcsvdp_px', p, x)
|
|
|
|
def dcsldx_px(self, p, x):
|
|
return self.func_f_2f('dcsldx_px', p, x)
|
|
|
|
def dcsldp_px(self, p, x):
|
|
return self.func_f_2f('dcsldp_px', p, x)
|
|
|
|
def dcdx_px(self, p, x):
|
|
return self.func_f_2f('dcdx_px', p, x)
|
|
|
|
def dcdp_px(self, p, x):
|
|
return self.func_f_2f('dcdp_px', p, x)
|
|
|
|
def dmudx_px(self, p, x):
|
|
return self.func_f_2f('dmudx_px', p, x)
|
|
|
|
def dmudp_px(self, p, x):
|
|
return self.func_f_2f('dmudp_px', p, x)
|
|
|
|
def dmu_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dmu_px', p, x, dp, dx)
|
|
|
|
def dCpCvdx_px(self, p, x):
|
|
return self.func_f_2f('dCpCvdx_px', p, x)
|
|
|
|
def dCpCvdp_px(self, p, x):
|
|
return self.func_f_2f('dCpCvdp_px', p, x)
|
|
|
|
def dCpsvdx_px(self, p, x):
|
|
return self.func_f_2f('dCpsvdx_px', p, x)
|
|
|
|
def dCpsvdp_px(self, p, x):
|
|
return self.func_f_2f('dCpsvdp_px', p, x)
|
|
|
|
def ds_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('ds_px', p, x, dp, dx)
|
|
|
|
def dhsl_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dhsl_px', p, x, dp, dx)
|
|
|
|
def dh_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dh_px', p, x, dp, dx)
|
|
|
|
def dv_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('dv_px', p, x, dp, dx)
|
|
|
|
def drhosv_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('drhosv_px', p, x, dp, dx)
|
|
|
|
def drhosl_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('drhosl_px', p, x, dp, dx)
|
|
|
|
def drho_px(self, p, x, dp, dx):
|
|
return self.func_f_4f('drho_px', p, x, dp, dx)
|
|
|
|
def dTsdx_px(self, p, x):
|
|
return self.func_f_2f('dTsdx_px', p, x)
|
|
|
|
def dTdx_px(self, p, x):
|
|
return self.func_f_2f('dTdx_px', p, x)
|
|
|
|
def p_Tx(self, T, x):
|
|
return self.func_f_2f('p_Tx', T, x)
|
|
|
|
def h_ps(self, p, s):
|
|
return self.func_f_2f('h_ps', p, s)
|
|
|
|
def vx_px(self, p, x):
|
|
return self.func_f_2f('vx_px', p, x)
|
|
|
|
def vp_px(self, p, x):
|
|
return self.func_f_2f('vp_px', p, x)
|
|
|
|
def hx_px(self, p, x):
|
|
return self.func_f_2f('hx_px', p, x)
|
|
|
|
def hp_px(self, p, x):
|
|
return self.func_f_2f('hp_px', p, x)
|
|
|
|
def sigma_px(self, p, x):
|
|
return self.func_f_2f('sigma_px', p, x)
|
|
|
|
def c_px(self, p, x):
|
|
return self.func_f_2f('c_px', p, x)
|
|
|
|
def lambdasv_px(self, p, x):
|
|
return self.func_f_2f('lambdasv_px', p, x)
|
|
|
|
def lambdasl_px(self, p, x):
|
|
return self.func_f_2f('lambdasl_px', p, x)
|
|
|
|
def lambda_px(self, p, x):
|
|
return self.func_f_2f('lambda_px', p, x)
|
|
|
|
def musv_px(self, p, x):
|
|
return self.func_f_2f('musv_px', p, x)
|
|
|
|
def musl_px(self, p, x):
|
|
return self.func_f_2f('musl_px', p, x)
|
|
|
|
def mu_px(self, p, x):
|
|
return self.func_f_2f('mu_px', p, x)
|
|
|
|
def CpCv_px(self, p, x):
|
|
return self.func_f_2f('CpCv_px', p, x)
|
|
|
|
def Cpsv_px(self, p, x):
|
|
return self.func_f_2f('Cpsv_px', p, x)
|
|
|
|
def Cpsl_px(self, p, x):
|
|
return self.func_f_2f('Cpsl_px', p, x)
|
|
|
|
def Cp_px(self, p, x):
|
|
return self.func_f_2f('Cp_px', p, x)
|
|
|
|
def ssv_px(self, p, x):
|
|
return self.func_f_2f('ssv_px', p, x)
|
|
|
|
def ssl_px(self, p, x):
|
|
return self.func_f_2f('ssl_px', p, x)
|
|
|
|
def s_px(self, p, x):
|
|
return self.func_f_2f('s_px', p, x)
|
|
|
|
def hsv_px(self, p, x):
|
|
return self.func_f_2f('hsv_px', p, x)
|
|
|
|
def hsl_px(self, p, x):
|
|
return self.func_f_2f('hsl_px', p, x)
|
|
|
|
def h_px(self, p, x):
|
|
return self.func_f_2f('h_px', p, x)
|
|
|
|
def v_px(self, p, x):
|
|
return self.func_f_2f('v_px', p, x)
|
|
|
|
def rhosv_px(self, p, x):
|
|
return self.func_f_2f('rhosv_px', p, x)
|
|
|
|
def rhosl_px(self, p, x):
|
|
return self.func_f_2f('rhosl_px', p, x)
|
|
|
|
def rho_px(self, p, x):
|
|
return self.func_f_2f('rho_px', p, x)
|
|
|
|
def Ts_px(self, p, x):
|
|
return self.func_f_2f('Ts_px', p, x)
|