From b523132247007978cb9b4d0a1d04d563a5e118f5 Mon Sep 17 00:00:00 2001 From: lrennels Date: Tue, 14 Apr 2020 13:54:38 -0700 Subject: [PATCH 01/11] Initial comments --- src/core/build.jl | 12 +++++++++--- src/core/types/instances.jl | 9 +++++---- 2 files changed, 14 insertions(+), 7 deletions(-) diff --git a/src/core/build.jl b/src/core/build.jl index c6693f756..e7995f259 100644 --- a/src/core/build.jl +++ b/src/core/build.jl @@ -241,9 +241,10 @@ function _instantiate_params(comp_def::ComponentDef, par_dict::Dict{Tuple{Compon return ComponentInstanceParameters(names, types, vals, paths) end -function _instantiate_params(comp_def::AbstractCompositeComponentDef, par_dict::Dict{Tuple{ComponentPath, Symbol}, Any}) - _combine_exported_pars(comp_def) -end +# LFR: commented out because potentially doing nothing ... never called +# function _instantiate_params(comp_def::AbstractCompositeComponentDef, par_dict::Dict{Tuple{ComponentPath, Symbol}, Any}) +# _combine_exported_pars(comp_def) +# end # Return a built leaf or composite LeafComponentInstance function _build(comp_def::ComponentDef, @@ -269,6 +270,11 @@ function _build(comp_def::AbstractCompositeComponentDef, # @info " par_dict $(par_dict)" comps = [_build(cd, var_dict, par_dict, time_bounds) for cd in compdefs(comp_def)] + + # LFR TODO + # vars_dict = get_vars_dict(comp_def) + # pars_dict = get_pars_dict(comp_def) + return CompositeComponentInstance(comps, comp_def, time_bounds) end diff --git a/src/core/types/instances.jl b/src/core/types/instances.jl index 5e5c58ef0..409c6d87f 100644 --- a/src/core/types/instances.jl +++ b/src/core/types/instances.jl @@ -189,8 +189,8 @@ end @class mutable CompositeComponentInstance <: ComponentInstance begin comps_dict::OrderedDict{Symbol, AbstractComponentInstance} - var_dict::OrderedDict{Symbol, Any} - par_dict::OrderedDict{Symbol, Any} + var_dict::OrderedDict{Symbol, UnnamedReference} + par_dict::OrderedDict{Symbol, UnnamedReference} function CompositeComponentInstance(self::AbstractCompositeComponentInstance, comps::Vector{<: AbstractComponentInstance}, @@ -203,8 +203,9 @@ end comps_dict[ci.comp_name] = ci end - var_dict = OrderedDict{Symbol, Any}() - par_dict = OrderedDict{Symbol, Any}() + # LFR TODO - will pass in the pardict and vardict from build + # var_dict = OrderedDict{Symbol, Any}() + # par_dict = OrderedDict{Symbol, Any}() ComponentInstance(self, comp_def, time_bounds, name) CompositeComponentInstance(self, comps_dict, var_dict, par_dict) From 51e08e3f97812a8168346ca2e1ad9eb78cfed45e Mon Sep 17 00:00:00 2001 From: lrennels Date: Thu, 16 Apr 2020 12:18:25 -0700 Subject: [PATCH 02/11] Change types and names; alter constructor --- src/core/build.jl | 10 +++++----- src/core/types/instances.jl | 12 +++++------- 2 files changed, 10 insertions(+), 12 deletions(-) diff --git a/src/core/build.jl b/src/core/build.jl index e7995f259..fdcb5802b 100644 --- a/src/core/build.jl +++ b/src/core/build.jl @@ -241,7 +241,7 @@ function _instantiate_params(comp_def::ComponentDef, par_dict::Dict{Tuple{Compon return ComponentInstanceParameters(names, types, vals, paths) end -# LFR: commented out because potentially doing nothing ... never called +# commented out because potentially doing nothing ... the fcn is never called # function _instantiate_params(comp_def::AbstractCompositeComponentDef, par_dict::Dict{Tuple{ComponentPath, Symbol}, Any}) # _combine_exported_pars(comp_def) # end @@ -272,10 +272,10 @@ function _build(comp_def::AbstractCompositeComponentDef, comps = [_build(cd, var_dict, par_dict, time_bounds) for cd in compdefs(comp_def)] # LFR TODO - # vars_dict = get_vars_dict(comp_def) - # pars_dict = get_pars_dict(comp_def) - - return CompositeComponentInstance(comps, comp_def, time_bounds) + variables = NamedTuple(Tuple(:var1, :var2), Tuple(1.0, 2.0)) + parameters = NamedTuple(Tuple(:par1, :par2), Tuple(1.0, 2.0)) + + return CompositeComponentInstance(comps, comp_def, time_bounds, variables, parameters) end """ diff --git a/src/core/types/instances.jl b/src/core/types/instances.jl index 409c6d87f..85a09bc97 100644 --- a/src/core/types/instances.jl +++ b/src/core/types/instances.jl @@ -189,13 +189,15 @@ end @class mutable CompositeComponentInstance <: ComponentInstance begin comps_dict::OrderedDict{Symbol, AbstractComponentInstance} - var_dict::OrderedDict{Symbol, UnnamedReference} - par_dict::OrderedDict{Symbol, UnnamedReference} + variables::NamedTuple + parameters::NamedTuple function CompositeComponentInstance(self::AbstractCompositeComponentInstance, comps::Vector{<: AbstractComponentInstance}, comp_def::AbstractCompositeComponentDef, time_bounds::Tuple{Int,Int}, + variables::NamedTuple, + parameters::NamedTuple, name::Symbol=nameof(comp_def)) comps_dict = OrderedDict{Symbol, AbstractComponentInstance}() @@ -203,12 +205,8 @@ end comps_dict[ci.comp_name] = ci end - # LFR TODO - will pass in the pardict and vardict from build - # var_dict = OrderedDict{Symbol, Any}() - # par_dict = OrderedDict{Symbol, Any}() - ComponentInstance(self, comp_def, time_bounds, name) - CompositeComponentInstance(self, comps_dict, var_dict, par_dict) + CompositeComponentInstance(self, comps_dict, variables, parameters) return self end From bb1e21de0a93c4d9dbfb9055d3af350d07afdf6e Mon Sep 17 00:00:00 2001 From: lrennels Date: Thu, 16 Apr 2020 12:36:34 -0700 Subject: [PATCH 03/11] Add skeleton functions for getting vars and pars --- src/core/build.jl | 21 ++++++++++++++++++--- 1 file changed, 18 insertions(+), 3 deletions(-) diff --git a/src/core/build.jl b/src/core/build.jl index fdcb5802b..05fff412a 100644 --- a/src/core/build.jl +++ b/src/core/build.jl @@ -271,13 +271,28 @@ function _build(comp_def::AbstractCompositeComponentDef, comps = [_build(cd, var_dict, par_dict, time_bounds) for cd in compdefs(comp_def)] - # LFR TODO - variables = NamedTuple(Tuple(:var1, :var2), Tuple(1.0, 2.0)) - parameters = NamedTuple(Tuple(:par1, :par2), Tuple(1.0, 2.0)) + variables = _get_variables(comp_def, var_dict) + parameters = _get_parameters(comp_def, par_dict) return CompositeComponentInstance(comps, comp_def, time_bounds, variables, parameters) end +# helper functions for to create the variables and parameters NamedTuples for a +# CompositeComponentInstance +function _get_variables(comp_def::AbstractCompositeComponentDef, var_dict::Dict{ComponentPath, Any}) + + # TODO (dummy below) + NT = NamedTuple(Tuple(:var1, :var2), Tuple(1.0, 2.0)) + return NT +end + +function _get_parameters(comp_def::AbstractCompositeComponentDef, par_dict::Dict{Tuple{ComponentPath, Symbol}, Any}) + + # TODO (dummy below) + NT = NamedTuple(Tuple(:par1, :par2), Tuple(1.0, 2.0)) + return NT +end + """ _set_defaults!(md::ModelDef) From 8375b11bc8971668ccd1d34c36f52a341665d4e8 Mon Sep 17 00:00:00 2001 From: lrennels Date: Thu, 16 Apr 2020 15:23:46 -0700 Subject: [PATCH 04/11] Finish variables and parameters structs to CompositeComponentInstance --- src/core/build.jl | 30 +++++++++++++++++++----------- src/core/types/instances.jl | 4 +++- test/test_composite.jl | 14 +++++++++++++- 3 files changed, 35 insertions(+), 13 deletions(-) diff --git a/src/core/build.jl b/src/core/build.jl index 05fff412a..5e7bd3c3f 100644 --- a/src/core/build.jl +++ b/src/core/build.jl @@ -271,26 +271,34 @@ function _build(comp_def::AbstractCompositeComponentDef, comps = [_build(cd, var_dict, par_dict, time_bounds) for cd in compdefs(comp_def)] - variables = _get_variables(comp_def, var_dict) - parameters = _get_parameters(comp_def, par_dict) + variables = _get_variables(comp_def) + parameters = _get_parameters(comp_def) return CompositeComponentInstance(comps, comp_def, time_bounds, variables, parameters) end # helper functions for to create the variables and parameters NamedTuples for a # CompositeComponentInstance -function _get_variables(comp_def::AbstractCompositeComponentDef, var_dict::Dict{ComponentPath, Any}) - - # TODO (dummy below) - NT = NamedTuple(Tuple(:var1, :var2), Tuple(1.0, 2.0)) - return NT +function _get_variables(comp_def::AbstractCompositeComponentDef) + + namespace = comp_def.namespace + var_defs = filter(namespace -> isa(namespace.second, CompositeVariableDef), namespace) + names = [k for (k,v) in var_defs] + vals = [v.ref for (k,v) in var_defs] + variables = (; zip(names, vals)...) + + return variables end -function _get_parameters(comp_def::AbstractCompositeComponentDef, par_dict::Dict{Tuple{ComponentPath, Symbol}, Any}) +function _get_parameters(comp_def::AbstractCompositeComponentDef) + + namespace = comp_def.namespace + par_defs = filter(namespace -> isa(namespace.second, CompositeParameterDef), namespace) + names = [k for (k,v) in par_defs] + vals = [v.refs[1] for (k,v) in par_defs] + parameters = (; zip(names, vals)...) - # TODO (dummy below) - NT = NamedTuple(Tuple(:par1, :par2), Tuple(1.0, 2.0)) - return NT + return parameters end """ diff --git a/src/core/types/instances.jl b/src/core/types/instances.jl index 85a09bc97..559e1330e 100644 --- a/src/core/types/instances.jl +++ b/src/core/types/instances.jl @@ -214,8 +214,10 @@ end function CompositeComponentInstance(comps::Vector{<: AbstractComponentInstance}, comp_def::AbstractCompositeComponentDef, time_bounds::Tuple{Int,Int}, + variables::NamedTuple, + parameters::NamedTuple, name::Symbol=nameof(comp_def)) - CompositeComponentInstance(new(), comps, comp_def, time_bounds, name) + CompositeComponentInstance(new(), comps, comp_def, time_bounds, variables, parameters, name) end end diff --git a/test/test_composite.jl b/test/test_composite.jl index 7279399ac..786d0cf1e 100644 --- a/test/test_composite.jl +++ b/test/test_composite.jl @@ -6,7 +6,7 @@ using Mimi import Mimi: ComponentId, ComponentPath, ComponentDef, AbstractComponentDef, CompositeComponentDef, ModelDef, build, time_labels, compdef, find_comp, - import_params! + import_params!, CompositeVariableDef, CompositeParameterDef @defcomp Comp1 begin par_1_1 = Parameter(index=[time]) # external input @@ -138,6 +138,7 @@ run(m) mi = m.mi +# test access methods @test mi[:top][:A][:Comp2, :par_2_2] == collect(1.0:16.0) @test mi["/top/A/Comp2", :par_2_2] == collect(1.0:16.0) @@ -145,6 +146,17 @@ mi = m.mi @test mi["/top/A/Comp1", :var_1_1] == collect(1.0:16.0) @test mi["/top/B/Comp4", :par_4_1] == collect(6.0:6:96.0) +# test parameters and variables fields of CompositeComponentInstance +top_var_keys = keys(mi[:top].variables) +top_par_keys = keys(mi[:top].parameters) +for item in md[:top].namespace + if isa(item.second, CompositeVariableDef) + @test in(item.first, top_var_keys) + elseif isa(item.second, CompositeParameterDef) + @test in(item.first, top_par_keys) + end +end + # # Test joining external params. # From 744702d0cf3844f6f05c9a7a5f41ff6956169ec2 Mon Sep 17 00:00:00 2001 From: lrennels Date: Thu, 16 Apr 2020 16:46:28 -0700 Subject: [PATCH 05/11] Start _get_datum method for compositecomponentinstance --- src/core/instances.jl | 34 ++++++++++++++++++++++++++++++++-- 1 file changed, 32 insertions(+), 2 deletions(-) diff --git a/src/core/instances.jl b/src/core/instances.jl index b5fa810de..4bdd8803b 100644 --- a/src/core/instances.jl +++ b/src/core/instances.jl @@ -168,10 +168,37 @@ function Base.getindex(obj::AbstractCompositeComponentInstance, comp_name::Symbo return compinstance(obj, comp_name) end -function _get_datum(ci::AbstractComponentInstance, datum_name::Symbol) +# LFR TODO some of this is very similar to _get_datum for leaf component instance, +# but in some ways it seems clearner to separate them +function _get_datum(ci::CompositeComponentInstance, datum_name::Symbol) vars = variables(ci) - if datum_name in names(vars) + if datum_name in keys(vars) # could merge with below if made names(NamedTuple) = keys(NamedTuple) + which = vars + else + pars = parameters(ci) + if datum_name in keys(pars) # could merge with below if made names(NamedTuple) = keys(NamedTuple) + which = pars + else + error("$datum_name is not a parameter or a variable in component $(ci.comp_path).") + end + end + + ref = getproperty(which, datum_name) + leaf_comp_name = ref.comp_name + leaf_datum_name = ref.datum_name + + # LFR TODO figure out which path to go down to find the leaf + # next_comp_name = + # next_datum_name = + return _get_datum(ci.comps_dict[next_comp_name, next_datum_name]) + +end + +function _get_datum(ci::LeafComponentInstance, datum_name::Symbol) + vars = variables(ci) + + if datum_name in names(vars) which = vars else pars = parameters(ci) @@ -191,11 +218,14 @@ function Base.getindex(mi::ModelInstance, key::AbstractString, datum::Symbol) _get_datum(mi[key], datum) end +# LFR TODO: does this get used? should we keep it? function Base.getindex(obj::AbstractCompositeComponentInstance, comp_name::Symbol, datum::Symbol) ci = obj[comp_name] return _get_datum(ci, datum) end + + """ dim_count(mi::ModelInstance, dim_name::Symbol) From 7d924cbdad98236881b7d82cac114baecbb9f9f6 Mon Sep 17 00:00:00 2001 From: lrennels Date: Thu, 16 Apr 2020 16:54:53 -0700 Subject: [PATCH 06/11] FIx _get_datum --- src/core/instances.jl | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/src/core/instances.jl b/src/core/instances.jl index 4bdd8803b..0c0057eed 100644 --- a/src/core/instances.jl +++ b/src/core/instances.jl @@ -185,13 +185,9 @@ function _get_datum(ci::CompositeComponentInstance, datum_name::Symbol) end ref = getproperty(which, datum_name) - leaf_comp_name = ref.comp_name - leaf_datum_name = ref.datum_name - # LFR TODO figure out which path to go down to find the leaf - # next_comp_name = - # next_datum_name = - return _get_datum(ci.comps_dict[next_comp_name, next_datum_name]) + # LFR TODO get the comp_name and datum_name to use ... + return _get_datum(ci.comps_dict[comp_name, datum_name]) end From 9c7122faf685a6a86d6a070d52feeff563fc5597 Mon Sep 17 00:00:00 2001 From: lrennels Date: Thu, 16 Apr 2020 18:42:52 -0700 Subject: [PATCH 07/11] Finish _get_datum --- src/core/instances.jl | 10 ++++------ test/test_composite.jl | 24 ++++++++++++++---------- 2 files changed, 18 insertions(+), 16 deletions(-) diff --git a/src/core/instances.jl b/src/core/instances.jl index 0c0057eed..4fbe1cdb0 100644 --- a/src/core/instances.jl +++ b/src/core/instances.jl @@ -168,16 +168,16 @@ function Base.getindex(obj::AbstractCompositeComponentInstance, comp_name::Symbo return compinstance(obj, comp_name) end -# LFR TODO some of this is very similar to _get_datum for leaf component instance, +# TBD: some of this is very similar to _get_datum for leaf component instance, # but in some ways it seems clearner to separate them function _get_datum(ci::CompositeComponentInstance, datum_name::Symbol) vars = variables(ci) - if datum_name in keys(vars) # could merge with below if made names(NamedTuple) = keys(NamedTuple) + if datum_name in keys(vars) # could merge with method below if made names(NamedTuple) = keys(NamedTuple) which = vars else pars = parameters(ci) - if datum_name in keys(pars) # could merge with below if made names(NamedTuple) = keys(NamedTuple) + if datum_name in keys(pars) # could merge with method below if made names(NamedTuple) = keys(NamedTuple) which = pars else error("$datum_name is not a parameter or a variable in component $(ci.comp_path).") @@ -186,8 +186,7 @@ function _get_datum(ci::CompositeComponentInstance, datum_name::Symbol) ref = getproperty(which, datum_name) - # LFR TODO get the comp_name and datum_name to use ... - return _get_datum(ci.comps_dict[comp_name, datum_name]) + return _get_datum(ci.comps_dict[ref.comp_name], ref.datum_name) end @@ -214,7 +213,6 @@ function Base.getindex(mi::ModelInstance, key::AbstractString, datum::Symbol) _get_datum(mi[key], datum) end -# LFR TODO: does this get used? should we keep it? function Base.getindex(obj::AbstractCompositeComponentInstance, comp_name::Symbol, datum::Symbol) ci = obj[comp_name] return _get_datum(ci, datum) diff --git a/test/test_composite.jl b/test/test_composite.jl index 786d0cf1e..1200e826d 100644 --- a/test/test_composite.jl +++ b/test/test_composite.jl @@ -88,7 +88,7 @@ end foo3 = Parameter(B.foo3) foo4 = Parameter(B.foo4) - var_3_1 = Variable(B.Comp3.var_3_1) + var_3_1 = Variable(B.var_3_1) connect(B.par_3_1, A.var_2_1) connect(B.par_4_1, B.var_3_1) @@ -138,14 +138,6 @@ run(m) mi = m.mi -# test access methods -@test mi[:top][:A][:Comp2, :par_2_2] == collect(1.0:16.0) -@test mi["/top/A/Comp2", :par_2_2] == collect(1.0:16.0) - -@test mi["/top/A/Comp2", :var_2_1] == collect(3.0:3:48.0) -@test mi["/top/A/Comp1", :var_1_1] == collect(1.0:16.0) -@test mi["/top/B/Comp4", :par_4_1] == collect(6.0:6:96.0) - # test parameters and variables fields of CompositeComponentInstance top_var_keys = keys(mi[:top].variables) top_par_keys = keys(mi[:top].parameters) @@ -157,7 +149,19 @@ for item in md[:top].namespace end end -# +# test access methods +@test mi[:top][:A][:Comp2, :par_2_2] == collect(1.0:16.0) +@test mi["/top/A/Comp2", :par_2_2] == collect(1.0:16.0) + +@test mi["/top/A/Comp2", :var_2_1] == collect(3.0:3:48.0) +@test mi["/top/A/Comp1", :var_1_1] == collect(1.0:16.0) +@test mi["/top/B/Comp4", :par_4_1] == collect(6.0:6:96.0) + +@test m[:top, :fooA1] == 1 +@test m[:top, :var_3_1] == collect(6.0:6:96.0) + +# vars + # Test joining external params. # m2 = Model() From 7bb3cae014127da839d2653558d32e1f330b0ecd Mon Sep 17 00:00:00 2001 From: lrennels Date: Thu, 16 Apr 2020 21:44:57 -0700 Subject: [PATCH 08/11] Add tests --- src/core/instances.jl | 6 +++--- test/test_composite.jl | 1 + 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/src/core/instances.jl b/src/core/instances.jl index 4fbe1cdb0..3fc1dc326 100644 --- a/src/core/instances.jl +++ b/src/core/instances.jl @@ -168,8 +168,9 @@ function Base.getindex(obj::AbstractCompositeComponentInstance, comp_name::Symbo return compinstance(obj, comp_name) end -# TBD: some of this is very similar to _get_datum for leaf component instance, -# but in some ways it seems clearner to separate them +# TBD we could probably combine the two _get_datum methods into one that takes a +# ci::AbstractComponentInstance, but for now it seems there are enough differences +# that keeping them separate is cleaner function _get_datum(ci::CompositeComponentInstance, datum_name::Symbol) vars = variables(ci) @@ -187,7 +188,6 @@ function _get_datum(ci::CompositeComponentInstance, datum_name::Symbol) ref = getproperty(which, datum_name) return _get_datum(ci.comps_dict[ref.comp_name], ref.datum_name) - end function _get_datum(ci::LeafComponentInstance, datum_name::Symbol) diff --git a/test/test_composite.jl b/test/test_composite.jl index 1200e826d..aa912c1c9 100644 --- a/test/test_composite.jl +++ b/test/test_composite.jl @@ -158,6 +158,7 @@ end @test mi["/top/B/Comp4", :par_4_1] == collect(6.0:6:96.0) @test m[:top, :fooA1] == 1 +@test m[:top, :foo3] == 10 @test m[:top, :var_3_1] == collect(6.0:6:96.0) # vars From 2999d8b3928045512975a659c3f6581a875aadd4 Mon Sep 17 00:00:00 2001 From: lrennels Date: Thu, 16 Apr 2020 21:50:22 -0700 Subject: [PATCH 09/11] Final cleanup; tests passing --- test/test_composite.jl | 2 -- 1 file changed, 2 deletions(-) diff --git a/test/test_composite.jl b/test/test_composite.jl index aa912c1c9..49e39c23b 100644 --- a/test/test_composite.jl +++ b/test/test_composite.jl @@ -161,8 +161,6 @@ end @test m[:top, :foo3] == 10 @test m[:top, :var_3_1] == collect(6.0:6:96.0) -# vars - # Test joining external params. # m2 = Model() From fd6896ec404188d1d105821397f22cef4e266c70 Mon Sep 17 00:00:00 2001 From: lrennels Date: Fri, 17 Apr 2020 15:35:24 -0700 Subject: [PATCH 10/11] Update instances docs --- docs/src/internals/structures_3_instances.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/docs/src/internals/structures_3_instances.md b/docs/src/internals/structures_3_instances.md index 61f7a132b..0f46ac883 100644 --- a/docs/src/internals/structures_3_instances.md +++ b/docs/src/internals/structures_3_instances.md @@ -18,8 +18,8 @@ run_timestep::Union{Nothing, Function} # CompositeComponentInstance <: ComponentInstance comps_dict::OrderedDict{Symbol, ComponentInstance} -pars_dict::OrderedDict{Symbol, Any} # not currently being used but, probably should for better datum access -vars_dict::OrderedDict{Symbol, Any} # ^ same +parameters::NamedTuple +variables::NamedTuple # ModelInstance <: CompositeComponentInstance md::ModelDef From 54a6b82a5f1a137bb0aea1c1541f68b3bf881e93 Mon Sep 17 00:00:00 2001 From: lrennels Date: Tue, 28 Apr 2020 11:44:05 -0700 Subject: [PATCH 11/11] Delete old functions --- src/core/build.jl | 13 ------------- 1 file changed, 13 deletions(-) diff --git a/src/core/build.jl b/src/core/build.jl index 5e7bd3c3f..fcc7d4efe 100644 --- a/src/core/build.jl +++ b/src/core/build.jl @@ -77,14 +77,6 @@ function _instantiate_component_vars(md::ModelDef, comp_def::ComponentDef) return ComponentInstanceVariables(names, types, values, paths) end -function _combine_exported_pars(comp_def::AbstractCompositeComponentDef) - names = Symbol[] - values = Any[] - paths = repeat(Any[comp_def.comp_path], length(names)) - types = DataType[typeof(val) for val in values] - return ComponentInstanceParameters(names, types, values, paths) -end - # Creates the top-level vars for the model function _instantiate_vars(md::ModelDef) vdict = Dict{ComponentPath, Any}() @@ -241,11 +233,6 @@ function _instantiate_params(comp_def::ComponentDef, par_dict::Dict{Tuple{Compon return ComponentInstanceParameters(names, types, vals, paths) end -# commented out because potentially doing nothing ... the fcn is never called -# function _instantiate_params(comp_def::AbstractCompositeComponentDef, par_dict::Dict{Tuple{ComponentPath, Symbol}, Any}) -# _combine_exported_pars(comp_def) -# end - # Return a built leaf or composite LeafComponentInstance function _build(comp_def::ComponentDef, var_dict::Dict{ComponentPath, Any},