Internals

AbstractGUIObj

Supertype for EnergyModelsGUI objects representing Nodes/Links/Areas/Transmissions.

AbstractSystem

Supertype for EnergyModelsGUI objects representing a sub system of a Case.

Connection <: AbstractGUIObj

Mutable type for providing a flexible data structure for connections between EnergySystemDesigns.

Fields

• from::EnergySystemDesign is the EnergySystemDesign from which the connection originates.
• to::EnergySystemDesign is the EnergySystemDesign to which the connection is linked.
• connection::AbstractElement is the EMX connection structure.
• parent::EnergySystemDesign is the parent EnergySystemDesign of the connection.
• colors::Vector{RGBA{Float32}} are the associated colors of the connection.
• inv_data::Vector{ProcInvData} stores processed investment data.
• regular_plots::Vector{Makie.AbstractPlot} is a vector with all regular plots associated with the connection.
• simplified_plots::Vector{Makie.AbstractPlot} is a vector with all simplified plots associated with the connection.
• alpha::Vector{Observable{Float32}} is the alpha value of the connection, observed for changes. For each line it controls the alpha value, which is used to toggle the visibility of the line when the connection has not been invested in.

EnergySystemIterator

Type for iterating over nested EnergySystemDesign structures, enabling recursion through AbstractGUIObjs.

Fields

• stack::Vector{<:AbstractGUIObj} is the stack used to manage the iteration through the nested EnergySystemDesign components (and its connections). It starts with the initial EnergySystemDesign object and progressively includes its subcomponents as the iteration proceeds.

NothingDesign <: AbstractGUIObj

Type for representing a non-existent design.

NothingElement <: AbstractElement

Type for representing an empty AbstractElement (the "nothing" element).

PlotContainer{T}

Type for storing plot-related data available from the "Data" menu.

Fields

• name::String: is the reference name for the data.
• selection::Vector: is the indices used to extract the data to be plotted.
• field_data::Any: is the data from which plots are extracted based on selection.
• description::String: is the description to be used for the legend.

ProcInvData

Type for storing processed investment data.

Fields

• id::String is the identifier for structures that have TransmissionModes (default is thus an empty string).
• inv_times::Vector{String} is a vector of formatted strings for added investments.
• capex::Vector{Float64} contains the capex of all times with added investments.
• invested::Observable{Bool} indicates if the element has been invested in.

System

Type for storing processed system data from EnergyModelsBase.

Fields

• T::TimeStructure is the time structure of the model.
• products::Vector{<:Resource} are the resources that should be incorporated into the model.
• elements::Vector{Vector} are the vectors of AbstractElement that should be included in the analysis.
• children::Vector{<:EMB.Node} are the children of the system.
• connections::Vector{<:Link} are the connections between system parts.
• parent::AbstractElement is the parent of the system (a NothingElement for the top level system, otherwise the element, e.g., an Area, that the system belongs to).
• ref_element::AbstractElement is the reference element of the system (first Availability node, or NothingElement if there is none).

SystemGeo

Type for storing processed system data from EnergyModelsGeography.

Fields

• T::TimeStructure is the time structure of the model.
• products::Vector{<:Resource} are the resources that should be incorporated into the model.
• elements::Vector{Vector} are the vectors of AbstractElement that should be included in the analysis.
• children::Vector{<:AbstractElement} are the children of the system (the Areas).
• connections::Vector{<:AbstractElement} are the connections between system parts (the Transmissions).
• parent::AbstractElement is the parent of the system.
• ref_element::AbstractElement is the reference element of the system (the first Area).

iterate(itr::EnergySystemIterator, state = nothing)

Iterate over an EnergySystemIterator, returning the next object of the stack (an EnergySystemDesign or a Connection) and the index of that object as the new state. Without state, the first object is returned. If the end of the stack is reached, return nothing.

EMB.get_elements_vec(system::AbstractSystem)

Returns the vector of element-vectors of the AbstractSystem system.

EMB.get_links(system::AbstractSystem)

Returns the links of a AbstractSystem system.

EMB.get_nodes(system::AbstractSystem)

Returns the nodes of a AbstractSystem system.

EMB.get_products(system::AbstractSystem)

Returns the vector of products of the AbstractSystem system.

EMB.get_time_struct(system::AbstractSystem)

Returns the time structure of the AbstractSystem system.

EMB.get_time_struct(design::EnergySystemDesign)

Returns the time structure of the EnergySystemDesign design.

EMB.get_time_struct(gui::GUI)

Returns the time structure of the GUI gui.

_type_to_header(::Type{<:TS.AbstractStrategicPeriod})
_type_to_header(::Type{<:TS.AbstractRepresentativePeriod})
_type_to_header(::Type{<:TS.AbstractOperationalScenario})
_type_to_header(::Type{<:TS.TimePeriod})
_type_to_header(::Type{<:TS.TimeStructure})
_type_to_header(::Type{<:TS.PeriodPartition})
_type_to_header(::Type{<:Resource})
_type_to_header(::Type{<:AbstractElement})
_type_to_header(::Type{<:Int})

Map types to header symbols for saving results.

add_component!(gui::GUI, component::EnergySystemDesign)

Draw a box containing the icon and add a label with the id of the EnergySystemDesign component.

add_description!(
    field::Any,
    name::String,
    key_str::String,
    pre_desc::String,
    selection::Vector,
    available_data::Vector{PlotContainer},
    gui::GUI,
)

Loop through all struct fieldnames of field (i.e., for the field level of type NoStartInvData) and update available_data with an added description.

add_description!(
    field::Dict,
    name::String,
    key_str::String,
    pre_desc::String,
    selection::Vector,
    available_data::Vector{PlotContainer},
    gui::GUI,
)

Loop through all dictnames for a field of type Dict (e.g. for the field penalty having the keys :deficit and :surplus) and update available_data with an added description.

add_description!(
    field::TS.TimeProfile,
    name::String,
    key_str::String,
    pre_desc::String,
    selection::Vector,
    available_data::Vector{PlotContainer},
    gui::GUI,
)

Create a container with a description, and add container to available_data.

add_description!(
    field::Vector,
    name::String,
    key_str::String,
    pre_desc::String,
    selection::Vector,
    available_data::Vector{PlotContainer},
    gui::GUI,
)

Loop through all elements of field of type Vector (i.e., for the field data) and update available_data with an added description.

add_inspector_to_poly!(p::Makie.AbstractPlot, inspector_label::Function)

Add inspector_label for Poly and Mesh plots in plot p.

adjust_limits!(gui::GUI)

Adjust the limits of get_axes(gui)[:topo] based on its content.

align(gui::GUI, align::Symbol)

Align components in get_selected_systems(gui) based on the value of Symbol align.

The following values are allowed

• :horizontal for horizontal alignment.
• :vertical for vertical alignment.

angle(node_1::EnergySystemDesign, node_2::EnergySystemDesign)

Based on the location of node_1 and node_2, return the angle between the x-axis and node_2 with node_1 being the origin.

angle_difference(angle1::Float32, angle2::Float32)

Compute the (smallest, non-negative) difference between two angles.

box(x::Float32, y::Float32, Δ::Float32)

Get the coordinates of a box with half side lengths Δ and centered at (x,y) starting at the upper right corner, returned as the vectors xs and ys of a closed path.

clear_selection!(gui::GUI, ax_type::Symbol)

Clear the color selection of the topology axis if ax_type = :topo, and of the results axis if ax_type = :results.

close(gui::GUI)

Closes the GUI gui.

connect!(gui::GUI, connection::Connection, two_way::Bool)

Draw the lines and the arrows of connection. If two_way is true, a connection in the opposite direction exists and the lines are shifted to separate the two.

connect!(gui::GUI, design::EnergySystemDesign)

Draws lines between connected nodes/areas in GUI gui using EnergySystemDesign design.

convert_array(v::AbstractArray, dict::Dict)

Apply the transformation of the dict to the array v.

convert_partitions(df::DataFrame, 𝒯::TimeStructure, varname::Symbol)

Convert the string representations of the TS.PeriodPartitions in column :pd of df to the partitions themselves and store them in column :t.

As the string representation of a partition does not include its operational periods and the partitions may differ between elements, the partitions are reconstructed for each element in column :element through period_partitions. Rows whose partition cannot be reconstructed are removed with a warning highlighting the element.

create_description(
    gui::GUI,
    key_str::String;
    pre_desc::String="",
)

Create description from get_var(gui,:descriptive_names) if available

create_indent_string(indent::Int64)

Create an indentation string based on the indent level.

create_label(selection::PlotContainer)

Return a label for a given selection to be used in the getmenus(gui)[:availabledata] menu.

create_makie_objects(vars::Dict, design::EnergySystemDesign)

Create Makie figure and all its objects (buttons, menus, toggles, sliders, legends and axes) for EnergySystemDesign design and the options vars. Returns the tuple (fig, buttons, menus, toggles, sliders, axes, legends).

data_to_pixel(gui::GUI, data_size::Real)

Convert data_size (in x- and y-direction) to pixel sizes in design object gui.

define_event_functions(gui::GUI)

Define event functions (handling button clicks, plot updates, etc.) for the GUI gui.

design_file(system::AbstractSystem, path::String)

Construct and return the path for the .yml file for system in the folder path (an empty string if path is empty).

draw_box!(gui::GUI, design::EnergySystemDesign)

Draw a box for EnergySystemDesign design and its appearance, including style, color, size.

draw_icon!(gui::GUI, design::EnergySystemDesign)

Draw an icon for EnergySystemDesign design.

draw_label!(gui::GUI, component::EnergySystemDesign)

Add a label to an EnergySystemDesign component.

export_svg(ax::Makie.Block, filename::String; legend=nothing)

Export the ax to a .svg file with path given by filename. The optional keyword argument legend is a Makie.Legend that is added to the exported file.

export_to_file(gui::GUI)

Export results based on the state of gui to a file located within the folder specified through the path_to_results keyword of GUI. The file name and format are given by the menus :axes and :export_type. Returns 0 on success, 1 if the combination of axes and file format is not supported, and 2 if an error occurred (nothing is returned if path_to_results is empty).

export_to_repl(gui::GUI)

Export results based on the state of gui to the REPL.

export_xlsx(gui::GUI, filename::String)

Export the variables of the JuMP model of gui to an xlsx file (one sheet per variable) with path given by filename. Returns 0 on success and 1 if the model is empty.

export_xlsx(plots::Vector, filename::String, xlabel::Symbol)

Export the plots to a .xlsx file with path given by filename and top header xlabel for the first column. Returns 0 on success and 1 if plots is empty.

extract_data_selection(var::SparseVars, selection::Vector, i_T::Int64, periods::Vector)
extract_data_selection(var::JuMP.Containers.DenseAxisArray, selection::Vector, i_T::Int64, ::Vector)
extract_data_selection(var::DataFrame, selection::Vector, ::Int64, ::Vector)

Extract data from var having its time dimension at index i_T for all time periods in periods.

extract_svg(svg_string)

Extract the raw SVG content from the SVG string svg_string. Returns the content between the opening <svg ...> and closing </svg> tags and the header preceding the content (both empty strings if svg_string is empty).

filter_partitions(
    pds::Vector{<:TS.PeriodPartition}, sp::Int64, rp::Int64, sc::Int64,
)

Filter the TS.PeriodPartitions pds to the strategic period sp, representative period rp, and scenario sc (indices not present in the partitions are ignored).

find_icon(system::AbstractSystem, id_to_icon_map::Dict)

Find the icon associated with a given system's node id utilizing the mapping provided through id_to_icon_map, with a lookup by id taking precedence over a lookup by type. An empty string is returned if no icon is found.

find_icon_path(icon::String)

Search for the path to the .png file of the icon based on the icon name icon (without file ending). The search covers icon as a path, the icons folder of EnergyModelsGUI, and the folder ext/EMGUIExt/icons of installed EnergyModels packages. An empty string is returned if no icon is found.

find_min_max_coordinates(
    design::EnergySystemDesign,
    min_x::Number,
    max_x::Number,
    min_y::Number,
    max_y::Number
)

Find the minimum and maximum coordinates of the components of EnergySystemDesign design given the minimum and maximum coordinates min_x, max_x, min_y, and max_y. The updated values are returned as the tuple (min_x, max_x, min_y, max_y).

find_min_max_coordinates(design::EnergySystemDesign)

Find the minimum and maximum coordinates of the components of EnergySystemDesign design, returned as the tuple (min_x, max_x, min_y, max_y).

find_type_field(dict::Dict, x::Any)

Return the closest supertype of x (including its own type) that is a key of dict, or Nothing if there is none.

format_number(x::Number)

Format number x to two decimals and add thousands separators (comma).

get_EMGUI_obj(plt)

Get the EnergySystemDesign/Connection associated with plt. Note that due to the nested structure of Makie, we must iteratively look through up to three nested layers to find where this object is stored.

get_JuMP_dict(model::Model)
get_JuMP_dict(model::Dict)

Get the dictionary of the model results. If the model is a JuMP.Model, it returns the object dictionary. If the model is a Dict (results read from CSV-files), the entry :metadata is excluded.

get_JuMP_names(gui::GUI)

Get all names registered in the model as a vector except the names to be ignored.

get_all_periods!(vec::Vector, per, ::TwoLevel)
get_all_periods!(vec::Vector, per, ::RepresentativePeriods)
get_all_periods!(vec::Vector, per, ::OperationalScenarios)
get_all_periods!(vec::Vector, per, ::SimpleTimes)
get_all_periods!(::Vector, per, ::Any)

Get all TimeStructures in per and append them to vec. The required time structures are automatically deduced from the internal structure of per.

get_all_periods(𝒯::TimeStructure)

Get all TimeStructures and TimePeriods in 𝒯 as a dictionary with their string representation as keys.

get_alpha(obj::AbstractGUIObj)

Returns the alpha field of a AbstractGUIObj obj.

get_available_data(gui::GUI)

Get the vector of containers for the available data from the gui.

get_ax(gui::GUI, ax_name)

Returns the ax object with name ax_name of a GUI gui.

get_axes(gui::GUI)

Returns the axes field of a GUI gui.

get_button(gui::GUI, button_name::Symbol)

Returns the button with name button_name of a GUI gui.

get_capex(data::ProcInvData)

Returns the capex of the investments of a ProcInvData object data.

get_change(::GUI, ::Val)

Handle different keyboard inputs (events) and return changes in x, y coordinates in the design object gui.

get_children(system::AbstractSystem)

Returns the children field of an AbstractSystem system.

get_color(design::EnergySystemDesign)

Returns the color field of a EnergySystemDesign design.

get_colors(conn::Connection)

Returns the colors field of a Connection conn.

get_combinations(var::SparseVars, i_T::Int)
get_combinations(var::JuMP.Containers.DenseAxisArray, i_T::Int)
get_combinations(var::DataFrame, ::Int)

Get an iterator of combinations of unique indices excluding the time index located at index i_T.

get_component(designs::Vector{EnergySystemDesign}, id)
get_component(designs::EnergySystemDesign, id)

Extract the component from a vector of EnergySystemDesign(s) that has a parent with the given id.

get_components(design::EnergySystemDesign)

Returns the components field of a EnergySystemDesign design.

get_connections(system::AbstractSystem)

Returns the connections field of a AbstractSystem system.

get_connections(design::EnergySystemDesign)

Returns the connections field of a EnergySystemDesign design.

get_data(data::String)
get_data(data::DataFrame)

Get the data from a string path to a CSV file or directly from a DataFrame.

get_data(
    model::Union{JuMP.Model, Dict},
    selection::PlotContainer,
    T::TS.TimeStructure,
    sp::Int64,
    rp::Int64,
    sc::Int64,
)

Get the values from the JuMP model, or the input data, at selection for all periods in T restricted to strategic period sp, representative period rp, and scenario sc.

Return the periods, the corresponding values, and the time axis (e.g., :results_op).

get_default_colors()

Get the default colors in the EnergyModelsGUI repository at src/colors.yml.

get_description(container::PlotContainer)

Returns the description field of a PlotContainer container.

get_design(gui::GUI)

Returns the design field of a GUI gui.

get_element(system::AbstractSystem)

Returns the element associated with an AbstractSystem system (its parent field).

get_element(conn::Connection)

Returns the associated Transmission/Link of conn.

get_element(design::EnergySystemDesign)

Returns the system node (i.e., availability node for areas) of a EnergySystemDesign design.

get_element_label(element)

Get the label of the element based on its id field. If the id is a number it returns the built in Base.display() functionality of node, otherwise, the id field is converted to a string. For a Link, the labels of from and to are joined by -.

get_field_data(container::PlotContainer)

Returns the field_data field of a PlotContainer container.

get_fig(gui::GUI)

Returns the fig field of a GUI gui.

get_file(design::EnergySystemDesign)

Returns the file field of a EnergySystemDesign design.

get_from(conn::Connection)

Returns the from field of a Connection conn.

get_hover_string(obj::AbstractGUIObj)

Return the string for an EMB.Node/Area/Link/Transmission to be shown on hovering.

get_icon(design::EnergySystemDesign)

Returns the icon field of a EnergySystemDesign design.

get_inv_data(obj::AbstractGUIObj)

Returns the inv_data field of a AbstractGUIObj obj.

get_inv_objs(obj::AbstractElement)

Get the objects for which investment information should be stored for a given AbstractElement. By default, this is just the element itself, but for some elements (e.g., Transmission) it can be relevant to also store the investment information of related objects (e.g., its modes).

get_inv_times(data::ProcInvData)

Returns the inv_times field of a ProcInvData object data.

get_investment_times(gui::GUI, max_inst::Float64)

Calculate when investments have taken place and store the information. An investment is assumed to have taken place if any investment_indicators are larger than get_var(gui, :tol) relative to max_inst.

get_jump_axis_types(data::JuMP.Containers.DenseAxisArray)
get_jump_axis_types(data::SparseVars)
get_jump_axis_types(data::DataFrame)

Get the types for each axis in the data.

get_legend(gui::GUI, key::Symbol)

Returns the legend object key of a GUI gui.

get_linestyle(::GUI, ::AbstractElement)

Dispatchable function for the EnergyModelsGeography extension.

get_linestyle(gui::GUI, connection::Connection)

Get the line style for a Connection connection based on its properties.

get_linestyle(gui::GUI, design::EnergySystemDesign)

Get the line style for an EnergySystemDesign design based on its properties.

get_max_installed(n, t::Vector{<:TS.TimeStructure})

Get the maximum capacity installable by an investment in the node n over the time periods t (zero if n has no investments). For a Storage, the maximum over the charge, level, and discharge capacities is returned.

get_menu(gui::GUI, menu_name::Symbol)

Returns the menu with name menu_name of a GUI gui.

get_menus(gui::GUI)

Returns the menus field of a GUI gui.

get_mode_to_transmission_map(::System)

Dispatchable function to get the mapping between modes and transmissions. It returns an empty Dict for a System and is overloaded for a SystemGeo in EMGExt.

get_model(gui::GUI)

Returns the model field of a GUI gui.

get_name(container::PlotContainer)

Returns the name field of a PlotContainer container.

get_nested_value(dict::Dict, keys_str::String)

Get the value of a nested dict based on the keys in the string keys_str separated by periods.

get_nth_field(s::String, delimiter::Char, n::Int)

Get the n'th value of a string s separated by the character delimiter (an empty string if s has fewer than n values).

get_obj_value(model::Model)
get_obj_value(model::Dict)

Get the objective value of the model.

get_op(tp::TS.TimePeriod)

Get the operational period of TimePeriod tp.

get_parent(obj::AbstractGUIObj)

Returns the parent field of a AbstractGUIObj obj.

get_parent(system::AbstractSystem)

Returns the parent field of a AbstractSystem system.

get_parent(gui::GUI)

Returns the parent field of a GUI gui.

get_partition_periods(selection::JuMPContainer, ::TS.TimeStructure)
get_partition_periods(selection::PlotContainer, T::TS.TimeStructure)

Get all TS.PeriodPartitions for the data in selection, either from the time periods of the extracted JuMP data (sorted through partition_sort_key) or, for case data, constructed from the element itself (see period_partitions).

get_periods(T::TS.TimeStructure, type::Type, sp::Int64, rp::Int64, sc::Int64)

Get the periods for a given TimePeriod/TimeProfile type (e.g., TS.StrategicPeriod, TS.RepresentativePeriod, TS.OperationalPeriod) restricted to the strategic period sp, representative period rp and the scenario sc.

get_plotables(system::System)

Returns the Nodes and Links of a System system.

get_plots(conn::Connection, simplified::Bool)

Returns the plots field of a Connection conn based on the simplified flag.

get_plots(conn::Connection)

Returns the active plots field of a Connection conn.

get_plots(design::EnergySystemDesign)

Returns the plots field of a EnergySystemDesign design.

get_plotted_data(gui::GUI)

Get the plots from the gui.

get_ref_element(system::AbstractSystem)

Returns the ref_element field of a AbstractSystem system.

get_ref_element(design::EnergySystemDesign)

Returns the ref_element field in the system field of a EnergySystemDesign design.

get_regular_plots(conn::Connection)

Returns the regular_plots field of a Connection conn.

get_repr_dict(vec::AbstractVector{T}) where T

Get a dictionary with the string representation of each element in vec as keys.

get_representative_period_indices(T::TS.TimeStructure, sp::Int64)

Return indices in the time structure T of the representative periods for strategic period sp.

get_resource_colors(l::Link, id_to_color_map::Dict{Any,Any})

Get the colors linked to the resources in the link l based on the mapping id_to_color_map.

get_resource_colors(resources::Vector{<:Resource}, id_to_color_map::Dict{Any,Any})

Get the colors linked to the resources in resources based on the mapping id_to_color_map.

get_resource_colors(::Vector{Any}, ::Dict{Any,Any})

Return empty RGBA{Float32} vector for empty input.

get_results_legend(gui::GUI)

Get the legend from the current visible time axis from the gui.

get_root_design(gui::GUI)

Returns the root_design field of a GUI gui.

get_scenario_indices(T::TS.TimeStructure, sp::Int64, rp::Int64)

Return indices of the scenarios in the time structure T for strategic period number sp and representative period rp.

get_screen(gui::GUI)

Returns the screen field of a GUI gui.

get_sector_points(;
    c::Point2f = Point2f(0.0f0, 0.0f0),
    Δ::Float32 = 1.0f0,
    θ₁::Float32 = 0.0f0,
    θ₂::Float32 = π32 / 4,
    steps::Int = 200,
    geometry::Symbol = :circle)

Get points for the boundary of a sector defined by the center c, radius/half side length Δ, and angles θ₁ and θ₂ for a square (geometry = :rect), a circle (geometry = :circle), or a triangle (geometry = :triangle).

get_selected_plots(gui::GUI, time_axis::Symbol)

Get the selected plots from the gui in the category time_axis.

get_selected_systems(gui::GUI)

Get the selected systems from the gui.

get_selection(container::PlotContainer)

Returns the selection field of a PlotContainer container.

get_selection_color(gui::GUI)

Get the selection color for the gui.

get_simplified(conn::Connection)

Returns the simplified field of the parent EnergySystemDesign of a Connection conn.

get_simplified(design::EnergySystemDesign)

Returns the simplified field of a EnergySystemDesign design.

get_simplified_plots(conn::Connection)

Returns the simplified_plots field of a Connection conn.

get_slider(gui::GUI, slider_name::Symbol)

Returns the slider with name slider_name of a GUI gui.

get_supertypes(x::Any)

Return the vector of the supertypes of x.

get_supertypes(input) -> Dict{Symbol, Vector{Type}}

Retrieves the supertypes of all defined types from modules or packages.

Method Overloads

• get_supertypes(modul::Module): Returns a dictionary mapping type names to their supertypes from the given module.

• get_supertypes(moduls::Vector{Module}): Merges and returns supertypes from multiple modules.

Arguments

• input: Can be a single module or a vector of modules.

Returns

• Dict: A dictionary where each key is a type name and the value is a vector of its supertypes.

Description

This set of functions helps extract the inheritance hierarchy of types defined in Julia modules or packages. It filters out non-type bindings and collects supertypes using supertypes. The supertypes are ordered starting with the type itself.

get_svg(blockscene::Makie.Scene)

Get the SVG representation of the blockscene.

get_system(design::EnergySystemDesign)

Returns the system field of a EnergySystemDesign design.

get_system(gui::GUI)

Returns the system field in the design field of a GUI gui.

get_text_alignment(wall::Symbol)

Get the text alignment for a label attached to a wall.

get_time_axis(
    data::Union{
        JuMP.Containers.DenseAxisArray,
        JuMP.Containers.SparseAxisArray,
        SparseVariables.IndexedVarArray,
        DataFrames.DataFrame,
    },
)

Get the index of the axis/column of data (i.e., from a JuMP variable) corresponding to a TS.TimePeriod, TS.TimeStructure, or TS.PeriodPartition and return this index (i_T) alongside its TimeStruct type (both nothing if there is no such axis).

get_time_periods(field_data::DataFrame)
get_time_periods(field_data)

Get the time periods of the extracted data field_data of a JuMP variable, i.e., the column :t if the model results are read from CSV-files and the first axis otherwise.

get_to(conn::Connection)

Returns the to field of a Connection conn.

get_toggle(gui::GUI, toggle_name::Symbol)

Returns the toggle with name toggle_name of a GUI gui.

get_topo_legend(gui::GUI)

Get the legend from the topology axis from the gui.

get_total_sum_time(data::JuMP.Containers.DenseAxisArray, ::Vector{<:TS.TimeStructure})
get_total_sum_time(data::DataFrame, periods::Vector{<:TS.TimeStructure})

Get the total sum of data over all indices except the time for each period in periods.

get_types(input) -> Vector{Symbol}

Retrieves the names of all defined types from modules or packages (exported names only).

Method Overloads

• get_types(modul::Module): Returns a vector of type names defined in the given module.

• get_types(moduls::Vector{Module}): Returns a vector containing one vector of type names per module.

• get_types(pkg::Union{String, Symbol}): Converts the package name to a module (via Main) and returns its defined types.

• get_types(pkgs::Union{Vector{<:Union{String, Symbol}}, Set{<:Union{String, Symbol}}}): Returns a vector containing one vector of type names per package.

Arguments

• input: Can be a single module, a vector of modules, a single package name (as String or Symbol), or a collection of package names.

Returns

• Vector{Symbol} for a single module or package: A list of names corresponding to types defined in it. A vector of such vectors for a collection of modules or packages.

Description

This set of functions helps extract type definitions from Julia modules or packages. It filters out non-type bindings and collects only those that are (possibly parametric) DataTypes.

Example

get_types(Base)  # returns type names defined in Base

get_types(["Base", "Core"])  # returns type names from both packages

get_types_structure(emx_supertypes_dict::Dict{Any, Vector{Type}}) -> Dict{Type, Union{Dict, Nothing}}

Constructs a nested dictionary representing type dependencies from a dictionary of supertypes.

Arguments

• emx_supertypes_dict::Dict{Any, Vector{Type}}: A dictionary where each key corresponds to a type identifier, and the value is a vector of supertypes ordered from the most specific (the type itself) to the most general.

Returns

• Dict{Type, Union{Dict, Nothing}}: A nested dictionary structure where each type is a key pointing to its subtype hierarchy. Leaf nodes point to an empty Dict.

Description

This function builds a tree-like structure of type dependencies by iterating through each type's supertypes and nesting them accordingly. It uses the helper function update_tree! to insert types into the correct level of the hierarchy.

get_values(vals::SparseVars)
get_values(vals::JuMP.Containers.DenseAxisArray)
get_values(vals::DataFrame)
get_values(vals::JuMP.Containers.SparseAxisArray, ts::Vector)
get_values(vals::SparseVariables.IndexedVarArray, ts::Vector)
get_values(vals::JuMP.Containers.DenseAxisArray, ts::Vector)
get_values(vals::DataFrame, ts::Vector)
get_values(vals::DataFrame, ts::Vector{<:TS.PeriodPartition})
get_values(vals::TimeProfile, ts::Vector)

Get the values of the variables in vals. If a vector of time periods ts is provided, it returns the values for the times in ts. For TS.PeriodPartitions read from CSV-files, the values are returned in the order of ts.

get_var(gui::GUI, key::Symbol)

Returns the vars field at key of a GUI gui.

get_var_periods(var::SparseVars, selection::Vector, i_T::Int64)

Get the sorted time indices available in var at axis i_T for the combination selection of the remaining indices. This is required for variables indexed over TS.PeriodPartitions as the partitions may differ between elements.

get_vars(gui::GUI)

Returns the vars field of a GUI gui.

get_vis_plots(ax::Axis)

Get visible BarPlots and Stairs plots.

get_visible(obj::AbstractGUIObj)

Returns the visible field of a AbstractGUIObj obj.

get_visible_data(gui::GUI, time_axis::Symbol)

Get the visible plots from the gui in the category time_axis.

get_wall(design::EnergySystemDesign)

Returns the wall field of a EnergySystemDesign design.

get_xy(design::EnergySystemDesign)

Returns the xy field of a EnergySystemDesign design.

getfirst(f::Function, a::Vector)

Return the first element of Vector a satisfying the requirement of Function f, or nothing if there is none.

has_fields(type::Type) -> Bool

Checks whether a given type is a struct type with at least one field.

Arguments

• type: The type to be inspected (a UnionAll is unwrapped first).

Returns

• Bool: Returns true if the type is a struct type and has one or more fields; otherwise, returns false.

Description

This function combines three checks:

• type isa DataType: Ensures the type is a DataType.
• isstructtype(type): Ensures the type is a struct.
• nfields(type) > 0: Ensures the struct has at least one field.

Example

struct MyStruct
    x::Int
end

has_fields(MyStruct)  # returns true

abstract type AbstractType end
has_fields(AbstractType)  # returns false

has_invested(data::ProcInvData)
has_invested(data::EnergySystemDesign)

Returns an observable of the boolean indicator for if investment has occurred.

has_partition_data(gui::GUI, element)

Return true if element has available data indexed over TS.PeriodPartitions.

includes_area(case::Case)

Check if the case includes elements from the EnergyModelsGeography package.

inherit_descriptive_names_from_supertypes!(descriptive_names, emx_supertypes_dict)

Copies descriptive field names from supertypes to subtypes in the descriptive_names dictionary.

Arguments

• descriptive_names::Dict: A dictionary containing descriptive names for structure fields,

organized by type.

• emx_supertypes_dict::Dict: A dictionary mapping type identifiers to arrays of types,

where the first element is the type itself and the remaining elements are its supertypes.

Description

For each type in emx_supertypes_dict, this function checks if the type has fields. For each field, it looks for descriptive names in the supertypes. If a descriptive name exists for a field in a supertype but not in the subtype, it copies the descriptive name from the supertype to the subtype.

Modifies

• Updates descriptive_names in-place by inheriting missing descriptive names from supertypes.

initialize_available_data!(gui)

For all plotable objects, initialize the available data menu with items.

initialize_plot!(gui::GUI, design::EnergySystemDesign)

Initialize the plot of the topology of design object gui given an EnergySystemDesign design.

installed()

Get a dictionary of the direct dependencies (with versions) of the active environment (replacement for the deprecated Pkg.installed()).

instantiate_inv_data(element::AbstractElement)

Instantiate the inv_data field for an AbstractElement by creating a vector of ProcInvData. This function can be specialized for different types of AbstractElement to handle specific cases, such as Transmission where multiple modes may require separate ProcInvData instances.

is_partition_data(container::PlotContainer)

Return true if container holds data indexed over TS.PeriodPartitions, i.e., a JuMP variable with a TS.PeriodPartition axis or a field of type PartitionProfile.

l2_norm(x::Point2f)

Compute the l2-norm of a vector.

merge_dicts(dict1::Dict, dict2::Dict)

Merge dict1 and dict2 (in case of overlap, dict2 overwrites entries in dict1).

merge_svg_strings(svg1, svg2)

Merge two SVG strings svg1 and svg2 into one with header from svg1.

mouse_within_axis(ax::Makie.AbstractAxis, mouse_pos::Tuple{Float32,Float32})

Check if mouse position is within the pixel area of ax.

nested_eltype(x::TimeProfile)

Return the type of the lowest TimeProfile, of a nested TimeProfile x, not being a FixedProfile.

new_global_delta_h(gui::GUI)

Recalculate the sizes of the boxes in get_axes(gui)[:topo] such that their size is independent of zooming and resizing the window.

outer_bbox(ax::Makie.AbstractAxis; padding::Number = 0)

Compute the outer bounding box of the axis ax with additional padding.

pad_amount(val::Real)

Return the amount with which degenerate axis limits around val are padded.

parse_case(case::Case)

Parse the case and return an AbstractSystem instance (SystemGeo if the case includes elements from the EnergyModelsGeography package, otherwise System).

parse_color(type::Type, color::Colorant)
parse_color(type::Type, color::Any)

Parse color into the type type.

partition_sort_key(pd::TS.PeriodPartition)

Return a sort key for the TS.PeriodPartition pd given by the tuple of its strategic period, representative period, scenario, and partition indices (indices not present in pd are set to zero).

period_partitions(element, T::TS.TimeStructure)

Return the vector of TS.PeriodPartitions partitioning the operational periods of T for element.

By default, the partitions are constructed from the field period_duration of element (the convention introduced by, e.g., PeriodDemandSink in EnergyModelsFlex). Elements that store the partition duration differently require a specialized method of this function. If the partitions cannot be determined, a warning highlighting element is issued and an empty vector is returned.

pick_component!(gui::GUI, ax_type::Symbol)
pick_component!(gui::GUI, plt::AbstractPlot, ax_type::Symbol)
pick_component!(gui::GUI, element::AbstractGUIObj, ::Symbol)
pick_component!(gui::GUI, element::Dict, ::Symbol)
pick_component!(gui::GUI, ::Nothing, ax_type::Symbol)

Check if a system is found under the mouse pointer and if it is an AbstractGUIObj (for objects in the topology axis) or a Dict (for objects in the results axis). If found, state variables are updated. Otherwise, the selection in the topology axis is only cleared if ax_type = :topo and the selection in the results axis if ax_type = :results.

pixel_to_data(gui::GUI, pixel_size::Real)

Convert pixel_size to data widths (in x- and y-direction) in design object gui.

place_nodes_in_circle(n::Int64, i::Int64, r::Float32, c::Point2f)

Return coordinate for point number i of a total of n points evenly distributed around a circle of radius r centered at c from -π/4 to 5π/4 (point 1 at 5π/4; a single point is placed at π).

plot_design!(
    gui::GUI, design::EnergySystemDesign; visible::Bool=true, expand_all::Bool=true
)

Set the visibility of design to visible and recursively of its components. If expand_all is false, only the component equal to get_design(gui) is visible.

print_nested_structure!(
    element,
    io::IOBuffer,
    indent::Int64,
    vector_limit::Int64,
    show_the_n_last_elements::Int64,
)

Append the nested structure of element in a nice format to the io buffer. The parameter indent tracks the indentation level, the parameter vector_limit is used to truncate large vectors and show_the_n_last_elements specifies how many of the last elements to show.

read_csv(file::String)

Read a CSV file and return it as a DataFrame. The time column is renamed to :t if it is named "t", "sp", "rp", "osc", or "op".

rename_time_column!(df::DataFrame)

Rename the time column in df to :t if it is named "t", "sp", "rp", "osc", or "op". If more than one of these columns are present, an error is thrown.

results_available(model::Model)
results_available(model::Dict)

Check if the model has a feasible solution.

save_design(design_dict::Dict, file::String)

Save the x,y-coordinates stored in design_dict to a .yml file at location and filename given by file.

save_design(design::EnergySystemDesign)

Save the x,y-coordinates of the components of EnergySystemDesign design (including its sub designs) to a .yml file specified in the field file of design.

scroll_ylim(ax::Makie.AbstractAxis, val::Float64)

Shift the ylim with val units to mimic scrolling feature of an axis ax (the limits are reset to (0, 1) if the upper limit would exceed 1).

select_data!(gui::GUI, name::String; selection::Vector = Any[], fun::Function = findfirst)

Select the data with name name from the available_data menu. If selection is provided, it is used to further specify which data to select. The fun argument is used to specify the function for finding the data in the menu (default is findfirst).

square_intersection(c::Point2f, θ::Float32, Δ::Float32)

Calculate the intersection point between a line starting at c and direction described by θ and a square with half side lengths Δ centered at center c.

square_intersection(c::Point2f, x::Point2f, θ::Float32, Δ::Float32)

Calculate the intersection point between a line starting at x and direction described by θ, and a square with half side lengths Δ centered at center c. If the line does not intersect the square, the extension of the two facing sides to x will be used instead.

sub_plots_empty(component::EnergySystemDesign)

Check if any sub-component of component is missing plots.

sub_system(system::System, element::AbstractElement)

Create a sub-system of system with the element as the parent and reference node.

toggle_selection_color!(gui::GUI, selection::EnergySystemDesign, selected::Bool)
toggle_selection_color!(gui::GUI, selection::Connection, selected::Bool)
toggle_selection_color!(gui::GUI, selection::Dict{Symbol,Any}, selected::Bool)

Set the color of selection to get_selection_color(gui) if selected, and its original color otherwise using the argument selected.

toggle_simplified!(gui::GUI, design::EnergySystemDesign, val::Bool)

Toggle simplified connection plotting for EnergySystemDesign design in GUI gui.

transfer_model(model::Model, system::AbstractSystem)
transfer_model(model::String, system::AbstractSystem)

Return model unchanged if it is a Model. If it is a path to a directory with results saved as CSV-files, convert it to a Dict containing a DataFrame for each variable and the :metadata.

update!(gui::GUI, element; updateplot::Bool=true)

Based on element, update the text in get_axes(gui)[:info] and update plot in get_axes(gui)[:results] if updateplot = true.

update!(gui::GUI, connection::Connection; updateplot::Bool=true)

Based on Connection, update the text in get_axes(gui)[:info] and update plot in get_axes(gui)[:results] if updateplot = true.

update!(gui::GUI, design::EnergySystemDesign; updateplot::Bool=true)

Based on design, update the text in get_axes(gui)[:info] and update plot in get_axes(gui)[:results] if updateplot = true.

update!(gui::GUI)

Upon release of left mouse button update plots.

update_available_data_menu!(gui::GUI, element)

Update the get_menus(gui)[:available_data] with the available data of element.

update_axis!(gui::GUI, time_axis::Symbol)

Update the xlabel, ylabel and ticks of the :results axis

update_barplot_dodge!(gui::GUI)

Update the barplot of the state of the GUI (such that the bars are dodged away from each other).

update_distances!(gui::GUI)

Find the minimum distance between the elements in the design object gui and update Δh such that neighbouring icons do not overlap.

update_info_box!(gui::GUI, element)

Based on element update the text in info box.

update_legend!(gui::GUI)

Update the legend based on the visible plots of the time axis selected in the time menu.

update_limits!(ax::Axis, limits::GLMakie.HyperRectangle)

Set the limits of ax to limits, padding limits without a span.

update_limits!(ax::Axis)

Adjust limits automatically to avoid legend box overlapping the data.

update_plot!(gui::GUI)

Based on selected_systems update plots.

update_plot!(gui::GUI, element)

Based on element update the results in get_axes(gui)[:results].

update_plot!(gui::GUI, connection::Connection)

Based on connection update plots.

update_plot!(gui::GUI, design::EnergySystemDesign)

Based on design update plots.

update_sub_system_locations!(design::EnergySystemDesign, Δ::Point2f)

Update the coordinates of the components of EnergySystemDesign design by shifting them by the displacement Δ.

update_time_menu!(gui::GUI, element)

Update the options of the time menu based on element: The option for plotting data over TS.PeriodPartitions is only made available if element has data indexed over such partitions.

update_title!(gui::GUI)

Update the title of get_axes(gui)[:topo] based on get_design(gui).

update_tree!(current_lvl::Dict{Type, Union{Dict, Nothing}}, tmp_type::Type) -> Nothing

Ensures that a given type exists as a key in the current level of a nested type dependency dictionary.

Arguments

• current_lvl::Dict{Type, Union{Dict, Nothing}}: The current level of the nested dictionary structure representing type dependencies.
• tmp_type::Type: The type to be added as a key in the current level if it does not already exist.

Behavior

If tmp_type is not already a key in current_lvl, it adds it with an empty dictionary as its value, preparing for further nesting.

Returns

• This function modifies current_lvl in-place; its return value should not be used.