github/CoolProp
1
1
Fork 0
mirror of https://github.com/CoolProp/CoolProp.git synced 2026-04-23 03:00:17 -04:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/coolprop/coolprop

Browse Source
This commit is contained in:
Ian Bell
2015-03-22 21:20:22 -06:00
parent c8b8b76496 9cf833e323
commit b0c4e32563
3 changed files with 25 additions and 176 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
Web/coolprop/wrappers/Julia/index.rst
View File

@@ -18,12 +18,19 @@ Option A: Calling shared library directly
Download a precompiled shared library appropriate to the computer you are using from :sfdownloads:`sourceforge <shared_library>` or the development version from :sfnightly:`the nightly snapshots <shared_library>`.
NB: For Linux users, the file libCoolProp.so must be renamed into CoolProp.so and copied into Julia's library folder (e.g. /usr/lib/x86_64-linux-gnu/julia/), or you can set the system shared library search path to the current directory::
NB: For Linux users, the file libCoolProp.so must be renamed into CoolProp.so and copied into Julia's library folder (e.g. /usr/lib/x86_64-linux-gnu/julia/).
If you compile/download the library often, you may prefer to make a symbolic link from your downloaded/compiled library to Julia's library folder::
sudo ln -s libCoolProp.so /usr/lib/x86_64-linux-gnu/julia/CoolProp.so
If you want to use the library in an other directory, once renamed (or after creating a `CoolProp.so` symbolic link) you can set the system shared library search path to the current directory before running Julia::
export LD_LIBRARY_PATH=${PWD}
Or directly ask Julia to search in the current directory::
Download the module ``CoolProp.jl`` from :sfdownloads:`sourceforge <Julia>` or the development version from :sfnightly:`the nightly snapshots <Julia>` and place in the same folder as the shared library.
The wrapper should be valid for Julia 0.4 and above. For Julia 0.3 and lower, use the one in the 0.3 folder.
push!(DL_LOAD_PATH,".")
Note that you can replace `${PWD}` (present working directory) by any path you want, and similarly for the `.` of the `"."` in Julia.
Download the module ``CoolProp.jl`` from :sfdownloads:`sourceforge <Julia>` or the development version from :sfnightly:`the nightly snapshots <Julia>` and place in the same folder as the shared library (in `~/.julia/$version/CoolProp/src/` for Linux users).
Usage
-----

166
wrappers/Julia/0.3/CoolProp.jl
View File

@@ -1,166 +0,0 @@
module CoolProp
export F2K, K2F, HAPropsSI, PropsSI, PhaseSI, get_global_param_string, get_param_index, get_input_pair_index, AbstractState_factory, AbstractState_free, AbstractState_update, AbstractState_keyed_output
const buffer_length = 255
message_buffer = Array(Uint8, buffer_length)
function F2K(TF::Number)
return ccall( (:F2K, "CoolProp"), Cdouble, (Cdouble,), TF)
end
function K2F(TK::Number)
return ccall( (:K2F, "CoolProp"), Cdouble, (Cdouble,), TK)
end
function HAPropsSI(Output::String, Name1::String, Value1::Number, Name2::String, Value2::Number, Name3::String, Value3::Number)
val = ccall( (:HAPropsSI, "CoolProp"), Cdouble, (Ptr{Uint8},Ptr{Uint8},Float64,Ptr{Uint8},Float64,Ptr{Uint8},Float64), Output,Name1,Value1,Name2,Value2,Name3,Value3)
if val == Inf
error("CoolProp: ", get_global_param_string("errstring"))
end
return val
end
function PropsSI(Output::String, Name1::String, Value1::Number, Name2::String, Value2::Number, Fluid::String)
val = ccall( (:PropsSI, "CoolProp"), Cdouble, (Ptr{Uint8},Ptr{Uint8},Float64,Ptr{Uint8},Float64,Ptr{Uint8}), Output,Name1,Value1,Name2,Value2,Fluid)
if val == Inf
error("CoolProp: ", get_global_param_string("errstring"))
end
return val
end
function PropsSI(FluidName::String, Output::String)
val = ccall( (:Props1SI, "CoolProp"), Cdouble, (Ptr{Uint8},Ptr{Uint8}), FluidName,Output)
if val == Inf
error("CoolProp: ", get_global_param_string("errstring"))
end
return val
end
function PhaseSI(Name1::String, Value1::Number, Name2::String, Value2::Number, Fluid::String)
val = ccall( (:PhaseSI, "CoolProp"), Int32, (Ptr{Uint8},Float64,Ptr{Uint8},Float64,Ptr{Uint8}, Ptr{Uint8}, Int), Name1,Value1,Name2,Value2,Fluid,message_buffer::Array{Uint8,1},buffer_length)
return bytestring(convert(Ptr{Uint8}, pointer(message_buffer::Array{Uint8,1})))
end
# This function returns the output string in pre-allocated char buffer. If buffer is not large enough, no copy is made
function get_global_param_string(Key::String)
val = ccall( (:get_global_param_string, "CoolProp"), Clong, (Ptr{Uint8},Ptr{Uint8},Int), Key,message_buffer::Array{Uint8,1},buffer_length)
return bytestring(convert(Ptr{Uint8}, pointer(message_buffer::Array{Uint8,1})))
end
# Get the index for a parameter "T", "P", etc.
# returns the index as a long.
function get_param_index(Param::String)
val = ccall( (:get_param_index, "CoolProp"), Clong, (Ptr{Uint8},), Param)
if val == -1
error("CoolProp: Unknown parameter: ", Param)
end
return val
end
# Get the index for an input pair for AbstractState.update function
# returns the index as a long.
function get_input_pair_index(Param::String)
val = ccall( (:get_input_pair_index, "CoolProp"), Clong, (Ptr{Uint8},), Param)
if val == -1
error("CoolProp: Unknown input pair: ", Param)
end
return val
end
# ---------------------------------
# Low-level access
# ---------------------------------
errcode = Array(Clong, 1)
# 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
# return A handle to the state class generated
function AbstractState_factory(backend::String, fluids::String)
AbstractState = ccall( (:AbstractState_factory, "CoolProp"), Clong, (Ptr{Uint8},Ptr{Uint8},Ptr{Clong},Ptr{Uint8},Clong), backend,fluids,errcode::Array{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{Uint8}, pointer(message_buffer))))
elseif errcode[] == 2
error("CoolProp: message buffer too small")
else # == 3
error("CoolProp: unknown error")
end
end
return AbstractState
end
# Release a state class generated by the low-level interface wrapper
# param handle The integer handle for the state class stored in memory
function AbstractState_free(handle::Clong)
ccall( (:AbstractState_free, "CoolProp"), Void, (Clong,Ptr{Clong},Ptr{Uint8},Clong), handle,errcode::Array{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{Uint8}, pointer(message_buffer))))
elseif errcode[] == 2
error("CoolProp: message buffer too small")
else # == 3
error("CoolProp: unknown error")
end
end
return nothing
end
# 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
function AbstractState_set_fractions(handle::Clong,fractions::Array)
ccall( (:AbstractState_set_fractions, "CoolProp"), Void, (Clong,Ptr{Cdouble},Clong,Ptr{Clong},Ptr{Uint8},Clong), handle,fractions,length(fractions),errcode::Array{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{Uint8}, pointer(message_buffer))))
elseif errcode[] == 2
error("CoolProp: message buffer too small")
else # == 3
error("CoolProp: unknown error")
end
end
return nothing
end
# 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 get_input_pair_index(Param::String)
# param value1 The first input value
# param value2 The second input value
function AbstractState_update(handle::Clong,input_pair::Clong,value1::Number,value2::Number)
ccall( (:AbstractState_update, "CoolProp"), Void, (Clong,Clong,Cdouble,Cdouble,Ptr{Clong},Ptr{Uint8},Clong), handle,input_pair,value1,value2,errcode::Array{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{Uint8}, pointer(message_buffer))))
elseif errcode[] == 2
error("CoolProp: message buffer too small")
else # == 3
error("CoolProp: unknown error")
end
end
return nothing
end
# 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
function AbstractState_keyed_output(handle::Clong, param::Clong)
output = ccall( (:AbstractState_keyed_output, "CoolProp"), Cdouble, (Clong,Clong,Ptr{Clong},Ptr{Uint8},Clong), handle,param,errcode::Array{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{Uint8}, pointer(message_buffer))))
elseif errcode[] == 2
error("CoolProp: message buffer too small")
else # == 3
error("CoolProp: unknown error")
end
elseif output == -Inf
error("CoolProp: no correct state has been set with AbstractState_update")
end
return output
end
end #module

22
wrappers/Julia/CoolProp.jl
View File

@@ -2,6 +2,16 @@ module CoolProp
export F2K, K2F, HAPropsSI, PropsSI, PhaseSI, get_global_param_string, get_param_index, get_input_pair_index, AbstractState_factory, AbstractState_free, AbstractState_update, AbstractState_keyed_output
# Check the current Julia version to make this Julia 0.4 code compatible with older version
if VERSION <= VersionNumber(0,4)
typealias UInt8 Uint8
typealias Ref Ptr
typealias RefValue Array
errcode = Array(Clong, 1)
else
errcode = Ref{Clong}(0)
end
const buffer_length = 255
message_buffer = Array(UInt8, buffer_length)
@@ -72,14 +82,12 @@ end
# Low-level access
# ---------------------------------
errcode = Ref{Clong}(0)
# 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
# return A handle to the state class generated
function AbstractState_factory(backend::String, fluids::String)
AbstractState = ccall( (:AbstractState_factory, "CoolProp"), Clong, (Ptr{UInt8},Ptr{UInt8},Ref{Clong},Ptr{UInt8},Clong), backend,fluids,errcode::Base.RefValue{Clong},message_buffer::Array{Uint8,1},buffer_length)
AbstractState = ccall( (:AbstractState_factory, "CoolProp"), Clong, (Ptr{UInt8},Ptr{UInt8},Ref{Clong},Ptr{UInt8},Clong), backend,fluids,errcode::RefValue{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{UInt8}, pointer(message_buffer))))
@@ -95,7 +103,7 @@ end
# Release a state class generated by the low-level interface wrapper
# param handle The integer handle for the state class stored in memory
function AbstractState_free(handle::Clong)
ccall( (:AbstractState_free, "CoolProp"), Void, (Clong,Ref{Clong},Ptr{UInt8},Clong), handle,errcode::Base.RefValue{Clong},message_buffer::Array{Uint8,1},buffer_length)
ccall( (:AbstractState_free, "CoolProp"), Void, (Clong,Ref{Clong},Ptr{UInt8},Clong), handle,errcode::RefValue{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{UInt8}, pointer(message_buffer))))
@@ -112,7 +120,7 @@ end
# param handle The integer handle for the state class stored in memory
# param fractions The array of fractions
function AbstractState_set_fractions(handle::Clong,fractions::Array)
ccall( (:AbstractState_set_fractions, "CoolProp"), Void, (Clong,Ptr{Cdouble},Clong,Ref{Clong},Ptr{UInt8},Clong), handle,fractions,length(fractions),errcode::Base.RefValue{Clong},message_buffer::Array{Uint8,1},buffer_length)
ccall( (:AbstractState_set_fractions, "CoolProp"), Void, (Clong,Ptr{Cdouble},Clong,Ref{Clong},Ptr{UInt8},Clong), handle,fractions,length(fractions),errcode::RefValue{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{UInt8}, pointer(message_buffer))))
@@ -131,7 +139,7 @@ end
# param value1 The first input value
# param value2 The second input value
function AbstractState_update(handle::Clong,input_pair::Clong,value1::Number,value2::Number)
ccall( (:AbstractState_update, "CoolProp"), Void, (Clong,Clong,Cdouble,Cdouble,Ref{Clong},Ptr{UInt8},Clong), handle,input_pair,value1,value2,errcode::Base.RefValue{Clong},message_buffer::Array{Uint8,1},buffer_length)
ccall( (:AbstractState_update, "CoolProp"), Void, (Clong,Clong,Cdouble,Cdouble,Ref{Clong},Ptr{UInt8},Clong), handle,input_pair,value1,value2,errcode::RefValue{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{UInt8}, pointer(message_buffer))))
@@ -148,7 +156,7 @@ end
# param handle The integer handle for the state class stored in memory
# param param The integer value for the parameter you want
function AbstractState_keyed_output(handle::Clong, param::Clong)
output = ccall( (:AbstractState_keyed_output, "CoolProp"), Cdouble, (Clong,Clong,Ref{Clong},Ptr{UInt8},Clong), handle,param,errcode::Base.RefValue{Clong},message_buffer::Array{Uint8,1},buffer_length)
output = ccall( (:AbstractState_keyed_output, "CoolProp"), Cdouble, (Clong,Clong,Ref{Clong},Ptr{UInt8},Clong), handle,param,errcode::RefValue{Clong,1},message_buffer::Array{Uint8,1},buffer_length)
if errcode[] != 0
if errcode[] == 1
error("CoolProp: ", bytestring(convert(Ptr{UInt8}, pointer(message_buffer))))