CLEANUP: changing tests

Author: quffaro

packages/algjulia-interop/src/CatColabInterop.jl

@@ -1,79 +1,33 @@
 module CatColabInterop
 
+import Base: run
+using JSON3
 using MLStyle
 using Reexport
 
-const Maybe{T} = Union{T, Nothing}
-
-struct QualifiedName
-    segments::Vector{String}
-    QualifiedName() = new([])
-    QualifiedName(str::String) = new([str])
-end
-
-Base.isempty(name::QualifiedName) = isempty(name.segments)
-Base.join(name::QualifiedName) = join(name.segments, ".")
-Base.convert(::Type{QualifiedName}, str::String) = QualifiedName(str)
-
-Core.Symbol(name::QualifiedName) = Symbol("$(String(name))")
-
-struct QualifiedLabel
-    segments::Vector{String}
-    QualifiedLabel() = new([])
-    QualifiedLabel(str::String) = new([str])
-    QualifiedLabel(segments::Vector{String}) = new(segments)
-end
-
-# I want to promote the qualified label to Maybe
-Core.String(name::QualifiedLabel) = join(name)
-Core.Symbol(name::QualifiedLabel) = Symbol("$(String(name))")
-
-Base.isempty(name::QualifiedLabel) = isempty(name.segments)
-Base.join(name::QualifiedLabel) = join(name.segments, ".")
-
-Base.convert(::Type{String}, name::QualifiedLabel) = join(name)
-Base.convert(::Type{QualifiedLabel}, data::T) where T<:AbstractVector = QualifiedLabel(String.(data))
-
-
-
 # this code tracks integrations and allows for basic theory/model-building code to dispatch from it.
 # the intent is that this is an interface for AlgebraicJulia code to interoperate with CatColab 
 abstract type AlgebraicJuliaIntegration end 
 
-""" 
-Functions to build a dictionary associating ids in the theory to elements in the model
-"""
-function to_model end
-export to_model
-
-abstract type AbstractAnalysis{T<:AlgebraicJuliaIntegration} end
-
-# an analysis is something that we run
-function run(::AbstractAnalysis{T}) where T end
+#= These files are responsible for parsing the model and diagram in the CCL payload =#
+include("qualified_name.jl")
+include("model.jl")
+include("diagram.jl")
+include("payload.jl") # payload and analysis are here
 
 struct ImplError <: Exception
     name::String
 end
 export ImplError
-
 Base.showerror(io::IO, e::ImplError) = print(io, "$(e.name) not implemented")
 
-# utility
-include("result.jl")
-
-# kernel
-include("kernel/kernel_management.jl")
-include("kernel/kernel_support.jl")
-
-# ccl
-include("model.jl")
-include("diagram.jl")
-include("payload.jl")
-# this is actually the analysis
-
+# Kernel utilities
+include("kernel/KernelUtility.jl")
 
+#= The Decapodes service contains an analysis =#
 include("decapodes-service/DecapodesService.jl")
 
+@reexport using .KernelUtility
 @reexport using .DecapodesService
 
 end

packages/algjulia-interop/src/decapodes-service/DecapodesService.jl

@@ -17,29 +17,37 @@ using Distributions # for initial conditions
 # meshing
 using CoordRefSystems
 using GeometryBasics: Point2, Point3
-Point3D = Point3{Float64};
+Point3D = Point3{Float64}
 
 # simulation
 using OrdinaryDiffEq
 
 using ..CatColabInterop
 using ..CatColabInterop: AlgebraicJuliaIntegration, AbstractDiagram, AbstractAnalysis
-import ..CatColabInterop: Model, to_model, ObGenerator, MorGenerator, DiagramObGenerator, DiagramMorGenerator
+import ..CatColabInterop: Model, ObGenerator, MorGenerator, DiagramObGenerator, DiagramMorGenerator
 
 # necessary to export
-export infer_types!, evalsim, default_dec_generate, default_dec_matrix_generate,
-    DiagonalHodge, ComponentArray
+export infer_types!, evalsim, default_dec_generate, default_dec_matrix_generate, DiagonalHodge, ComponentArray
 
 struct ThDecapode <: AlgebraicJuliaIntegration end
 export ThDecapode
 
-struct ObTag end
-struct HomTag end
-
-# # funcitons for geometry and initial conditions
+# functions for geometry and initial conditions
 include("geometry.jl")
-include("model.jl") ## model-building
-include("diagram.jl") ## diagram-building
-include("analysis/Analysis.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")
+
+# executes the analysis 
+include("execute.jl")
 
 end

packages/algjulia-interop/src/decapodes-service/diagram.jl

@@ -1,3 +1,7 @@
+"""    DecapodeSimulation
+
+This analysis contains the data necessary to execute a simulation.
+"""
 struct DecapodeSimulation <: AbstractAnalysis{ThDecapode}
     diagram::ModelDiagramPresentation{ThDecapode}
     model::Model{ThDecapode}
@@ -10,12 +14,9 @@ function DecapodeSimulation(path::String; hodge=GeometricHodge())
     DecapodeSimulation(payload)
 end
 
-#=
-Simulation: Payload => Analysis 
-=#
 function DecapodeSimulation(payload::Payload; hodge=GeometricHodge())
     pode = DecapodeDiagram(payload)
-    plotVars = @match payload.data[:plotVariables] begin
+    plotVars = @match payload[:plotVariables] begin
         vars::AbstractArray => Dict{String, Bool}(key => key ∈ vars for key ∈ keys(pode.vars))
         vars => Dict{String, Bool}( "$key" => var for (key, var) in vars)
     end
@@ -46,11 +47,12 @@ function DecapodeSimulation(payload::Payload; hodge=GeometricHodge())
         return (args...) -> op(args...)
     end
     #
-    u0 = initial_conditions(payload.data[:initialConditions], geometry, uuid2symb)
+    u0 = initial_conditions(payload[: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}()
     data = Dict(
         :pode => pode.pode,
@@ -60,17 +62,23 @@ function DecapodeSimulation(payload::Payload; hodge=GeometricHodge())
         :init => u0,
         :generate => sys_generate,
         :uuiddict => symb2uuid,
-        :duration => payload.data[:duration])
+        :duration => payload[:duration])
     return DecapodeSimulation(payload.diagram, payload.model, data)
 end
 
-Base.show(io::IO, system::DecapodeSimulation) = println(io, system.data[:pode])
+Base.show(io::IO, system::DecapodeSimulation) = println(io, system[:pode])
+
+Base.getindex(system::DecapodeSimulation, field::Symbol) = system.data[field]
+
+points(system::DecapodeSimulation) = collect(values(system[:geometry].dualmesh.subparts.point.m))
+indexing_bounds(system::DecapodeSimulation) = indexing_bounds(system[:geometry].domain)
 
-points(system::DecapodeSimulation) = collect(values(system.data[:geometry].dualmesh.subparts.point.m))
-indexing_bounds(system::DecapodeSimulation) = indexing_bounds(system.data[:geometry].domain)
+import Base: run
 
-function Base.run(fm, u0, t0, constparam)
-    prob = ODEProblem(fm, u0, (0, t0), constparam)
+"""
+"""
+function Base.run(fm, sim::DecapodeSimulation, constparam)
+    prob = ODEProblem(fm, sim[:init], sim[:duration], constparam)
     solve(prob, Tsit5(), saveat=0.01)
 end
 export run

…decapodes-service/analysis/simulation.jl …interop/src/decapodes-service/execute.jlpackages/algjulia-interop/src/decapodes-service/analysis/simulation.jl renamed to packages/algjulia-interop/src/decapodes-service/execute.jl packages/algjulia-interop/src/decapodes-service/analysis/simulation.jl renamed to packages/algjulia-interop/src/decapodes-service/execute.jl

@@ -1,28 +1,15 @@
-# Build the model
-
-export Model
-
-# """ 
-# A model for the Decapodes integration is the same as the default Model method. 
-# A dictionary mapping UUID strings with ModelElements is instantiated. 
-# """
-# Model(::ThDecapode) = Model{ThDecapode}(Dict{String, ModelElement}())
+#= Build the model
 
+A model for the Decapodes integration is the same as the default Model method. 
+A dictionary mapping UUID strings with ModelElements is instantiated. 
+=#
 function ObGenerator(::ThDecapode, obgen::AbstractDict)
     ObGenerator(obgen[:id], ob_name(ThDecapode(), obgen[:label]), obgen[:obType])
 end
 export ObGenerator
 
-# XXX the use of an `only` here means we're being hostile to multiarrows
-function MorGenerator(::ThDecapode, ob_generators::Vector{ObGenerator}, morgen::AbstractDict)
-    dom = only(filter(ob -> ob.id == morgen[:dom][:content], ob_generators))
-    cod = only(filter(ob -> ob.id == morgen[:cod][:content], ob_generators))
-    MorGenerator(morgen[:id], mor_name(ThDecapode(), morgen[:label]), morgen[:morType], dom, cod)
-end
-export MorGenerator
-
 """ Helper function to convert CatColab values (Obs) in Decapodes """
-function ob_name(model::ThDecapode,  name::String)
+function ob_name(model::ThDecapode, name::String)
     @match lowercase(name) begin
         "0-form" => :Form0
         "1-form" => :Form1
@@ -36,11 +23,20 @@ function ob_name(model::ThDecapode,  name::String)
         x => throw(ImplError(x))
     end
 end
-ob_name(model::ThDecapode, name::AbstractVector) = 
-    ob_name(model, join(String.(name), ""))
+export ob_name
+
+ob_name(model::ThDecapode, name::AbstractVector) = ob_name(model, join(String.(name), ""))
+
+# XXX the use of an `only` here means we're being hostile to multiarrows
+function MorGenerator(::ThDecapode, ob_generators::Vector{ObGenerator}, morgen::AbstractDict)
+    dom = only(filter(ob -> ob.id == morgen[:dom][:content], ob_generators))
+    cod = only(filter(ob -> ob.id == morgen[:cod][:content], ob_generators))
+    MorGenerator(morgen[:id], mor_name(ThDecapode(), morgen[:label]), morgen[:morType], dom, cod)
+end
+export MorGenerator
 
 """ Helper function to convert CatColab values (Homs) in Decapodes """
-function mor_name(model::ThDecapode,  name::String)
+function mor_name(model::ThDecapode, name::String)
     @match replace(name," " => "") begin
         "∂t" || "∂ₜ" => :∂ₜ
         "Δ" => :Δ
@@ -58,6 +54,7 @@ function mor_name(model::ThDecapode,  name::String)
         x => throw(ImplError(x))
     end
 end
+export mor_name
 
 mor_name(model::ThDecapode, name::AbstractVector) = mor_name(model, join(String.(name), ""))
 

…s-service/analysis/initial_conditions.jl …/decapodes-service/initial_conditions.jlpackages/algjulia-interop/src/decapodes-service/analysis/initial_conditions.jl renamed to packages/algjulia-interop/src/decapodes-service/initial_conditions.jl packages/algjulia-interop/src/decapodes-service/analysis/initial_conditions.jl renamed to packages/algjulia-interop/src/decapodes-service/initial_conditions.jl

@@ -1,5 +1,7 @@
-include("ns_helper.jl")
-include("initial_conditions.jl")
+
+function uuid_to_symb(decapode::SummationDecapode, vars::Dict{String, Int})
+    Dict([key => (subpart(decapode, vars[key], :name)) for key ∈ keys(vars)])
+end
 
 #=
 We produce a ModelDiagramPresentation and Analysis data from the CCL payload.
@@ -56,31 +58,6 @@ function DecapodeDiagram(payload::Payload)
     return pode
 end
 
-# TODO move to diagram
-function Base.nameof(model::Model, ob::DiagramObGenerator)
-    if isnothing(ob.over)
-        :no_name
-    else
-        nameof(model.ob_generators[ob.over.content])
-    end
-end
-
-function Base.nameof(model::Model, mor::DiagramMorGenerator)
-    if isnothing(mor.over)
-        :no_name
-    else
-        nameof(model.mor_generators[mor.over.content])
-    end
-end
-
-function Base.nameof(model::Model, content::AbstractDict)
-    if isnothing(content[:over])
-        :no_name
-    else
-        Symbol(model.data[content[:over][:content]].name)
-    end
-end
-
 # endpoint being `dom` or `codom`
 function check_endpoint!(diagram::DecapodeDiagram, endpoint::DiagramObGenerator)
     if haskey(diagram.vars, endpoint.id)
@@ -99,4 +76,3 @@ function check_endpoint!(diagram::DecapodeDiagram, endpoint::DiagramObGenerator)
     end
 end
 
-include("simulation.jl")

packages/algjulia-interop/src/decapodes-service/model.jl

@@ -17,9 +17,14 @@ function DiagramObGenerator(data::AbstractDict)
 end
 
 Base.nameof(ob::DiagramObGenerator) = ob.label
-
-Base.getindex(obs::Vector{MorGenerator}, id::String) = 
-only(filter(ob -> ob.id == id, obs))
+function Base.nameof(model::Model, ob::DiagramObGenerator)
+    if isnothing(ob.over)
+        :no_name
+    else
+        nameof(model.ob_generators[ob.over.content])
+    end
+end
+Base.getindex(obs::Vector{MorGenerator}, id::String) = only(filter(ob -> ob.id == id, obs))
 
 """ Struct defining an morphism generator """
 struct DiagramMorGenerator 
@@ -40,10 +45,14 @@ function DiagramMorGenerator(data::AbstractDict; obs::Vector{DiagramObGenerator}
 end
 
 Base.nameof(mor::DiagramMorGenerator) = mor.label
-
-Base.getindex(mors::Vector{MorGenerator}, id::String) = 
-only(filter(mor -> mor.id == id, mors))
-
+function Base.nameof(model::Model, mor::DiagramMorGenerator)
+    if isnothing(mor.over)
+        :no_name
+    else
+        nameof(model.mor_generators[mor.over.content])
+    end
+end
+Base.getindex(mors::Vector{MorGenerator}, id::String) = only(filter(mor -> mor.id == id, mors))
 
 """ Struct wrapping a dictionary """
 struct ModelDiagramPresentation{T<:AlgebraicJuliaIntegration}
@@ -54,7 +63,7 @@ struct ModelDiagramPresentation{T<:AlgebraicJuliaIntegration}
 end
 export ModelDiagramPresentation
 
-function ModelDiagramPresentation(::T, data::JSON3.Object) where T
+function ModelDiagramPresentation(::T, data::AbstractDict) where T
     ob_generators = DiagramObGenerator.(data[:obGenerators])
     mor_generators = DiagramMorGenerator.(data[:morGenerators]; obs=ob_generators)
     ModelDiagramPresentation(T(), ob_generators, mor_generators)