Merge pull request #48 from siravan/master

ver 2.4.1

Author: shahriariravanian

Project.toml

@@ -1,7 +1,7 @@
 name = "CellMLToolkit"
 uuid = "03cb29e0-1ef4-4721-aa24-cf58a006576f"
 authors = ["Shahriar Iravanian <siravan@svtsim.com>"]
-version = "2.4.0"
+version = "2.4.1"
 
 [deps]
 EzXML = "8f5d6c58-4d21-5cfd-889c-e3ad7ee6a615"

src/accessors.jl

@@ -122,3 +122,20 @@ list_imports(xml) = findall("//x:import", get_model(xml), ["x"=>cellml_ns(xml)])
     node: an import node as returned by list_imports
 """
 list_import_components(node) = findall("./x:component", nodeof(node), ["x"=>cellml_ns(node)])
+
+function list_encapsulation(doc, comp)
+    name = string(nameof(comp))
+    ns = cellml_ns(doc)
+    groups = parentnode.(findall("//x:group/x:relationship_ref[@relationship='encapsulation']", root(doc), ["x"=>ns]))
+    if isempty(groups)  # CellML ver 2.0
+        return findall("//x:encapsulation//x:component_ref[@component='$name']//x:component_ref", root(doc), ["x"=>ns])
+    else                # CellML ver 1.0 and 1.1
+        for g in groups
+            nodes = findall(".//x:component_ref[@component='$name']//x:component_ref", g, ["x"=>ns])
+            if !isempty(nodes)
+                return nodes
+            end
+        end
+        return EzXML.Node[]
+    end
+end

src/components.jl

@@ -139,7 +139,16 @@ end
 @memoize function classify_variables(doc::Document)
     groups = find_equivalence_groups(doc)
     lhs = list_all_lhs(doc)
-    Dict{Var, Bool}(first(g) => (length(last(g) ∩ lhs) == 1) for g in groups)
+    class = Dict{Var, Bool}()
+
+    for g in groups
+        n = length(last(g) ∩ lhs)
+        if n > 1
+            error("Equivalence group $g has more than one initial_value: $(last(g) ∩ lhs)")
+        end
+        class[first(g)] = (n == 1)
+    end
+    class
 end
 
 """
@@ -150,7 +159,7 @@ function translate_connections(doc::Document, systems, class)
     a = []
     for conn in connections(doc)
         for (u1,u2) in variables(conn)
-            if class[u1] && class[u2] 
+            if class[u1] && class[u2]
                 var1 = getproperty(systems[u1.comp], u1.var)
                 var2 = getproperty(systems[u2.comp], u2.var)
                 push!(a, var1 ~ var2)
@@ -250,7 +259,7 @@ end
     comp in the name of the component
     class is the output of classify_variables
 """
-function process_component(doc::Document, comp, class)
+function process_component(doc::Document, comp, class)    
     math = list_component_math(comp)
     pre_sub = pre_substitution(doc, comp, class)
 
@@ -274,13 +283,19 @@ end
 
 function collect_initiated_values(doc::Document)
     vars = Dict{Var, Float64}()
+    syms = Dict{Var, Var}()
 
     for comp in components(doc)
         for v in list_initiated_variables(comp)
-            vars[make_var(to_symbol(comp), v)] = Float64(Meta.parse(v["initial_value"]))
+            val = Meta.parse(v["initial_value"])
+            if val isa Symbol
+                syms[make_var(to_symbol(comp), v)] = make_var(to_symbol(comp), val)
+            else
+                vars[make_var(to_symbol(comp), v)] = Float64(val)
+            end
         end
     end
-    vars
+    vars, syms
 end
 
 function split_sym(sym)
@@ -292,21 +307,22 @@ end
 find_sys_p(doc::Document, sys) = find_list_value(doc, parameters(sys))
 find_sys_u0(doc::Document, sys) = find_list_value(doc, states(sys))
 
-function find_list_value(doc::Document, a)
-    c = collect_initiated_values(doc)
-    iv = find_iv(doc)
-
-    d = collect(keys(c))
+function find_list_value(doc::Document, names)
+    vars, syms = collect_initiated_values(doc)
+    varkeys = Set(keys(vars))
     groups = find_equivalence_groups(doc)
 
-    val = []
-    for x in a
-        var = [x for x in groups[split_sym(x)] ∩ d]
+    vals = []
+
+    for x in names
+        u = split_sym(x)
+        u = haskey(syms,u) ? syms[u] : u
+        var = groups[u] ∩ varkeys
         if length(var) == 0
             error("value of $x is not found")
         end
-        push!(val, x => c[var[1]])
+        push!(vals, x => vars[first(var)])
 
     end
-    return val
+    return vals
 end

src/import.jl

@@ -1,6 +1,26 @@
 using Random
 
-component_sym(x) = Symbol(x)
+sym(x) = Symbol(x)
+
+function populate_dependency!(doc, comp)
+    empty!(comp.deps)
+    for x in list_encapsulation(doc, comp)
+        push!(comp.deps, sym(x["component"]))
+    end
+end
+
+function add_component!(doc, name, node, populate=true)
+    comp = Component(name, node, Set{Symbol}())
+    populate && populate_dependency!(doc, comp)
+    push!(doc.comps, comp)
+    comp
+end
+
+function add_connection!(doc, c1, c2, vars)
+    conn = Connection(c1, c2, vars)
+    push!(doc.conns, conn)
+    conn
+end
 
 """
     load_cellml loads a CellML file and populates a Document structures with
@@ -10,22 +30,20 @@ component_sym(x) = Symbol(x)
 """
 function load_cellml(path; resolve=true)
     xml = readxml(path)
+    doc = Document(path, [xml], Component[], Connection[])
 
-    comps = [Component(component_sym(c["name"]), c) for c in list_components(xml)]
+    for c in list_components(xml)
+        add_component!(doc, sym(c["name"]), c)
+    end
 
-    conns = Connection[]
     for conn in list_connections(xml)
-        c1, c2 = component_sym.(components_of(get_connection_component(conn)))
+        c1, c2 = sym.(components_of(get_connection_component(conn)))
         vars = [make_var(c1,v1) => make_var(c2,v2)
                 for (v1,v2) in variables_of.(list_connection_variables(conn))]
-        push!(conns, Connection(c1, c2, vars))
+        add_connection!(doc, c1, c2, vars)
     end
 
-    doc = Document(path, [xml], comps, conns)
-
-    if resolve
-        resolve_imports(doc)
-    end
+    resolve && resolve_imports!(doc)
 
     return doc
 end
@@ -40,44 +58,55 @@ end
 
 find_component(doc::Document, name) = find_component(doc.comps, name)
 
-implicit_name(sym) = Symbol("$(string(sym))_$(randstring(6))")
+# implicit_name(sym) = Symbol("$(string(sym))_$(randstring(6))")
+implicit_name(sym) = Symbol("$(string(sym))")
 
 """
     resolve_imports recursivelly resolves the imported components of doc.
 """
-function resolve_imports(doc::Document)
+function resolve_imports!(doc::Document)
     for ϵ in list_imports(doc)  # εισαγωγή == import
         href = ϵ["xlink:href"]
         @info "importing $href"
         path = joinpath(splitdir(doc.path)[1], href)
         child = load_cellml(path)
         append!(doc.xmls, child.xmls)
 
-        L = Dict{Symbol, Symbol}()    # L keeps the import names of components
+        L = Dict{Symbol, Symbol}()      # L keeps the import names of components
+        D = Set{Symbol}()               # D is the set of imported dependencies
+        C = Set{Symbol}()
 
         # first, import explicitly imported component
         for σ in list_import_components(ϵ)  # συστατικό == component
-            name = component_sym(σ["component_ref"])
-            comp = find_component(child, name)
-            push!(doc.comps, Component(component_sym(σ["name"]), comp.node))
-            L[name] = component_sym(σ["name"])
+            old_name = sym(σ["component_ref"])
+            new_name = sym(σ["name"])
+            old_comp = find_component(child, old_name)
+
+            add_component!(doc, new_name, old_comp.node)
+
+            D = D ∪ old_comp.deps
+            L[old_name] = new_name
+            push!(C, old_name)
         end
 
         # second, import implicitly imported component, as defined by closure
-        for c in find_closure(child, collect(keys(L)))
-            comp = find_component(child, c)
-            name = implicit_name(c) # generates a name with a random suffix to prevent name collision
-            push!(doc.comps, Component(name, comp.node))
-            L[c] = name
+        #for c in find_closure(child, collect(keys(L)))
+        for old_name in D
+            if old_name ∉ C
+                old_comp = find_component(child, old_name)
+                new_name = implicit_name(old_name) # generates a name with a random suffix to prevent name collision
+                add_component!(doc, new_name, old_comp.node, false)
+                L[old_name] = new_name
+            end
         end
 
         # third, we also need to import connections from the child CellML file
         for conn in connections(child)
             c1, c2 = components(conn)
-            if haskey(L,c1) || haskey(L,c2)
+            if haskey(L,c1) && haskey(L,c2)
                 d1, d2 = L[c1], L[c2]
                 vars = [Var(d1,v1.var) => Var(d2,v2.var) for (v1,v2) in conn.vars]
-                push!(doc.conns, Connection(d1, d2, vars))
+                add_connection!(doc, d1, d2, vars)
             end
         end
     end

src/structures.jl

@@ -6,6 +6,7 @@ end
 struct Component
     name::Symbol
     node::EzXML.Node
+    deps::Set{Symbol}
 end
 
 nameof(comp::Component) = comp.name