Create PropsSImulti()

[duncanam]

I think we should look into adding this call to this package to leverage single AbstractState setup if a user wants to pull lots of combinations of input parameters.

Currently the options are to use the low level interface and loop over AbstractState updates or to loop (or dot syntax) over PropsSI() which instantiates a new AbstractState each time. For things like REFPROP, this is a painful performance hit.

[longemen3000]

probably something like this:

function PropsSIMulti(output::AbstractString, name1::AbstractString, value1,
                      name2::AbstractString, value2, fluid::AbstractString)

    result = zeros(Float64,Base.promote_shape(value1,value2))
    return PropsSIMulti!(result,output,name1,value1,name2,value2,fluid)
end


function PropsSIMulti!(result, output::AbstractString, name1::AbstractString, value1,
                       name2::AbstractString, value2, fluid::AbstractString)
    
    pair_inputs = CoolProp.get_input_pair(name1, name2)
    handle = CoolProp.AbstractState_factory("HEOS", fluid) #TODO: support other AbstractState EoS
    out_prop = CoolProp.get_param_index(output)
    function prop(v1, v2)
        CoolProp.AbstractState_update(handle, pair_inputs, Float64(v1), Float64(v2))
        return CoolProp.AbstractState_keyed_output(handle, out_prop)
    end

    broadcast!(prop, result, value1, value2)
    CoolProp.AbstractState_free(handle)
    return result
end

[spinnau]

Maybe the PropsSIMulti function from the C-Interface can be used, so the handling of the most things is done by CoolProp, e.g. returning Inf if errors occurs for some of the value pairs.

For convenience the broadcasting PropsSI.(...) can also be used to call PropsSImulti.

using CoolProp
using CoolProp_jll
using BenchmarkTools

import Base.Broadcast: broadcasted


function PropsSImulti(
    outputs::String, 
    name1::String, 
    prop1::Vector{<:Real},
    name2::String, 
    prop2::Vector{<:Real}, 
    backend::String,
    fluids::String, 
    fractions::Vector{Float64}
)

    size_outputs = length(split(outputs, ","))
    size_prop1 = length(prop1)
    size_prop2 = length(prop2)
    size_props = max(size_prop1, size_prop2)
    length_fractions = length(fractions)
    
    resdim1 = Ref{Clong}(size_props)
    resdim2 = Ref{Clong}(size_outputs)
    result = Vector{Cdouble}(undef, size_outputs * size_props)

    prop1 = convert(Vector{Float64}, prop1)
    prop2 = convert(Vector{Float64}, prop2)

    ccall((:PropsSImulti, libcoolprop), Cvoid,
        (
            Cstring, Cstring, Ptr{Cdouble}, Clong, Cstring, Ptr{Cdouble}, Clong, 
            Cstring, Cstring, Ptr{Cdouble}, Clong, Ptr{Cdouble}, Ref{Clong}, Ref{Clong}
        ),
        outputs, name1, prop1, Clong(size_prop1), name2, prop2, Clong(size_prop2),
        backend, fluids, fractions, Clong(length_fractions), result, resdim1, resdim2
    )

    n_cols = resdim1[]
    n_rows = resdim2[]
    size = n_rows * n_cols

    if size == 0
        error("CoolProp: ", get_global_param_string("errstring"))
    end

    return reshape(result, n_rows, n_cols)
end


function broadcasted(
    ::typeof(PropsSI), 
    out::String, 
    name1::String, 
    prop1::Union{AbstractVector, Real}, 
    name2::String, 
    prop2::Union{AbstractVector, Real}, 
    fluid::String
)
    # make prop1 and prop2 the same size if one of them is a scalar
    size_props = max(length(prop1), length(prop2))
    prop1 = prop1 isa Real ? fill(Float64(prop1), size_props) : convert(Vector{Float64}, prop1)
    prop2 = prop2 isa Real ? fill(Float64(prop2), size_props) : convert(Vector{Float64}, prop2)
    
    if occursin("::", fluid)
        backend, fluid_name = String.(split(fluid, "::"))
    else
        backend = "HEOS"
        fluid_name = fluid
    end
    
    result = PropsSImulti(out, name1, prop1, name2, prop2, backend, fluid_name, [1.0])    
    return vec(result)
end

fluid = "water"
T = collect(300:1.0:500)

@benchmark PropsSI.("H", "T", T, "Q", 1.0, fluid)

BenchmarkTools.Trial: 10000 samples with 1 evaluation per sample.
 Range (min … max):  405.636 μs …  2.927 ms  ┊ GC (min … max): 0.00% … 79.71%
 Time  (median):     411.474 μs              ┊ GC (median):    0.00%
 Time  (mean ± σ):   415.185 μs ± 34.877 μs  ┊ GC (mean ± σ):  0.11% ±  1.11%

    ▆██▆▂  ▁                                                    
  ▁▅█████▇████▆▅▄▄▄▄▅▅▄▃▄▃▃▃▃▃▃▃▃▃▂▂▂▂▂▂▂▂▂▂▂▂▂▃▃▃▃▂▂▂▂▂▂▂▁▂▁▁ ▃
  406 μs          Histogram: frequency by time          438 μs <

 Memory estimate: 3.48 KiB, allocs estimate: 9.

Performance is the same as with the Python wrapper:

from CoolProp.CoolProp import PropsSI
import numpy as np

fluid = "water"
T = np.arange(300, 500, 1.0)

%%timeit
PropsSI("H", "T", T, "Q", 1.0, fluid)

419 μs ± 2.27 μs per loop (mean ± std. dev. of 7 runs, 1,000 loops each)