mirror of
https://github.com/CoolProp/CoolProp.git
synced 2026-01-22 12:28:04 -05:00
579bba98c4
* Cubic calc_molar_mass, closes #1124 * Add simplified update and output functions This allows simpler use of the low level interface by using the strings name instead of the parameter number. The parameter number version stays and will be faster for more than one call with the same parameter. * Add AbstractState_update_and_1_out * Export specify_phase() to the library * small correction Safer to only accept an array of real numbers here. * Small correction Specifying the type of the array to avoid any convertion
442 lines
24 KiB
C++
442 lines
24 KiB
C++
/** \brief This file defines an interface for shared library (DLL) wrapping
|
|
*
|
|
* In general the functions defined here take strings which are 0-terminated (C-style),
|
|
* vectors of doubles are passed as double* and length
|
|
* These functions pass directly to equivalently named functions in CoolProp.h in the CoolProp namespace
|
|
* that take std::string, vector<double> etc.
|
|
*
|
|
* Functions with the call type like
|
|
* EXPORT_CODE void CONVENTION AFunction(double, double);
|
|
* will be exported to the DLL
|
|
*
|
|
* The exact symbol that will be exported depends on the values of the preprocessor macros COOLPROP_LIB, EXPORT_CODE, CONVENTION, etc.
|
|
*
|
|
* In order to have 100% control over the export macros, you can specify EXPORT_CODE and CONVENTION directly. Check out
|
|
* CMakeLists.txt in the repo root to see some examples.
|
|
*
|
|
*/
|
|
|
|
#ifndef COOLPROPDLL_H
|
|
#define COOLPROPDLL_H
|
|
|
|
// See also http://stackoverflow.com/questions/5919996/how-to-detect-reliably-mac-os-x-ios-linux-windows-in-c-preprocessor
|
|
// Copied verbatim from PlatformDetermination.h in order to have a single-include header
|
|
#if _WIN64
|
|
# define __ISWINDOWS__
|
|
#elif _WIN32
|
|
# define __ISWINDOWS__
|
|
#elif __APPLE__
|
|
# define __ISAPPLE__
|
|
#elif __linux || __unix || __posix
|
|
# define __ISLINUX__
|
|
#elif __powerpc__
|
|
# define __ISPOWERPC__
|
|
#else
|
|
# pragma error
|
|
#endif
|
|
|
|
#if defined(COOLPROP_LIB)
|
|
# ifndef EXPORT_CODE
|
|
# if defined(__ISWINDOWS__)
|
|
# define EXPORT_CODE extern "C" __declspec(dllexport)
|
|
# else
|
|
# define EXPORT_CODE extern "C"
|
|
# endif
|
|
# endif
|
|
# ifndef CONVENTION
|
|
# if defined(__ISWINDOWS__)
|
|
# define CONVENTION __stdcall
|
|
# else
|
|
# define CONVENTION
|
|
# endif
|
|
# endif
|
|
#else
|
|
# ifndef EXPORT_CODE
|
|
# define EXPORT_CODE
|
|
# endif
|
|
# ifndef CONVENTION
|
|
# define CONVENTION
|
|
# endif
|
|
#endif
|
|
|
|
// Hack for PowerPC compilation to only use extern "C"
|
|
#if defined(__powerpc__) || defined(EXTERNC)
|
|
# undef EXPORT_CODE
|
|
# define EXPORT_CODE extern "C"
|
|
#endif
|
|
|
|
#if defined(__powerpc__)
|
|
// From https://rowley.zendesk.com/entries/46176--Undefined-reference-to-assert-error-message
|
|
// The __assert function is an error handler function that is invoked when an assertion fails.
|
|
// If you are writing a program that uses the assert macro then you must supply you own __assert error handler function. For example
|
|
inline void __assert(const char *error)
|
|
{
|
|
while(1);
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* \overload
|
|
* \sa \ref CoolProp::Props1SI(std::string, std::string)
|
|
*
|
|
* \note If there is an error, a huge value will be returned, you can get the error message by doing something like get_global_param_string("errstring",output)
|
|
*/
|
|
EXPORT_CODE double CONVENTION Props1SI(const char *FluidName, const char* Output);
|
|
/**
|
|
*\overload
|
|
*\sa \ref CoolProp::PropsSI(const std::string &, const std::string &, double, const std::string &, double, const std::string&)
|
|
*
|
|
* \note If there is an error, a huge value will be returned, you can get the error message by doing something like get_global_param_string("errstring",output)
|
|
*/
|
|
EXPORT_CODE double CONVENTION PropsSI(const char *Output, const char *Name1, double Prop1, const char *Name2, double Prop2, const char *Ref);
|
|
|
|
/**
|
|
*\overload
|
|
*\sa \ref CoolProp::PhaseSI(const std::string &, double, const std::string &, double, const std::string&)
|
|
*
|
|
* \note This function returns the phase string in pre-allocated phase variable. If buffer is not large enough, no copy is made
|
|
*/
|
|
EXPORT_CODE long CONVENTION PhaseSI(const char *Name1, double Prop1, const char *Name2, double Prop2, const char *Ref, char *phase, int n);
|
|
|
|
/**
|
|
*\overload
|
|
*\sa \ref CoolProp::get_global_param_string
|
|
*
|
|
* @returns error_code 1 = Ok 0 = error
|
|
*
|
|
* \note This function returns the output string in pre-allocated char buffer. If buffer is not large enough, no copy is made
|
|
*/
|
|
EXPORT_CODE long CONVENTION get_global_param_string(const char *param, char *Output, int n);
|
|
/**
|
|
* \overload
|
|
* \sa \ref CoolProp::get_parameter_information_string
|
|
* \note This function returns the output string in pre-allocated char buffer. If buffer is not large enough, no copy is made
|
|
*
|
|
* @returns error_code 1 = Ok 0 = error
|
|
*/
|
|
EXPORT_CODE long CONVENTION get_parameter_information_string(const char *key, char *Output, int n);
|
|
/**
|
|
* \overload
|
|
* \sa \ref CoolProp::get_mixture_binary_pair_data
|
|
*/
|
|
EXPORT_CODE long CONVENTION get_mixture_binary_pair_data(const char *CAS1, const char *CAS2, const char *key);
|
|
/**
|
|
* \overload
|
|
* \sa \ref CoolProp::get_fluid_param_string
|
|
*
|
|
* @returns error_code 1 = Ok 0 = error
|
|
*/
|
|
EXPORT_CODE long CONVENTION get_fluid_param_string(const char *fluid, const char *param, char *Output, int n);
|
|
/**
|
|
* \overload
|
|
* \sa \ref CoolProp::set_reference_stateS
|
|
* @returns error_code 1 = Ok 0 = error
|
|
*/
|
|
EXPORT_CODE int CONVENTION set_reference_stateS(const char *Ref, const char *reference_state);
|
|
/**
|
|
* \overload
|
|
* \sa \ref CoolProp::set_reference_stateD
|
|
* @returns error_code 1 = Ok 0 = error
|
|
*/
|
|
EXPORT_CODE int CONVENTION set_reference_stateD(const char *Ref, double T, double rhomolar, double hmolar0, double smolar0);
|
|
/** \brief FORTRAN 77 style wrapper of the PropsSI function
|
|
* \overload
|
|
* \sa \ref CoolProp::PropsSI(const std::string &, const std::string &, double, const std::string &, double, const std::string&)
|
|
*
|
|
* \note If there is an error, a huge value will be returned, you can get the error message by doing something like get_global_param_string("errstring",output)
|
|
*/
|
|
EXPORT_CODE void CONVENTION propssi_(const char *Output, const char *Name1, const double *Prop1, const char *Name2, const double *Prop2, const char * Ref, double *output);
|
|
|
|
/// Convert from degrees Fahrenheit to Kelvin (useful primarily for testing)
|
|
EXPORT_CODE double CONVENTION F2K(double T_F);
|
|
/// Convert from Kelvin to degrees Fahrenheit (useful primarily for testing)
|
|
EXPORT_CODE double CONVENTION K2F(double T_K);
|
|
/** \brief Get the index for a parameter "T", "P", etc.
|
|
*
|
|
* @returns index The index as a long. If input is invalid, returns -1
|
|
*/
|
|
EXPORT_CODE long CONVENTION get_param_index(const char *param);
|
|
/** \brief Get the index for an input pair for AbstractState.update function
|
|
*
|
|
* @returns index The index as a long. If input is invalid, returns -1
|
|
*/
|
|
EXPORT_CODE long CONVENTION get_input_pair_index(const char *param);
|
|
/** \brief Redirect all output that would go to console (stdout) to a file
|
|
*/
|
|
EXPORT_CODE long CONVENTION redirect_stdout(const char *file);
|
|
|
|
// ---------------------------------
|
|
// Getter and setter for debug level
|
|
// ---------------------------------
|
|
|
|
/// Get the debug level
|
|
/// @returns level The level of the verbosity for the debugging output (0-10) 0: no debgging output
|
|
EXPORT_CODE int CONVENTION get_debug_level();
|
|
/// Set the debug level
|
|
/// @param level The level of the verbosity for the debugging output (0-10) 0: no debgging output
|
|
EXPORT_CODE void CONVENTION set_debug_level(int level);
|
|
|
|
/* \brief Extract a value from the saturation ancillary
|
|
*
|
|
* @param fluid_name The name of the fluid to be used - HelmholtzEOS backend only
|
|
* @param output The desired output variable ("P" for instance for pressure)
|
|
* @param Q The quality, 0 or 1
|
|
* @param input The input variable ("T")
|
|
* @param value The input value
|
|
*/
|
|
EXPORT_CODE double CONVENTION saturation_ancillary(const char *fluid_name, const char *output, int Q, const char *input, double value);
|
|
|
|
// ---------------------------------
|
|
// Humid Air Properties
|
|
// ---------------------------------
|
|
|
|
/** \brief DLL wrapper of the HAPropsSI function
|
|
* \sa \ref HumidAir::HAPropsSI(const char *OutputName, const char *Input1Name, double Input1, const char *Input2Name, double Input2, const char *Input3Name, double Input3);
|
|
*
|
|
* \note If there is an error, a huge value will be returned, you can get the error message by doing something like get_global_param_string("errstring",output)
|
|
*/
|
|
EXPORT_CODE double CONVENTION HAPropsSI(const char *Output, const char *Name1, double Prop1, const char *Name2, double Prop2, const char *Name3, double Prop3);
|
|
|
|
/** \brief DLL wrapper of the cair_sat function
|
|
* \sa \ref HumidAir::cair_sat(double);
|
|
*/
|
|
EXPORT_CODE double CONVENTION cair_sat(double T);
|
|
|
|
/** \brief FORTRAN 77 style wrapper of the HAPropsSI function
|
|
* \sa \ref HumidAir::HAPropsSI(const char *OutputName, const char *Input1Name, double Input1, const char *Input2Name, double Input2, const char *Input3Name, double Input3);
|
|
*
|
|
* \note If there is an error, a huge value will be returned, you can get the error message by doing something like get_global_param_string("errstring",output)
|
|
*/
|
|
EXPORT_CODE void CONVENTION hapropssi_(const char *Output, const char *Name1, const double *Prop1, const char *Name2, const double *Prop2, const char *Name3, const double *Prop3, double *output);
|
|
|
|
/** \brief DLL wrapper of the HAProps function
|
|
*
|
|
* \warning DEPRECATED!!
|
|
* \sa \ref HumidAir::HAProps(const char *OutputName, const char *Input1Name, double Input1, const char *Input2Name, double Input2, const char *Input3Name, double Input3);
|
|
*
|
|
* \note If there is an error, a huge value will be returned, you can get the error message by doing something like get_global_param_string("errstring",output)
|
|
*/
|
|
EXPORT_CODE double CONVENTION HAProps(const char *Output, const char *Name1, double Prop1, const char *Name2, double Prop2, const char *Name3, double Prop3);
|
|
|
|
/** \brief FORTRAN 77 style wrapper of the HAProps function
|
|
*
|
|
* \warning DEPRECATED!!
|
|
* \sa \ref HumidAir::HAProps(const char *OutputName, const char *Input1Name, double Input1, const char *Input2Name, double Input2, const char *Input3Name, double Input3);
|
|
*
|
|
* \note If there is an error, a huge value will be returned, you can get the error message by doing something like get_global_param_string("errstring",output)
|
|
*/
|
|
EXPORT_CODE void CONVENTION haprops_(const char *Output, const char *Name1, const double *Prop1, const char *Name2, const double *Prop2, const char *Name3, const double *Prop3, double *output);
|
|
|
|
// ---------------------------------
|
|
// Low-level access
|
|
// ---------------------------------
|
|
|
|
/**
|
|
* @brief Generate an AbstractState instance, return an integer handle to the state class generated to be used in the other low-level accessor functions
|
|
* @param backend The backend you will use, "HEOS", "REFPROP", etc.
|
|
* @param fluids '&' delimited list of fluids
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return A handle to the state class generated
|
|
*/
|
|
EXPORT_CODE long CONVENTION AbstractState_factory(const char* backend, const char* fluids, long *errcode, char *message_buffer, const long buffer_length);
|
|
/**
|
|
* @brief Release a state class generated by the low-level interface wrapper
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*/
|
|
EXPORT_CODE void CONVENTION AbstractState_free(const long handle, long *errcode, char *message_buffer, const long buffer_length);
|
|
/**
|
|
* @brief Set the fractions (mole, mass, volume) for the AbstractState
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param fractions The array of fractions
|
|
* @param N The length of the fractions array
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*/
|
|
EXPORT_CODE void CONVENTION AbstractState_set_fractions(const long handle, const double* fractions, const long N, long *errcode, char *message_buffer, const long buffer_length);
|
|
/**
|
|
* @brief Update the state of the AbstractState
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param input_pair The integer value for the input pair obtained from XXXXXXXXXXXXXXXX
|
|
* @param value1 The first input value
|
|
* @param value2 The second input value
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*/
|
|
EXPORT_CODE void CONVENTION AbstractState_update(const long handle, const long input_pair, const double value1, const double value2, long *errcode, char *message_buffer, const long buffer_length);
|
|
/**
|
|
* @brief Specify the phase to be used for all further calculations
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param phase The string with the phase to use
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*/
|
|
EXPORT_CODE void CONVENTION AbstractState_specify_phase(const long handle, const char *phase, long *errcode, char *message_buffer, const long buffer_length);
|
|
/**
|
|
* @brief Unspecify the phase to be used for all further calculations
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*/
|
|
EXPORT_CODE void CONVENTION AbstractState_unspecify_phase(const long handle, long *errcode, char *message_buffer, const long buffer_length);
|
|
/**
|
|
* @brief Get an output value from the AbstractState using an integer value for the desired output value
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param param The integer value for the parameter you want
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*/
|
|
EXPORT_CODE double CONVENTION AbstractState_keyed_output(const long handle, const long param, long *errcode, char *message_buffer, const long buffer_length);
|
|
|
|
/**
|
|
* @brief Calculate a saturation derivative from the AbstractState using integer values for the desired parameters
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param Of The parameter of which the derivative is being taken
|
|
* @param Wrt The derivative with with respect to this parameter
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*/
|
|
EXPORT_CODE double CONVENTION AbstractState_first_saturation_deriv(const long handle, const long Of, const long Wrt, long *errcode, char *message_buffer, const long buffer_length);
|
|
|
|
/**
|
|
* @brief Calculate the first partial derivative in homogeneous phases from the AbstractState using integer values for the desired parameters
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param Of The parameter of which the derivative is being taken
|
|
* @param Wrt The derivative with with respect to this parameter
|
|
* @param Constant The parameter that is not affected by the derivative
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*/
|
|
EXPORT_CODE double CONVENTION AbstractState_first_partial_deriv(const long handle, const long Of, const long Wrt, const long Constant, long *errcode, char *message_buffer, const long buffer_length);
|
|
|
|
/**
|
|
* @brief Update the state of the AbstractState and get an output value five common outputs (temperature, pressure, molar density, molar enthalpy and molar entropy)
|
|
* @brief from the AbstractState using pointers as inputs and output to allow array computation.
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param input_pair The integer value for the input pair obtained from get_input_pair_index
|
|
* @param value1 The pointer to the array of the first input parameters
|
|
* @param value2 The pointer to the array of the second input parameters
|
|
* @param length The number of elements stored in the arrays (both inputs and outputs MUST be the same length)
|
|
* @param T The pointer to the array of temperature
|
|
* @param p The pointer to the array of pressure
|
|
* @param rhomolar The pointer to the array of molar density
|
|
* @param hmolar The pointer to the array of molar enthalpy
|
|
* @param smolar The pointer to the array of molar entropy
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*
|
|
* @note If there is an error in an update call for one of the inputs, no change in the output array will be made
|
|
*/
|
|
EXPORT_CODE void CONVENTION AbstractState_update_and_common_out(const long handle, const long input_pair, const double* value1, const double* value2, const long length, double* T, double* p, double* rhomolar, double* hmolar, double* smolar, long *errcode, char *message_buffer, const long buffer_length);
|
|
|
|
/**
|
|
* @brief Update the state of the AbstractState and get one output value (temperature, pressure, molar density, molar enthalpy and molar entropy)
|
|
* @brief from the AbstractState using pointers as inputs and output to allow array computation.
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param input_pair The integer value for the input pair obtained from get_input_pair_index
|
|
* @param value1 The pointer to the array of the first input parameters
|
|
* @param value2 The pointer to the array of the second input parameters
|
|
* @param length The number of elements stored in the arrays (both inputs and outputs MUST be the same length)
|
|
* @param output The indice for the output desired
|
|
* @param out The pointer to the array for output
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*
|
|
* @note If there is an error in an update call for one of the inputs, no change in the output array will be made
|
|
*/
|
|
EXPORT_CODE void CONVENTION AbstractState_update_and_1_out(const long handle, const long input_pair, const double* value1, const double* value2, const long length, const long output, double* out, long *errcode, char *message_buffer, const long buffer_length);
|
|
|
|
/**
|
|
* @brief Update the state of the AbstractState and get an output value five common outputs (temperature, pressure, molar density, molar enthalpy and molar entropy)
|
|
* @brief from the AbstractState using pointers as inputs and output to allow array computation.
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param input_pair The integer value for the input pair obtained from get_input_pair_index
|
|
* @param value1 The pointer to the array of the first input parameters
|
|
* @param value2 The pointer to the array of the second input parameters
|
|
* @param length The number of elements stored in the arrays (both inputs and outputs MUST be the same length)
|
|
* @param outputs The 5-element vector of indices for the outputs desired
|
|
* @param out1 The pointer to the array for the first output
|
|
* @param out2 The pointer to the array for the second output
|
|
* @param out3 The pointer to the array for the third output
|
|
* @param out4 The pointer to the array for the fourth output
|
|
* @param out5 The pointer to the array for the fifth output
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*
|
|
* @note If there is an error in an update call for one of the inputs, no change in the output array will be made
|
|
*/
|
|
EXPORT_CODE void CONVENTION AbstractState_update_and_5_out(const long handle, const long input_pair, const double* value1, const double* value2, const long length, long *outputs, double* out1, double* out2, double* out3, double* out4, double* out5, long *errcode, char *message_buffer, const long buffer_length);
|
|
|
|
/**
|
|
* @brief Set binary interraction parrameter for mixtures
|
|
* @param handle The integer handle for the state class stored in memory
|
|
* @param i indice of the first fluid of the binary pair
|
|
* @param j indice of the second fluid of the binary pair
|
|
* @param parameter string wit the name of the parameter
|
|
* @param value the value of the binary interaction parameter
|
|
* @param errcode The errorcode that is returned (0 = no error, !0 = error)
|
|
* @param message_buffer A buffer for the error code
|
|
* @param buffer_length The length of the buffer for the error code
|
|
* @return
|
|
*/
|
|
EXPORT_CODE void CONVENTION AbstractState_set_binary_interaction_double(const long handle, const long i, const long j, const char* parameter, const double value, long *errcode, char *message_buffer, const long buffer_length);
|
|
|
|
// *************************************************************************************
|
|
// *************************************************************************************
|
|
// ***************************** DEPRECATED *******************************************
|
|
// *************************************************************************************
|
|
// *************************************************************************************
|
|
|
|
/**
|
|
\overload
|
|
\sa \ref Props(const char *Output, const char Name1, double Prop1, const char Name2, double Prop2, const char *Ref)
|
|
*/
|
|
EXPORT_CODE double CONVENTION PropsS(const char *Output, const char *Name1, double Prop1, const char *Name2, double Prop2, const char *Ref);
|
|
/**
|
|
Works just like \ref CoolProp::PropsSI, but units are in KSI system. This function is deprecated, no longer supported, and users should transition to using the PropsSI function
|
|
*/
|
|
EXPORT_CODE double CONVENTION Props(const char *Output, const char Name1, double Prop1, const char Name2, double Prop2, const char *Ref);
|
|
/**
|
|
Works just like \ref CoolProp::Props1SI, but units are in KSI system. This function is deprecated, no longer supported, and users should transition to using the Props1SI function
|
|
*/
|
|
EXPORT_CODE double CONVENTION Props1(const char *FluidName, const char *Output);
|
|
///**
|
|
//\overload
|
|
// IsFluidType(std::string, std::string)
|
|
//*/
|
|
//EXPORT_CODE int CONVENTION IsFluidType(const char *Ref, const char *Type);
|
|
|
|
// This version uses the indices in place of the strings for speed. Get the parameter indices
|
|
// from get_param_index('D') for instance and the Fluid index from get_Fluid_index('Air') for instance
|
|
EXPORT_CODE double CONVENTION IPropsSI(long iOutput, long iName1, double Prop1, long iName2, double Prop2, long iFluid);
|
|
EXPORT_CODE double CONVENTION IProps(long iOutput, long iName1, double Prop1, long iName2, double Prop2, long iFluid);
|
|
|
|
|
|
|
|
#endif
|