EnergyCommunity.ASSET_TYPEType
@enum ASSET_TYPE

Enumeration type to specify the type of the assets. Implemented values:

  • LOAD: load components
  • REN: renewable assets
  • BATT: battery components
  • CONV: battery converters
  • THER: thermal generators
EnergyCommunity.ModelECType

Constructor of a ModelEC

Inputs

data : Dict Data of the EC grouptype : AbstractGroup Type of EC optimizer Optimizer of the model userset : Vector Vector of the users

TheoryOfGames.EnumModeMethod
EnumMode(ECModel::AbstractEC)

Function to create the EnumMode item for the TheoryOfGames.jl package

TheoryOfGames.IterModeMethod
IterMode(ECModel::AbstractEC, base_group_type::AbstractGroup)

Function to create the IterMode item for the TheoryOfGames.jl package

Base.zeroMethod

Function zero to represent the empty ModelEC

EnergyCommunity.build_base_utility!Method

buildbaseutility!(ECModel::AbstractEC, base_group::AbstractGroupANC)

When in the CO case the ANC model is used as base case, then this function builds the corresponding constraint

EnergyCommunity.build_base_utility!Method

buildbaseutility!(ECModel::AbstractEC, base_group::AbstractGroupNC)

When in the CO case the NC model is used as base case, then this function builds the corresponding constraint

EnergyCommunity.build_base_utility!Method

buildbaseutility!(ECModel::AbstractEC, noaggregatorgroup::AbstractGroupANC)

When in the CO case the ANC model is used as reference case for when the aggregator is not in the group, then this function builds the corresponding constraint

EnergyCommunity.build_least_profitable!Method

buildleastprofitable!(ECModel::AbstractEC; noaggregatorgroup::AbstractGroup=GroupNC(), add_EC=true)

Function to build the model to identify the least profitable coalition

EnergyCommunity.build_no_agg_utility!Method

buildnoaggutility!(ECModel::AbstractEC, noaggregatorgroup::AbstractGroupANC; basemodel=nothing)

When in the CO case the ANC model is used as reference case for when the aggregator is not in the group, then this function builds the corresponding constraint

EnergyCommunity.build_no_agg_utility!Method

buildnoaggutility!(ECModel::AbstractEC, noaggregator_group::AbstractGroupNC; kwargs...)

When the NC case is the reference value when no aggregator is available, then no changes in the model are required

EnergyCommunity.build_noagg_least_profitable!Method

buildnoaggleastprofitable(ECModel::ModelEC; usenotations=false, optimizer=nothing)

Function to create an ecmodel that returns the least profitable coalition for ANC models

EnergyCommunity.business_planFunction
business_plan(ECModel::AbstractEC, profit_distribution)

Function to describe the cost term distributions by all users for all years.

Parameters

  • ECModel : AbstractEC EnergyCommunity model
  • profit_distribution Final objective function
  • usersetfinancial User set to be considered for the financial analysis

Returns

The output value is a NamedTuple with the following elements
- df_business
    Dataframe with the business plan information
EnergyCommunity.business_plan_plotMethod
business_plan_plot(ECModel::AbstractEC, profit_distribution)

Function to describe the cost term distributions by all users for all years.

Parameters

  • ECModel : AbstractEC EnergyCommunity model
  • df_business Dataframe with the business plan information
  • plot_struct Plot structure of the business plan

Returns

The output value is a plot with the business plan information
EnergyCommunity.calculate_energy_ratiosMethod
calculate_energy_ratios(users_data, _P_ren_us, user_agg_set, agg_id, time_set, _P_tot_us, _x_us)

Calculate energy ratios '''

Outputs

  • PV_frac
  • PVfractot
  • wind_frac
  • windfractot

'''

EnergyCommunity.calculate_grid_exportMethod
calculate_grid_export(ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid export for the energy community and users. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- grid_frac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

EnergyCommunity.calculate_grid_exportMethod
calculate_grid_export(::AbstractGroupANC, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid export for the Aggregated Non Cooperative case. Output is normalized with respect to the demand when perunit is true ''' Outputs –––- gridfrac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

EnergyCommunity.calculate_grid_exportMethod
calculate_grid_export(::AbstractGroupCO, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid export for the Cooperative case. Output is normalized with respect to the demand when perunit is true ''' Outputs –––- gridfrac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

EnergyCommunity.calculate_grid_exportMethod
calculate_grid_export(::AbstractGroupNC, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid export for the Non-Cooperative case Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- grid_frac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

EnergyCommunity.calculate_grid_importMethod
calculate_grid_import(ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid usage for the energy community and users. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- grid_frac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

EnergyCommunity.calculate_grid_importMethod
calculate_grid_import(::AbstractGroupANC, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid usage for the Aggregated Non Cooperative case. Output is normalized with respect to the demand when perunit is true ''' Outputs –––- gridfrac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

EnergyCommunity.calculate_grid_importMethod
calculate_grid_import(::AbstractGroupCO, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid usage for the Cooperative case. Output is normalized with respect to the demand when perunit is true ''' Outputs –––- gridfrac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

EnergyCommunity.calculate_grid_importMethod
calculate_grid_import(::AbstractGroupNC, ECModel::AbstractEC; per_unit::Bool=true)

Calculate grid usage for the Non-Cooperative case Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- grid_frac : DenseAxisArray Reliance on the grid demand for each user and the aggregation '''

EnergyCommunity.calculate_productionMethod
calculate_production(ECModel::AbstractEC)

Function to calculate the energy production by user Outputs –––- productionusEC : DenseAxisArray DenseAxisArray representing the production by the EC and each user

EnergyCommunity.calculate_production_sharesMethod
calculate_production_shares(ECModel::AbstractEC; per_unit::Bool=true)

Calculate energy ratio by energy production resource for a generic group Output is normalized with respect to the demand when per_unit is true '''

Outputs

frac : DenseAxisArray DenseAxisArray describing the share of energy production by energy resource by user and the entire system, normalized with respect to the demand of the corresponding group

'''

EnergyCommunity.calculate_self_consumptionMethod
calculate_self_consumption(ECModel::AbstractEC; per_unit::Bool=true)

Calculate the demand that each user meets using its own sources, or self consumption. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

EnergyCommunity.calculate_self_productionMethod
calculate_self_production(ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the self production for each user. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- sharedenfrac : DenseAxisArray Shared energy for each user and the aggregation '''

EnergyCommunity.calculate_shared_consumptionMethod
calculate_shared_consumption(ECModel::AbstractEC; per_unit::Bool=true)

Calculate the demand that each user meets using its own sources or other users. When onlyshared is false, also self consumption is considered, otherwise only shared consumption. Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

EnergyCommunity.calculate_shared_consumptionMethod
calculate_shared_consumption(::AbstractGroupANC, ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the demand that each user meets using its own sources or other users for the Aggregated Non Cooperative case. In this case, there can be shared energy, non only self consumption. When onlyshared is false, also self consumption is considered, otherwise only shared energy. Shared energy means energy that is shared between Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

EnergyCommunity.calculate_shared_consumptionMethod
calculate_shared_consumption(::AbstractGroupCO, ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the demand that each user meets using its own sources or other users for the Cooperative case. In the Cooperative case, there can be shared energy, non only self consumption. When onlyshared is false, also self consumption is considered, otherwise only shared energy. Shared energy means energy that is shared between Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

EnergyCommunity.calculate_shared_consumptionMethod
calculate_shared_consumption(::AbstractGroupNC, ECModel::AbstractEC; kwargs...)

Calculate the demand that each user meets using its own sources or other users for the Non-Cooperative case. In the Non-Cooperative case, there is no shared energy, only self consumption. Shared energy means energy that is shared between Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

EnergyCommunity.calculate_shared_energy_abs_aggMethod
calculate_shared_energy_abs_agg(users_data, user_set, time_set,
    _P_ren_us, _P_tot_us, shared_en_frac, shared_cons_frac)

Calculate the absolute shared produced energy (en), the shared consumption (cons) and self consumption (self cons) '''

Outputs

  • sharedenfracusagg
  • sharedentotfracagg
  • sharedconsfracusagg
  • sharedconstotfracagg
  • selfconsfracusagg
  • selfconstotfracagg

'''

EnergyCommunity.calculate_shared_energy_aggMethod
calculate_shared_energy(users_data, user_agg_set, agg_id, time_set,
    _P_ren_us, _P_tot_us, shared_en_frac, shared_cons_frac)

Calculate the shared produced energy (en) and the shared consumption (cons) ratios '''

Outputs

  • sharedenfracusagg
  • sharedentotfracagg
  • sharedconsfracusagg
  • sharedconstotfracagg

'''

EnergyCommunity.calculate_shared_productionMethod
calculate_shared_production(ECModel::AbstractEC; per_unit::Bool=true)

Calculate the energy that each user produces and uses in its own POD or it is commercially consumed within the EC, when creaded. When onlyshared is false, also self production is considered, otherwise only shared energy. Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedconsfrac : DenseAxisArray Shared consumption for each user and the aggregation '''

EnergyCommunity.calculate_shared_productionMethod
calculate_shared_production(::AbstractGroupANC, ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the shared produced energy for the Aggregated Non Cooperative case. In this case, there can be shared energy between users, not only self production. When onlyshared is false, also self production is considered, otherwise only shared energy. Shared energy means energy that is shared between Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedenfrac : DenseAxisArray Shared energy for each user and the aggregation '''

EnergyCommunity.calculate_shared_productionMethod
calculate_shared_production(::AbstractGroupCO, ECModel::AbstractEC; per_unit::Bool=true, only_shared::Bool=false)

Calculate the shared produced energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production. When onlyshared is false, also self production is considered, otherwise only shared energy. Shared energy means energy that is shared between Output is normalized with respect to the demand when perunit is true

''' Outputs –––- sharedenfrac : DenseAxisArray Shared energy for each user and the aggregation '''

EnergyCommunity.calculate_shared_productionMethod
calculate_shared_production(::AbstractGroupNC, ECModel::AbstractEC; kwargs...)

Calculate the shared produced energy for the Non-Cooperative case. In the Non-Cooperative case, there is no shared energy between users, only self production. Output is normalized with respect to the demand when per_unit is true

''' Outputs –––- sharedenfrac : DenseAxisArray Shared energy for each user and the aggregation '''

EnergyCommunity.calculate_time_shared_consumptionMethod
calculate_time_shared_consumption(ECModel::AbstractEC)

Calculate the time series of the shared consumed energy for the Energy Community.

For every time step and user, this time series highlight the quantity of load that is met by using shared energy.

''' Outputs –––- sharedconsus : DenseAxisArray Shared consumption for each user and the aggregation and time step '''

EnergyCommunity.calculate_time_shared_consumptionMethod
calculate_time_shared_consumption(::AbstractGroupANC, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared consumed energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of load that is met by using shared energy.

''' Outputs –––- sharedconsus : DenseAxisArray Shared consumption for each user and the aggregation and time step '''

EnergyCommunity.calculate_time_shared_consumptionMethod
calculate_time_shared_consumption(::AbstractGroupCO, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared consumed energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of load that is met by using shared energy.

''' Outputs –––- sharedconsus : DenseAxisArray Shared consumption for each user and the aggregation and time step '''

EnergyCommunity.calculate_time_shared_consumptionMethod
calculate_time_shared_consumption(::AbstractGroupNC, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared consumed energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of load that is met by using shared energy.

''' Outputs –––- sharedconsus : DenseAxisArray Shared consumption for each user and the aggregation and time step '''

EnergyCommunity.calculate_time_shared_productionMethod
calculate_time_shared_production(ECModel::AbstractEC; kwargs...)

Calculate the time series of the shared consumed energy for the Energy Community.

For every time step and user, this time series highlight the quantity of production that meets needs by other users.

''' Outputs –––- sharedprodus : DenseAxisArray Shared production for each user and the aggregation and time step '''

EnergyCommunity.calculate_time_shared_productionMethod
calculate_time_shared_production(::AbstractGroupANC, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared produced energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of production that meets needs by other users.

''' Outputs –––- sharedprodus : DenseAxisArray Shared production for each user and the aggregation and time step '''

EnergyCommunity.calculate_time_shared_productionMethod
calculate_time_shared_production(::AbstractGroupCO, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared produced energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of production that meets needs by other users.

''' Outputs –––- sharedprodus : DenseAxisArray Shared production for each user and the aggregation and time step '''

EnergyCommunity.calculate_time_shared_productionMethod
calculate_time_shared_production(::AbstractGroupNC, ECModel::AbstractEC; add_EC=true, kwargs...)

Calculate the time series of the shared produced energy for the Cooperative case. In the Cooperative case, there can be shared energy between users, not only self production.

For every time step and user, this time series highlight the quantity of production that meets needs by other users.

''' Outputs –––- sharedprodus : DenseAxisArray Shared production for each user and the aggregation and time step '''

EnergyCommunity.data_sankeyMethod
plot_sankey(ECModel::AbstractEC)

Function to create the input data for plotting any Sankey diagram representing the energy flows across the energy community

Inputs

ECModel : AbstractEC Energy Community model name_units : (optional) Vector Labels used for the sankey diagram with the following order: "Market buy", [users labels], "Community", "Market sell", [users labels]

EnergyCommunity.explode_dataMethod

Return main data elements of the dataset of the ECModel: general parameters, users data and market data

EnergyCommunity.finalize_results!Method

finalize_results!(::AbstractGroupANC, ECModel::AbstractEC)

Function to finalize the results of the Aggregated Non Cooperative model after the execution

EnergyCommunity.finalize_results!Method

finalize_results!(::AbstractGroupCO, ECModel::AbstractEC)

Function to finalize the results of the Cooperative model after the execution Nothing to do

EnergyCommunity.finalize_results!Method

finalize_results!(::AbstractGroupNC, ECModel::AbstractEC)

Function to finalize the results of the Non Cooperative model after the execution Many of the variables are set to zero due to the absence of cooperation between users

EnergyCommunity.has_typeMethod

Auxiliary function to check if the key 'type' is available in the dictionary d, otherwise false

EnergyCommunity.load!Method
load!(output_file::AbstractString, ECModel::AbstractEC)

Function to save the results and the model to the hard drive

EnergyCommunity.parse_dataprofileMethod

Function to parse a personalized processing to generate the data When profile_value is a dictionary, then the user is asking a custom processing of data by a function

EnergyCommunity.plot_sankeyMethod
plot_sankey(ECModel::AbstractEC, sank_data::Dict)

Function to plot the Sankey diagram representing the energy flows across the energy community. This function can be used to plot the sankey diagram of already processed data sank_data.

Inputs

ECModel : AbstractEC Energy Community model name_units : (optional) Vector Labels used for the sankey diagram with the following order: "Market buy", [users labels], "Community", "Market sell", [users labels]

EnergyCommunity.plot_sankeyMethod
plot_sankey(ECModel::AbstractEC)

Function to plot the Sankey diagram representing the energy flows across the energy community

Inputs

ECModel : AbstractEC Energy Community model name_units : (optional) Vector Labels used for the sankey diagram with the following order: "Market buy", [users labels], "Community", "Market sell", [users labels]

EnergyCommunity.prepare_summaryMethod
prepare_summary(::AbstractGroupANC, ECModel::AbstractEC;
    user_set::Vector=Vector())

Save base excel file with a summary of the results for the Aggregated Non Cooperative case

EnergyCommunity.prepare_summaryMethod
prepare_summary(::AbstractGroupCO, ECModel::AbstractEC;
    user_set::Vector=Vector())

Save base excel file with a summary of the results for the Cooperative case

EnergyCommunity.prepare_summaryMethod
prepare_summary(::AbstractGroupNC, ECModel::AbstractEC, file_summary_path::AbstractString;
    user_set::Vector=Vector())

Prepare the dataframe lists to be saved in an excel file

Outputs

output_list: Vector{Pair{String, DataFrame}} Vector of pairs representing the sheets of the Excel file and the corresponding data to save

EnergyCommunity.print_summaryMethod

Function to print a summary of the results of the model. The function dispatches the execution to the appropriate function depending on the Aggregation type of the EC

EnergyCommunity.save_summaryMethod

Function to save a summary of the results of the model. The function dispatches the execution to the appropriate function depending on the Aggregation type of the EC

EnergyCommunity.set_least_profitable_profit!Method

setleastprofitableprofit!(ECModel::AbstractEC, profitdistribution)

Function to set the profit distribution of the least profitable problem

Parameters

ECModel : ModelEC Model of the community profit_distribution : AbstractDict Profit distribution per user

EnergyCommunity.split_financial_termsFunction
split_financial_terms(ECModel::AbstractEC, profit_distribution)

Function to describe the cost term distributions by all users.

Parameters

  • ECModel : AbstractEC EnergyCommunity model
  • profit_distribution Final objective function

Returns

The output value is a NamedTuple with the following elements
- NPV: the NPV of each user given the final profit_distribution adjustment
by game theory techniques
- CAPEX: the annualized CAPEX
- OPEX: the annualized operating costs (yearly maintenance and yearly peak and energy grid charges)
- REP: the annualized replacement costs
- RV: the annualized recovery charges
- REWARD: the annualized reward distribution by user
- PEAK: the annualized peak costs
- EN_SELL: the annualized revenues from energy sales
- EN_BUY: the annualized costs from energy consumption and buying
- EN_NET: the annualized net energy costs
EnergyCommunity.split_yearly_financial_termsFunction

splityearlyfinancialterms(ECModel::AbstractEC, profitdistribution)

Function to describe the cost term distributions by all users for all years.

Parameters

  • ECModel : AbstractEC EnergyCommunity model
  • profit_distribution Final objective function
  • usersetfinancial User set to be considered for the financial analysis

Returns

The output value is a NamedTuple with the following elements
- NPV: the NPV of each user given the final profit_distribution adjustment by game theory techniques
- CAPEX: the annualized CAPEX
- OPEX: the annualized operating costs (yearly maintenance and yearly peak and energy grid charges)
- REP: the annualized replacement costs
- RV: the annualized recovery charges
- REWARD: the annualized reward distribution by user
- PEAK: the annualized peak costs
- EN_SELL: the annualized revenues from energy sales
- EN_BUY: the annualized costs from energy consumption and buying
- EN_NET: the annualized net energy costs
EnergyCommunity.to_least_profitable_coalition_callbackMethod
to_least_profitable_coalition_callback(ECModel::AbstractEC, base_group::AbstractGroup=GroupNC(); no_aggregator_group::AbstractGroup=GroupNC())

Function that returns a callback function that, given as input a profit distribution scheme, returns the coalition that has the least benefit in remaining in the grand coalition. The returned function leastprofitablecoalition_callback accepts an AbstractDict as argument that specifies the profit distribution by user that is used to compute the least benefit procedure.

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown. basegroup : AbstractGroup (optional, default GroupNC()) Base group with respect the benefit is calculated. noaggregatorgroup : AbstractGroup (optional, default GroupNC()) Type of aggregation group of the community when no aggregator is available When not provided, an equivalent NonCooperative model is created and the corresponding utilities by user are used as reference case. numberofsolutions : (optional, default 1) Number of solutions to be returned at every iteration numberofsolutions <= 0: all solutions are returned numberofsolutions >= 1: specific number of solutions are returned relaxcombinatorial : (optional, default false) When true, the full least profitable coalition MILP problem is relaxed to continuous, in the combinatorial part directmodel : (optional, default false) When true the JuMP model is direct callbacksolution : Dict (optional, default empty) Dictionary of callbacks depending on the termination status of the optimization. Keys shall be of type JuMP.TerminationStatusCode, and outputs a function with as argument a ModelEC branchingpriorities : Bool (optional, default true) Option to specify if add the branching priorities decomposeANC : Bool (optional, default false) When True, if the noaggregatorgroup is ANC and, then the main optimization model is decomposed into two models: (a) when no Aggregator is in the coalition and (b) when the aggregator is in the coalition In this case, (a) is optimized first and if the optimization is beyond a given threshold, the execution is terminated without optimizing (b). The threshold is provided as an optional input in the callback function returned by the function. Otherwise the optimization continues with (b). decomposereltolerance : Float Relative tolerance of the decomposeANC procedure that compares the stopping criterion with the current result decomposeabstolerance : Float Absolute tolerance of the decomposeANC procedure that compares the stopping criterion with the current result

Return

leastprofitablecoalition_callback : Function Function that accepts as input an AbstractDict representing the benefit distribution by user

EnergyCommunity.to_objective_callback_by_subgroupMethod
to_objective_callback_by_subgroup(ECModel::AbstractEC)

Function that returns a callback function that quantifies the objective of a given subgroup of users The returned function objective_func accepts as arguments an AbstractVector of users and returns the objective of the aggregation for any model

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown.

Return

objectivecallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

EnergyCommunity.to_objective_callback_by_subgroupMethod
to_objective_callback_by_subgroup(::AbstractGroupANC, ECModel::AbstractEC)

Function that returns a callback function that quantifies the objective of a given subgroup of users The returned function objective_func accepts as arguments an AbstractVector of users and returns the objective of the aggregation for Aggregated Non Cooperative models

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown. base_model : AbstractEC optional When provided, it represents the base model used to perform the calculations

Return

objectivecallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

EnergyCommunity.to_objective_callback_by_subgroupMethod
to_objective_callback_by_subgroup(::AbstractGroupCO, ECModel::AbstractEC)

Function that returns a callback function that quantifies the objective of a given subgroup of users The returned function objective_func accepts as arguments an AbstractVector of users and returns the objective of the aggregation for Aggregated Cooperative models

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown. noaggregatorgroup : AbstractGroup (otional, default NonCooperative) EC group type when no aggregator is considered

Return

objectivecallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

EnergyCommunity.to_objective_callback_by_subgroupMethod
to_objective_callback_by_subgroup(::AbstractGroupNC, ECModel::AbstractEC)

Function that returns a callback function that quantifies the objective of a given subgroup of users The returned function objective_func accepts as arguments an AbstractVector of users and returns the objective of the aggregation for Non Cooperative models

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown.

Return

objectivecallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

EnergyCommunity.to_utility_callback_by_subgroupMethod
to_utility_callback_by_subgroup(ECModel::AbstractEC, base_group_type::AbstractGroup)

Function that returns a callback function that quantifies the benefit of a given subgroup of users The returned function utility_func accepts as arguments an AbstractVector of users and returns the benefit with respect to the base case of the users optimized independently

Parameters

ECModel : AbstractEC Cooperative EC Model of the EC to study. When the model is not cooperative an error is thrown. basegrouptype : AbstractGroup Type of the base case to consider noaggregatorgroup : AbstractGroup (otional, default NonCooperative) EC group type for when no aggregator is considered

Return

utilitycallbackby_subgroup : Function Function that accepts as input an AbstractVector (or Set) of users and returns as output the benefit of the specified community

FileIO.loadMethod
load(output_file::AbstractString)

Function to save the results and the model to the hard drive

FileIO.saveMethod
save(output_file::AbstractString, ECModel::AbstractEC)

Function to save the results and the model to the hard drive

JuMP.termination_statusMethod
termination_status(ECModel::AbstractEC)

Calculate the optimization status of the model

RecipesBase.plotMethod

Function to plot the results of the Aggregated non cooperative configuration

RecipesBase.plotMethod
plot(::AbstractGroupNC, ECModel::AbstractEC, output_plot_file::AbstractString;
    user_set::Vector=Vector(), line_width=2.0)

Function to plot the results of the user model