PyCall and Julia

[delta-pi-1701]

In Python

import CoolProp.constants
from CoolProp.CoolProp import generate_update_pair,get_parameter_index,set_debug_level,get_phase_index
from CoolProp.CoolProp import AbstractState as State
nnstate = State("HEOS","water")
pair, in1, in2 = generate_update_pair(CoolProp.constants.iP, 3e6, CoolProp.constants.iQ,0.0)
nnstate.update(pair, in1, in2)
print nnstate.keyed_output(CoolProp.constants.iDmass)

In Julia

using PyCall
@pyimport CoolProp.constants as CPc
@pyimport CoolProp.CoolProp as CP
st = CP.AbstractState("HEOS","water")
(pair, in1, in2) = CP.generate_update_pair(CPc.iP, 2e5, CPc.iT, 300)
st.update(pair, in1, in2)
println(CP.AbstractState.keyed_output(CoolProp.constants.iDmass))

Error
type PyObject has no field update while loading In[77], in expression starting on line 6

typeof(st)
PyObject (constructor with 34 methods)

[stevengj]

Do st[:update](...). See the README: this is the main difference from Python, because Julia currently overload . we use [:...] instead.

[delta-pi-1701]

The Coolprop wrapper (exclusively made for julia which employs ccall) seems slower than PyCall.

using PyCall
@pyimport CoolProp.CoolProp as CP
import CoolProp

len = 2500
p = 1e6*linspace(2.8,3,len)
h = 1e3*linspace(700,1500,len)

@time for i = 1:len;CP.PropsSI("D","P",p[i],"H",h[i],"Water");end
@time for i = 1:len;CoolProp.PropsSI("D","P",p[i],"H",h[i],"Water");end

elapsed time: 1.860561627 seconds (3123688 bytes allocated)
elapsed time: 2.617331437 seconds (263688 bytes allocated)

Surprising !
PyCall(Bytes allocated) > CoolProp_Wrapper(Bytes allocated)
PyCall(Time) < CoolProp_Wrapper(Time)

I need a something fast, as my system involves ~1000 State Variables and ode solvers are very very slow.

[stevengj]

Where is the CoolProp wrapper? It doesn't seem to be on pkg.julialang.org. I would be happy to give them some suggestions on getting better performance, but I would need to see what they are doing.

[delta-pi-1701]

The Coolprop Julia Wrapper.
The Shared Lib.

The wrapper is meant for julia v0.4, however changing the UInt8 to Uint8, things do work for 0.3.5 (as in Juliabox).

[delta-pi-1701]

Any suggestion to speed things up....

[stevengj]

Well, your Julia wrapper is just:

function PropsSI(Output::String, Name1::String, Value1::Float64, Name2::String,Value2::Float64, Fluid::String)
  return ccall( (:PropsSI, "CoolProp"), Cdouble, (Ptr{UInt8},Ptr{UInt8},Float64,Ptr{UInt8},Float64,Ptr{UInt8}), Output,Name1,Value1,Name2,Value2,Fluid)
end

I don't see how you could do any better than that, unless Python is calling a different C function entirely. What is the Python PropsSI function doing?

Also, note that you should never run benchmarks in global scope. Can you put your benchmark code into a function and try it again?

Note also that the string-handling in the PhaseSI wrapper looks incorrect to me if you pass in anything other than an ASCIIString.

[delta-pi-1701]

The CoolProp people suggest to use the Low Level Interface for speed. (somewhere they mention regarding the string comparison which I think is the bottleneck !)

Python Wrapper

Benchmark Code, I have tried using function, not much of a difference.

For 1000 state variables, the function which employs the usage of coolprop takes ~3.5sec (to be executed in each iteration). Hence, one can just imagine how long shall it take for solving the system using ode solvers for transient analysis.