Class based

.gitignore

@@ -5,4 +5,5 @@ docs/site/
 .DS_Store
 benchmark/tune.json
 docs/Manifest.toml
+types-old.jl
 .vscode

Project.toml

@@ -4,6 +4,7 @@ version = "0.9.5-DEV"
 
 [deps]
 CSVFiles = "5d742f6a-9f54-50ce-8119-2520741973ca"
+Classes = "1a9c1350-211b-5766-99cd-4544d885a0d1"
 Compose = "a81c6b42-2e10-5240-aca2-a61377ecd94b"
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"
 DataStructures = "864edb3b-99cc-5e75-8d2d-829cb0a9cfe8"

docs/src/internals/composite_components.md

@@ -0,0 +1,82 @@
+# Composite Components
+
+## Goals
+
+In Mimi v0.4, we have two levels of model elements, (i) `Model` and (ii) `Component`. (For now, we ignore the distinction between model / component "definition" and "instance" types.) The primary goal of the `MetaComponent` construct is to extend this structure recursively to _N_ levels, by allowing a `MetaComponent` to contain other `MetaComponent`s as well as `LeafComponent`s, which cannot contain other components.
+
+## Major elements
+This suggests three types of elements:
+
+1. `LeafComponent(Def|Instance)` -- equivalent to the Mimi v0.4 `Component(Def|Instance)` concept.
+
+1. `MetaComponent(Def|Instance)` -- presents the same API as a `LeafComponent(Def|Instance)`, but the variables and parameters it exposes are the aggregated sets of variables and parameters exposed by its components, each of which can be a `MetaComponent` or `LeafComponent`. A `MetaComponentInstance` creates no new storage for variables and parameters; it references the storage in its internal components. By default, the `run_timestep` method of a `MetaComponentInstance` simply calls the `run_timestep` method of each of its internal components in dependency order. 
+
+1. `Model` -- Contains a top-level `MetaComponentInstance` that holds all the actual user-defined components, which are instances of `MetaComponentInstance` or `LeafComponentInstance`. The API for `Model` delegates some calls to its top-level `MetaComponentInstance` while providing additional functionality including running a Monte Carlo simulation.
+
+## Implementation Notes
+
+### Model
+
+* A `Model` will be defined using the `@defmodel` macro.
+
+* As with the currently defined (but not exported) `@defmodel`, component ordering will be determined automatically based on defined connections, with loops avoided by referencing timestep `[t-1]`. This simplifies the API for `addcomponent!`.
+
+* We will add support for two optional functions defined inside `@defmodel`:
+  * `before(m::Model)`, called before the model runs its first timestep
+  * `after(m:Model)`, called after the model runs its final timestep.
+
+* A `Model` will be implemented as a wrapper around a single top-level `MetaComponent` that handles the ordering and iteration over sub-components. (In an OOP language, `Model` would subclass `MetaComponent`, but in Julia, we use composition.)
+
+![MetaComponent Schematic](../figs/Mimi-model-schematic-v3.png)
+
+
+### MetaComponent
+
+* Defined using `@defcomp` as with `LeafComponent`. It's "meta" nature is defined by including a new term:
+
+    `subcomps = [sc1, sc2, sc3, ...]`, where the referenced sub-components (`sc1`, etc.) refer to previously defined `ComponentId`s.
+
+* A `MetaComponent`'s `run_timestep` function is optional. The default function simply calls `run_timestep(subcomps::Vector)` to iterate over sub-components and calls `run_timestep` on each. If a `MetaComponent` defines its own `run_timestep` function, it should either call `run_timestep` on the vector of sub-components or perform a variant of this function itself.
+
+* The `@defcomp` macro allows definition of an optional `init` method. To this, we will add support for an `after` method as in `@defmodel`. We will allow `before` as an alias for `init` (perhaps with a deprecation) for consistency with `@defmodel`.
+
+## Other Notes
+
+* Currently, `run()` calls `_run_components(mi, clock, firsts, lasts, comp_clocks)` with simple vectors of firsts, lasts, and comp_clocks. To handle this with the recursive component structure:
+
+  * Aggregate from the bottom up building `_firsts` and `_lasts` in each `MetaComponentInstance` holding the values for its sub-components.
+
+  * Also store the `MetaComponentInstance`'s own summary `first` and `last` which are just `min(firsts)` and `max(lasts)`, respectively.
+
+* Currently, the `run()` function creates a vector of `Clock` instances, corresponding to each model component. I see two options here:
+
+  1. Extend the current approach to have each `MetaComponentInstance` hold a vector of `Clock` instances for its sub-components.
+
+  2. Store a `Clock` instance with each `MetaComponentInstance` or `LeafComponentInstance` and provide a recursive method to reset all clocks.
+
+
+### Other stuff
+
+* This might be is a good time to reconsider the implementation of external parameters. The main question is about naming these and whether they need to be globally unique or merely unique within a (meta) component.
+
+* Unit conversion components should be simple "multiplier" components that are bound with specific conversion factors, conceptually like a "closure" on a component.
+
+* An "identity" component takes an input (external input, bound constant) and allows multiple components to access it. One issue is how to handle the type of argument. Could function wrappers be useful here?
+  * Identity is simply a unit conversion of 1.
+
+* If > 1 component exports parameters of the same name, it's an error. At least one comp must rename.
+
+* David suggested making composite comps immutable, generating a new one each time a change is made. (Why not just have the CompositeComponentInstance be immutable?)
+
+## Notes from 9/21/18 Meeting
+
+```
+@defcomp foo begin
+  Component(bar; export=[var_1, var_2, param_1])
+  Component(Mimi.adder, comp_1;         # rename locally as :comp_1
+            bind=[par_3 => 5,           # set a parameter to a fixed value
+                  par_4 => bar.var_1])  # connect a parameter to a variable
+
+
+end
+```

examples/tutorial/02-two-region-model/two-region-model.jl

@@ -12,16 +12,17 @@ function construct_MyModel()
 
 	m = Model()
 
-	set_dimension!(m, :time, collect(2015:5:2110))
-	set_dimension!(m, :regions, [:Region1, :Region2, :Region3])	 # Note that the regions of your model must be specified here
+	set_dimension!(m, :time, 2015:5:2110)
+	# Note that the regions of your model must be specified here
+	set_dimension!(m, :regions, [:Region1, :Region2, :Region3])
 
 	add_comp!(m, grosseconomy)
 	add_comp!(m, emissions)
 
 	set_param!(m, :grosseconomy, :l, l)
 	set_param!(m, :grosseconomy, :tfp, tfp)
 	set_param!(m, :grosseconomy, :s, s)
-	set_param!(m, :grosseconomy, :depk,depk)
+	set_param!(m, :grosseconomy, :depk, depk)
 	set_param!(m, :grosseconomy, :k0, k0)
 	set_param!(m, :grosseconomy, :share, 0.3)
 

src/Mimi.jl

@@ -1,5 +1,6 @@
 module Mimi
 
+using Classes
 using DataFrames
 using DataStructures
 using Distributions
@@ -11,9 +12,10 @@ using StringBuilders
 export
     @defcomp,
     @defsim,
+    @defcomposite,
     MarginalModel,
     Model,
-    add_comp!,  
+    add_comp!,
     components,
     connect_param!,
     create_marginal_model,
@@ -48,47 +50,37 @@ export
     variable_dimensions,
     variable_names
 
-include("core/types.jl")
-
-# After loading types, the rest can just be alphabetical
+include("core/delegate.jl")
+include("core/types/includes.jl")
+#
+# After loading types and delegation macro, the rest can be loaded in any order.
+#
 include("core/build.jl")
 include("core/connections.jl")
 include("core/defs.jl")
 include("core/defcomp.jl")
+include("core/defmodel.jl")
+include("core/defcomposite.jl")
 include("core/dimensions.jl")
 include("core/instances.jl")
 include("core/references.jl")
 include("core/time.jl")
+include("core/time_arrays.jl")
 include("core/model.jl")
+include("core/order.jl")
+include("core/paths.jl")
+include("core/show.jl")
+
 include("mcs/mcs.jl") # need mcs types for explorer
 include("explorer/explore.jl")
-include("utils/graph.jl")
-include("utils/plotting.jl")
 include("utils/getdataframe.jl")
+include("utils/graph.jl")
 include("utils/lint_helper.jl")
 include("utils/misc.jl")
+include("utils/plotting.jl")
 
-"""
-    load_comps(dirname::String="./components")
-
-Call include() on all the files in the indicated directory `dirname`.
-This avoids having modelers create a long list of include()
-statements. Just put all the components in a directory.
-"""
-function load_comps(dirname::String="./components")
-    files = readdir(dirname)
-    for file in files
-        if endswith(file, ".jl")
-            pathname = joinpath(dirname, file)
-            include(pathname)
-        end
-    end
-end
-
-# Components are defined here to allow pre-compilation to work
-function __init__()
-    compdir = joinpath(@__DIR__, "components")
-    load_comps(compdir)
-end
+# Load built-in components
+include("components/adder.jl")
+include("components/connector.jl")
 
 end # module

src/components/adder.jl

@@ -1,7 +1,5 @@
 using Mimi
 
-# When evaluated in the __init__() function, the surrounding module
-# is Main rather than Mimi.
 @defcomp adder begin
     add    = Parameter(index=[time])
     input  = Parameter(index=[time])

src/core/_preliminary.jl

@@ -0,0 +1,42 @@
+# Preliminary file to think through David's suggestion of splitting defs between "registered" 
+# readonly "templates"  and user-constructed models so it's clear which functions operate on 
+# templates vs defs within a model.
+
+@class ComponentDef <: NamedObj begin
+    comp_id::Union{Nothing, ComponentId}
+    variables::OrderedDict{Symbol, VariableDef}
+    parameters::OrderedDict{Symbol, ParameterDef}
+    dim_names::Set{Symbol}
+end
+
+@class CompositeComponentDef <: ComponentDef begin
+    comps_dict::OrderedDict{Symbol, AbstractComponentDef}
+    exports::ExportsDict
+    internal_param_conns::Vector{InternalParameterConnection}
+    external_params::Dict{Symbol, ModelParameter}
+end
+
+# Define these for building out a ModelDef, which reference the
+# central definitions using the classes above.
+
+@class mutable ModelComponentDef <: NamedObj begin
+    comp_id::ComponentId    # references registered component def
+    comp_path::Union{Nothing, ComponentPath}
+    dim_dict::OrderedDict{Symbol, Union{Nothing, Dimension}}
+    first::Union{Nothing, Int}
+    last::Union{Nothing, Int}
+    is_uniform::Bool
+end
+
+@class mutable ModelCompositeComponentDef <: ModelComponentDef begin
+    comps_dict::OrderedDict{Symbol, AbstractModelComponentDef}
+    bindings::Vector{Binding}
+    exports::ExportsDict
+    external_param_conns::Vector{ExternalParameterConnection}
+    external_params::Dict{Symbol, ModelParameter}
+
+    # Names of external params that the ConnectorComps will use as their :input2 parameters.
+    backups::Vector{Symbol}
+
+    sorted_comps::Union{Nothing, Vector{Symbol}}
+end