mirror of
https://github.com/CoolProp/CoolProp.git
synced 2026-02-12 23:05:18 -05:00
992 lines
31 KiB
C++
992 lines
31 KiB
C++
//============================================================================================//
|
|
// //
|
|
// Microsoft Visual C++ 2005 Client //
|
|
// -------------------------------- //
|
|
// //
|
|
// This is an example of a client application in Microsoft Visual C++ 2005 for FluidProp, //
|
|
// a COM server module for the calculation of fluid properties. FluidProp is a common //
|
|
// interface to GasMix, IF97, Refprop, StanMix, TPSI and is developed by Piero Colonna //
|
|
// and Teus van der Stelt. //
|
|
// //
|
|
// The class implemented in this file, TFluidProp, is as a wrapper class for the base //
|
|
// class IFluidProp_COM. TFluidProp hides specific COM server details like safe arrays //
|
|
// (SAFEARRAY) and binary strings (BSTR) in IFluidProp_COM. In the TFluidProp class //
|
|
// only standard C++ data types are used. This seriously facilitates working with the //
|
|
// COM server. //
|
|
// //
|
|
// Teus van der Stelt //
|
|
// Energy Technology Section //
|
|
// TU Delft //
|
|
// //
|
|
// July, 2004, for FluidProp 1 //
|
|
// January, 2006, for FluidProp 2 //
|
|
// April, 2007, for FluidProp 2.3 //
|
|
// //
|
|
//============================================================================================//
|
|
|
|
|
|
#include "FluidProp_IF.h"
|
|
|
|
|
|
// {F30D147D-1F7C-4092-B481-ADE326A2ECD5}
|
|
//
|
|
static const GUID CLSID_FluidProp =
|
|
{ 0xF30D147DL, 0x1F7C, 0x4092,
|
|
{ 0xB4, 0x81, 0xAD, 0xE3, 0x26, 0xA2, 0xEC, 0xD5 } };
|
|
|
|
// {2430EE09-2C1E-4A86-AB62-CB67AEF6E484}
|
|
//
|
|
static const IID IID_IFluidProp =
|
|
{ 0x2430EE09L, 0x2C1E, 0x4A86,
|
|
{ 0xAB, 0x62, 0xCB, 0x67, 0xAE, 0xF6, 0xE4, 0x84 } };
|
|
|
|
|
|
TFluidProp::TFluidProp()
|
|
{
|
|
// Init OLE
|
|
CoInitialize(0);
|
|
|
|
// Retrieve class factory interface pointer to our FluidProp COM object
|
|
HRESULT hr = CoGetClassObject( CLSID_FluidProp, CLSCTX_INPROC_SERVER, 0,
|
|
IID_IClassFactory, (void**)&ClassFactory);
|
|
|
|
// Have class factory make the object for us - then release factory
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
ClassFactory->CreateInstance( 0, IID_IFluidProp, (void**)&FluidProp_COM);
|
|
ClassFactory->Release();
|
|
ClassFactory = 0;
|
|
}
|
|
}
|
|
|
|
TFluidProp::~TFluidProp()
|
|
{
|
|
// Free FluidProp object
|
|
FluidProp_COM->Release();
|
|
|
|
// Unitialize OLE
|
|
CoUninitialize();
|
|
}
|
|
|
|
void TFluidProp::CreateObject( string ModelName, string* ErrorMsg)
|
|
{
|
|
BSTR BSTR_Model = _com_util::ConvertStringToBSTR( ModelName.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->CreateObject( BSTR_Model, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_Model);
|
|
}
|
|
|
|
void TFluidProp::ReleaseObjects()
|
|
{
|
|
FluidProp_COM->ReleaseObjects();
|
|
}
|
|
|
|
void TFluidProp::SetFluid( string ModelName, int nComp, string* Comp, double* Conc, string* ErrorMsg)
|
|
{
|
|
// _com_util::Convert model name to binary string
|
|
BSTR BSTR_Model = _com_util::ConvertStringToBSTR( ModelName.c_str());
|
|
|
|
long long_nComp = nComp;
|
|
|
|
// _com_util::Convert character array Comp via binary strings (BSTR) into an OLE SafeArray
|
|
SAFEARRAYBOUND sa_bounds_Comp[1];
|
|
sa_bounds_Comp[0].lLbound = 0;
|
|
sa_bounds_Comp[0].cElements = 20; //nComp;
|
|
|
|
SAFEARRAY FAR* sa_Comp;
|
|
sa_Comp = SafeArrayCreate( VT_BSTR, 1, sa_bounds_Comp);
|
|
BSTR BSTR_Comp;
|
|
for( long i = 0; i < long_nComp; i++)
|
|
{
|
|
BSTR_Comp = _com_util::ConvertStringToBSTR( Comp[i].c_str());
|
|
SafeArrayPutElement(sa_Comp, &i, BSTR_Comp);
|
|
}
|
|
|
|
// _com_util::Convert the double array Conc into an OLE SafeArray
|
|
SAFEARRAYBOUND sa_bounds_Conc[1];
|
|
sa_bounds_Conc[0].lLbound = 0;
|
|
sa_bounds_Conc[0].cElements = 20; //nComp;
|
|
|
|
SAFEARRAY FAR* sa_Conc;
|
|
sa_Conc = SafeArrayCreate( VT_R8, 1, sa_bounds_Conc);
|
|
for(long i = 0; i < long_nComp; i++)
|
|
SafeArrayPutElement(sa_Conc, &i, &Conc[i]);
|
|
|
|
// Now load the fluid parameters for the model selected.
|
|
BSTR BSTR_Error;
|
|
FluidProp_COM->SetFluid( BSTR_Model, long_nComp, &sa_Comp, &sa_Conc, &BSTR_Error);
|
|
|
|
// Error handling
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
// Destroy the SafeArrays
|
|
SafeArrayDestroy( sa_Comp);
|
|
SafeArrayDestroy( sa_Conc);
|
|
|
|
SysFreeString(BSTR_Comp);
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_Model);
|
|
}
|
|
|
|
void TFluidProp::GetFluid( string* ModelName, int* nComp, string* Comp, double* Conc, bool CompInfo)
|
|
{
|
|
// When CompInfo is true, the components and their concentrations in the mixture are returned
|
|
// instead of the mixture name.
|
|
|
|
long long_nComp = *nComp;
|
|
|
|
// Convert character array Comp via binary strings (BSTR) into an OLE SafeArray
|
|
// This needs to be done because in the COM interface Comp is an inout argument,
|
|
// because for out arguments an assumed array size is not allowed....
|
|
SAFEARRAYBOUND sa_bounds_Comp[1];
|
|
sa_bounds_Comp[0].lLbound = 0;
|
|
sa_bounds_Comp[0].cElements = long_nComp;
|
|
|
|
SAFEARRAY FAR* sa_Comp;
|
|
BSTR BSTR_Comp;
|
|
sa_Comp = SafeArrayCreate( VT_BSTR, 1, sa_bounds_Comp);
|
|
for( long i = 0; i < long_nComp; i++)
|
|
{
|
|
BSTR_Comp = _com_util::ConvertStringToBSTR( Comp[i].c_str());
|
|
SafeArrayPutElement(sa_Comp, &i, BSTR_Comp);
|
|
}
|
|
|
|
// Convert the double array Conc into an OLE SafeArray
|
|
// This needs to be done because in the COM interface Conc is an inout argument,
|
|
// because for out arguments an assumed array size is not allowed....
|
|
SAFEARRAYBOUND sa_bounds_Conc[1];
|
|
sa_bounds_Conc[0].lLbound = 0;
|
|
sa_bounds_Conc[0].cElements = long_nComp;
|
|
|
|
SAFEARRAY FAR* sa_Conc;
|
|
sa_Conc = SafeArrayCreate( VT_R8, 1, sa_bounds_Conc);
|
|
for(long i = 0; i < long_nComp; i++)
|
|
SafeArrayPutElement(sa_Conc, &i, &Conc[i]);
|
|
|
|
// Now retrieve the fluid parameters set wit SetFluid
|
|
BSTR BSTR_Model = _com_util::ConvertStringToBSTR( " ");
|
|
if ( CompInfo)
|
|
long_nComp = -1;
|
|
FluidProp_COM->GetFluid( BSTR_Model, &long_nComp, &sa_Comp, &sa_Conc);
|
|
|
|
// Convert model name from binary string to string
|
|
string TmpName = _com_util::ConvertBSTRToString( BSTR_Model);
|
|
*ModelName = TmpName;//ConvertBSTRToString( BSTR_Model);
|
|
|
|
// Convert from long to int
|
|
*nComp = long_nComp;
|
|
|
|
// Put the values in the string array Comp
|
|
for(long i = 0; i < long_nComp; i++)
|
|
{
|
|
SafeArrayGetElement( sa_Comp, &i, &BSTR_Comp);
|
|
Comp[i] = _com_util::ConvertBSTRToString( BSTR_Comp);
|
|
}
|
|
|
|
// Put the values in the double array Conc
|
|
for(long i = 0; i < long_nComp; i++)
|
|
SafeArrayGetElement( sa_Conc, &i, &Conc[i]);
|
|
|
|
// Destroy the SafeArrays
|
|
SafeArrayDestroy( sa_Comp);
|
|
SafeArrayDestroy( sa_Conc);
|
|
|
|
SysFreeString(BSTR_Comp);
|
|
SysFreeString(BSTR_Model);
|
|
}
|
|
|
|
void TFluidProp::GetFluidNames( string LongShort, string ModelName, int* nFluids,
|
|
string* FluidNames, string* ErrorMsg)
|
|
{
|
|
long long_nFluids;
|
|
|
|
// Get available fluids
|
|
BSTR BSTR_Model = _com_util::ConvertStringToBSTR( ModelName.c_str());
|
|
BSTR BSTR_LongShort = _com_util::ConvertStringToBSTR( LongShort.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
// Convert character array FluidNames via binary strings (BSTR) into an OLE SafeArray
|
|
// This needs to be done because in the COM interface FluidNames is an inout argument,
|
|
// because Visual Basic is not able to deal out arrays....
|
|
//
|
|
SAFEARRAYBOUND sa_bounds_FluidNames[1];
|
|
sa_bounds_FluidNames[0].lLbound = 0;
|
|
sa_bounds_FluidNames[0].cElements = 250;
|
|
SAFEARRAY* sa_FluidNames;
|
|
sa_FluidNames = SafeArrayCreate( VT_BSTR, 1, sa_bounds_FluidNames);
|
|
|
|
FluidProp_COM->GetFluidNames( BSTR_LongShort, BSTR_Model, &long_nFluids, &sa_FluidNames,
|
|
&BSTR_Error);
|
|
|
|
// Retrieve array with components from SafeArray
|
|
BSTR BSTR_Fluid;
|
|
for( long i = 0; i < long_nFluids; i++)
|
|
{
|
|
SafeArrayGetElement( sa_FluidNames, &i, &BSTR_Fluid);
|
|
FluidNames[i] = _com_util::ConvertBSTRToString( BSTR_Fluid);
|
|
}
|
|
*nFluids = long_nFluids;
|
|
|
|
// Error handling
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Fluid);
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_LongShort);
|
|
SysFreeString(BSTR_Model);
|
|
}
|
|
|
|
double TFluidProp::Pressure( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR(InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Pressure( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Temperature( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Temperature( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::SpecVolume( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->SpecVolume( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Density( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Density( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Enthalpy( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Enthalpy( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Entropy( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Entropy( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::IntEnergy( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->IntEnergy( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::VaporQual( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->VaporQual( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double* TFluidProp::LiquidCmp( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double* Output = new double[20];
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
// _com_util::Convert the double array Conc into an OLE SafeArray
|
|
SAFEARRAYBOUND sa_bounds_Output[1];
|
|
sa_bounds_Output[0].lLbound = 0;
|
|
sa_bounds_Output[0].cElements = 20;
|
|
SAFEARRAY* sa_Output;
|
|
sa_Output = SafeArrayCreate( VT_R8, 1, sa_bounds_Output);
|
|
|
|
FluidProp_COM->LiquidCmp( BSTR_InputSpec, Input1, Input2, &sa_Output, &BSTR_Error);
|
|
|
|
// Retrieve array with concentrations from SafeArray
|
|
for( long i = 0; i < (signed)sa_bounds_Output[0].cElements; i++)
|
|
SafeArrayGetElement( sa_Output, &i, &Output[i]);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double* TFluidProp::VaporCmp( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double* Output = new double[20];
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
// _com_util::Convert the double array Conc into an OLE SafeArray
|
|
SAFEARRAYBOUND sa_bounds_Output[1];
|
|
sa_bounds_Output[0].lLbound = 0;
|
|
sa_bounds_Output[0].cElements = 20;
|
|
SAFEARRAY* sa_Output;
|
|
sa_Output = SafeArrayCreate( VT_R8, 1, sa_bounds_Output);
|
|
|
|
FluidProp_COM->VaporCmp( BSTR_InputSpec, Input1, Input2, &sa_Output, &BSTR_Error);
|
|
|
|
// Retrieve array with concentrations from SafeArray
|
|
for( long i = 0; i < (signed)sa_bounds_Output[0].cElements; i++)
|
|
SafeArrayGetElement( sa_Output, &i, &Output[i]);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::HeatCapV( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->HeatCapV( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::HeatCapP( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->HeatCapP( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::SoundSpeed( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->SoundSpeed( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Alpha( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Alpha( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Beta( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Beta( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Chi( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Chi( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Fi( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Fi( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Ksi( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Ksi( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Psi( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR(InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Psi( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Zeta( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Zeta( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Theta( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Theta( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Kappa( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Kappa( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Gamma( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR(InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Gamma( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Viscosity( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR(InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Viscosity( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::ThermCond( string InputSpec, double Input1, double Input2, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR(InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->ThermCond( BSTR_InputSpec, Input1, Input2, &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
void TFluidProp::AllProps( string InputSpec, double Input1, double Input2, double& P, double& T,
|
|
double& v, double& d, double& h, double& s, double& u, double& q,
|
|
double* x, double* y, double& cv, double& cp, double& c, double& alpha,
|
|
double& beta, double& chi, double& fi, double& ksi, double& psi,
|
|
double& zeta, double& theta, double& kappa, double& gamma, double& eta,
|
|
double& lambda, string* ErrorMsg)
|
|
{
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR(InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
// Convert double arrays with liquid and vapor phase compositions x and y into OLE SafeArrays
|
|
SAFEARRAYBOUND sa_bounds_x[1], sa_bounds_y[1];
|
|
sa_bounds_x[0].lLbound = 0;
|
|
sa_bounds_y[0].lLbound = 0;
|
|
sa_bounds_x[0].cElements = 20;
|
|
sa_bounds_y[0].cElements = 20;
|
|
SAFEARRAY *sa_x, *sa_y;
|
|
sa_x = SafeArrayCreate( VT_R8, 1, sa_bounds_x);
|
|
sa_y = SafeArrayCreate( VT_R8, 1, sa_bounds_y);
|
|
|
|
FluidProp_COM->AllProps( BSTR_InputSpec, Input1, Input2, &P, &T, &v, &d, &h, &s, &u, &q, &sa_x,
|
|
&sa_y, &cv, &cp, &c, &alpha, &beta, &chi, &fi, &ksi, &psi, &zeta,
|
|
&theta, &kappa, &gamma, &eta, &lambda, &BSTR_Error);
|
|
|
|
// Retrieve array with liquid and vapor phase compositions from SafeArrays
|
|
for( long i = 0; i < (signed)sa_bounds_x[0].cElements; i++)
|
|
SafeArrayGetElement( sa_x, &i, &x[i]);
|
|
|
|
for( long i = 0; i < (signed)sa_bounds_y[0].cElements; i++)
|
|
SafeArrayGetElement( sa_y, &i, &y[i]);
|
|
|
|
// Destroy the SafeArrays
|
|
SafeArrayDestroy( sa_x);
|
|
SafeArrayDestroy( sa_y);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
}
|
|
|
|
void TFluidProp::AllPropsSat( string InputSpec, double Input1, double Input2, double& P, double& T,
|
|
double& v, double& d, double& h, double& s, double& u, double& q,
|
|
double* x, double* y, double& cv, double& cp, double& c, double& alpha,
|
|
double& beta, double& chi, double& fi, double& ksi, double& psi,
|
|
double& zeta, double& theta, double& kappa, double& gamma, double& eta,
|
|
double& lambda, double& d_liq, double& d_vap, double& h_liq, double& h_vap,
|
|
double& T_sat, double& dd_liq_dP, double& dd_vap_dP, double& dh_liq_dP,
|
|
double& dh_vap_dP, double& dT_sat_dP, string* ErrorMsg)
|
|
{
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR( InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
// Convert double arrays with liquid and vapor phase compositions x and y into OLE SafeArrays
|
|
SAFEARRAYBOUND sa_bounds_x[1], sa_bounds_y[1];
|
|
sa_bounds_x[0].lLbound = 0;
|
|
sa_bounds_y[0].lLbound = 0;
|
|
sa_bounds_x[0].cElements = 20;
|
|
sa_bounds_y[0].cElements = 20;
|
|
SAFEARRAY *sa_x, *sa_y;
|
|
sa_x = SafeArrayCreate( VT_R8, 1, sa_bounds_x);
|
|
sa_y = SafeArrayCreate( VT_R8, 1, sa_bounds_y);
|
|
|
|
FluidProp_COM->AllPropsSat( BSTR_InputSpec, Input1, Input2, &P, &T, &v, &d, &h, &s, &u, &q, &sa_x,
|
|
&sa_y, &cv, &cp, &c, &alpha, &beta, &chi, &fi, &ksi, &psi, &zeta,
|
|
&theta, &kappa, &gamma, &eta, &lambda, &d_liq, &d_vap, &h_liq, &h_vap,
|
|
&T_sat, &dd_liq_dP, &dd_vap_dP, &dh_liq_dP, &dh_vap_dP, &dT_sat_dP,
|
|
&BSTR_Error);
|
|
|
|
// Retrieve array with liquid and vapor phase compositions from SafeArrays
|
|
for( long i = 0; i < (signed)sa_bounds_x[0].cElements; i++)
|
|
SafeArrayGetElement( sa_x, &i, &x[i]);
|
|
|
|
for( long i = 0; i < (signed)sa_bounds_y[0].cElements; i++)
|
|
SafeArrayGetElement( sa_y, &i, &y[i]);
|
|
|
|
// Destroy the SafeArrays
|
|
SafeArrayDestroy( sa_x);
|
|
SafeArrayDestroy( sa_y);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
}
|
|
|
|
|
|
double TFluidProp::Solve( string FuncSpec, double FuncVal, string InputSpec, long Target,
|
|
double FixedVal, double MinVal, double MaxVal, string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_FuncSpec = _com_util::ConvertStringToBSTR( FuncSpec.c_str());
|
|
BSTR BSTR_InputSpec = _com_util::ConvertStringToBSTR(InputSpec.c_str());
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Solve( BSTR_FuncSpec, FuncVal, BSTR_InputSpec, Target, FixedVal, MinVal,
|
|
MaxVal, &Output, &BSTR_Error);
|
|
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Error);
|
|
SysFreeString(BSTR_InputSpec);
|
|
SysFreeString(BSTR_FuncSpec);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Mmol( string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Mmol( &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
SysFreeString(BSTR_Error);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Tcrit( string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Tcrit( &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
SysFreeString(BSTR_Error);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Pcrit( string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Pcrit( &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
SysFreeString(BSTR_Error);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Tmin( string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Tmin( &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
SysFreeString(BSTR_Error);
|
|
|
|
return Output;
|
|
}
|
|
|
|
double TFluidProp::Tmax( string* ErrorMsg)
|
|
{
|
|
double Output;
|
|
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->Tmax( &Output, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
SysFreeString(BSTR_Error);
|
|
|
|
return Output;
|
|
}
|
|
|
|
void TFluidProp::AllInfo( double& Mmol, double& Tcrit, double& Pcrit, double& Tmin, double& Tmax,
|
|
string* ErrorMsg)
|
|
{
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->AllInfo( &Mmol, &Tcrit, &Pcrit, &Tmin, &Tmax, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
SysFreeString(BSTR_Error);
|
|
}
|
|
|
|
void TFluidProp::SetUnits( string UnitSet, string MassOrMole, string Properties, string Units,
|
|
string* ErrorMsg)
|
|
{
|
|
BSTR BSTR_Error;
|
|
BSTR BSTR_UnitSet = _com_util::ConvertStringToBSTR( UnitSet.c_str());
|
|
BSTR BSTR_MassOrMole = _com_util::ConvertStringToBSTR( MassOrMole.c_str());
|
|
BSTR BSTR_Properties = _com_util::ConvertStringToBSTR( Properties.c_str());
|
|
BSTR BSTR_Units = _com_util::ConvertStringToBSTR( Units.c_str());
|
|
|
|
FluidProp_COM->SetUnits( BSTR_UnitSet, BSTR_MassOrMole, BSTR_Properties, BSTR_Units, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
|
|
SysFreeString(BSTR_Units);
|
|
SysFreeString(BSTR_Properties);
|
|
SysFreeString(BSTR_MassOrMole);
|
|
SysFreeString(BSTR_UnitSet);
|
|
SysFreeString(BSTR_Error);
|
|
}
|
|
|
|
void TFluidProp::SetRefState( double T_ref, double P_ref, string* ErrorMsg)
|
|
{
|
|
BSTR BSTR_Error;
|
|
|
|
FluidProp_COM->SetRefState( T_ref, P_ref, &BSTR_Error);
|
|
|
|
char* lpszErrorMsg = _com_util::ConvertBSTRToString( BSTR_Error);
|
|
*ErrorMsg = lpszErrorMsg;
|
|
delete[] lpszErrorMsg;
|
|
SysFreeString(BSTR_Error);
|
|
}
|
|
|
|
//==================================================================================== EOF ===//
|
|
|
|
|