Allow non-integer values for the number of groups in GC models (#539)

* Allow floats for group numbers

* fix tests

* make GroupParam parametric

* fix tests

* add parametric types of GroupParam to gc models

* fix `has_groups`

* fix test (SAFTgammaMie constructor)

* insert proposed changes

* Only use one parametric type per model

* Update src/database/params/GroupParam.jl

---------

Co-authored-by: Andrés Riedemann <38795484+longemen3000@users.noreply.github.com>

Author: se-schmitt

src/base/EoSModel.jl

@@ -194,7 +194,7 @@ has_groups(::Type{T}) where T <: EoSModel = _has_groups(T)
 Base.@assume_effects :foldable function _has_groups(::Type{T}) where T <: EoSModel
     s1 = hasfield(T,:groups)
     if s1
-       return fieldtype(T,:groups) == GroupParam
+       return fieldtype(T,:groups) <: GroupParam
     end
     return false
 end

src/database/ClapeyronParam.jl

@@ -100,8 +100,6 @@ end
 Base.eltype(p::EoSParam) = Float64
 Base.eltype(p::ParametricEoSParam{T}) where T = T
 
-const PARSED_GROUP_VECTOR_TYPE = Vector{Tuple{String, Vector{Pair{String, Int64}}}}
-
 function pack_vectors(x::AbstractVector{<:AbstractVector})
     return PackedVectorsOfVectors.pack(x)
 end

src/database/database_group.jl

@@ -121,7 +121,15 @@ function __GroupParam(components,found_gcpairs,found_intragcpairs,grouplocations
     componentstolookup = components[to_lookup]
     filepaths = flattenfilepaths(grouplocations,usergrouplocations)
 
-    gccomponents_parsed = PARSED_GROUP_VECTOR_TYPE(undef,length(components))
+    _T = Int64
+    _eltypepair(::Array{Pair{S,T},1}) where {S,T} = T
+    for (i,gcp) in enumerate(found_gcpairs)
+        if !to_lookup[i] 
+            _T = promote_type(_T, _eltypepair(gcp))
+        end
+    end
+
+    gccomponents_parsed = Vector{Tuple{String, Vector{Pair{String,_T}}}}(undef,length(components))
 
     #fill gccomponents_parsed
     for i in 1:length(components)

src/database/params/GroupParam.jl

@@ -61,26 +61,26 @@ julia> grouplist = [
 ```
 In this case, `SAFTGammaMie` files support the second order group `CH2OH`.
 """
-struct GroupParam <: GroupParameter
+struct GroupParam{T<:Number} <: GroupParameter
     components::Array{String,1}
     groups::Array{Array{String,1},1}
     grouptype::Symbol
-    n_groups::Array{Array{Int,1},1}
-    n_intergroups::Vector{Matrix{Int}}
+    n_groups::Array{Array{T,1},1}
+    n_intergroups::Vector{Matrix{T}}
     i_groups::Array{Array{Int,1},1}
     flattenedgroups::Array{String,1}
-    n_flattenedgroups::Array{Array{Int,1},1}
+    n_flattenedgroups::Array{Array{T,1},1}
     sourcecsvs::Array{String,1}
 end
 
-function GroupParam(input::PARSED_GROUP_VECTOR_TYPE)
+function GroupParam(input::Vector{Tuple{String, Vector{Pair{String,T}}}}) where {T<:Number}
     return GroupParam(input,:unknown,String[])
 end
 
 format_components(g::GroupParameter) = g
 
 #given components, groups, n_groups, reconstitute GroupParam
-function recombine!(param::GroupParameter)
+function recombine!(param::GroupParam{T}) where T
     components = param.components
     groups = param.groups
     n_groups = param.n_groups
@@ -102,7 +102,7 @@ function recombine!(param::GroupParameter)
     for i in 1:ℂ
         group = groups[i]
         if !isassigned(i_groups,i)
-            i_groups[i] = Int[]
+            i_groups[i] = T[]
         end
         i_group = i_groups[i]
         resize!(i_group,length(group))
@@ -148,7 +148,7 @@ function recombine!(param::GroupParameter)
     return param
 end
 
-function GroupParam(input::PARSED_GROUP_VECTOR_TYPE,grouptype,sourcecsvs::Vector{String},gc_intragroups=nothing)
+function GroupParam(input::Vector{Tuple{String, Vector{Pair{String,T}}}},grouptype,sourcecsvs::Vector{String},gc_intragroups=nothing) where {T<:Number}
     grouptype = Symbol(grouptype)
     components = [first(i) for i ∈ input]
     raw_groups = [last(i) for i ∈ input]
@@ -159,15 +159,20 @@ function GroupParam(input::PARSED_GROUP_VECTOR_TYPE,grouptype,sourcecsvs::Vector
     n_flattenedgroups = Vector{Vector{Int}}(undef,0)
     empty_intergroup = fill(0,(0,0)) #0x0 Matrix{Int}
     n_intergroups = fill(empty_intergroup,length(components))
-    param = GroupParam(components,
-    groups,
-    grouptype,
-    n_groups,
-    n_intergroups,
-    i_groups,
-    flattenedgroups,
-    n_flattenedgroups,
-    sourcecsvs)
+
+    _neltype(x) = eltype(eltype(x))     # nested eltype
+    _T = promote_type(_neltype(n_groups), _neltype(n_intergroups), _neltype(i_groups), _neltype(n_flattenedgroups))
+    param = GroupParam{_T}(
+        components,
+        groups,
+        grouptype,
+        n_groups,
+        n_intergroups,
+        i_groups,
+        flattenedgroups,
+        n_flattenedgroups,
+        sourcecsvs
+    )
     n_intergroups
     #do the rest of the work here
     if gc_intragroups != nothing
@@ -177,6 +182,49 @@ function GroupParam(input::PARSED_GROUP_VECTOR_TYPE,grouptype,sourcecsvs::Vector
     return param
 end
 
+function GroupParam(components,groups,grouptype,n_groups,n_intergroups,i_groups,flattenedgroups,n_flattenedgroups,sourcecsvs)
+    TT = eltype(eltype(n_groups))
+    return GroupParam{TT}(components,groups,grouptype,n_groups,n_intergroups,i_groups,flattenedgroups,n_flattenedgroups,sourcecsvs)
+end
+
+function Solvers.primalval(param::GroupParam{T}) where T
+    n_groups2 = Solvers.primalval_eager.(param.n_groups)
+    n_intergroups2 = Solvers.primalval_eager.(param.n_intergroups)
+    n_flattenedgroups2 = Solvers.primalval_eager.(param.n_flattenedgroups)
+    T2 = Solvers.primal_eltype(eltype(eltype(n_groups2)))
+    param = GroupParam{T2}(
+        param.components,
+        param.groups,
+        param.grouptype,
+        n_groups2,
+        n_intergroups2,
+        param.i_groups,
+        param.flattenedgroups,
+        n_flattenedgroups2,
+        param.sourcecsvs
+    )
+end
+
+Base.eltype(param::GroupParam{T}) where T = T
+Base.eltype(param::Type{<:GroupParam{T}}) where T = T
+
+function Base.convert(::Type{GroupParam{T1}},param::GroupParam{T2}) where {T1<:Number,T2<:Number}
+    n_groups2 = convert.(Vector{T1},param.n_groups)
+    n_intergroups2 = convert.(Matrix{T1},param.n_intergroups)
+    n_flattenedgroups2 = convert.(Vector{T1},param.n_flattenedgroups)
+    param = GroupParam{T1}(
+        param.components,
+        param.groups,
+        param.grouptype,
+        n_groups2,
+        n_intergroups2,
+        param.i_groups,
+        param.flattenedgroups,
+        n_flattenedgroups2,
+        param.sourcecsvs
+    )
+end
+
 function Base.show(io::IO, mime::MIME"text/plain", param::GroupParam)
     print(io,string(typeof(param)),"(:",param.grouptype,") ")
     len = length(param.components)
@@ -195,14 +243,14 @@ function Base.show(io::IO, param::GroupParam)
     print(io,"]")
 end
 
-function build_gc_intragroups!(group::GroupParam,gc_intragroups)
+function build_gc_intragroups!(group::GroupParam{T}, gc_intragroups) where T
     groupnames = group.flattenedgroups
     n_gc = length(groupnames)
     n_comps = length(group.components)
-    n_intergroups = [zeros(n_gc,n_gc) for i in 1:n_comps]
+    
     n_intergroups = group.n_intergroups
     for i in 1:n_comps
-        n_intergroups[i] = zeros(Int,n_gc,n_gc)
+        n_intergroups[i] = zeros(T,n_gc,n_gc)
     end
 
     for i in 1:n_comps

src/database/params/SiteParam.jl

@@ -122,7 +122,7 @@ function SiteParam(pairs::Dict{String,SingleParam{Int}},allcomponentsites)
     return SiteParam(components,sites,n_sites,sourcecsvs)
 end
 
-function SiteParam(input::PARSED_GROUP_VECTOR_TYPE,sourcecsvs=String[])
+function SiteParam(input::Vector{Tuple{String, Vector{Pair{String,T}}}},sourcecsvs=String[]) where {T<:Number}
     components = [first(i) for i ∈ input]
     raw_sites = [last(i) for i ∈ input]
     sites = [first.(sitepairs) for sitepairs ∈ raw_sites]

src/models/Activity/UNIFAC/UNIFAC.jl

@@ -1,17 +1,17 @@
-struct UNIFACParam <: EoSParam
-    A::PairParam{Float64}
-    B::PairParam{Float64}
-    C::PairParam{Float64}
-    R::SingleParam{Float64}
-    Q::SingleParam{Float64}
+struct UNIFACParam{T} <: EoSParam
+    A::PairParam{T}
+    B::PairParam{T}
+    C::PairParam{T}
+    R::SingleParam{T}
+    Q::SingleParam{T}
 end
 
 abstract type UNIFACModel <: ActivityModel end
 
-struct UNIFAC{c<:EoSModel} <: UNIFACModel
+struct UNIFAC{c<:EoSModel,T} <: UNIFACModel
     components::Array{String,1}
-    groups::GroupParam
-    params::UNIFACParam
+    groups::GroupParam{T}
+    params::UNIFACParam{T}
     puremodel::EoSVectorParam{c}
     references::Array{String,1}
     unifac_cache::UNIFACCache

src/models/Activity/UNIFAC/variants/PSRK.jl

@@ -1,7 +1,7 @@
-struct PSRKUNIFAC{c<:EoSModel} <: UNIFACModel
+struct PSRKUNIFAC{c<:EoSModel,T} <: UNIFACModel
     components::Array{String,1}
-    groups::GroupParam
-    params::UNIFACParam
+    groups::GroupParam{T}
+    params::UNIFACParam{T}
     puremodel::EoSVectorParam{c}
     references::Array{String,1}
     unifac_cache::UNIFACCache

src/models/Activity/UNIFAC/variants/UNIFAC2.jl

@@ -1,7 +1,7 @@
-struct UNIFAC2{c<:EoSModel} <: UNIFACModel
+struct UNIFAC2{c<:EoSModel,T} <: UNIFACModel
     components::Array{String,1}
-    groups::GroupParam
-    params::UNIFACParam
+    groups::GroupParam{T}
+    params::UNIFACParam{T}
     puremodel::EoSVectorParam{c}
     references::Array{String,1}
     unifac_cache::UNIFACCache

src/models/Activity/UNIFAC/variants/UNIFACFV.jl

@@ -30,20 +30,20 @@ function recombine_unifac_cache!(cache::UNIFACFVCache,groups,params)
     return cache
 end
 
-struct UNIFACFVParam <: EoSParam
-    volume::SingleParam{Float64}
-    A::PairParam{Float64}
-    R::SingleParam{Float64}
-    Q::SingleParam{Float64}
-    Mw::SingleParam{Float64}
+struct UNIFACFVParam{T} <: EoSParam
+    volume::SingleParam{T}
+    A::PairParam{T}
+    R::SingleParam{T}
+    Q::SingleParam{T}
+    Mw::SingleParam{T}
 end
 
 abstract type UNIFACFVModel <: ActivityModel end
 
-struct UNIFACFV{c<:EoSModel} <: UNIFACFVModel
+struct UNIFACFV{c<:EoSModel,T} <: UNIFACFVModel
     components::Array{String,1}
-    groups::GroupParam
-    params::UNIFACFVParam
+    groups::GroupParam{T}
+    params::UNIFACFVParam{T}
     puremodel::EoSVectorParam{c}
     references::Array{String,1}
     UNIFACFV_cache::UNIFACFVCache

src/models/Activity/UNIFAC/variants/UNIFACFVPoly.jl

@@ -1,18 +1,18 @@
-struct UNIFACFVPolyParam <: EoSParam
-    volume::SingleParam{Float64}
-    c::SingleParam{Float64}
-    A::PairParam{Float64}
-    R::SingleParam{Float64}
-    Q::SingleParam{Float64}
-    Mw::SingleParam{Float64}
+struct UNIFACFVPolyParam{T} <: EoSParam
+    volume::SingleParam{T}
+    c::SingleParam{T}
+    A::PairParam{T}
+    R::SingleParam{T}
+    Q::SingleParam{T}
+    Mw::SingleParam{T}
 end
 
 abstract type UNIFACFVPolyModel <: UNIFACFVModel end
 
-struct UNIFACFVPoly{c<:EoSModel} <: UNIFACFVPolyModel
+struct UNIFACFVPoly{c<:EoSModel,T} <: UNIFACFVPolyModel
     components::Array{String,1}
-    groups::GroupParam
-    params::UNIFACFVPolyParam
+    groups::GroupParam{T}
+    params::UNIFACFVPolyParam{T}
     puremodel::EoSVectorParam{c}
     references::Array{String,1}
     UNIFACFV_cache::UNIFACFVCache