WIP: tests; endpoint script->funct; remove intermediate var

Author: quffaro

packages/algjulia-interop/Project.toml

@@ -1,28 +1,43 @@
 name = "CatColabInterop"
 uuid = "9ecda8fb-39ab-46a2-a496-7285fa6368c1"
 license = "MIT"
-version = "0.1.1"
 authors = ["CatColab team"]
+version = "0.1.1"
 
 [deps]
 HTTP = "cd3eb016-35fb-5094-929b-558a96fad6f3"
+JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1"
 MLStyle = "d8e11817-5142-5d16-987a-aa16d5891078"
 Oxygen = "df9a0d86-3283-4920-82dc-4555fc0d1d8b"
 Reexport = "189a3867-3050-52da-a836-e630ba90ab69"
 StructTypes = "856f2bd8-1eba-4b0a-8007-ebc267875bd4"
+TOML = "fa267f1f-6049-4f14-aa54-33bafae1ed76"
 
 [weakdeps]
 ACSets = "227ef7b5-1206-438b-ac65-934d6da304b8"
 Catlab = "134e5e36-593f-5add-ad60-77f754baafbe"
+CombinatorialSpaces = "b1c52339-7909-45ad-8b6a-6e388f7c67f2"
+ComponentArrays = "b0b7db55-cfe3-40fc-9ded-d10e2dbeff66"
+CoordRefSystems = "b46f11dc-f210-4604-bfba-323c1ec968cb"
+Decapodes = "679ab3ea-c928-4fe6-8d59-fd451142d391"
+DiagrammaticEquations = "6f00c28b-6bed-4403-80fa-30e0dc12f317"
+Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f"
+GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326"
+LinearAlgebra = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e"
+OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed"
+StaticArrays = "90137ffa-7385-5640-81b9-e52037218182"
 
 [extensions]
 CatlabExt = ["Catlab", "ACSets"]
+DecapodesExt = ["DiagrammaticEquations", "Decapodes", "ACSets", "CombinatorialSpaces", "JSON3", "StaticArrays", "LinearAlgebra", "ComponentArrays", "Distributions", "CoordRefSystems", "GeometryBasics", "OrdinaryDiffEq"]
 
 [compat]
-Catlab = "0.17.2"
+Catlab = "0.17.3"
 HTTP = "1.10.19"
+JSON3 = "1.14.3"
 MLStyle = "0.4.17"
 Oxygen = "1.7.5"
 Reexport = "1.2.2"
 StructTypes = "1.11.0"
+TOML = "1.0.3"
 julia = "1.11"

…xt/decapodes-service/DecapodesService.jl …interop/ext/DecapodesExt/DecapodesExt.jlpackages/algjulia-interop/ext/decapodes-service/DecapodesService.jl renamed to packages/algjulia-interop/ext/DecapodesExt/DecapodesExt.jl packages/algjulia-interop/ext/decapodes-service/DecapodesService.jl renamed to packages/algjulia-interop/ext/DecapodesExt/DecapodesExt.jl

@@ -1,4 +1,4 @@
-module DecapodesService
+module DecapodesExt 
 
 import Base: run
 
@@ -24,32 +24,42 @@ Point3D = Point3{Float64}
 # simulation
 using OrdinaryDiffEq
 
-using ..CatColabInterop
-using ..CatColabInterop: AlgebraicJuliaIntegration, AbstractDiagram, AbstractAnalysis
-import ..CatColabInterop: Model, ObGenerator, MorGenerator, DiagramObGenerator, DiagramMorGenerator
+
+using CatColabInterop, Oxygen, HTTP
+import CatColabInterop: Model, ModelDiagram, ObGenerator, MorGenerator, DiagramObGenerator, DiagramMorGenerator
+import CatColabInterop: endpoint
 
 # necessary to export
 export infer_types!, evalsim, default_dec_generate, default_dec_matrix_generate, DiagonalHodge, ComponentArray
 
-struct ThDecapode <: AlgebraicJuliaIntegration end
-export ThDecapode
+include("interop.jl")
 
 # functions for geometry and initial conditions
 include("geometry.jl")
 
-# responsible for constructing a valid model 
-include("model.jl")
-
 # helper functions for Navier-Stokes
 include("ns_helper.jl")
 
 # constructing initial conditions
 include("initial_conditions.jl")
 
-# parses a payload to a valid analysis 
-include("parse.jl")
+# constructs a simulation from the payload
+include("simulation.jl")
 
 # executes the analysis 
 include("execute.jl")
 
+"""
+"""
+function endpoint(::Val{:DecapodeSimulation})
+    @post "/decapodes-simulation" function(req::HTTP.Request)
+        payload = json(req, ModelDiagrma)
+        simulation = DecapodesSimulation(payload)
+        sim = evalsim(simulation.pode)
+        f = sim(simulation.geometry.dualmesh, simulation.generate, DiagonalHodge())
+        res = run(f, simulation, ComponentArray(k=0.5,))
+        sim_to_json(res)
+    end
+end
+
 end

…interop/ext/decapodes-service/execute.jl …ulia-interop/ext/DecapodesExt/execute.jlpackages/algjulia-interop/ext/decapodes-service/execute.jl renamed to packages/algjulia-interop/ext/DecapodesExt/execute.jl packages/algjulia-interop/ext/decapodes-service/execute.jl renamed to packages/algjulia-interop/ext/DecapodesExt/execute.jl

@@ -83,11 +83,16 @@ function Geometry(json_object::AbstractDict)
     Geometry(domain)
 end
 
-function Geometry(payload::DiagramPayload{ThDecapode})
-    domain = PREDEFINED_MESHES[Symbol(payload.data[:mesh])]
+function Geometry(analysis::Analysis)
+    domain = PREDEFINED_MESHES[Symbol(analysis.analysis[:mesh])]
     Geometry(domain)
 end
 
+# function Geometry(payload::DiagramPayload{ThDecapode})
+#     domain = PREDEFINED_MESHES[Symbol(payload.data[:mesh])]
+#     Geometry(domain)
+# end
+
 # function Geometry(d::Domain, args...)
 #     throw(ImplError("The mesh ($(d)) is"))
 # end

…nterop/ext/decapodes-service/geometry.jl …lia-interop/ext/DecapodesExt/geometry.jlpackages/algjulia-interop/ext/decapodes-service/geometry.jl renamed to packages/algjulia-interop/ext/DecapodesExt/geometry.jl packages/algjulia-interop/ext/decapodes-service/geometry.jl renamed to packages/algjulia-interop/ext/DecapodesExt/geometry.jl

@@ -80,7 +80,7 @@ end
 
 function initial_conditions(ics::GaussianIC, geometry::Geometry)
     c_dist = MvNormal(ics.ξ)
-    c = [pdf(c_dist, [p[1], p[2]]) for p ∈ geometry.dualmesh[:point]]
+    c = [Distributions.pdf(c_dist, [p[1], p[2]]) for p ∈ geometry.dualmesh[:point]]
     return c
 end
 

…/decapodes-service/initial_conditions.jl …p/ext/DecapodesExt/initial_conditions.jlpackages/algjulia-interop/ext/decapodes-service/initial_conditions.jl renamed to packages/algjulia-interop/ext/DecapodesExt/initial_conditions.jl packages/algjulia-interop/ext/decapodes-service/initial_conditions.jl renamed to packages/algjulia-interop/ext/DecapodesExt/initial_conditions.jl

@@ -0,0 +1,86 @@
+# TODO change to Analysis
+
+@kwdef mutable struct DecapodeDiagram
+    pode::SummationDecapode = SummationDecapode(parse_decapode(quote end))
+    scalars::Dict{Symbol, String} = Dict{Symbol, String}()
+    vars::Dict{String, Int} = Dict{String, Int}()
+    nc::Dict{Int, String} = Dict{Int, String}()
+end
+
+function Base.push!(diagram::DecapodeDiagram, analysis::Analysis, ob::DiagramObGenerator)
+    model_elem = only(filter(x->x.id==ob.over.content, analysis.model.obGenerators))
+    name = if isempty(ob.label)
+        id = isempty(keys(diagram.nc)) ? 1 : maximum(keys(diagram.mc)) + 1
+        push!(diagram.nc, id => "")
+        Symbol("•$id")
+    else
+        Symbol(join(string.(ob.label),"."))
+    end
+    id = add_part!(diagram.pode, :Var, name=name, type=nameof(model_elem))
+    push!(diagram.vars, ob.id => id)
+    diagram
+end
+
+# TODO remove only when we have multiple source/targets
+function mor_dom(diagram::Diagram, mor::DiagramMorGenerator)
+    filter(ob -> ob.id == mor.dom.content, diagram.obGenerators) |> only
+end
+
+function mor_cod(diagram::Diagram, mor::DiagramMorGenerator)
+    filter(ob -> ob.id == mor.dom.content, diagram.obGenerators) |> only
+end
+
+function Base.nameof(model::Model, mor::DiagramMorGenerator)
+    model_mor = filter(m -> m.id == mor.over.content, model.morGenerators) |> only
+    join(model_mor.label, ".") # TODO
+end
+
+function Base.push!(diagram::DecapodeDiagram, analysis::Analysis, mor::DiagramMorGenerator)
+    dom = mor_dom(analysis.diagram, mor) # get ObGenerator
+    cod = mor_cod(analysis.diagram, mor)
+    dom_id = check_endpoint!(diagram, dom)
+    cod_id = check_endpoint!(diagram, cod)
+    # get the name of the Op1 and add it to the model
+    op1 = nameof(analysis.model, mor)
+    add_part!(diagram.pode, :Op1, src=dom_id, tgt=cod_id, op1=op1)
+    if op1 == :∂ₜ
+        add_part!(diagram.pode, :TVar, incl=cod_id)
+    end
+    if mor.morType.content isa JSON3.Object
+        scalar = analysis.model.mor_generators[mor.over.content]
+        push!(diagram.scalars, scalar.label => mor.over.content)
+    end
+    diagram
+end
+
+function DecapodeDiagram(analysis::Analysis)
+    diagram = DecapodeDiagram()
+    for ob in analysis.diagram.obGenerators
+        push!(diagram, analysis, ob)
+    end
+    for mor in analysis.diagram.morGenerators
+        push!(diagram, analysis, mor)
+    end
+    return diagram
+end
+
+function check_endpoint!(diagram::DecapodeDiagram, endpoint::DiagramObGenerator)
+    if haskey(diagram.vars, endpoint.id)
+        diagram.vars[endpoint.id]
+    else
+        if endpoint.id ∉ values(diagram.nc)
+            id = isempty(keys(diagram.nc)) ? 1 : length(keys(diagram.nc)) + 1
+            name = Symbol("•$id")
+            acset_id = add_part!(diagram.pode, :Var, name=name, type=:infer)
+            push!(diagram.nc, acset_id => endpoint.label)
+            acset_id
+        else
+            out = filter(x -> x[2] == endpoint, pairs(diagram.nc))
+            first(keys(out))
+        end
+    end
+end
+
+function uuid_to_symb(decapode::SummationDecapode, vars::Dict{String, Int})
+    Dict([key => (subpart(decapode, vars[key], :name)) for key ∈ keys(vars)])
+end

packages/algjulia-interop/ext/DecapodesExt/interop.jl

@@ -0,0 +1,70 @@
+# =======================================================================
+
+"""    DecapodeSimulation
+
+This analysis contains the data necessary to execute a simulation.
+"""
+struct DecapodeSimulation
+    pode::SummationDecapode
+    plotVariables::Dict{String, Bool}
+    scalars::Dict{Symbol, Any} # closures
+    geometry::Geometry
+    init::ComponentArray
+    generate::Any
+    uuiddict::Dict{Symbol, String}
+    duration::Int
+end
+export DecapodeSimulation
+
+function DecapodeSimulation(path::String; kwargs...)
+    payload = JSON3.read(path, Analysis)
+    DecapodeSimulation(payload; kwargs...)
+end
+
+# TODO we need to amend this so other parameters are provided
+function DecapodeSimulation(analysis::Analysis; hodge=GeometricHodge())
+    wrapped = DecapodeDiagram(analysis)
+    plotVars = @match analysis.analysis[:plotVariables] begin
+        vars::AbstractArray => Dict{String, Bool}(key => key ∈ vars for key ∈ keys(wrapped.vars))
+        vars => Dict{String, Bool}( "$key" => var for (key, var) in vars) # TODO
+    end
+    dot_rename!(wrapped.pode)
+    uuid2symb = uuid_to_symb(wrapped.pode, wrapped.vars)
+    geometry = Geometry(analysis)
+    ♭♯_m = ♭♯_mat(geometry.dualmesh)
+    wedge_dp10 = dec_wedge_product_dp(Tuple{1,0}, geometry.dualmesh)
+    dual_d1_m = dec_dual_derivative(1, geometry.dualmesh)
+    star0_inv_m = dec_inv_hodge_star(0, geometry.dualmesh, hodge)
+    Δ0 = Δ(0,geometry.dualmesh)
+    #fΔ0 = factorize(Δ0);
+    function sys_generate(s, my_symbol)
+        op = @match my_symbol begin
+            sym && if haskey(wrapped.scalars, sym) end => x -> begin
+                k = scalars[wrapped.scalars[sym]]
+                k * x
+            end
+            :♭♯ => x -> ♭♯_m * x
+            :dpsw => x -> wedge_dp10(x, star0_inv_m*(dual_d1_m*x))
+            :Δ⁻¹ => x -> begin
+                y = Δ0 \ x
+                y .- minimum(y)
+            end
+            _ => default_dec_matrix_generate(s, my_symbol, hodge)
+        end
+        return (args...) -> op(args...)
+    end
+    #
+    @info analysis.analysis[:initialConditions] 
+    u0 = initial_conditions(analysis.analysis[:initialConditions], geometry, uuid2symb)
+
+    # reversing `uuid2symb` into `symbol => uuid.` we need this to reassociate the var to its UUID 
+    symb2uuid = Dict([v => k for (k,v) in pairs(uuid2symb)])
+
+    # TODO what is anons doing here?
+    anons = Dict{Symbol, Any}()
+    DecapodeSimulation(wrapped.pode, plotVars, wrapped.scalars, geometry, u0, sys_generate, symb2uuid, analysis.analysis[:duration])
+end
+
+Base.show(io::IO, system::DecapodeSimulation) = println(io, system.pode)
+
+