From 22633dd9194fbd68bb8e515c4a9e1d591a1a75d9 Mon Sep 17 00:00:00 2001 From: marynve Date: Fri, 21 Jun 2024 10:13:10 +0200 Subject: [PATCH 01/28] add get_distribution_method --- src/io.jl | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/io.jl b/src/io.jl index 92bc524..4b0644e 100644 --- a/src/io.jl +++ b/src/io.jl @@ -10,6 +10,7 @@ struct DefaultJulESInput <: AbstractJulESInput datayear::Int weatheryear::Int onlysubsystemmodel::Bool # TODO: can probably remove this + steps::Int steplength::Millisecond @@ -29,6 +30,7 @@ struct DefaultJulESInput <: AbstractJulESInput settings = config[mainconfig["settings"]] numcores = mainconfig["numcores"] cores = collect(1:numcores) + onlysubsystemmodel = false if !haskey(settings["problems"], "prognosis") && !haskey(settings["problems"], "endvalue") && haskey(settings["problems"], "stochastic") && !haskey(settings["problems"], "clearing") @@ -95,6 +97,8 @@ get_phaseinsteps(input::DefaultJulESInput) = input.phaseinsteps get_horizons(input::DefaultJulESInput) = input.horizons +get_distribution_method(input::DefaultJulESInput) = get_mainconfig(input)["distribution_method"] + function get_datascenarios(datayear::Int64, weatheryear::Int64, weekstart::Int64, datanumscen::Int64, simtimetype::String) # Standard time for market clearing - perfect information so simple time type datasimtime = getisoyearstart(datayear) + Week(weekstart-1) From 32a3c0d59411a9473f516853824b778d6d9f1843 Mon Sep 17 00:00:00 2001 From: marynve Date: Fri, 21 Jun 2024 10:31:41 +0200 Subject: [PATCH 02/28] add two distribution functions stoch --- src/generic_io.jl | 129 ++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 125 insertions(+), 4 deletions(-) diff --git a/src/generic_io.jl b/src/generic_io.jl index 759e602..42394f9 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -14,6 +14,7 @@ function get_dist_ppp(input::AbstractJulESInput) for s in 1:S j = (s - 1) % N + 1 + #println("j in get_dist_ppp is $j") dist[s] = (s, cores[j]) end @@ -26,10 +27,15 @@ How end value problems (evp) are distributed on cores initially function get_dist_evp(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) cores = get_cores(input) - N = length(cores) - S = get_numscen_sim(input) + N = length(cores) #number of cores + S = get_numscen_sim(input) #number of scenarios Y = length(subsystems) + # println("Y is $Y") + # println("N is $N") + # println("S is $S") + + out = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, S*Y) if N >= S*Y @@ -38,6 +44,7 @@ function get_dist_evp(input::AbstractJulESInput, subsystems::Vector{Tuple{Subsys for scenix in 1:S k += 1 out[k] = (scenix, subix, cores[k]) + #println("scenix is $scenix , k is $k") end end return out @@ -50,7 +57,9 @@ function get_dist_evp(input::AbstractJulESInput, subsystems::Vector{Tuple{Subsys for scenix in 1:S k += 1 j = (scenix - 1) % N + 1 + #println("j is $j") out[k] = (scenix, subix, cores[j]) + #println("N < S*Y, scenix is $scenix , k is $k") end end return out @@ -83,8 +92,18 @@ Scenario problems (sp) will be put on the same core as master problems (mp). function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) cores = get_cores(input) subsystems_desc = get_subsystem_ids_by_decending_size(subsystems) + + distribution_method = get_distribution_method(input) + # println(method) + #distribution_method = config[method]["subsystems"]["distribution_function"] - dist_mp = _distribute_subsystems_by_size!(subsystems_desc, cores) + if distribution_method == "random" + dist_mp = _distribute_subsystems_randomly!(subsystems_desc, cores) + elseif distribution_method == "by_size" + dist_mp = _distribute_subsystems_by_size!(subsystems_desc, cores) + elseif distribution_method == "greedy" + _distribute_subsystems_elements_smarter!(subsystems, cores) + end N = get_numscen_stoch(input) dist_sp = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, N*length(dist_mp)) @@ -99,6 +118,29 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs return (dist_mp, dist_sp) end + + + + +function _distribute_subsystems_randomly!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) + + #println("subsystems: $subsystems") + dist = Tuple{SubsystemIx, CoreId}[] + + for sub in subsystems + # Randomly select a core + core = rand(cores) + + #println("sub is $sub, core is $core") + # Assign the subsystem to the randomly selected core + push!(dist, (sub, core)) + end + + return dist +end + + + function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) N = length(cores) @@ -108,9 +150,12 @@ function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores: while length(subsystems) > 0 K = length(subsystems) M = min(K, N) - + # println("M is $M") + # println("K is $K") if loop_forward for i in 1:M + #println("i is $i") + push!(dist, (subsystems[i], cores[i])) end subsystems = subsystems[(M+1):end] @@ -128,12 +173,88 @@ function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores: return dist end + +# elements_all = get_elements(input) +# elements_ix_in_subsystem = get_dataelements(s) +# elements_in_subsystem = elements[elements_ix] +# for element in elements_in_subsystem +# if element.conceptname == "Storage" + function get_subsystem_ids_by_decending_size(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) subsystems = [(length(get_dataelements(s)), ix) for (ix, s) in subsystems] sort!(subsystems, rev=true) return [ix for (n, ix) in subsystems] end +function _distribute_subsystems_elements_smarter!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) + + + num_cores = length(cores) + + dist = Tuple{SubsystemIx, CoreId}[] + # Initialize an array to hold the load (number of data elements) for each core + core_loads = fill(0, num_cores) + println("1") + sorted_elements = get_sorted_subsystem_number_of_elements(subsystems) + println(typeof(sorted_elements)) + println(sorted_elements) + for (subsystem_index, num_elements) in sorted_elements + # Find the core with the least load + min_load_core_index = argmin(core_loads) + # Assign the subsystem to this core + push!(dist,(subsystem_index,min_load_core_index)) + # Update the load for this core + core_loads[min_load_core_index] += num_elements + end + return dist +end + + + +#function to get a tuple(subsystem index, number of data elements) that is sorted from highest to lowest number of data elements in the subsystem +#function get_sorted_subsystem_number_of_elements(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) +function get_sorted_subsystem_number_of_elements(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) + + dataelements_in_each_subsystem = Tuple{SubsystemIx, Int}[] + + for (ix, s) in subsystems + + data_elements_in_sub= get_dataelements(s) + number_data_elements = length(data_elements_in_sub) + + # Create a tuple (data_element_index, number_data_elements) + data_tuple = (ix, number_data_elements) + + # Add the tuple to the dataelements array + push!(dataelements_in_each_subsystem, data_tuple) + end + + + #want to sort the tuple by the number of data_elements in each subsystem: + sorted_dataelements = sort(dataelements_in_each_subsystem, by = x -> x[2], rev=true) + + return sorted_dataelements +end + + +function distribute_subsystems_cores(sorted_subsystems::Vector{Tuple{Int, Int}}, num_cores::Int) + # Initialize an array to hold the load (number of data elements) for each core + core_loads = fill(0, num_cores) + # Initialize an array to hold the subsystems assigned to each core + core_assignments = [Vector{Int}() for _ in 1:num_cores] + + for (subsystem_index, num_elements) in sorted_subsystems + # Find the core with the least load + min_load_core = argmin(core_loads) + # Assign the subsystem to this core + push!(core_assignments[min_load_core], subsystem_index) + # Update the load for this core + core_loads[min_load_core] += num_elements + end + + return core_assignments +end + """ Find which subsystems should have evp and stoch problems """ From fd6c3d60c358a3ca8a126177247338ce53435b52 Mon Sep 17 00:00:00 2001 From: marynve Date: Fri, 21 Jun 2024 10:35:11 +0200 Subject: [PATCH 03/28] add random to demo --- demos/Demo prognosis.ipynb | 3697 +++++++++++++++++++++++++++++++++++- 1 file changed, 3675 insertions(+), 22 deletions(-) diff --git a/demos/Demo prognosis.ipynb b/demos/Demo prognosis.ipynb index 8e90dcd..59d1ed4 100644 --- a/demos/Demo prognosis.ipynb +++ b/demos/Demo prognosis.ipynb @@ -18,38 +18,105 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "6d67dd8b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1mProject\u001b[22m\u001b[39m JulES v0.1.0\n", + "\u001b[32m\u001b[1mStatus\u001b[22m\u001b[39m `X:\\Prosjekter\\2022_FoU_markedsmodell_julia\\Brukere\\mary\\JulES\\Project.toml`\n", + " \u001b[90m[336ed68f] \u001b[39mCSV v0.10.14\n", + " \u001b[90m[aaaa29a8] \u001b[39mClustering v0.15.7\n", + " \u001b[90m[a93c6f00] \u001b[39mDataFrames v1.6.1\n", + " \u001b[90m[aaf54ef3] \u001b[39mDistributedArrays v0.6.7\n", + "\u001b[32m⌃\u001b[39m \u001b[90m[31c24e10] \u001b[39mDistributions v0.25.107\n", + " \u001b[90m[7073ff75] \u001b[39mIJulia v1.24.2\n", + " \u001b[90m[682c06a0] \u001b[39mJSON v0.21.4\n", + " \u001b[90m[f0f68f2c] \u001b[39mPlotlyJS v0.18.13\n", + " \u001b[90m[91a5bcdd] \u001b[39mPlots v1.40.4\n", + "\u001b[32m⌃\u001b[39m \u001b[90m[aea7be01] \u001b[39mPrecompileTools v1.2.0\n", + " \u001b[90m[08abe8d2] \u001b[39mPrettyTables v2.3.2\n", + " \u001b[90m[295af30f] \u001b[39mRevise v3.5.14\n", + " \u001b[90m[970f5c25] \u001b[39mTuLiPa v0.1.0 `https://github.com/NVE/TuLiPa.git#redesign_JulES`\n", + "\u001b[32m⌃\u001b[39m \u001b[90m[ddb6d928] \u001b[39mYAML v0.4.9\n", + " \u001b[90m[ade2ca70] \u001b[39mDates\n", + " \u001b[90m[8ba89e20] \u001b[39mDistributed\n", + " \u001b[90m[10745b16] \u001b[39mStatistics v1.9.0\n", + "\u001b[36m\u001b[1mInfo\u001b[22m\u001b[39m Packages marked with \u001b[32m⌃\u001b[39m have new versions available and may be upgradable.\n" + ] + } + ], "source": [ "using Pkg; Pkg.status()\n", "# Pkg.add(\"CSV\"); Pkg.add(\"Revise\"); Pkg.add(\"Plots\"); Pkg.add(\"PlotlyJS\"); Pkg.add(\"PrettyTables\")\n", "# Pkg.update(\"TuLiPa\") # uncomment to update TuLiPa to latest version\n", "# Pkg.develop(path=joinpath(dirname(dirname(pwd())),\"TuLiPa\")); Pkg.status() # go to development version\n", "# Pkg.undo(); Pkg.status() # go back to main package version\n", - "# Pkg.add(url=\"https://github.com/NVE/TuLiPa.git\"); Pkg.status() # alternative go back to latest version" + "#Pkg.add(url=\"https://github.com/NVE/TuLiPa.git\", rev=\"redesign_JulES\"); Pkg.status() # alternative go back to latest version" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "ecbf4aa8", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.webio.node+json": { + "children": [], + "instanceArgs": { + "namespace": "html", + "tag": "div" + }, + "nodeType": "DOM", + "props": {}, + "type": "node" + }, + "text/html": [ + "
\n", + "

The WebIO Jupyter extension was not detected. See the\n", + "\n", + " WebIO Jupyter integration documentation\n", + "\n", + "for more information.\n", + "

\n" + ], + "text/plain": [ + "WebIO._IJuliaInit()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ - "using DataFrames, Statistics, JSON, Distributed, Clustering, YAML, Distributions, Revise, Plots, PrettyTables\n", + "using DataFrames, Statistics, JSON, Distributed, Clustering, YAML, Distributions, Revise, Plots, PrettyTables, Random\n", "plotlyjs(); # uncomment for interactive plots" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 32, "id": "a8a9f2cf", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "2024" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# config = YAML.load_file(joinpath(\"data\", \"config_jules_prognose.yml\")) # config without datasets\n", "config = YAML.load_file(joinpath(\"data\", \"config_jules_prognose_demo.yml\")) # config with NVE datasets\n", @@ -67,10 +134,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "3971d0bb", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nprocs() = 5\n" + ] + } + ], "source": [ "const numcores = config[\"main\"][\"numcores\"]\n", "\n", @@ -83,7 +158,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "696e5ec2", "metadata": {}, "outputs": [], @@ -94,7 +169,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 34, "id": "d2448075", "metadata": {}, "outputs": [], @@ -104,10 +179,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "id": "35482c34", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "getdataset (generic function with 1 method)" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "function getdataset(config, weatheryear)\n", " settings = config[config[\"main\"][\"settings\"]]\n", @@ -167,8 +253,7 @@ " return Dict(\"elements\" => elements, \"elements_ppp\" => progelements, \"startmagdict\" => startmagdict, \"aggstartmagdict\" => aggstartmagdict, \"detailedrescopl\" => detailedrescopl)\n", " end\n", "end\n", - "\n", - "dataset = getdataset(config, weatheryear)" + "\n" ] }, { @@ -181,11 +266,387 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "id": "ca8bc8dd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time parameters\n", + " 0.000133 seconds (89 allocations: 3.844 KiB)\n", + "Handle elements\n", + " 0.000790 seconds (14.37 k allocations: 716.344 KiB)\n", + "Add local dbs\n", + " 0.011243 seconds (390 allocations: 21.234 KiB)\n", + "Add local cores\n", + " 0.000571 seconds (318 allocations: 14.078 KiB)\n", + "Add local input\n", + " 1.150356 seconds (163.52 k allocations: 5.548 MiB)\n", + "Add local dummyobjects\n", + " 0.369161 seconds (1.13 M allocations: 89.254 MiB)\n", + "Add local subsystems\n", + "Number of shortterm storagesystems 0\n", + "Number of longterm storagesystems 19\n", + " 0.105985 seconds (1.29 M allocations: 38.495 MiB)\n", + "Add local scenmod\n", + " 0.000755 seconds (321 allocations: 17.375 KiB)\n", + "Add local problem distribution\n", + "[(1, 1), (2, 2), (3, 3), (4, 4)]\n", + "[(1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, 4), (1, 2, 1), (2, 2, 2), (3, 2, 3), (4, 2, 4), (1, 3, 1), (2, 3, 2), (3, 3, 3), (4, 3, 4), (1, 4, 1), (2, 4, 2), (3, 4, 3), (4, 4, 4), (1, 5, 1), (2, 5, 2), (3, 5, 3), (4, 5, 4), (1, 6, 1), (2, 6, 2), (3, 6, 3), (4, 6, 4), (1, 7, 1), (2, 7, 2), (3, 7, 3), (4, 7, 4), (1, 8, 1), (2, 8, 2), (3, 8, 3), (4, 8, 4), (1, 9, 1), (2, 9, 2), (3, 9, 3), (4, 9, 4), (1, 10, 1), (2, 10, 2), (3, 10, 3), (4, 10, 4), (1, 11, 1), (2, 11, 2), (3, 11, 3), (4, 11, 4), (1, 12, 1), (2, 12, 2), (3, 12, 3), (4, 12, 4), (1, 13, 1), (2, 13, 2), (3, 13, 3), (4, 13, 4), (1, 14, 1), (2, 14, 2), (3, 14, 3), (4, 14, 4), (1, 15, 1), (2, 15, 2), (3, 15, 3), (4, 15, 4), (1, 16, 1), (2, 16, 2), (3, 16, 3), (4, 16, 4), (1, 17, 1), (2, 17, 2), (3, 17, 3), (4, 17, 4), (1, 18, 1), (2, 18, 2), (3, 18, 3), (4, 18, 4), (1, 19, 1), (2, 19, 2), (3, 19, 3), (4, 19, 4)]\n", + "[(19, 1), (17, 5), (16, 2), (15, 1), (14, 5), (12, 2), (11, 5), (10, 5), (7, 1), (6, 1), (5, 5), (4, 3), (3, 2), (2, 1), (1, 3), (18, 4), (13, 3), (9, 4), (8, 1)]\n", + "[(1, 19, 1), (1, 17, 5), (1, 16, 2), (1, 15, 1), (1, 14, 5), (1, 12, 2), (1, 11, 5), (1, 10, 5), (1, 7, 1), (1, 6, 1), (1, 5, 5), (1, 4, 3), (1, 3, 2), (1, 2, 1), (1, 1, 3), (1, 18, 4), (1, 13, 3), (1, 9, 4), (1, 8, 1), (2, 19, 1), (2, 17, 5), (2, 16, 2), (2, 15, 1), (2, 14, 5), (2, 12, 2), (2, 11, 5), (2, 10, 5), (2, 7, 1), (2, 6, 1), (2, 5, 5), (2, 4, 3), (2, 3, 2), (2, 2, 1), (2, 1, 3), (2, 18, 4), (2, 13, 3), (2, 9, 4), (2, 8, 1), (3, 19, 1), (3, 17, 5), (3, 16, 2), (3, 15, 1), (3, 14, 5), (3, 12, 2), (3, 11, 5), (3, 10, 5), (3, 7, 1), (3, 6, 1), (3, 5, 5), (3, 4, 3), (3, 3, 2), (3, 2, 1), (3, 1, 3), (3, 18, 4), (3, 13, 3), (3, 9, 4), (3, 8, 1), (4, 19, 1), (4, 17, 5), (4, 16, 2), (4, 15, 1), (4, 14, 5), (4, 12, 2), (4, 11, 5), (4, 10, 5), (4, 7, 1), (4, 6, 1), (4, 5, 5), (4, 4, 3), (4, 3, 2), (4, 2, 1), (4, 1, 3), (4, 18, 4), (4, 13, 3), (4, 9, 4), (4, 8, 1)]\n", + " 0.444825 seconds (205.19 k allocations: 12.704 MiB, 43.43% compilation time: 51% of which was recompilation)\n", + "Add local horizons\n", + " 1.375227 seconds (604.83 k allocations: 39.495 MiB, 56.43% compilation time)\n", + "Add local problems\n", + " 27.314695 seconds (13.43 M allocations: 906.464 MiB, 0.80% gc time, 45.76% compilation time)\n", + "Add local output\n", + " 0.360472 seconds (190.06 k allocations: 12.035 MiB, 99.83% compilation time: 13% of which was recompilation)\n", + "PrognosisTime(DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-29T00:00:00\"), DateTime(\"1991-01-28T00:00:00\"))\n", + "Startstates\n", + " 1.610177 seconds (370.98 k allocations: 24.247 MiB, 30.05% compilation time)\n", + "Price prognosis problems\n", + " 31.884334 seconds (19.03 M allocations: 1.182 GiB, 1.17% gc time, 47.95% compilation time)\n", + "End value problems\n", + " 2.220010 seconds (801.47 k allocations: 51.108 MiB, 55.07% compilation time)\n", + "Subsystem problems\n", + " 5.418691 seconds (1.97 M allocations: 127.483 MiB, 43.95% compilation time)\n", + "Clearing problem\n", + " 1.523355 seconds (472.82 k allocations: 28.987 MiB, 53.91% compilation time)\n", + "Update output\n", + " 3.002423 seconds (1.96 M allocations: 128.172 MiB, 84.48% compilation time)\n", + "PrognosisTime(DateTime(\"2024-01-31T00:00:00\"), DateTime(\"2024-01-31T00:00:00\"), DateTime(\"1991-01-30T00:00:00\"))\n", + "Startstates\n", + " 0.221641 seconds (68.51 k allocations: 4.678 MiB, 71.31% compilation time)\n", + "Price prognosis problems\n", + " 0.365376 seconds (274.94 k allocations: 8.969 MiB, 22.93% compilation time)\n", + "End value problems\n", + " 0.033307 seconds (744 allocations: 34.680 KiB, 32.55% compilation time)\n", + "Subsystem problems\n", + " 0.001457 seconds (945 allocations: 37.188 KiB)\n", + "Clearing problem\n", + " 0.027292 seconds (78.65 k allocations: 2.961 MiB)\n", + "Update output\n", + " 0.117519 seconds (93.23 k allocations: 5.995 MiB, 81.29% compilation time)\n", + "PrognosisTime(DateTime(\"2024-02-02T00:00:00\"), DateTime(\"2024-02-02T00:00:00\"), DateTime(\"1991-02-01T00:00:00\"))\n", + "Startstates\n", + " 0.001728 seconds (2.04 k allocations: 104.031 KiB)\n", + "Price prognosis problems\n", + " 0.305750 seconds (247.26 k allocations: 7.143 MiB, 36.86% gc time)\n", + "End value problems\n", + " 0.000654 seconds (494 allocations: 18.141 KiB)\n", + "Subsystem problems\n", + " 0.011659 seconds (945 allocations: 36.492 KiB)\n", + "Clearing problem\n", + " 0.026986 seconds (78.66 k allocations: 2.963 MiB)\n", + "Update output\n", + " 0.022008 seconds (8.15 k allocations: 381.344 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-04T00:00:00\"), DateTime(\"2024-02-04T00:00:00\"), DateTime(\"1991-02-03T00:00:00\"))\n", + "Startstates\n", + " 0.012131 seconds (2.05 k allocations: 105.078 KiB)\n", + "Price prognosis problems\n", + " 0.185098 seconds (245.53 k allocations: 7.019 MiB)\n", + "End value problems\n", + " 0.000755 seconds (493 allocations: 17.531 KiB)\n", + "Subsystem problems\n", + " 0.001569 seconds (945 allocations: 37.188 KiB)\n", + "Clearing problem\n", + " 0.036923 seconds (78.65 k allocations: 2.961 MiB)\n", + "Update output\n", + " 0.010894 seconds (8.15 k allocations: 381.281 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-06T00:00:00\"), DateTime(\"2024-02-06T00:00:00\"), DateTime(\"1991-02-05T00:00:00\"))\n", + "Startstates\n", + " 0.011642 seconds (2.05 k allocations: 240.312 KiB)\n", + "Price prognosis problems\n", + " 0.171500 seconds (245.53 k allocations: 7.018 MiB)\n", + "End value problems\n", + " 0.011080 seconds (500 allocations: 18.484 KiB)\n", + "Subsystem problems\n", + " 0.011829 seconds (1.06 k allocations: 46.969 KiB)\n", + "Clearing problem\n", + " 0.037338 seconds (78.65 k allocations: 2.962 MiB)\n", + "Update output\n", + " 0.010998 seconds (8.15 k allocations: 384.609 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-08T00:00:00\"), DateTime(\"2024-02-08T00:00:00\"), DateTime(\"1991-02-07T00:00:00\"))\n", + "Startstates\n", + " 0.011945 seconds (2.05 k allocations: 105.141 KiB)\n", + "Price prognosis problems\n", + " 0.171793 seconds (245.53 k allocations: 7.019 MiB)\n", + "End value problems\n", + " 0.000758 seconds (492 allocations: 17.281 KiB)\n", + "Subsystem problems\n", + " 0.001204 seconds (945 allocations: 37.188 KiB)\n", + "Clearing problem\n", + " 0.037033 seconds (78.78 k allocations: 2.973 MiB)\n", + "Update output\n", + " 0.021820 seconds (8.15 k allocations: 377.969 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-10T00:00:00\"), DateTime(\"2024-02-10T00:00:00\"), DateTime(\"1991-02-09T00:00:00\"))\n", + "Startstates\n", + " 0.012474 seconds (2.04 k allocations: 104.125 KiB)\n", + "Price prognosis problems\n", + " 0.182394 seconds (245.54 k allocations: 7.025 MiB)\n", + "End value problems\n", + " 0.001002 seconds (620 allocations: 28.734 KiB)\n", + "Subsystem problems\n", + " 0.001482 seconds (943 allocations: 36.328 KiB)\n", + "Clearing problem\n", + " 0.025064 seconds (78.65 k allocations: 2.962 MiB)\n", + "Update output\n", + " 0.022105 seconds (8.15 k allocations: 378.031 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-12T00:00:00\"), DateTime(\"2024-02-12T00:00:00\"), DateTime(\"1991-02-11T00:00:00\"))\n", + "Startstates\n", + " 0.001295 seconds (2.04 k allocations: 104.828 KiB)\n", + "Price prognosis problems\n", + " 0.179196 seconds (245.61 k allocations: 7.022 MiB)\n", + "End value problems\n", + " 0.011657 seconds (617 allocations: 28.047 KiB)\n", + "Subsystem problems\n", + " 0.001624 seconds (950 allocations: 37.312 KiB)\n", + "Clearing problem\n", + " 0.037453 seconds (79.28 k allocations: 3.006 MiB)\n", + "Update output\n", + " 0.021211 seconds (8.15 k allocations: 384.547 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-14T00:00:00\"), DateTime(\"2024-02-14T00:00:00\"), DateTime(\"1991-02-13T00:00:00\"))\n", + "Startstates\n", + " 0.011688 seconds (2.05 k allocations: 104.281 KiB)\n", + "Price prognosis problems\n", + " 0.560941 seconds (1.07 M allocations: 32.176 MiB, 4.95% compilation time)\n", + "End value problems\n", + " 0.026427 seconds (27.45 k allocations: 925.703 KiB)\n", + "Subsystem problems\n", + " 0.175272 seconds (96.09 k allocations: 3.878 MiB, 35.10% compilation time)\n", + "Clearing problem\n", + " 0.041502 seconds (88.22 k allocations: 3.323 MiB)\n", + "Update output\n", + " 0.011113 seconds (8.15 k allocations: 378.172 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-16T00:00:00\"), DateTime(\"2024-02-16T00:00:00\"), DateTime(\"1991-02-15T00:00:00\"))\n", + "Startstates\n", + " 0.001472 seconds (2.05 k allocations: 104.188 KiB)\n", + "Price prognosis problems\n", + " 0.197297 seconds (245.65 k allocations: 7.028 MiB)\n", + "End value problems\n", + " 0.013930 seconds (495 allocations: 18.391 KiB)\n", + "Subsystem problems\n", + " 0.001779 seconds (948 allocations: 36.453 KiB)\n", + "Clearing problem\n", + " 0.026273 seconds (78.65 k allocations: 2.962 MiB)\n", + "Update output\n", + " 0.021669 seconds (8.15 k allocations: 378.031 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-18T00:00:00\"), DateTime(\"2024-02-18T00:00:00\"), DateTime(\"1991-02-17T00:00:00\"))\n", + "Startstates\n", + " 0.011880 seconds (2.05 k allocations: 105.047 KiB)\n", + "Price prognosis problems\n", + " 0.184789 seconds (245.53 k allocations: 7.019 MiB)\n", + "End value problems\n", + " 0.011659 seconds (617 allocations: 28.047 KiB)\n", + "Subsystem problems\n", + " 0.011887 seconds (950 allocations: 37.312 KiB)\n", + "Clearing problem\n", + " 0.026922 seconds (78.65 k allocations: 2.961 MiB)\n", + "Update output\n", + " 0.022157 seconds (8.15 k allocations: 403.344 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-20T00:00:00\"), DateTime(\"2024-02-20T00:00:00\"), DateTime(\"1991-02-19T00:00:00\"))\n", + "Startstates\n", + " 0.001506 seconds (2.04 k allocations: 104.125 KiB)\n", + "Price prognosis problems\n", + " 0.191408 seconds (245.53 k allocations: 7.019 MiB)\n", + "End value problems\n", + " 0.011459 seconds (617 allocations: 28.047 KiB)\n", + "Subsystem problems\n", + " 0.001526 seconds (944 allocations: 36.391 KiB)\n", + "Clearing problem\n", + " 0.037827 seconds (78.65 k allocations: 2.961 MiB)\n", + "Update output\n", + " 0.011273 seconds (8.15 k allocations: 377.906 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-22T00:00:00\"), DateTime(\"2024-02-22T00:00:00\"), DateTime(\"1991-02-21T00:00:00\"))\n", + "Startstates\n", + " 0.001389 seconds (2.04 k allocations: 104.828 KiB)\n", + "Price prognosis problems\n", + " 0.192499 seconds (245.53 k allocations: 7.018 MiB)\n", + "End value problems\n", + " 0.000776 seconds (492 allocations: 17.281 KiB)\n", + "Subsystem problems\n", + " 0.011879 seconds (1.07 k allocations: 47.859 KiB)\n", + "Clearing problem\n", + " 0.038007 seconds (78.65 k allocations: 2.961 MiB)\n", + "Update output\n", + " 0.011997 seconds (8.15 k allocations: 377.906 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-24T00:00:00\"), DateTime(\"2024-02-24T00:00:00\"), DateTime(\"1991-02-23T00:00:00\"))\n", + "Startstates\n", + " 0.012040 seconds (2.05 k allocations: 104.219 KiB)\n", + "Price prognosis problems\n", + " 0.191848 seconds (245.65 k allocations: 7.029 MiB)\n", + "End value problems\n", + " 0.000843 seconds (492 allocations: 17.281 KiB)\n", + "Subsystem problems\n", + " 0.001309 seconds (946 allocations: 37.250 KiB)\n", + "Clearing problem\n", + " 0.038207 seconds (78.65 k allocations: 2.961 MiB)\n", + "Update output\n", + " 0.010469 seconds (8.15 k allocations: 378.891 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-26T00:00:00\"), DateTime(\"2024-02-26T00:00:00\"), DateTime(\"1991-02-25T00:00:00\"))\n", + "Startstates\n", + " 0.001550 seconds (2.05 k allocations: 105.141 KiB)\n", + "Price prognosis problems\n", + " 0.176722 seconds (245.53 k allocations: 7.019 MiB)\n", + "End value problems\n", + " 0.011612 seconds (619 allocations: 28.094 KiB)\n", + "Subsystem problems\n", + " 0.001350 seconds (943 allocations: 36.328 KiB)\n", + "Clearing problem\n", + " 0.036140 seconds (78.65 k allocations: 2.961 MiB)\n", + "Update output\n", + " 0.020744 seconds (8.15 k allocations: 378.031 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-28T00:00:00\"), DateTime(\"2024-02-28T00:00:00\"), DateTime(\"1991-02-27T00:00:00\"))\n", + "Startstates\n", + " 0.011884 seconds (2.04 k allocations: 104.125 KiB)\n", + "Price prognosis problems\n", + " 0.175584 seconds (245.53 k allocations: 7.019 MiB)\n", + "End value problems\n", + " 0.011913 seconds (612 allocations: 27.953 KiB)\n", + "Subsystem problems\n", + " 0.001342 seconds (945 allocations: 37.188 KiB)\n", + "Clearing problem\n", + " 0.041911 seconds (78.65 k allocations: 2.961 MiB)\n", + "Update output\n", + " 0.010780 seconds (8.15 k allocations: 377.906 KiB)\n", + "\n", + "The simulation took: 0.87 minutes\n", + "Time usage per simulation step: 3.27 seconds\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "
5×5 DataFrame
Rowmodelupdatesolveothertotal
StringFloat64Float64Float64Float64
1long37.67610.5073570.37723938.5607
2med0.7907350.3741930.7177131.88264
3short0.03500680.06291770.02217220.120097
4evp0.008929610.001131920.07817260.0882341
5clearing0.007783470.01606140.07901480.10286
" + ], + "text/latex": [ + "\\begin{tabular}{r|ccccc}\n", + "\t& model & update & solve & other & total\\\\\n", + "\t\\hline\n", + "\t& String & Float64 & Float64 & Float64 & Float64\\\\\n", + "\t\\hline\n", + "\t1 & long & 37.6761 & 0.507357 & 0.377239 & 38.5607 \\\\\n", + "\t2 & med & 0.790735 & 0.374193 & 0.717713 & 1.88264 \\\\\n", + "\t3 & short & 0.0350068 & 0.0629177 & 0.0221722 & 0.120097 \\\\\n", + "\t4 & evp & 0.00892961 & 0.00113192 & 0.0781726 & 0.0882341 \\\\\n", + "\t5 & clearing & 0.00778347 & 0.0160614 & 0.0790148 & 0.10286 \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m5×5 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m model \u001b[0m\u001b[1m update \u001b[0m\u001b[1m solve \u001b[0m\u001b[1m other \u001b[0m\u001b[1m total \u001b[0m\n", + " │\u001b[90m String \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", + "─────┼──────────────────────────────────────────────────────────\n", + " 1 │ long 37.6761 0.507357 0.377239 38.5607\n", + " 2 │ med 0.790735 0.374193 0.717713 1.88264\n", + " 3 │ short 0.0350068 0.0629177 0.0221722 0.120097\n", + " 4 │ evp 0.00892961 0.00113192 0.0781726 0.0882341\n", + " 5 │ clearing 0.00778347 0.0160614 0.0790148 0.10286" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
19×4 DataFrame
Rowsubixupdate_sumsolve_sumtotal_sum
AnyFloat64Float64Float64
11.00.1587090.001819651.63415
24.00.00063560.00142480.00646285
32.00.00075690.00135240.00347545
48.00.00065470.0012960.0024052
53.00.000648250.00129940.0023433
67.00.00056920.00141910.00233
717.00.000594850.001365550.0023151
814.00.00058670.001387950.0023136
912.00.00057540.00141770.00230505
1013.00.000584650.00119130.00219825
1118.00.000603550.001144550.002122
129.00.000594550.001164650.0020836
135.00.00060150.00085560.00193725
1416.00.000593650.00084870.00181405
1515.00.000604450.000733250.0017801
1610.00.000595950.00068910.00163875
1711.00.000588850.000741350.00163475
1819.00.000581050.0006860.00158395
196.00.00058380.00066950.00155635
" + ], + "text/latex": [ + "\\begin{tabular}{r|cccc}\n", + "\t& subix & update\\_sum & solve\\_sum & total\\_sum\\\\\n", + "\t\\hline\n", + "\t& Any & Float64 & Float64 & Float64\\\\\n", + "\t\\hline\n", + "\t1 & 1.0 & 0.158709 & 0.00181965 & 1.63415 \\\\\n", + "\t2 & 4.0 & 0.0006356 & 0.0014248 & 0.00646285 \\\\\n", + "\t3 & 2.0 & 0.0007569 & 0.0013524 & 0.00347545 \\\\\n", + "\t4 & 8.0 & 0.0006547 & 0.001296 & 0.0024052 \\\\\n", + "\t5 & 3.0 & 0.00064825 & 0.0012994 & 0.0023433 \\\\\n", + "\t6 & 7.0 & 0.0005692 & 0.0014191 & 0.00233 \\\\\n", + "\t7 & 17.0 & 0.00059485 & 0.00136555 & 0.0023151 \\\\\n", + "\t8 & 14.0 & 0.0005867 & 0.00138795 & 0.0023136 \\\\\n", + "\t9 & 12.0 & 0.0005754 & 0.0014177 & 0.00230505 \\\\\n", + "\t10 & 13.0 & 0.00058465 & 0.0011913 & 0.00219825 \\\\\n", + "\t11 & 18.0 & 0.00060355 & 0.00114455 & 0.002122 \\\\\n", + "\t12 & 9.0 & 0.00059455 & 0.00116465 & 0.0020836 \\\\\n", + "\t13 & 5.0 & 0.0006015 & 0.0008556 & 0.00193725 \\\\\n", + "\t14 & 16.0 & 0.00059365 & 0.0008487 & 0.00181405 \\\\\n", + "\t15 & 15.0 & 0.00060445 & 0.00073325 & 0.0017801 \\\\\n", + "\t16 & 10.0 & 0.00059595 & 0.0006891 & 0.00163875 \\\\\n", + "\t17 & 11.0 & 0.00058885 & 0.00074135 & 0.00163475 \\\\\n", + "\t18 & 19.0 & 0.00058105 & 0.000686 & 0.00158395 \\\\\n", + "\t19 & 6.0 & 0.0005838 & 0.0006695 & 0.00155635 \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m19×4 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m subix \u001b[0m\u001b[1m update_sum \u001b[0m\u001b[1m solve_sum \u001b[0m\u001b[1m total_sum \u001b[0m\n", + " │\u001b[90m Any \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", + "─────┼───────────────────────────────────────────\n", + " 1 │ 1.0 0.158709 0.00181965 1.63415\n", + " 2 │ 4.0 0.0006356 0.0014248 0.00646285\n", + " 3 │ 2.0 0.0007569 0.0013524 0.00347545\n", + " 4 │ 8.0 0.0006547 0.001296 0.0024052\n", + " 5 │ 3.0 0.00064825 0.0012994 0.0023433\n", + " 6 │ 7.0 0.0005692 0.0014191 0.00233\n", + " 7 │ 17.0 0.00059485 0.00136555 0.0023151\n", + " 8 │ 14.0 0.0005867 0.00138795 0.0023136\n", + " 9 │ 12.0 0.0005754 0.0014177 0.00230505\n", + " 10 │ 13.0 0.00058465 0.0011913 0.00219825\n", + " 11 │ 18.0 0.00060355 0.00114455 0.002122\n", + " 12 │ 9.0 0.00059455 0.00116465 0.0020836\n", + " 13 │ 5.0 0.0006015 0.0008556 0.00193725\n", + " 14 │ 16.0 0.00059365 0.0008487 0.00181405\n", + " 15 │ 15.0 0.00060445 0.00073325 0.0017801\n", + " 16 │ 10.0 0.00059595 0.0006891 0.00163875\n", + " 17 │ 11.0 0.00058885 0.00074135 0.00163475\n", + " 18 │ 19.0 0.00058105 0.000686 0.00158395\n", + " 19 │ 6.0 0.0005838 0.0006695 0.00155635" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Dict{Any, Any} with 21 entries:\n", + " \"demandbalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", + " \"endvaluetimes\" => Dict{Any, Any}((1, 12)=>[0.0001711 0.0005423 0.000804…\n", + " \"resindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", + " \"areanames\" => [\"SORLAND\"]\n", + " \"priceindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-2…\n", + " \"batmatrix\" => Matrix{Float64}(undef, 128, 0)\n", + " \"stateindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", + " \"statematrix\" => [547.673 4078.56 … 0.174767 0.0; 547.673 4078.56 … 0.…\n", + " \"statenames\" => [\"Reservoir_FINNMARK_hydro_reservoir_max\", \"Reservoir…\n", + " \"resnames\" => [\"Reservoir_SORLAND_hydro_reservoir\"]\n", + " \"demandvalues\" => [0.0 0.0 … 0.0831064 1.40595; 0.0 0.94242 … 0.0476586…\n", + " \"batindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", + " \"resmatrix\" => [14.409; 14.3628; … ; 13.6008; 13.5783;;]\n", + " \"supplybalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", + " \"supplynames\" => [\"PlantResponse_SORLAND_BOLIDEN_ODDA\", \"PlantResponse…\n", + " \"demandnames\" => [\"Transm_SORLAND->TELEMARK\", \"Transm_SORLAND->HAUGESU…\n", + " \"clearingtimes\" => [0.0075346 0.017705 1.24733; 0.008654 0.0155684 0.026…\n", + " \"supplyvalues\" => [0.0 0.0 … 0.0 0.254503; 0.0 0.0 … 0.00267863 0.22869…\n", + " \"batnames\" => String[]\n", + " \"prognosistimes\" => [11.8098 0.105411 12.0116; 11.8098 0.105411 12.0116; …\n", + " \"pricematrix\" => [0.341822; 0.341822; … ; 0.359592; 0.359592;;]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ + "\n", + "dataset = getdataset(config, weatheryear)\n", "input = JulES.DefaultJulESInput(config, dataset, datayear, weatheryear)\n", "JulES.cleanup_jules(input)\n", "data = JulES.run_serial(input)" @@ -202,7 +663,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "9a7c42ff", "metadata": {}, "outputs": [], @@ -240,7 +701,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "d7715824", "metadata": {}, "outputs": [], @@ -262,10 +723,3202 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "91928a2e", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.plotly.v1+json": { + "data": [ + { + "colorbar": { + "len": 0.9231408573928259, + "title": "", + "x": 0.9950787401574803, + "y": 0.4916666666666667 + }, + "legendgroup": "SORLAND", + "line": { + "color": "rgba(0, 154, 250, 1.000)", + "dash": "solid", + "shape": "linear", + "width": 1 + }, + "mode": "lines", + "name": "SORLAND", + "showlegend": true, + "type": "scatter", + "x": [ + 63842169600000, + 63842191200000, + 63842212800000, + 63842234400000, + 63842256000000, + 63842277600000, + 63842299200000, + 63842320800000, + 63842342400000, + 63842364000000, + 63842385600000, + 63842407200000, + 63842428800000, + 63842450400000, + 63842472000000, + 63842493600000, + 63842515200000, + 63842536800000, + 63842558400000, + 63842580000000, + 63842601600000, + 63842623200000, + 63842644800000, + 63842666400000, + 63842688000000, + 63842709600000, + 63842731200000, + 63842752800000, + 63842774400000, + 63842796000000, + 63842817600000, + 63842839200000, + 63842860800000, + 63842882400000, + 63842904000000, + 63842925600000, + 63842947200000, + 63842968800000, + 63842990400000, + 63843012000000, + 63843033600000, + 63843055200000, + 63843076800000, + 63843098400000, + 63843120000000, + 63843141600000, + 63843163200000, + 63843184800000, + 63843206400000, + 63843228000000, + 63843249600000, + 63843271200000, + 63843292800000, + 63843314400000, + 63843336000000, + 63843357600000, + 63843379200000, + 63843400800000, + 63843422400000, + 63843444000000, + 63843465600000, + 63843487200000, + 63843508800000, + 63843530400000, + 63843552000000, + 63843573600000, + 63843595200000, + 63843616800000, + 63843638400000, + 63843660000000, + 63843681600000, + 63843703200000, + 63843724800000, + 63843746400000, + 63843768000000, + 63843789600000, + 63843811200000, + 63843832800000, + 63843854400000, + 63843876000000, + 63843897600000, + 63843919200000, + 63843940800000, + 63843962400000, + 63843984000000, + 63844005600000, + 63844027200000, + 63844048800000, + 63844070400000, + 63844092000000, + 63844113600000, + 63844135200000, + 63844156800000, + 63844178400000, + 63844200000000, + 63844221600000, + 63844243200000, + 63844264800000, + 63844286400000, + 63844308000000, + 63844329600000, + 63844351200000, + 63844372800000, + 63844394400000, + 63844416000000, + 63844437600000, + 63844459200000, + 63844480800000, + 63844502400000, + 63844524000000, + 63844545600000, + 63844567200000, + 63844588800000, + 63844610400000, + 63844632000000, + 63844653600000, + 63844675200000, + 63844696800000, + 63844718400000, + 63844740000000, + 63844761600000, + 63844783200000, + 63844804800000, + 63844826400000, + 63844848000000, + 63844869600000, + 63844891200000, + 63844912800000 + ], + "xaxis": "x", + "y": [ + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 36.077913759149105, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 41.02378198198199, + 43.408885585585594, + 44.25154555444965, + 44.25154555444965, + 42.33296535000001, + 44.25154555444965, + 40.5084825376739, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146, + 44.798763073389146 + ], + "yaxis": "y" + } + ], + "layout": { + "annotations": [ + { + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 20 + }, + "rotation": 0, + "showarrow": false, + "text": "Prices", + "x": 0.5206597222222222, + "xanchor": "center", + "xref": "paper", + "y": 1, + "yanchor": "top", + "yref": "paper" + } + ], + "height": 500, + "legend": { + "bgcolor": "rgba(255, 255, 255, 1.000)", + "bordercolor": "rgba(0, 0, 0, 1.000)", + "borderwidth": 1, + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "title": { + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "text": "" + }, + "tracegroupgap": 0, + "traceorder": "normal", + "x": 1, + "xanchor": "auto", + "y": 1, + "yanchor": "auto" + }, + "margin": { + "b": 20, + "l": 0, + "r": 0, + "t": 20 + }, + "paper_bgcolor": "rgba(255, 255, 255, 1.000)", + "plot_bgcolor": "rgba(255, 255, 255, 1.000)", + "showlegend": true, + "width": 800, + "xaxis": { + "anchor": "y", + "domain": [ + 0.046240704286964134, + 0.9950787401574803 + ], + "gridcolor": "rgba(0, 0, 0, 0.100)", + "gridwidth": 0.5, + "linecolor": "rgba(0, 0, 0, 1.000)", + "mirror": false, + "range": [ + 63842087304000, + 63844995096000 + ], + "showgrid": true, + "showline": true, + "showticklabels": true, + "tickangle": 0, + "tickcolor": "rgb(0, 0, 0)", + "tickfont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "tickmode": "array", + "ticks": "inside", + "ticktext": [ + "2024-01-29", + "2024-02-06", + "2024-02-14", + "2024-02-22", + "2024-03-01" + ], + "tickvals": [ + 63842169600000, + 63842860800000, + 63843552000000, + 63844243200000, + 63844934400000 + ], + "title": "", + "titlefont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "type": "-", + "visible": true, + "zeroline": false, + "zerolinecolor": "rgba(0, 0, 0, 1.000)" + }, + "yaxis": { + "anchor": "x", + "domain": [ + 0.030096237970253722, + 0.9532370953630797 + ], + "gridcolor": "rgba(0, 0, 0, 0.100)", + "gridwidth": 0.5, + "linecolor": "rgba(0, 0, 0, 1.000)", + "mirror": false, + "range": [ + 35.8162882797219, + 45.06038855281635 + ], + "showgrid": true, + "showline": true, + "showticklabels": true, + "tickangle": 0, + "tickcolor": "rgb(0, 0, 0)", + "tickfont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "tickmode": "array", + "ticks": "inside", + "ticktext": [ + "36", + "38", + "40", + "42", + "44" + ], + "tickvals": [ + 36, + 38, + 40, + 42, + 44 + ], + "title": "€/MWh", + "titlefont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "type": "-", + "visible": true, + "zeroline": false, + "zerolinecolor": "rgba(0, 0, 0, 1.000)" + } + } + }, + "image/png": "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", + "image/svg+xml": [ + "2024-01-292024-02-062024-02-142024-02-222024-03-013638404244SORLAND€/MWhPrices" + ], + "text/html": [ + "
\n", + " \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "data": [ + { + "colorbar": { + "len": 0.9231408573928259, + "title": "", + "x": 0.4950787401574803, + "y": 0.4916666666666667 + }, + "fill": "tozeroy", + "fillcolor": "rgba(0, 154, 250, 1.000)", + "legendgroup": "y1", + "line": { + "color": "rgba(0, 154, 250, 1.000)", + "dash": "solid", + "shape": "linear", + "width": 1 + }, + "mode": "lines", + "name": "y1", + "showlegend": true, + "type": "scatter", + "x": [ + 63842169600000, + 63842191200000, + 63842212800000, + 63842234400000, + 63842256000000, + 63842277600000, + 63842299200000, + 63842320800000, + 63842342400000, + 63842364000000, + 63842385600000, + 63842407200000, + 63842428800000, + 63842450400000, + 63842472000000, + 63842493600000, + 63842515200000, + 63842536800000, + 63842558400000, + 63842580000000, + 63842601600000, + 63842623200000, + 63842644800000, + 63842666400000, + 63842688000000, + 63842709600000, + 63842731200000, + 63842752800000, + 63842774400000, + 63842796000000, + 63842817600000, + 63842839200000, + 63842860800000, + 63842882400000, + 63842904000000, + 63842925600000, + 63842947200000, + 63842968800000, + 63842990400000, + 63843012000000, + 63843033600000, + 63843055200000, + 63843076800000, + 63843098400000, + 63843120000000, + 63843141600000, + 63843163200000, + 63843184800000, + 63843206400000, + 63843228000000, + 63843249600000, + 63843271200000, + 63843292800000, + 63843314400000, + 63843336000000, + 63843357600000, + 63843379200000, + 63843400800000, + 63843422400000, + 63843444000000, + 63843465600000, + 63843487200000, + 63843508800000, + 63843530400000, + 63843552000000, + 63843573600000, + 63843595200000, + 63843616800000, + 63843638400000, + 63843660000000, + 63843681600000, + 63843703200000, + 63843724800000, + 63843746400000, + 63843768000000, + 63843789600000, + 63843811200000, + 63843832800000, + 63843854400000, + 63843876000000, + 63843897600000, + 63843919200000, + 63843940800000, + 63843962400000, + 63843984000000, + 63844005600000, + 63844027200000, + 63844048800000, + 63844070400000, + 63844092000000, + 63844113600000, + 63844135200000, + 63844156800000, + 63844178400000, + 63844200000000, + 63844221600000, + 63844243200000, + 63844264800000, + 63844286400000, + 63844308000000, + 63844329600000, + 63844351200000, + 63844372800000, + 63844394400000, + 63844416000000, + 63844437600000, + 63844459200000, + 63844480800000, + 63844502400000, + 63844524000000, + 63844545600000, + 63844567200000, + 63844588800000, + 63844610400000, + 63844632000000, + 63844653600000, + 63844675200000, + 63844696800000, + 63844718400000, + 63844740000000, + 63844761600000, + 63844783200000, + 63844804800000, + 63844826400000, + 63844848000000, + 63844869600000, + 63844891200000, + 63844912800000 + ], + "xaxis": "x1", + "y": [ + 6.574205001267109, + 8.127919975707236, + 7.297916032490041, + 7.794421672298373, + 6.535733359200007, + 7.279753035145999, + 7.98648688425669, + 7.454511335063038, + 7.289926181087705, + 7.516003694108415, + 6.986900627306799, + 6.898543303852239, + 6.563634872115653, + 7.387050279804364, + 7.789243229326251, + 6.976999506360899, + 7.502311081114395, + 7.627640670767589, + 8.21850218315144, + 7.18260706913734, + 6.743482923077907, + 7.017688007951819, + 7.683371670725411, + 7.926854064373792, + 7.284295041326425, + 7.686308431687609, + 6.953761089821539, + 6.9953709233147885, + 6.719525351819637, + 8.421679954245427, + 8.499619927870189, + 7.380382548030014, + 6.697823548703533, + 8.431385948166096, + 7.444637666505756, + 8.23656454472441, + 7.515128305836559, + 7.970056510241287, + 7.895675065481881, + 8.432618937817635, + 6.798251960742744, + 8.255303607756796, + 8.652108072562427, + 8.751871399483404, + 5.829770178693131, + 8.97735578120521, + 8.288987918649218, + 7.181288867720242, + 7.186063889814587, + 6.95277436631325, + 7.600249645158159, + 7.009546747479446, + 6.719434650714582, + 6.826962776557851, + 7.4569206418999405, + 7.812353827019493, + 6.767945446962029, + 8.434716816571342, + 8.547076808128832, + 7.488950184166062, + 6.793727822671071, + 8.366870970869615, + 8.463500233791162, + 7.299184968131016, + 7.3491578787414396, + 7.65660128496186, + 7.5899434751239365, + 8.210120829778774, + 7.345358693892994, + 7.864706115128738, + 7.693700337994396, + 8.565632135580547, + 7.4805555279776685, + 7.937981160294842, + 8.171315997331787, + 7.211249540520038, + 6.606935739274011, + 6.820735356426445, + 7.386804576813753, + 7.527179647959425, + 6.897741918731258, + 6.668495942219161, + 7.3585494049598354, + 6.79610455846497, + 6.621825130418569, + 8.033228941596228, + 7.116877588749005, + 7.59844128352876, + 7.359249069165777, + 7.199152090788555, + 6.845672990191558, + 7.007578637183952, + 5.996867163607161, + 6.768583820448072, + 7.022827052680558, + 7.503226679763787, + 6.422560628573476, + 6.769130573215708, + 7.489405588144041, + 6.900518623098074, + 5.752346279637653, + 6.821999189451523, + 6.087309092418224, + 6.582419033174865, + 5.030316214581194, + 4.827968972274853, + 5.0824851119626455, + 5.029103164702669, + 4.5195876442824385, + 4.902683820448072, + 5.267007210516158, + 5.8967680357068195, + 6.972298824359173, + 7.2898262194792505, + 6.68446086842047, + 6.689328580606076, + 7.010743521313239, + 6.988276518401495, + 7.607733953383641, + 6.748083562155154, + 7.16674218872149, + 7.6115482147834435, + 7.0215813858160745, + 7.028653865720258, + 7.261733447811021, + 7.401695852068862, + 7.989287844795312, + 7.107355316565722 + ], + "yaxis": "y1" + }, + { + "colorbar": { + "len": 0.9231408573928259, + "title": "", + "x": 0.9950787401574803, + "y": 0.4916666666666667 + }, + "fill": "tozeroy", + "fillcolor": "rgba(0, 154, 250, 1.000)", + "legendgroup": "y1", + "line": { + "color": "rgba(0, 154, 250, 1.000)", + "dash": "solid", + "shape": "linear", + "width": 1 + }, + "mode": "lines", + "name": "y1", + "showlegend": true, + "type": "scatter", + "x": [ + 63842169600000, + 63842191200000, + 63842212800000, + 63842234400000, + 63842256000000, + 63842277600000, + 63842299200000, + 63842320800000, + 63842342400000, + 63842364000000, + 63842385600000, + 63842407200000, + 63842428800000, + 63842450400000, + 63842472000000, + 63842493600000, + 63842515200000, + 63842536800000, + 63842558400000, + 63842580000000, + 63842601600000, + 63842623200000, + 63842644800000, + 63842666400000, + 63842688000000, + 63842709600000, + 63842731200000, + 63842752800000, + 63842774400000, + 63842796000000, + 63842817600000, + 63842839200000, + 63842860800000, + 63842882400000, + 63842904000000, + 63842925600000, + 63842947200000, + 63842968800000, + 63842990400000, + 63843012000000, + 63843033600000, + 63843055200000, + 63843076800000, + 63843098400000, + 63843120000000, + 63843141600000, + 63843163200000, + 63843184800000, + 63843206400000, + 63843228000000, + 63843249600000, + 63843271200000, + 63843292800000, + 63843314400000, + 63843336000000, + 63843357600000, + 63843379200000, + 63843400800000, + 63843422400000, + 63843444000000, + 63843465600000, + 63843487200000, + 63843508800000, + 63843530400000, + 63843552000000, + 63843573600000, + 63843595200000, + 63843616800000, + 63843638400000, + 63843660000000, + 63843681600000, + 63843703200000, + 63843724800000, + 63843746400000, + 63843768000000, + 63843789600000, + 63843811200000, + 63843832800000, + 63843854400000, + 63843876000000, + 63843897600000, + 63843919200000, + 63843940800000, + 63843962400000, + 63843984000000, + 63844005600000, + 63844027200000, + 63844048800000, + 63844070400000, + 63844092000000, + 63844113600000, + 63844135200000, + 63844156800000, + 63844178400000, + 63844200000000, + 63844221600000, + 63844243200000, + 63844264800000, + 63844286400000, + 63844308000000, + 63844329600000, + 63844351200000, + 63844372800000, + 63844394400000, + 63844416000000, + 63844437600000, + 63844459200000, + 63844480800000, + 63844502400000, + 63844524000000, + 63844545600000, + 63844567200000, + 63844588800000, + 63844610400000, + 63844632000000, + 63844653600000, + 63844675200000, + 63844696800000, + 63844718400000, + 63844740000000, + 63844761600000, + 63844783200000, + 63844804800000, + 63844826400000, + 63844848000000, + 63844869600000, + 63844891200000, + 63844912800000 + ], + "xaxis": "x2", + "y": [ + 6.57420500126711, + 8.127919975707234, + 7.297916032490039, + 7.794421672298372, + 6.535733359200007, + 7.279753035145998, + 7.986486884256689, + 7.454511335063038, + 7.289926181087706, + 7.516003694108413, + 6.986900627306799, + 6.898543303852239, + 6.563634872115653, + 7.387050279804364, + 7.789243229326251, + 6.976999506360899, + 7.502311081114395, + 7.627640670767587, + 8.21850218315144, + 7.182607069137341, + 6.743482923077907, + 7.01768800795182, + 7.683371670725411, + 7.926854064373793, + 7.284295041326425, + 7.686308431687608, + 6.95376108982154, + 6.9953709233147885, + 6.719525351819638, + 8.421679954245427, + 8.49961992787019, + 7.380382548030014, + 6.697823548703532, + 8.431385948166094, + 7.444637666505754, + 8.23656454472441, + 7.51512830583656, + 7.970056510241287, + 7.895675065481881, + 8.432618937817635, + 6.7982519607427445, + 8.255303607756796, + 8.652108072562427, + 8.751871399483402, + 5.82977017869313, + 8.97735578120521, + 8.288987918649218, + 7.181288867720241, + 7.186063889814587, + 6.95277436631325, + 7.600249645158159, + 7.009546747479446, + 6.719434650714582, + 6.826962776557852, + 7.4569206418999405, + 7.812353827019493, + 6.76794544696203, + 8.43471681657134, + 8.547076808128832, + 7.488950184166062, + 6.793727822671071, + 8.366870970869615, + 8.463500233791164, + 7.299184968131016, + 7.3491578787414396, + 7.656601284961859, + 7.5899434751239365, + 8.210120829778774, + 7.345358693892994, + 7.8647061151287385, + 7.693700337994396, + 8.56563213558055, + 7.4805555279776685, + 7.937981160294842, + 8.171315997331789, + 7.211249540520037, + 6.60693573927401, + 6.820735356426446, + 7.386804576813753, + 7.527179647959424, + 6.897741918731257, + 6.66849594221916, + 7.358549404959835, + 6.79610455846497, + 6.621825130418568, + 8.033228941596228, + 7.116877588749005, + 7.59844128352876, + 7.359249069165777, + 7.199152090788554, + 6.845672990191558, + 7.007578637183953, + 5.9968671636071615, + 6.768583820448072, + 7.022827052680558, + 7.503226679763787, + 6.422560628573476, + 6.769130573215709, + 7.489405588144042, + 6.900518623098073, + 5.752346279637653, + 6.821999189451522, + 6.087309092418223, + 6.582419033174864, + 5.030316214581195, + 4.827968972274853, + 5.082485111962646, + 5.02910316470267, + 4.5195876442824385, + 4.902683820448071, + 5.267007210516157, + 5.896768035706819, + 6.972298824359174, + 7.2898262194792505, + 6.68446086842047, + 6.689328580606076, + 7.01074352131324, + 6.988276518401497, + 7.607733953383642, + 6.748083562155154, + 7.16674218872149, + 7.6115482147834435, + 7.0215813858160745, + 7.028653865720258, + 7.261733447811021, + 7.40169585206886, + 7.989287844795312, + 7.107355316565721 + ], + "yaxis": "y2" + } + ], + "layout": { + "annotations": [ + { + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 20 + }, + "rotation": 0, + "showarrow": false, + "text": "Supply", + "x": 0.2651041666666667, + "xanchor": "center", + "xref": "paper", + "y": 1, + "yanchor": "top", + "yref": "paper" + }, + { + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 20 + }, + "rotation": 0, + "showarrow": false, + "text": "Demand", + "x": 0.7651041666666667, + "xanchor": "center", + "xref": "paper", + "y": 1, + "yanchor": "top", + "yref": "paper" + } + ], + "height": 500, + "legend": { + "bgcolor": "rgba(255, 255, 255, 1.000)", + "bordercolor": "rgba(0, 0, 0, 1.000)", + "borderwidth": 1, + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "title": { + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "text": "" + }, + "tracegroupgap": 0, + "traceorder": "normal", + "x": 1, + "xanchor": "auto", + "y": 1, + "yanchor": "auto" + }, + "margin": { + "b": 20, + "l": 0, + "r": 0, + "t": 20 + }, + "paper_bgcolor": "rgba(255, 255, 255, 1.000)", + "plot_bgcolor": "rgba(255, 255, 255, 1.000)", + "showlegend": true, + "width": 800, + "xaxis1": { + "anchor": "y1", + "domain": [ + 0.03512959317585302, + 0.4950787401574803 + ], + "gridcolor": "rgba(0, 0, 0, 0.100)", + "gridwidth": 0.5, + "linecolor": "rgba(0, 0, 0, 1.000)", + "mirror": false, + "range": [ + 63842087304000, + 63844995096000 + ], + "showgrid": true, + "showline": true, + "showticklabels": true, + "tickangle": 0, + "tickcolor": "rgb(0, 0, 0)", + "tickfont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "tickmode": "array", + "ticks": "inside", + "ticktext": [ + "2024-01-29", + "2024-02-06", + "2024-02-14", + "2024-02-22", + "2024-03-01" + ], + "tickvals": [ + 63842169600000, + 63842860800000, + 63843552000000, + 63844243200000, + 63844934400000 + ], + "title": "", + "titlefont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "type": "-", + "visible": true, + "zeroline": false, + "zerolinecolor": "rgba(0, 0, 0, 1.000)" + }, + "xaxis2": { + "anchor": "y2", + "domain": [ + 0.5351295931758531, + 0.9950787401574803 + ], + "gridcolor": "rgba(0, 0, 0, 0.100)", + "gridwidth": 0.5, + "linecolor": "rgba(0, 0, 0, 1.000)", + "mirror": false, + "range": [ + 63842087304000, + 63844995096000 + ], + "showgrid": true, + "showline": true, + "showticklabels": true, + "tickangle": 0, + "tickcolor": "rgb(0, 0, 0)", + "tickfont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "tickmode": "array", + "ticks": "inside", + "ticktext": [ + "2024-01-29", + "2024-02-06", + "2024-02-14", + "2024-02-22", + "2024-03-01" + ], + "tickvals": [ + 63842169600000, + 63842860800000, + 63843552000000, + 63844243200000, + 63844934400000 + ], + "title": "", + "titlefont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "type": "-", + "visible": true, + "zeroline": false, + "zerolinecolor": "rgba(0, 0, 0, 1.000)" + }, + "yaxis1": { + "anchor": "x1", + "domain": [ + 0.030096237970253722, + 0.9532370953630797 + ], + "gridcolor": "rgba(0, 0, 0, 0.100)", + "gridwidth": 0.5, + "linecolor": "rgba(0, 0, 0, 1.000)", + "mirror": false, + "range": [ + -0.2693206734361562, + 9.246676454641367 + ], + "showgrid": true, + "showline": true, + "showticklabels": true, + "tickangle": 0, + "tickcolor": "rgb(0, 0, 0)", + "tickfont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "tickmode": "array", + "ticks": "inside", + "ticktext": [ + "0", + "2", + "4", + "6", + "8" + ], + "tickvals": [ + 0, + 2, + 4, + 6, + 8 + ], + "title": "GWh/h", + "titlefont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "type": "-", + "visible": true, + "zeroline": false, + "zerolinecolor": "rgba(0, 0, 0, 1.000)" + }, + "yaxis2": { + "anchor": "x2", + "domain": [ + 0.030096237970253722, + 0.9532370953630797 + ], + "gridcolor": "rgba(0, 0, 0, 0.100)", + "gridwidth": 0.5, + "linecolor": "rgba(0, 0, 0, 1.000)", + "mirror": false, + "range": [ + -0.2693206734361562, + 9.246676454641367 + ], + "showgrid": true, + "showline": true, + "showticklabels": true, + "tickangle": 0, + "tickcolor": "rgb(0, 0, 0)", + "tickfont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "tickmode": "array", + "ticks": "inside", + "ticktext": [ + "0", + "2", + "4", + "6", + "8" + ], + "tickvals": [ + 0, + 2, + 4, + 6, + 8 + ], + "title": "GWh/h", + "titlefont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "type": "-", + "visible": true, + "zeroline": false, + "zerolinecolor": "rgba(0, 0, 0, 1.000)" + } + } + }, + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArwAAAH0CAYAAADfWf7fAAAgAElEQVR4XuxdB5gUVdY91d3DkDNIBgElIxjIKsFAEBUBSSLGVdesv66uWdfVdV111dV1TSg5iYoEJUmSnEVAkIwgSE6DXV31f6eqa7q6p3u6OsxMT8993/f/i9Ovqt4779WtU7fuPVfRdV2HNEFAEBAEBAFBQBAQBAQBQSBNEVCE8Kbpysq0BAFBQBAQBAQBQUAQEAQMBITwykYQBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUFAEEhrBITwpvXyyuQEAUFAEBAEBAFBQBAQBITwyh4QBAQBQUAQEAQEAUHAIQKKojjsmR7ddF1Pi4kI4U2LZZRJCAKCgCAgCAgCgkB+IEDCmy4kMBpe6TRXIbzRVlt+FwQEAUFAEBAEBAFBwI9AOpHAaIuaTnMVwhttteV3QUAQEAQEAUFAEBAEhPAW6j0ghLdQL58MXhAQBAQBQUAQEATyE4F08npGwy2d5iqEN9pqy++FCgHGVa1btw7vvPMOZs2ahZ07d6JRo0a49NJLcd9996Fly5ZItYSDM2fO4OGHHzZwfvPNN1GiRIlChbkMVhAQBMIjMGrUKNx0001hf2zXrh169eqFm2++GXXq1ClyEBKbf/7znxg3bpxhowtTSycSGA33dJqrEN5oqy2/FxoEfD4f/ve//+Evf/kLatSogWuvvRaVKlXCoUOH8PXXX+PXX381iDAfQG63O2XmJYQ3ZZZCBiIIJBUBi/DS5jRv3jz73LRVy5cvx+zZsw1bRbt12WWXJfXaqX4yIbypvkLm+ITwFo51klEWMQQ2bNiA/v37o0uXLnjttddQqlSpbAQOHz6MJ554At999x0mTpyIiy++OGXQEcKbMkshAxEEkoqARXhHjhyJIUOG5Dj3ypUrce+99xp/HzFiBM4777ykXj+VTyaEN5VXJzA2IbyFY51klEUMAevhsnDhQnTs2DHH7JctW4brr78ef/7zn/HUU0+lTGiDEN4itlFlukUGgWiEl0DwJbxfv3546KGH8Nxzz6XU16e8XCghvHmJbvLOLYQ3eVjKmQSBpCFgPVymTZuGHj165DjvwYMHMXToULRq1QrPP/88ihcvjkWLFqFTp04IR5Jfeukl43eel6ERmzdvxoABA4x428zMTLz11ltYunQpunXrZpBohlB4PB7jurH0DSW8u3btMq7Ts2dPcAz28Is//vjD8FTv2LEDH3/8MSpUqJA0/OREgoAgkFwEnBDeI0eO4PbbbwftAL28lStXNgZh5SP8+9//xldffQWv12vYGhJjhj9YuQiWrWE/hm+99957RqhE27Ztjb59+/YFPcn/+Mc/jL/Xq1fPsGG0hZa94vVoH2lTeK0lS5YYY7j88ssxcOBADBs2LDu3gDaRXmmO9ccffwSvSzvI6z344IO44YYbDPtoNVVVjZAya1x9+vTBs88+C36Rkxje5O63vDibEN68QFXOKQgkiIAV0qBpGh577DEjIeScc87J1ZMbD+FlUtmJEyeMhxTj8vi58vPPPzfCKB555BGDoFoPISd9Qwmvy+XC448/biTf8YHJGD+rbd++HYMGDcKNN95oPLRSLQEvwSWUwwWBtELACeFlPO8zzzxjhFrx/5hYS7LLZC4Sy0suuQR33HGHQTh5vm+++Qb//e9/DTvA+9+yNS1atMCWLVtwzz33GC/CH374IebNm4e7777beHHnOapWrYrPPvsMM2bMMAjrddddZ+DN5N5bbrkFJN933nknmjVrZvx7zJgxmDBhgvFy/8ADDxjX47luvfVW8HqnTp0KGhv72/tybm+88YZhzzgukt1t27YZ177ggguMc0nSWmpveSG8qb0+MroiioD9IcGYXbbWrVsbCg00tHxw2ON6+Xs8hPfo0aPGQ4PeDzZ6MPgpcvLkycbDgQ8L6yHkpG+4kIYvvvjC8Mzwc+eVV16ZvaL8O9UmpkyZgosuuqiIrrRMWxAoHAg4IbycCb/k0OtpfWniFxwmujVt2tRQbrHsFm3Nq6++itGjR+ewNaVLl8bw4cPRsGFDAxy+MDNUgl7csWPHGkSajcm7jCembeS5ihUrZvzOF3YS6TZt2mSDe+zYMYN0046RpJJIWzaTZPmDDz4wnApslqeaL/wfffQRypUrZ3hxmVcxePBg48uU5VHeuHGjQdjZhPCm9l4Wwpva6yOjK+IIMCSAHld6Xkk8rVaxYkU8/fTThsfDkv6Kh/CGCzWwHi70YtDzahFeJ33DEV56XPiQIKm2whrOnj1reEqOHz+Od999Nwd5L+LLLtMXBFIOAaeEl/aKYQMW4eVxtCXTp0/PkY9g2ZpHH30Ud911V0Rbw/AGEtvatWsbYQclS5Y08Dl9+rQRekBi6kQGMTS0y7KZJMe8vtXocHjhhReMcAgrDIyE+F//+le259rqa3m1GX4mhLdgti3XkS8x0faAEN6CWR+5qiAQEwIMbdi/fz9WrFhhGNypU6eCnl976EE8hJfhEqEZ19bDpUGDBoaBJ2FlHK6TvnxQhOrwWg+ExYsXZ4c1WOEM/OTIcAppgoAgkNoIOCW8oR5e/jfJCL8c1axZM2iSjLXl79dcc43xv1u3bjVsDb8IMTTCapZNot4vz2OFP+WWJMvf6F3es2eP4SFmbC7jfvl1zCKxls1krC/zFuyN42G4BD3Q1atXN7y669evN/67SpUqQX3TMWlN+dBbIBtSvzMjputa+5IvLEJ4Y4JOOgsChQMBJlgwjo2eDRrgunXrxhXS8Pbbb+fQzLQeLkwIoQGxEs+c9CV64QpP8EHDUIxJkyYZYQ2F+QFROHaIjFIQSC4CTgiv9XLL2Nzx48cbdon2gN7R3JpFVixbE/pybdkkKtbYiXA4wsu/0WP7t7/9zXAKsDHkgXkQfHk/cOBADsIbKdGX9opeWxbT4DxIoC2ybJ9PYbZnkbyeqUR4+fJRv359wznDL45M1OaXwU2bNhlrwrZgwQIhvMm95eVsgkDeI0Cvx5/+9Cece+652XFp4a7KhwhDGixjHcnDaz2EVq1alUOlIZzXltdnCAITORgXR29sJA9vaF9eKxzh3bdvn1GFid6VJ5980vAWM/uZHmp7FnTeoytXEAQEgXgQcEJ4f//9d0MxgY1eXSrCMDRg5syZ2S/muV3bCp+Kl/BSrYYv5lR0oFwj7WO1atWMeNtwdjDaVzGL8NIWi4c3nl0T+zHhPLxcpzlz5hgvO9yHTBa0v/jwb0J4Y8dajhAEChwBZgszmYvJEMwUprENbQwdoPeViR30pDRu3DjbwxuaHEYVBiZr2D0b1oOFiSChOr6R4uqc9I30idEaLxPUXnzxRYPw/vWvf83xGbHAwZcBCAKCQFgEnBBehgaQ8NIDZymv8MWc93ukGF56d/kyzDjfRAkvpQ755YuJaaGhB+HsoFPCy3LBnAfJe2iSLW3byy+/bISapVMMbyp5eOnh53OKOFMSrmvXrkHx4EJ4xWgJAoUYAevBQd1I3uT2mDEaWMby3n///YYOrxW3ZBFVejXsMl+U82ESCUlxqA4vPSKffvopmjRpYqDFZDIadXsChvUQctI3t5g6FsugBBmJM7U0Q2XKCvFyydAFgbRHIDfCa7dJ9KYyyZYhUWyW/eDXHcp6lSlTxvg7bQVJDFUVvvzyS0NRIVHCS+UHvtzzMzcJb61atYxrcXy8Bu0gFWEs2xML4bXGxrAKe/VLOiYobZaVlSWENwl3QaQYXoY1UJ2DL058JvLrgdWE8CYB+HQ5BbPr6QWk1Eu4xrdixoLaiwKky9xjmQcNsKV4EMtxedGXhptEljd5RkaGIdJOcsvPcj/88IPhzW3fvr0Rx2SV8LTIJg09P+lRwoxhDPwsRy8xZXlCCS+9vnwo8CFBkXg+qJgQF04bM7RvOB3N3Agvr0/vCz0h/ByVypWY+PBiqEVR1gZmoiQLBOR3yInYK2cWJb/tlUV4KTFGzW6r8flh2STqbP/vf/8Lygsg2eSXKr6Id+jQIYfWLcOmqNJAohwr4aXXlsdS79t68bfGSQkxElw2xhTzkzfHzbhPyxMbC+G1z4NJdownZQjHf/7zHyMxjrrABeXhTcReFYYYXuvFiWvMxEd7OAN/E8LrzGYUiV7UG2QcZvny5cPOlzcLjY29Uk2RACZkkidPnoz4UlAQeNDA0jhTB3Lu3LlYvXq14R2hh4FeUnp/Q7V4maRBssqHDv/dvXt3I3SAGpKMqcut0tpPP/1kfCoi+b3iiityVD+yV2Vj33CVkqKVFs7t82ZBYBzpmpQ7okebD9Ki2kh4aRssCaj8wkHslTOk89teWUQydHS0SfTOsiIkQxNCFQwsDyu/QFmV1mibcqvq6DSGl7KGJLx2WTI6C/hSbVWPZDgCC1FQDWbNmjWGAgR1xnn9WAivNY/58+fj9ddfN0g0z83KlHSUkPgWFOFNxF5FIrwvrNKcbcQk93ruwvA213q2MGSGz0B7E8Kb5EUozKeTB4iz1cvvB4izUeVNr0ieFHr0SHTsXr1IfeMZGd/Q6WlJ9VLCiTxA4sElFY8RwpuKqxIYU1GyV5FWIpy9Su1Vy5vRJWKvCos2rV2dwR7OEAuihWWuTuak6HSJScuBgBBeZ5uiKD1ACoLwUkeYIQ2UJ0t17d1EHiDOdlvq9xLCm9prVJTslRDe3PdiIvaqMJBAyxPPkLtQ3fhY7tLCMFen8xHCGwEpIbzOtlBReoDkJ+GleDtjifkpkBjbE1qcrUz+90rkAZL/o82bKwrhzRtck3XWomSvhPAWbcKbrHtGCG+ykEzh8wjhdbY4RekBkp+El/Fy9Ow2a9bMyG5mtaRUb0J4YYS2SAxv6u7UomSvhPAK4U3GnSiENxkopvg5hPA6WyB5gMDIyg+N4XWGXnr1EsIrhDfVd7TYK7FX1h5NxF6lEwmMds+m01wlpEFCGqLt91x/lweIPECS8QBJaBOm0MHi4U2hxQgzFLFXYq+SYa/SiQRGu2PTaa5CeIXwRtvvQnijICQeXhOgRDwmCW3CFDpYCG8KLYYQ3rCLIfYqcXuVTiQw2h2bTnMVwiuEN9p+F8IrhNfRHhHCKyENjjZKAXYSD694eMXDG9sNKIQ3NrwKZW+J4XW2bPn1APlksw/LD+p4v5PH2cDysZd4TBL3mOTjcuXppcTDm6fwJnxysVdCeIXwxnYbCeGNDa9C2VsIr7Nly68HyIM/+DBxu4a9QzKcDSwfewnhFcJrbTchvPl448VxKbFXQniF8MZ24wjhjQ2vQtlbCK+zZcuvB8hflqr4cJOOw8OE8DpbmfzvJSENEtKQ/7sutiuKvRLCK4Q3tntGCG9seBXK3kJ4nS1bfj1Anl+h4rV1Ok7fJoTX2crkfy8hvEJ483/XxXZFsVdCeIXwmgiwEtuIESPA0vUlSpSIeCMJ4Y3NxhTK3kJ4nS1bfj1AXlmj4pkVOtQ7hPA6W5n87yWEVwhv/u+62K4o9koIb14SXuVDb2wbMkm99Ttjey6OGjUKN910E+666y4hvElag0J9GiG8zpYvvx4gr6314YllGrJu86CYW3E2uHzqJTG8JtBCeIXw5tMtF/dlxF4J4S0qhPell15C/fr1MWTIELBK6PPPP493330XmzZtwo4dOwwYFixYIIQ3bmuSRgcK4XW2mPn1APn7ah+eX6Vh+0APapYSwutsdfK3lxBeIbz5u+Niv5rYKyG8RYXwMmRhzpw5eOaZZ0CP7rZt24x/W41/E8Ibuw1JyyOE8Dpb1vx6gLyw0odX1mhYer0HF1QSwutsdfK3lxBeIbz5u+Niv5rYKyG8RYXwHjp0CE899RRefvllvPfee+jatSs6duwohDd2s5H+RwjhdbbGefUAOevTkKUC5TJdxkCeXu7D6+s0TO3uRrea5t9SpUlIg7kSQniF8KbKPRlpHGKvhPAWFcLLeTKsoWXLlpg+fbpBfCtVqiSEN9WNVEGMTwivM9Tz6gFSfaQXl1ZTMP4Ks9DEE8t8eGu9huGd3RjYQAivs9XJ315CeIXw5u+Oi/1qYq+E8BYlwsvYXaow1KxZMyicgRhISEPs9iNtjxDC62xp8+IB8tUODQNn+3BrIxfe6+Q2BvLgYh/e26DhzfYu3NfM/FuqNPHwiofX2otSeCJV7srw4xB7JYQ3LwnvC6u0ArkBnrswvBPozJkzePjhhzF06NCgcAYhvAWyTKl7USG8ztYmLx4g9O7uPwPc1siFjy8zye2fF/rw/kYNz17owgsXCeF1tjr520s8vOLhzd8dF/vVxF4J4c1Lwhv7jszbI+zqDPZwhliuKjq8saBVSPsK4XW2cMl+gHy62YeHFms47gWGnufC551Ncnv7PB8++VnDbee78PHlQnidrU7+9hLCK4Q3f3dc7FcTeyWEt6gQXqo0dOrUCSNHjjSkyeJtQnjjRa4QHSeE19liJfsB0n+WionbdePiN9ZXMK6bGcN78/cqRmzR0b2Wguk9zL+lSpOQBnMlhPAK4U2VezLSOMReCeEtKoQ3WfeiEN5kIZnC5xHC62xxkv0AaTnJi/WHzWtfX1fB5KtMcjtwtopx23RcWEnByhuE8DpbnfztJYRXCG/+7rjYryb2SgivEN7Y7hshvLHhVSh7C+F1tmzJfoCU/8yLY3+Y1+5ZW8HU7ia5vWGmisk7dNQtDewYFFsZRWczib+XeHjFw2vtHklai/8+yo8jxV4J4RXCG9udJoQ3NrwKZW8hvM6WLZkPkLM+HaU+VeEzIxpwZU0F3/U0CW/vb1V8s0tHuQzg6C15S3hHbdHQoiLQspIz+bN4Ce+O4xrOHedDrHXQna1M/vcSD694ePN/18V2RbFX8RNesVeBvZZOJDDaHZROc1V0XffTi2jTLlq/C+F1tt7JfID8dERH+69UI2GN7fLqCr6/xiS8V09X8d0eHS4F8N2Rd4T311M66o5RMa6bGzecm7eEd9NRHU0mqFBv98DNiRXyJoRXCG+qb2GxV/ETXrFXQnhT/f6ONj4hvBEQEsKbE5idJzTctVDDDFvSWDIfIFN2ahj6vS87pKHDOQoWXWsS3m5TVcz5VUcxF3BwqAdli+UNQbxlng9jt2r44FI3hp2ft4R3yW8aOn7tw+FhHpTLo/lEMwDJ/F0IrxDeZO6nRM8l9io8gvF+kRJ7JYQ30XuyoI8XwiuE1/EerDXKi0NngTO3BTysySS8b6334YllGs76tbsvqaJg2fUm4b1siooF+3WU9gBr+3pQv2zyCe/RszqqjVTBM/+zXeQCF7tOaDjjAxqVNwlxvA+QGbs19P7Wh+0DPahVOvnzcbywSeoohFcIb5K2UlJOI/bKhFHsVfjtlIi9SqfP/NFutnSaqxBeIbzR9rvx+yOLffjvRg1/aIBqCylIJuG9c74PH20OVKppXUnBKr8iA0MdlhzQUa4Y8G0PN9pWdeZ9dTQ5f6cHflDx/k86VB34+yUuPNkqvN5vyU+8uL2Rgnc6mmQ8XsI79hcNw773Yc0NHjSpIIQ3lrVK1b6StJYaKyP2KrAOYq+E8CZyVwrhTQS9QnKshDQEFmrdIQ19Z/mw9ThAmpl1uwcZ/phTi/C6P/LiyFA3ymY6I6I1RnlxRyMXXrw4QCo7fKVi8YFASHnzCsD6fqY3+eLJKlb+bhLeUV3c6FXH2XVi2W6Nx3ux+Zh5xBMXuPBKm5yE959rfXhquYY7GgfKHsdLeP/7kw8PL9Ew7xo32uQBgY9l7snom4jHJBnXT4VzCOEt+FUQexVYA7FXkfdjIvaKJLAotXRJ9RIPr3h4o963Kw5quGKaGVub6QZ+HexBxeLmDU/CW6JkKXg+VrFnsAc1SzkzBGWHe/FYSxeeuTBAKq2SwtaAGpUDNt1oEt4LJnmx7jCMkIZ3OzqPr406OVuHc8d4seOk+YfbG7nwkb+ssf0cyodmRt2gBgpGd03Mw/vqGh9Ye33q1W50rZl8Ah/L3JPRN5EHSDKunwrnEMJb8Ksg9iqwBmKv8obwFvwuT84ICspeJWf0sZ9FCK8Q3qi7ZuF+M9b06B9AKQ/wU38P6vhjTkl4lcxSKDNcxYZ+zj/NF/vYa4QN/F/LAOF1feiFXTKkQRlg60CT8Dab4MVPR2Ekrb0cclzUCTjsYCfcN9RTMOnK4AIXL6zy4fmVZsiFXSM4Xg/vo0t8+M9PGsZ1deO6ekJ4HS5TSncrqAeIfJEKbAuxVyYWYq9yNxXygl5wOQcFZcSF8Arhjbr3Zu3V0H+WSXjLZABLrvOgqT/mlIT3rKcUqo5Usai3G+3OiU7cvJqOYh+reKOdCw+3MAnvzhM6mk1UcUoNDMdeZMIebvB4Sxf+0TZ8fG3UyeTSodLnXhw+a3boWkPB7F7BhPfm730YscUkvJ2qKVjQOzEPL883/hfN8CTfdF503BKZW34cKw+QgnuACOEN7HCxVyYWYq+E8Eaz+wX1gh5tXHn1uxBeIbxR9xblwmg8SXhDk8ZIeI8ppVBvjIqp3d24qlZ04kZye944FS9cHEgMm/urhj4zA5JkHFTNksCeIaaHt8FYL7adMIc6sIGCMf5wgqiDj6FDmeFenPRrAF9cWcHyPsGE16r2xlO2qqRgtT+hLl4Pb88ZKmbv1fFWexfuaZp8Ah/D1JPSVQivEN6kbKQETyL2ygRQ7JUQ3mi3khDeaAgVkd/FYxJY6AnbNNwx32cUhCDhnXSFG938MackvL9ppYwCCqO7uNGvfnTCu/g3DV2m+owY3pf8SWsfbdLw4GIfTts8vOeUAPbfZBLeumO82OWPrx3cQMGoPCC8xT/2Zkui2eOHLSSunqbiu71m0MV5ZYGfB5hji5fwtvtSxYqDOv7exoXHLxDCmw6mpaAeIGKvxF5Z+Q5ir5xZEnlBL7gXdGcrlPxe4uGNgKk8QALA8DP+vYt8OOEFymYAn3V243p/zCkJ705vKVz0hYr3OrlxW6PohPeL7RoGz/Hh7iYuvNXBJHp/X+3DUysCkmT8W+VM4ODNJqmsOcqLX0+bY7qwsoKVId7XZNwaVJrQ/EHEtUoBuwcHV3S7dIqKhfvNDnbvc7yE1wrTeLp1gPgnYx4FdQ55gBTcA0TsldgrsVexWT6xVwVnr2JbqeT1FsIrhDfqbvpwk4aHF/uM+Fomrf23UyDmlIR385lS6DhFxauXuPCQPyaX3tAPOrlQr2xOAvzuBh8eXqwZlcwsJQTq0X7uj4+1BlS+GHBkmEk6q4304rcz5i/nlwM2+9Ubog7eYQdN1+H+KOBerpAJHPaTbesUljQa/9v+e7yEl9Js+04D9zQJSJw5HG5KdpMHSME9QITwBm4JsVcmFmKvcjeTYq8Kzl4V1ANMCG8aEV7Kaj3aMnKFsHg32Ts/+vD4Mg1ZPqC4G0aymRVzSsK79mRJdJvqw19bu/CsX2bM/aEXc3q5cXmNnIT3saU+vL5OC4rF7eFie+wAACAASURBVDdLxaTtdo0GoHQGcOIWk/BWGeHF71nmDOze1XjnFHrcKa+OCp+r8PqdzCXcwGlbRTn2t5Qi+G/775EI76w9Gj7bomFEl+BYYOvalGaj1zyvYpKThY3T88gDpOAeIIWR8Iq9cnpn5ewn9ip+7KwjxV4VnL1KfPXiO4MQ3jQivKU+9eLFi1x41Cb1Fd+2CD7KEC9foRlk0KOYVcge88eckvAuPVYS13zrw52NXXi7gxs+TTd0eWd0d+Pq2jkJb9+ZKr7YoaN3HQVfX22Swe7TVXy7J5jw2kllhc+8RtIcW8VM4FCI9zXReR7K0lFrtGqQejaqCWt3Boc02BPnWHfD5684F4nw/m21D6+v1XDUT9pDx+j5yAufDnSvpWB6j2BSvOmoBsqyZbijh4gkOvdkHS8PkIJ7gBRGwiv2Kv47T+xV/NgJ4Q1gV1A5B4mvXnxnEMKbRoQ34yMvXmsbkPqKb0vkPOqlVT4869ef5a/2mFMS3nmHSxqyZX3qmclkB8/oqD5Kxeed3RjcMCdha/OliuUHdXSroWCWX/qr09cqFv0WTHhZtC3rdpN0Wt5Q/juc9zXRue49peP88Wp20hyJ/fFbPCjBf/hbrVFe7PXHEZPwnrnVg2JuJWLS2lPLVbz1o45TtwYTZ54uS9VRerhqEN4O5yhYdG2A8B77Q0eFz1TsGuRBLb/ecaLzy4/jhfAK4Y1ln4m9igWt4L5ir+LHTgivEN7Ed0+ancGpx+S9TQqqFlcwMAyxy09Izvp0lPhExT/aBLyvybr+X5f78MqaQEKZPeaUhPfbgyUxdK4Pl1c3PZU/H9PRYqKKf7Z14YHmOdUH6oz2YvepYKLHpLdVh4IJL7mm1+9FpTfIUnAghfaFeF8Tnesvx3W0+kLNliUjqd4xyIOqJQKEt8rnXvzu1+m1V5yL5OF9YJGK/27S8YeftNvHuP+0jvpjVZzxAS0qAOv8JZTZZ9ouU6KNsmeW3nGi88uP44Xwpj7hFXsl9krslWkNxV4VnL3Kj+dRuGsUaQ/vSy+9hGeffdbAZeTIkRgyZEg2Rk4J74Vf6qhbRsEU/6f5glrIXSd1NByn4i8XJD/j/75FZkUwq9nL6pLwfrW/JO6c50Orygp+uM6DJb9p6DzVBxaIeNEvO2bHxSKvrSspWOXXsm0y3otNx4LRs4cVFP/Ei7P+cAO3Apy8xYPiNu9rorj/eFhHx69VQ3qNjSWM1/T1oEHZAOG1e5ntFeciPUD6z/Ji4nZAD0PONx3VQU83Y3jPLQNs81eU47X5gvHmes2IgW7voJBHonNP1vHyAMnbB4jYK2c7VeyViZPYq9z3i9irvLVXzu7W/O1VZAnvokWLwAfIqFGj8Pvvv+OBBx7A22+/jUaNGhkr4JjwfqWjcnEFc0KqcuXvMgLLD2q4bIoPtzZy4b2OydV0vXWeD8N/DhDeHrUVTOtufoIn4R23pyTu+8GHBmWBH/tlYPpuDX1n+jCggQufXh48FnqiS31qfspvXB7Y2N/83M8Elh1+nV07dtodHiiKApYithLKmDi3e7DHwD1ZbcVBDVdMCxS+oPzavN4eo8CE1eykm78v9leci0R4L/1axeIDOo4O86B0RvBY+VLQfYZ5varFgd+GBsIeWk3yYutxU+84XAx0suac7PPIAyTvHiBir5zvVrFXJlZir4TwRrtrJIY3GkJp8vvmzZvx/PPP49133zUIr/XvSpUqxUR4W3+po6RHwdLrw2fi5xdcrC40YLYP19ZVMLZbcscyYLaK8dsC4QYdz1Gw0B9zSsL72c4SeGSJhmolgJ2DMzBqq4Y75/vQubqCaSHJWNuP62gxySwhbPds2mXHLMwYupB1uwcZLgV2jVx6X9f19eBcm/c1UZwX7teMxDsSUDYW2JhylRuXVg/EINvHwN+/6+FGm6quiDG8548zQze23JgzFnfGbg0D55jXY7nm47bENteHXkOhgpJtNzoo5JHo3JN1vBDevCO8Yq+c71KxVyZWYq+E8Ea7a4TwRkMojX7nQ2TAgAFo164d3nzzTZQoUSJ7dvTwLlu2DGXKlAmacdWqVQ2PY1ZWFjweDy6YDLhcwPq+ySWZscLMSmX3/6AZcbQzeiTXw9v7Wx+m7g4Q3pYVgTX+UAQS3g+2l8STyzSDJB4c6sG7GzT831INLSoCy0NeBBbt19HrW7NqWw2WDh5s4lbpcxVH/GTTmjsjFo4OcxsvFC6bRi69qwt6u9GiYvI8vDP38oVBy1aC4FxGdnahVx2T8FJ5otgnPlgo8PcvrnChS43IhLfyCBV/+IAfrnWjechYx/6i4a6FmhHSkOECzt5m4rDkgI6eM3zGcSw5fEfj5Ko0PLHMh7m/6nnygiaEN3fCS7uRSBN75Qw9sVdir5zsFLFXeWuvnKxBfvcpsiENDGVYsGCBQXR37doVNqShYsWKxid7e1uzZg3Kli2bTXgvnl4cXk3Bhuv8wZ8RVvD4H8ARL1C3VN4s8T9+dOGldR60qaxhzlW2+rxJuFyv2R7M+y1AvOqX1rHuWnO+p06dwn+2l8GL6zwo4dZxcIAXr6x34eX1HtQtpefAZfIuBfcs8eCkqqBSpo6dfc3zVBmXgTO+YEJQzKVj+w1eI562/NgM6IZYGFAuQ8ekziraVQlOcktkqtP2KLhjsQfHveY1ynh0vNPWh351zVCOk16g9sQMeHXz97IZOj5qr6JnLT2ih7f8mAyU9AATL1fRoWrwWD/a4sKTq9z+Oes4PsgLKj+8vdGF59aYLywvtPLhgSbB1ecSmSOPfWCZGzP2uvBzn9z3azzXKYoPkF2ngG3Hgc7VTcRy85iUKhX/zS/2yvmOFHsl9srJbhF7lXf2ygn+BdGnyBJexu/Wr1/fSFQ7c+YMHn74YVx66aXZiWtOY3gbTdQNMmSPwQy3kE8v9+GDTRoO2mI1k7ngd8z34ePNGpqWBzb442KTdf4OX5mxqFZj6MK+m8yYU74QvLqxBF5eo2Vr17IM8Xs/aUHVyIbOVfFQc5chPfbYUg1/aMGf8ilRpIbwVytWl5/8rbhfg/AWA8Z3c+OqWsnzfk7YpoEYWklrJd0wyh5TW5jt9ywdtW06vRzTB53cGNQwvIf3+B86qoxQDQm1kV3duMbvKbYwfHWND08uN8lsMRdwYKgH5Yop6DZVxZxfTSCeaR0+6S+Rdb1noVng40Ae7MOi+ABhEZXPf9ay7/+8+kQo9sr5rhd7JfbKyW4Re5V3IVhO8C+IPkWW8No9Jtz4JL7PPPMMOnbsaKyDU8LbYLxufIq3x2CGJ7ymJuvJMJqsyVh4lvL9bq+OOqWBnYNy6r4mco0Lv1Cx2iYZRsJ51F/yl4T36XUl8O8NmlGU4tgtHkOijIUl+KnekuRi4QjKit3bzGUoELCR0J7xVzNTPszpcSRZ3DbQY8S42qugMaThk8vd6Htu8ggvSQuJ+km/c5wk9JU2LjziL5W8+6SOJhPM2GM2OyEOl7S29ZiOCyerRgjE+x0DpZitdfjLUh9eW2fiQC/wzzd6ULOUAsb9bjlu9sqLksMkvKO36jgWoRhGIvukKD5A7lukYswvenYhlLwivGKvnO9MsVeA2Kvo+0XslRDe6LskjXokQ+an9lgdh84GiF0keJ5YquL19TpUv65ssmFsOcmL9YeBSpnA71GqkPWfZZbQ/fIqZ3HHTSZ4seloYMT2ghAkvA+tKmF4ly2CyuS5+ft1gwBbxRssQssqaYf9WraUFyMep1Ud5YarOTy8lP7a2N8kvNVGqjjr/7rPEId3O7ox7PzkEd7/bdTw8GIfTvulzzjb5y904bmLzPACaguzNj1jbtlIiF9tYxb5CEd4f/hNQ68ZPqNyG/WI72sWHFd98/c+jNhiTojzW3a9B9VLAlUZ9+ufZ/9zFYy/wtkaOd1Pdy1QMWKLnqNsstPjc+tXFB8gg+aomLpLz37hzSvCS9zFXjm7F8Reib1yYs/EXgnhdbJPikQfpx7eaqN1HDkbUBOIBM7t83347GcNR272oEyxxJJXwl2j+kgv9p8xvYXhKnvZj6k9yot6ZRQssFX3ym1R64/1YvuJ4B6WtiwJ75+WFTe8XCRuK/p4wNLBPx4xx7K5vwfkb01t3lH7mSg7RgJsL+tr/U5iu7avB2WLISicgJ7hcCQykY359o8+PL5My9b65bnub2aWSmZbe0jHZVMCOr38G8s4P3NheMI7eYcGyiNRheGli114unUw4e05Q8V0fyIgPeYze7pR3K2AFeessIoraiqY2dPZQ97p3IfNVTH6Fz27oIfT45z0K4oPkCumerHwNyDL/6UiLwlvbmsg9iqAjtgrsVdir8IjkCr2ysn65EWfIhvSEA1Mpw+QCiN1w1u6e5AHVWxVuULP32uGGZtJdYNG5ZNPeC3NRSY++aJ4keltvbgysLyPs9CHmqO8+NVfUpfzMtUTPCiVoRgxvDf9UBxf7dRRLgOY1cttVAnbc4qJXcD83h6c8OpBkl8WNpYH+PcsBIULWL9bBJr/y6IaVqU1eob/drELT7RKnhrFP9b68PRyLcjLPKShgpFd/OoJNt1ca3wPt3DhjXbhCe8HG32GVBvHfF9TF97p6MamoxqeX6kZsnHtvlSx9KAZq2sqPjCBDRgyNyCNdnFlBcv7JJfwWpJN4YphRLsnov1eFAkvv6xsOByo/JfqhFfsldircF+kxF5Fs27p8Xuq2KuCQlMIbwTknRLe0p+Zsaorb/Dg/HKRiewlk1VsPKpjytVuQ8oqmS1L1VF6uFnMIVoVsmUHNFwx1YdKxYHtDmN9q4zwgqTUagxd2D7Qg3NKmoT3hvnFMXOvnk3cSHjppSSRY/EEep7vWeDDiRDxCKs878Es4BJ/1TE7LiTMrNzG/7XHz7LPk61c+PslySO8L6z04flVwYoIvWor+MZfYGPur2a5X0unl2O49XyXEUsc7gHy0iofnl1pnm9AfVMb+bs9ptYvwzT4ArTZX1mOLwqfdXbj19M6Hl2iGcSX7fxywOYbnb2UON1PvO53e3RDPq58ZnJfvIoi4eXL4G9ngBO3eFDCo+Sq0uB0jeLpJ/YqgJrYK0DsVfS7SOxVwdmr6KuTNz2E8CZIeDM/1VGmGPBtDzfaVo1MZBuMNUMO/nepG0MaJpfw7jiho/lEM6GKn/t35eJtNj7dL9VQ3BNIPIu2tcoN92Z/ZmdfhhqsvsGDhuVMwttjbnEs3K8bxJTErd8sn0G++d8fXubGL8d1/NWvSGC/FhO/tgzw4EAWcHlIuAD7WdXOSAhbTlKzE8r4212NXfjvpYkR3htmqniznQt1y7hAfdp/rA0mvJ2qKVjQ2/SwTtulYbDN+8q/3VBPwaQrPWEJr6WawX7daiiY1ctjVKu7e4EPf7vEhTfWa9jn95oTT85l1e+68XerMab31yHJJbydv1ENrV+GmrAkdjJbUXyAlPjEa6iT/DKQMdgF9wBxSnjFXom9CveCLvYqmZYwdc+VKvaqoBASwpsA4YXLjZKfwYgxHdfVLAN781wzsWlySEJYpc+9OHbWzPx/7IL4iFqLiV7M7uVG1RLBhHnpAQ1XTze9j1bca/0IVch6f6vim106eAbfnc7IVMlPvNleRzsRZdldEt4uM4tjxe+6ce032rnw50VmaAA9wf9q58IPB4CR/gQtO9zsv6avB7+dMYst2L2n7GfFtlKuy54wxt9urK9gXAIV5f7w6cj8RDUqtrGAxZ8X+fD+T8GE9wIW2OhrYjRpu4bb5gVky/g3K8Y23AOk+3QV3+4xQxYurKxgZR8PXl7tw9MrNDQpDyPkw0qAI07EjetiL/BBwp9sNYU2k1VsOKpj8bUetLSVTU6GASpqhJd7qMSnKphcyaTDxuVTm/CKvRJ7xZwAsVemtRN7VXD2KhnPm3jOIYQ3AcJ7RnfjnNGmV5We24ENXLh4stdIPrJK71qnz/zYa2Tf39PUhfc6xk54D2eZuq4/9c8ZA/zVDg3M+jfCCDKA73t7QDIarlX+3GuoSlBpYf9Nzj5rh2rk2svukvC2n5FpJKkVdwFPtVbwylo9O96WiV1MzrLr+FrjYmzu4us82H9aR99Z4Qnv9O5uQ5+2/VfBCWNX12JFufjjW9cf1nHRZBXfX+NGh3NcBn6WaoI1vvpl6LkzCS/LJdM7a8mW8W9tqyhYcn34B0irSV6sPWyeqUEZYOvADCOJjV5e7hfGfdMLzpahAC9f4sJnWzRsOBJYNbusWzw3d7hjmk/wYudJYFr34LLJyTh/UXuA7DqpG8mYHhcwo7sb7c5xpXRIg9grl/GCLvbKa+zTzMzM7Nte7FUyLGBqnyOV7FVBISWENwHCe9jrRsMJ5gnoybynqRsNx3pRrWQw4T3r07MLJ3SvpWB6HERt+UENnb72Yd415oPV3iip9dBin+GFtZPR0KntO61nJ39ZCWG5xR1bx4dq5JJUj+nmRo/a5gOk9dRMbPVrx97fVMFnW/TsEIi7m9BzqRkezdBmJbnx0/7Q78MT3q+vMgnv5d+oQR7g9lUVI7433jZxm/mS8MWVbnSv7UK/WWZBBns7pwRfCkzCy9LND1K2zBaH3KwC8GO/jLAeE3uiX5XiLCyRgS7fqPh+nw6KdNADbvcnP93ahf9s0ILKK/OVxXu7B25mIiapMYP94Blz/UKLYSR6iaJGeBkPf9V0M+B6bFdzH6Vy0prYK7FXYq8CVk7sVcHZq0SfNfEeL4Q3AcK7N8uNCybDiJ19+WIX/traDXpQmWz0w3WBcIG9p3ScP95UGWheAVjfz1kogX1o434xZa4mXWkSTXt7cZUPz/kTpEh4R3Vxo1dIZS/2/2K7BsqjHf0DKF8M+OZqNzpWyz2e2J4QZ13Tis29sb75AGn6dSZ2+wntoPoKpu/RjWuwXVdXMTy8lrasfdwkvN90Z7IWcKetypnVx0p6K88KZNOCCW+8OFrnZnjBS6s0jOjiRv/6Lthlwqw+fCmwCoq84499zrKx1HqlzcS/cJ8IS31qFtpgs6TizhvnzX4xIIW10+t7mih4f2Mw4aYXft9NHlRIYnJZjVFeHD9rxgzfdF5yY8mL2gPk650abp7rM9bxA/8XnlQmvGKvxF6JvSq6hDeV7FW8hDXR44TwJkB4t550o8M3Zizmg81deKu9G8U+9qJVJcb0BUjtOr+G6zEvYHn7Yl24v6/24cVVmqEKMDgk6c36VM5zkqRZ4RWh13htrQ9/WWYyNpLW4Z3d6FPPZcSWMuksnOf56Fk9qOgDj2XMIvVpb2tkPkAafplpZKqzdamuGMlXnCsb5c/WH0GQvm02oc0AJlzhxt7TwP22Kmf238d2cxsliq0YZeu3c8uwClvsLw7W8UxYY8GA9zuZ8+g8RcW8/cGE0x5SQOyeCpEtq1rcLCkdSnh9mo6Mj80qa2wkt9qdGSj/mTdHnLI1nmvrALN/NV+erMYY5/X9PIZmcrJaRX/FO36RuDekGEai1yhqhPfDTRoe+sH08L7R3oW7mrhT2sMr9krsldirgJUTe1Vw9irRZ028xwvhjYCck6zn9cfcuHI6DHI3qIFiEM3yn6loWh5YZ/PiUiLmhpmmZ5Xas944qq2xotOkbTrebJ+TqFwxVcXsX016ZS95Gzq1IXPMogNWvzfbu/GnJi70+U7Fyt917Bqck0Ayvrb+WDUoaY1Vxlj44YHmboPw1pmUmf0pnolevxxHdqxrnVIw5m0VU7CPiaR7ZBc3dp8y5bhYlSz091Fd3YY3uve3Jn5Ws8hmvBu/8XivMU7O46EWbrT9UsUyvy6u/Zy+OzxwKQrCyZZZHmCL8I7b6cHkHTr+09GN8/wefZ6LxPnQUA/Kfhaiy2a7UNuqwKYj5l6yGvGhSkQyk8tKf+oN+iIRL37hjitqDxBLeo73NJU3/nJBwT1AxF6ZO1LsldgrpzZN7FXB2Suna5TsfkJ4EyC8yw+70XsmDK8dM/bf6eA2EqGqlQgkO/H0jBdlKAFJX7yfqa368OGqdtkJLxOgqATxaMuciXFWDKk1ZetcbSZ7jZCEff54VTskdskz+99Z+OGp1ibhrTYhM9szSc/r3lPIDmEgaWMLR3hJGD+6zG3UfX9ymQZvsIM12wtdoRgMDVw74bWHG8RzU1CehQTbqpZ2wSQv1vmTzKzzkdgfGOoxYogfXeILkgxjH/5+9vaAh/fB5R58/rOG6+sqmLZHz/bm0iM+t5cbnacGxwDbx31eWRihHXYPb27x2PHM2SDfH3mN+OGHmrvAF55ktqL2ALF/WfnLBS682qbgHiBOCK/YK7FXYq8CFk/sVcHZq2Q+d2I5lxDeBAjv/ANu3DjXJLwXVVbwahuX4cktnRGsn2qvYmMVU2hWIbbP1JQ1Ywnee5u68K5N5WHFQQ1XTAtO+Hr2QhdeuCgnmWGG/oajgQnf2dhleKVrj/bilBc4PCynh3fTUR1twhSFsB7wJLyVxmVmE1x6XqmrazV6v/h/9thX6zcSQSpW7DypZxdpsC+HFStMwnvj7GDCG0nBYNdJzfAWT7gickLbb6d1nOv3WluhKOeP82KLP/HOGoNVGrlWaQV3LfDhf5uCZcvYjxXLLA9vh2mmlm6lTJPwW7JjnAdDJ+5dFDwH+1yZIGeFhVh/zy0eO5ab3N7XSkC8qaGCEV08WH5Awxc7dLzSJnHyWxgfIK2/8OKBZm7c2ig4npmFYpiUOLxz5H1kf9Ecdp7LCBFK5RhesVcm4RV7Zao0iL06jeLFi8PlSm4uQ7y22clx6WKvnMw1L/oI4U2A8H67z41h88zP0JSweuZCN+5d6AMriNnJI+Nvn1phkiWSmAnd3LiylvObzB4T2v9cBeNtZK7vTNUgLPYWSoqt32qM9GKfP9aWf+tZW8HU7h5QMk0hKb0tJ+Fdc0g34lvtn9p5LONeP77MfICUG5sJzT8Ekli7lzK3TUv9WYZo7DgBvBpS9IHHlfEA71/qRsVMYNCcnCoO2h0eKBy4rS3c78NlUzQjZjZSm79Pw3XfmeTzpoYuI3Gt7hgvdp0MPoJe5KXXedCkgoKb5qoYtTVnjO/hmz3IhGo8QCqNdoWdO0My/q+FC/9cr0WM4Q2HG2N4+UIyKEmFSk6rOsoNVw0Pb4/aCqZ19+CTTT7csSB3vJwansJIeMt86sVTrXOWqa41irH4gUp74TBoPtGbLSNnVeVLZcIr9krsldirwJ0s9spTYC/oTp8pye4nhDcBwvvlbjfuWmR+rmcy2gPNXXhmhWYUXDhtI4/3LfLhP/6iBiQx73R045bznRPen4/p2YUXmBQ25xrT6xQuoYx/Zzzx6K45PVOhBSRYEIEV4mqPVo2ksnASWEt+09A9TFEIq8rY8RMm4bUaPa/UmLVaqBqBHW6GBLzW1oVNR4H/bszpPSUJZDwsCW+obBmPZXncstT4sjVWROv9nQ9Hbs75m9WNyUYPL/YZ5PSaOgqmXO1BtZFmiVh748vJdz3caFPVjHP+cmcw4eU6bxvoQaUMFXtPamj2pStItsw6F88zsL6Cz7foQbHQ9mvRC04iam9WQYq7mybufeV5f8/SjbVmKEe7qoqhgWwlQ87o4UbnBEteF8YHCJNMGdbyRKtgjMsO96J1JQXz/JX2wpmJc0Z4s79mWDJ5qUx4xV55IPZK7JV1L4u9EsKbbEJdaM/nJCZu7A437l9sJmiRnPSr7zKKF7hJXmyJaaFeWEvCjOD8dlrDmF90I3EqUpuxW8PA2T7Dy2qv/vX0Ch9eX6vhbAhXtLx39vOFKgfwtzqlTW8ztURJeHcO8qBqiWACGa4mO4+1yuUeOHoSNSdmZpO1UIJLWp+TygZG9solLmw4omNkiPeUPRhS8O/2JuG9bX6wh5e/bbnRgxqlgsf72c8a/rTAZ6gbRNIYfuAHH97ZYI7q0moK5vf2gOoFR2xJcfzNkkXrVtOFq6apmLk3mJEydGXNDR7UKaHiuz0abprvCooztmZJT/Hl1RWjklosjSSYBSkez6UyH8NN/tzEhVtCPsmHuw5jpZtMMEtQs9rbT/0zsgtuPNrChdfbJUasC9sDRNd1uD5SES4unqEf9nstHJ4ky9bLHRNVN/TPKDCPidgrc4XEXrkh9sqZlRV7VXD2ytkKJb+XeHgjYOrkAfLpL248uhTZXrtO5yhY+JtuyFD9cbsHHn/BgEu/Vo2/W+32Ri4jWYvtPxt8eGSJZiQ/RWrsw7hUEtu6pYEdg8y+9uo49mPDFWUIl71MIvZBJzfuXmhqiVqf7+3nmr5bwyA/2bb/vU0VBUuv92DXoZM4/6vMsLJjTrYr443XHtLxVYj3lMdapYkrFVdy6PRy7Muvz1l17p9rfUY8MD3Xl1UP70W/bIqKBX4JMovUWOoF9jFXLAaM6OJCzzpudPpaxSLbGhqEOAOGB7BpWdVIaHtutSvHywf7sbJao3LIrrzmBBerz5OtXPj7JeGJ6NZjOppNVLMVM6Kdd/NRHZf447FrlgT2DMnInlfDssCWAfHJvFF7mhXr6hfPCoqJ+3SzD+3PUdC4vPOvGdHmkMzfGctda7SKPzd14d8dAhjzxYC62XzR2jskPCYnvToqfq5mE95apYDdgwvuASL2ytwZYq/EXkWzEWKvgIK2V9HWKK9+F8KbAOF9f7MbT6wwE5SovnBOSRhxoPbsfp6+yQSv8dneal1rKJjdyww5GPa9anzqVnOpqGUPiaAm7eGbzYdw8U+8YYlmuKIMLKVL0mZXSyAxN7xbKzTDm8lCFJ1CClFM3qHhFn/ZYjtUlodwy4GTaPVNJk6HSIo53bAPt3CBOsWWrJr9OMZCv9bGBRLeexb6spPADLJZDJjd04OLqgR7eB9b6sPbP2qG3BkLSoRr9caY5XXZrPLBVulne396kd9u78btjV246AsVqw4Fe2it4h1tKvkwYK6OyTsjJyLWKGmqMMTa7C9Hocc+stiHN3/U8NdWLrwcgRTbj1n9Wx5k0wAAIABJREFUu44uU80CHsTv6LAMWFhwz/7msNS0/ZxeTUexj1WsvsGD80ucCSK89Jo/1FzBsxfFXxEvVrxi6c97gh5yFkcZ2y0wRsZ4UwaP3lt7aJL93L8c19Fqkpotv2fhmcohDWKvMiD2yg2xV2KvCtpexWKnk9lXCG8ChPeNn9x4aqV5AsbmMnGLxC/0c3v1kV7st8WH2otPsATtkbPA5hs9qF06PGGyy4lZUlihHib7NOxeYOvvdi1g62/0PF5dSzG8q1QS+LyzG9fVCyaJY7ZquCuEbPJ46uvuHJyB9ftPosP0zOwHf6ybk0oRPx7WsfhAzs/9jAem8kWlTAUk/QwdsRrJ5uQrc8ad3jhLNbRw32jnwv3Nw3tGPR954fNfziof7P7QGzb0gtenvmrTCV5stL20cBwcA0vKdq3mQ+NJOradiEx4Y0nms2PYp56CL64MTxiZcEVMIsVsh67Fov0arvHrGVv7yKoIR485kxAjvSREWtdtx3U0Hq9idi83LioX7OGl1/z+Zq6kKEDEuq+c9J+110xe7HCOgpk9AxhTWu7Pi8xS3Wdu9aAYY5RCGrHs9W0gzMZSDUllwiv2SuyV2CuxVzRlBW2vnNjnvOgjhDcBwvu3dW68vNY8QVkPcNJnkl6Sh5V9PDivnPmgtJeZ5X/z7Yqf3BuUVYwkInoy+d9tq4b3SNYZberkslnhEttOIDuRLXQKlYszoSv4U+z4bVrYsAB6HjcfM0k6dYSpvmBvn27WcP8PZoKXvVnXWLH3FLrOLBbkfY1low5uoBgxvGtDNHB5DvIMxrBWzlTwoD/JzDo3MaQX95qQEspW6EEkr+fxP3RUGaFmy6hxrZi5TC9luAjbB5qZn7vrj/Vi+4ngmfElgZXvrq3lQ/HhuccqR4tljoQZY3+/9ycp2vt8s8uM6+a6XF5Nwfe5JFdZx83co2XLu3EfHRvmRsXPfdnx10MaKBgZJtkxt/Wct09D9+k+TLrCjc6VgwkvY1zvbqzg7Y6p6eEdvVXDHfN9aFJewcobAmO0SnXzJWVj//AvopO2a7htnqmtbb8vXdCRlZWFkiVLxnIbJNzXSUiD2KsMiL0SeyX2KsAjCspeJWzw4jyBEN4ECO9fVrrx9k/mCUicVM2M5yURYmwnZY2Mh+GHtvJZ/utROqxbTcUIF2CzyvyGG85547zY6teIpVd21yAPfjyiG8UY+Hk6tPFBffLWYMLLOODHlmpBKgEkjSTo1IsluWQC2WMhCVLv/2TGD3Ne9mbFgC7cdQq95hQLW1jCyZ7k5+SNR3X8fCx8b4ZcVM6EMQZ72IQVfxwq2WXp6Q6oH/yZ2jo7414vnKxmE3S+6ZLw2uMx7SPpd65iaPrWGOXFvpCQBHr1qYl8UUUf2k/RcVKNTVvZCT7cQwwXCG2D56hGsiNb4/IkZtHjb41a6t+be4YvWfN6sVJgIFSE+sG/+8NlnIyNfUZuMZMEP73cjd7Vgwkv931uHmqn18irfm+t9+HxpZqRvLnVVqa6/ywVE7frxovpzJ5uXFIl54vovYtUvPdT4BWJ9+XuwR5ULJa6hFfsVQbEXom9Entl5pUUpL3KK5se7bxCeBMgvPcuceOTLeYJWNKXjaSMD8qpV7vRsZorSArKfimSuBsbuPDeT5qx+V5vm7NkMPuf9eko9ama/QneStZa8buOexb4cCJMtdpQlQie57mVPry4KlgvgTq3/CRuPbYZT/tGSKb+m+t9eGKZlu0RteZAaket21nbT6Hf/GIR9WWjbcCrapqE1/Jgh/ZnUhtDQEjW7aWHSepZKYwhEUG4fu7FobMAEwgXXJuTKP7wm4ZeMwIFIDiPfUPcqDfWl6O0Mc9rqTgw0YHntTcm1bE0caViGu5cGCinHG7Oucmz5YaRFWMc2sfucQ5XZvmL7Zrx2ap33QA+Y3/RjAIa9EqSrL/X0YX7Fwe0gUO/TERbO/7+yhofnl+pGfJxg+sECC8l0GqMUnFhJQVLrk9ND+8Ty3z4x1rN2F8HbF9EWn+hgvrTTEoc2TXnVwTOOzR+ntit6uNB/TKpS3jFXom9Ensl9or2q6DtlZNnS170EcKbAOEdttCN8dvNEzBpzSComkl4x1Puq5YL9sx4+6XoBWY/i+hFysYPVVfgMTO6uzF/v46nlms5tFt5DYpDhMYe8vPrpz8HE16O2Sg44ffeUit2jC15xyI0f12eU1jMKpH8w57TGLKgWI7CFE43a8dzFGw5pgdVZ7MfS1xISFh62C6/xhhUllB+JETOzZKKiqQ68CWT8OYFPOM8z8o+brT7KmfYBsdheU/LDPfiZIijnrJhL1yk4PmVeo6yyE7nH62fFWMc2q/ccG+2V51rkRWi8tH+KxUeRceCawOe3082a6AkG8MgSOb4gvPaOi1bO7i4C3i9XfgXr0jjZMnszzZr+Gc7F+5qcDY7aY37np50kvHtflWRaHPN798HzFYxfptuhPOcsn0RsV5uLFm8O0JeqlgqnGWF7THlxJOJqK0rpS7hFXvlgdgrsVdir0z7X5D2Kr9tvXU9IbwJEN5+37sxdbd5AnpVGR5AbynJrBWiEOpRtF/O7vWzPp2HDie0tC836phubny1Q8cHYUrdGt4nN7BnsMdQN7Baj+kqZuzJGaVKsmQRSXtRC+u4Z1b48LfVOQmv5Q1c99sZ3L44I24PL0syM8wgtJKbdf2HmrvAOGNWqrMXtODvL1zkwrMXBhLT7JXEWI44XKnk/23U8MiSALklqZne3W0kc1mlgO1rYBHO4h97w0qOhSsYkcybmZ7YEyHhKTy/PUyGe+/kLR4U52D87cIvvNB1Bav7Bryr724wP+EzPIUJdww3+PTn4D3RubqCuWFihiPNqfM3Kubt0421+L/GAcLLfd9juvkmdeyW6OEWycTM6bkunaJi4X5TRtBemc+O7d8uduGp1sHJj+2+VLH0YDBulmZzl+pI2RhesVceiL3KWeDG6f3ipJ/YKycoxdcnnexVfAgkfpQQ3gQIb89Zbszdl/MEvOnf7+TGTee5MGWnlqNKWLhLXlJFwbIwn34XkzjYKp3x3B9c6sbwn7UchRCs87LPur4enFvWToBUrA6R1QodR4sKwLp+weTkocU+/PvHnISXD/hp3d3YcTgL9yzNiDuGt2kFYNvxgJc5dEz3NHWhdikYFewsZQWrz4PNXXirfYCM7Diho8VEUyqKXm6frfiHdczfVvuMc1nNejkJJ73GPlbVvEgqDonfgrmfIVx4CvVjzx2rZsdVM7zjp/4e1LGpfDQa7zViyn+xxaa+ttaHp5drhjeaL04tKynZesTWKKzsXafzskIrmNz3SqsA4bXvez2XMs9OrxNLPxaUYGIiY9RK2F4CQs9hxXtzzoeGelCmmIKdJ0xtYytJM1QW7tdTOhqOC2Bv30dMYOxTN3UJr9grsVex3Efx9BV7FTtqRdFexY5Sco4QwpsA4e08w42lB3OegCTpzfYu3NXEJKb3h0hqhbukJQQd+htL5Q6eG/gEb312ZqniUJks+8N3QW+PQWisZld6iLR1wo3hzgU+fBTGk0yiOKKLG7+fyMKDyzPiliVrUAbYcRI5yKw1RhIOJhU9tzIn6R52nsvwpFtt+UENV04LJGX9yiQim5eb/ZiwwNLCViNxf6OtC48sDcSyhuJz9jY3in9iFufI7xYuPIXxpZdPCWgqcy0oC3axLbmKcnesnmdPQnthpQ/P++O4+VJE7/UvIcoTlrYw48+dNKtgx00NXfigbYDwUt2D4RN8SdkRpoKfk3PH24f6uhd+oRoKCw39SinhzmUPXdjkV2Og6gSlyqxkUMr2zegR8JIz+fPhxeZLg73xpePtDm7ccl7qEl6xV2Kv4r2nnB4n9sopUoF+RdFexY5Sco4QwhsBRycyP22/cWPdkZwnsPRjGV/6r3U+PEmvWm71dW2exNCzjdqq4e4FwfGCVC54a72WI4kqm8RlAFO7m0lzVis73BtVOoxhCsdDPj8PmaNitF8NINwDnhJMj63KyI4DjXVb1igB7DsTSJwLPZ5e8nqlETas4tq6Cr66KkBGpu7SMMT/ckASuPg6D5pWCFZO6DVDxbTdAbZCwvtMaxdeWh2e8DI8ZEM/NxpPMAsR5HezVDmq2Eo+20tNczyc65iubvS0SbQxxpex2fYKfo8v9eGf68xJUKWBL2ZHw6h8MFHwhYuilxk+o+ooO1w14sivqaNg3KV/ZMfwvr7OB8Z+8xqhL195jSG1o1mKelbP4Hsg9LoZH3mNsRO/hdd60KKiApamvndRIOSlRUV+LQl89eCLBuPnQ5sVU/5QMyVlQxrEXrmNtRF7lXd3oNir2LEtivYqdpSSc4QQ3gQIb8uv3NjilwsLPc2LF7nwzIVuWJng0ZYrXBwmj2Hc5WNLNGTZyBYlzd7/SQtbKIHHWHG+PWoHCK/rQ29UDyV7+0I+P1//nRq27K+lkVtMO4u/rsoIGl+0udp/p1oF43cjkckb6ys4t4xiZNOHtnZVWYnNjfPLKTinpGJ401mggp+j6an84ko3utQI9lTS82cP7SDZeaC5C+9sCE94+RJAxY2rp5uFCPK70Qu7sLcbDcsF5sF5kpSd9it0MA6ZKgm3nB/ow+IapPpHh3lQKsMk/XfO9+GjzQEcI8Ufd6kBzOkVPe6WyYYX+SXeqGYxo1uA8Fr7ni8UE7q5cWUtZx7jZOD71+U+vLFOM2Ld+4QUUrHOf+IPHZVGmKWBeb9MudqNS6u7cqiZVOML2U0BLEI1te3jfbq1Cy9cmLqEV+yVC2KvknGHRT6H2KvY8S2K9ip2lJJzhBDeBAhvoy/c2OUvCBF6mkdauPCvdm7cNFfFqK3RP4bzE/Pavh7Ut8Xd8pwvrfLh2ZDP+dfUAWbtjRz3asSlMp7wXJNkHDmro/pINWzSlX3c9FIdHOpB2WIBr+jV01R8tzf8+Bm3Wa3YH3hujSdulQLOm5+9I5HJ6+sqqFtGCRtHTOPKss61Spqxx/9ca3oVLa/dfzu5EarTGxrawU/RLLbB6lrhEudI2P7XyYXb5ms5im8k5xbM/Sx2Mmb1pBRYqHLGP9q48LhfQ9kic/S2UCrL+qw/cLaKcdsCaxmpGIZVhS3a/Obs1dB3linx1rqSgoXdA4TX+jJgyJ91cmPoeflHeJlIt/g3Hf9u78LdTcN7qo3SwF+ohvIG7xcWMaGEW9+ZKr7YEcCInvCs20zCG5pAGorPnxq78H7H1CW8Yq/EXkW7pxP9XexV7AgWRXsVO0rJOUIIbwKEt+4Ed0Q5LSvZ5YqpKmb/Gp3wklh9c7UbnUJiJ+mxZLyuvV1cGUahBqvKU7gp/P0SF55sZT7sfz6mR6zKZj82XLLbZVPUHIlN1jFUlmhWxosX1sWvs0qVCIaA2CWe7GPqVVtBnTKK4dGO1KzPaC+v1vDvDYFP9iyk8XCIbJlVjtc6F6/P0ryTduhhQz5IhoxM/RVa1JCQ5NySwWehh/mTy9zoVz9AGEPjkHkEvf4sgsG2/biOlpNUeFzA11eZnku20HAOeulDEwHZL7Q0dqR58fM/q/BR3YIycGt7e7NDGrpNVTHHv++p/fl/LaOHSCQLv3NGeI378vkLXXguQmiGPRmU+54e8pvPd+GCSV6ss1X9s395+XiTGZdsL4BiH/MN9RRM6OZK2ZAGsVdir5J1j0U6j9ir2BEuivYqdpSSc4QQ3gQIb/Vx7rAxkDxl//oKxnfzoNUkb9iyuaGXpaH48FI3BjQI9oTdOEvFhO3BhJkxrUfOmqEAkdqQhi7Da8W2aL+GXt+Gr8pmP56km3GP9uSnSyarYJGLcK1TNQUdKnnx2ob4CS9HWDLDrPYWrl1ZUzHUBz62fYoP7cdxs9IX450n2bB6vKUL/2gbTLTCVb3rW0/Bt3tYKS3nCBiD+mgLf8hDLngn53bMeRYS8n+FaOOG87qzYt2X/nhmK3lP14GPLnOjv58sd56iYp4t/jSSh5d4Tg4TDhI6OrviRfWSwNY+AcJrJ45Weea8wsh+XnuhlmHnu4wvHeGaocfMqnNeU0P7tbYuPNDcjdACIyTD6/t5UK+MAku3N9I8WAZ6Ts/UJbxir8Re5fU9KPYqNoSLqr2KDaXk9RbCmwDhrTTaHdHbY2V3O1FH4BD4GfnVNjk9kl2/UTF3XzDhrJgJnFEjhwHwfG2qKFjqlznjw33Y92aFrdwa417HdnXjalvsb4uJXvwYJjGP52lUDuhWzYf3NifmveNnsEjknSSChHfEltwzxu5r5sLKgzoWHwhgFaptfOCMjnpjckpKXVFDwaLf9IhhFXc1VjB2mx631nCitytjQ1+6OIBxuDWxr/f03RoGzfEZKg0MdSCRM/bElyqWh+jHhhsbPeZvtoscDmAdc/P3KkZsMfEmSf61f4Dw1h7txR5/uI+djCeKRbTjuQe6TjUVLLrVUDCrV/iXMeoxU3LPCqWxNJ1DX4h4T8zo4Ubbqi5UH+nF/jORR8BiM33rpa5Kg9grsVfR7p9k/C72yjmKRdVeOUcouT2F8CZAeMuMdIetdMZTsoIYM7/LD/c6rkL2YDMX3uoQTB7DeYgpTWZPYgs3BXrcfh1ixh5ShuuhXD7FWsfTy8y418ENA17m88Z5sTVCYh6raPWo6cNnv8RPeHklXjcS4e1wjmLo8NpjT8PNt3E5U1DdPtb2VRX8cF2A8Gw4oqPDVwE5L+s81EBed0iPGOPcu45iZOZbUlXJvQWjn21IQwUjuwTmcc5ILw6EEK9zywDb/Jq7fDlgUhu95k9c4MIrbcz1aT7Riw0RXl5CR3FPE5cRe5tb6/S1arwosNGzc3hQgPDaK8FdXFnB8j7xfwWIjlCgh11loVkF4McQXWmrZ2hs/J+buvBYSxea2zR4LSL/2eVucB/WGaOGLT9tnZP3e/sqqVtpTeyV2KtY7qV4+4q9co5cUbVXzhFKbk8hvAkQ3hIjIhOCVpUUrL7BA/dHXqMCm5NGaacpVwcTg3pjvNh5Mvhoe4W2SOdlBr7XX3ghXJJTuONIpPlp936/R5B9cvNQ0xPYu5YPE3bGT3g5TsaMRvI+03NJfWB7IlG4sRMTer4PnQ38aieB/OvcXzX0mZkztKNJeTMmOlw8K49rWwXYdAwFRnjp5f7eVv0s82Ovkaxnb/REHhlmvuC8ud6XXYq5/7kKxl9h7qkGY73YFqK7G2n/tK2qYIntZSFcv7pjvNhl25unhgQIr33f1ykF7BwcXfXByT0SrY+9UEqkssw8xx3zfUFhMsSJRU5C9weTGhkaw5ept38Mn9hYWAiv2CuxV9Hun2T8LvbKOYpF1V45Ryi5PYXwxkl4j57KQuUx7ogk6byywMo+nmzpIyfLZpFke99Kn3tx2EbinJyHfRh7un2gx5DrilQeONy5LA1WKjtUyFQQzptoHUfvbPeaGqbtjT8Dn6EczISPFMPL7H8S3im7cn9r4Cd1ZtzbSSvVG3b7vdwc87hfNLCQRui16pZGjpcKOzbnlwP2n849SdDpusTTj97rjTeahPGkV0fFz005LXuzV5ajzM0ra8wO7aoqhh4xW41RXuw77WwElYtTsSMDrAK095SOmqUUKEqwpjGrufFFgY2Jh3v6eVG5THGcVBWj0plFyiOVG3U2kth6tf9KxRJ/WAu9zlm3BxPtjzZqyHDrGPOLbsRtW61rDQUsnsEkPKvKmvUbv0Bwn9pfpsKNinrDHaqmpodX7BUg9iq2eyne3mKvnCNXVO2Vc4SS21MIbwQ8oxWe2HcsC+dOdEf8DF6zpF/M3l/q1smytaoErL4h+AFd/GNvVDmxcOemusDMnm60qepCq0kq1h525ma+o5ELf2g6SrgV/PdSNyp85o2YmEfP7IUVNCw8GD/hJSmhmkAoybDm1LwCDLJlJyfh5ksfM2do54EkKb/7S8bymHd+9OGxpVoOPKuQ3GVFXiFqsZJMR1KScLK2ifSxyCfPsfWYjtaU0wpJsONcf7vJg/KZCobOVTHSL4XHBMftg8w9FcvLE1c063YP5u7V0H2GBi1En3njER001lYoCvfC+mu9qFehOHaeVAyVCPsYfXd44AohzIlgEulY+xzDaVuX/MQL/p0E/Yit6AZfrPiFhQVI4m2pTHjFXplfksRexbu7nR8n9so5VkXVXjlHKLk9hfDGSXi3Hc5Ciy8jJ61VygS+7eEB5ZlyU1OwX54k1a4d69N0ZHysRi0YEW4K9EoxQ//G+i7EQpoZl8uEOHrn6B2zSsdGItX1S2tYcyQBwus2PS+RdHiZGEfCa0lc5bb9Q0M9KhQDvrLJcj293IeX/Z7PUNxzS+ijh5JhKZHkqJJ7S+Y8mz08ZcE+Db2puBGSgFg6w/yiwCIcdik8e/W83NYy9KpW9bF/rdcMjeKzt3uQQTeyvzH2jBJdFm68zoLuXrSoWhyrDgFXTA2MkURj6wAPqpcM9hAnG7ezqob643z41e/FZjjChn4eQ8eZbd9pHQ3G5kxa5G8Mf+EXlsk2Dd5Yx5fKhFfslam3LPYq1l0de3+xV84wK8r2yhlCye8lhDdOwvvTwSywVGckrx8ftqz0dePs6HJg9iHQ+6T6Y29/z9JRe3TuiTKRtgSNDrV4r6/nyq6GFcv2IYEhgWIST2i8qHUexo1WydSw5UT8hJdxw/SpRbpGg7JAjZJKRC3g3OZEr+frtpjkSEVAGIvMMryRGteEeJ6N3/kXC/Q5+tIbecjvqZ6wTcPt83w4EeLhpdLFN91NHWe7JBipnur3rhb72Ou4PLKlp3nLPB9UDdg7xINKxQOE9fb5Pnxik4rj9ad286J9zeKYuRcYwH3vJ+X8be41HrSunLeE91CWjlq2+4VhLt/1ML9ysM3aq6HfrPD3I71STPRcb9PgjXXRUjlpTeyVWX1R7FWsuzr2/mKvnGFWlO2VM4SS30sIb5yEd+X+LHSZ4cIJb/iHOAnS553duGthzpjRaMtoaeiydOuFk81qUPE0lpqlPBoLFUSKkY10XnpD/nep25C3ihQMwT5lM3TsOR0/kSHhJdmNxCUZX0vPoBWXGSsOA+srGNPNjGHt8o2K70Mk3vj3SAUYrGtxdkbZ5VgvnqT+9DAzAZIV0972h2WEviCQoFJz9oZzXbBLgtmLSITTIM5tiLeerxjJgj4toEVr9Q9V7yCZGHOZiqvqZmLMNuDuBb7sl0ES3nHdXLi6dvzJjU6g3HFCRwtbCBEJ74jOZgU1tn//6MP/LTEr8YU2xrwX95j61vG2VCa8Yq9MD6/Yq3h3t/PjxF45w6oo2ytnCCW/lxDeOAnvwj1ZuGaWO9dwBZY2/ctSLaqEWOgQ6HE8McxtfBq+alrOz9dOtwGl0SgJZVUfc3qc1e+BZgre2aBHJLwkCaU8On4/Gz/hZcIa9WIjNcZCk/BGKn4RbU6sALZlgBnD2nSCFxuP5jwimuoFX17CkaRo107W74b3tLsbHau58OQyH15dG/714I12po6zvZocSd/snh40rQCUHa7GNA9iv/e0SRT4ub5lJXOdw4XacIwfd1DRp2Em3v1Jx+O2WGk+AD+4NFjuLlnY2M+z/rAOSqVZYRYk+/9u78YdjU3CO3iOaiSr5VVLZcIr9spM5BV7lVe7P3BesVfOMC7K9soZQsnvJYQ3TsI7a2cW+n3vjihVxc86j7ZQ8Ora2B+w9NYxs57Z8bGGRNinQ3WDKsUVrD4U+xh4ntaVYBSdCFUEsF+DHpPjEbzcTrZrBuXTchkepaWYNLY2zk/NpGhWwlVuihO5jZVrmRsGTuaZSB8STlaSo/e2/ywVE0Mq71nnthQZ7J5cel5ZcY+/2T/3xzIenmOKrew1y/L2nOELSmbknn27jYqbG2fi+VV6UPIXicZb7d34U5P4Q1+cjPcH/7jseslGWejWpmc50gsPf+M+LOaOnDzp5PqpHMMr9spcQbFXTnZyYn3EXjnDryjbK2cIJb+XEN44Ce+UbVkYOj+yh5cP+T71FIyOw6NkxU9SYiucjJbTbcAYVibG5+ZBze1cnAO5aG7xrcXdOrJ88Xt4I5W3tcZVORM4pyQcF0wInQ+N76JrPWheUclVUzg3HAraw8t1YHnhe5q60e5LFUsjVEvjeu8b4kGN0Wr2mjOWnGSzey0FjSaoOB2mfHK0/UQv8ZiubvTwV+B7a70PTyzXgvYVx/jaRSr+3CITdyzQ8enPAS80yeSrbV14pIVJPE/8oRnKHCX4/5LYvt2tYcCc4BjdOxu7jNActtySNxlak5GLPJ6TYaYy4RV7Za6g2CsnOzmxPmKvnOFXlO2VM4SS30sIb5yEd/zPWbjzB3fEggn8jMsKXqFlgZ0uIUudUjHh4SVaroQzt/ORANE7GUnyK9pYaLjYIiko8DePokPV4ye80cZA72LVEmZhiHgaXx7e6+gGw0Rumx97LDOvGS3kIZ5xxXqMpY9c6TMvDtvktOzn4VxHdnbjpu+D5/n3ixX0re/GxZPVmGO5eX4rnntAA5OgXjNDxdTdwW557rMXWvnwl9bFcM13GqaH/G6V7uXxTKo7t7SCL0OKrMSKSWj/iUzomx9cQptEf3oPD3af1NFkghrxXuD+4DrnttejjS+VCa/YK3P1xF5F28XJ+V3sVXQci7K9io5O3vQQwhsn4f1841ncu0QxRPbDNZKEOqXNkIB4Ws/aCjpVU/DX5fFLA5CwUkkqXsJL0s7Y1dw8vAoY45t3hJdyWyT+TiuEhcP6gWYuTNyuZctVxbMeBX3M0PNceLa1K6wGrzU2ks77mir45OfgMsjcR+90cOPyKTnLKjuZF73Eb7Z3g95StmojvfgtpLQx//5kCx/+1qYYOk7xYcmB4DM/2NxleJrZWOKYyhvf9UxuueHhP2u4b1Fw4QirmMuM3RoG2pQjQudNPehEVThSOYZX7JW54mKvnNzxifcRexUdw6Jsr6Kjkzc9hPDGSXg/+PEsHl2m4FSEz/nr8VrjAAAgAElEQVT8DEzCyKSfeBoLBlxXz4V//xg/4aWHN5Lcl9MxRY9fpacv7wgvE49YGCK0vLLT8bPfuaWBA1nxE/9YrpVXfVkJbGADFx76wZerHjDjrrcdR1AyJVdn3jVu9P4uNok8ay7cR5S4e7Sl26i85voofFzE3edr+M+lGag12od9IYR42HkuDO9sEt7G472olKlgUZTSxbFiycIiTJbLst0yTLzbMyQDr6/zGS+PkWKxoyl1OBlLKnt4xV5ZKyj2ysleTrSP2KvoCBZlexUdnbzpIYQ3TsL71tqzeHKlK6L3k4RX1+MvR0vP7ABKasURA5zMrRL9c37ePkDoeaNGarwvDsQiGWQmmZjGc66m5YF6ZRRMCwkVCD0XP81zvnavPr82PNTcZah12BO6YhmH9YkyVDvSfo4B9TSM6uqB55OcL2nX11Uw+SrTo9tgrBf03K/tG1xVMJbxhOv799U+PLUi+Np8YTp1a0auyX6JXtc6PpUJr9ir/CG8Yq9MnMVeRbcqRdleRUcnb3oI4Y2T8L668iyeWe2KKPNEksEEoXjlrEgILqgILPotbxa+sJyVCWOViiPsJ/TCModkjJNhHQwtya0iHK9Dbyx1c0OV3tpWATYdDfb8xjKue5u68G5HN6gNfVGEWOCra2j4V3sPOnyt5RgnPT6ze5mEt9Yor6GIsG1gcgnvE8t8+EcYybZ3O7jwyhotoZcmJ1ilMuEVe+VkBRPvI/bKxFDsVfS9VJTtVXR08qaHEN44Ce9zy87ixbWRs8wZzkAvW3yCYAC1DOnZ/OVE3ix8YTkrPcwkvL9nFZYR5804+SBlYYRoRUgixaLy+BIexJW0xhkNbKBgTFcPlh7Q0H16sCSZNeP2VTQ82tKD2+bnJLxM4Fx2vUl4q44wK6kcGJpcwnvHfB8+tlV/4zV4H7EsdGhlurxYpVQmvGKv8mLFc55T7JWJidir6PutKNur6OjkTQ8hvHES3sd+OIvXN0QmvCXoaculZK6T5ayYCRxOoPKTk2sUhj4VigFHIigTFIbxJ2OM3GlU8Yo3JpsJjPzYH69EnaV2MH23ZlTfCxca0by8jkENXXhqRc7XvMblgY39TYJbdrgXlNxjqEEy2w0zVUzeEe8rZuIjSeWkNbFXia+v0zOIvTIrU4q9yn3HFGV75fReSnY/IbxxEt4/zTuLD3+OTHj5hssbPjeFg2iLmYyks2jXSPXfiTDDO6J9yk/1eSQ6vmh6xU7On4iesFXUYvRWDXdHKJddr7SO1pVcmLwzJ+msUwrYOdgkuJkfefGHDuh3JpfwdpuqYs6vBUd4U9nDK/bKyR2SeB+xVyaGYq+i76WibK+io5M3PYTwxkl4h8z+A6O35a5OwASiRAhv3ix54TorSRrjPeMpmFC4Zprao2USyob+GXh3gw+PURs6jHhI1eI6yhdT8PPxnHNheM5BfwgDK8Ex9GLfTR5UyEyewsclk9W4S1AnA/1U9vCKvUrGCkc/h9ir6BjlRw+xV9FRLkh7FX10edNDCG+chHfS1rPoNzf3SlGJemijKyTkzaZIpbMmWi0uleZSmMdCTemdgzLw4iofnlsZXiqvTIaOPzQlbNgEY9pP3JqBk14dFT9XkekG1tzgQYOyCrpPV3HKq2PBtYl5fJuM92JTnAVKkrE2qezhFXuVjBWOfg6xV9Exyo8eYq+io1yQ9ir66PKmhxDeOAnvL4fPouGk3AlvMj7r5M2yF56z0kvOeM9I+qmFZyaFe6SVMoHfb87APQt9+O/G8ISXVawyXErYamX0fHnvyMC+0zoajlONCoDf9XCjTVUXWk/yokwxBfN7J1aIovZoL/acKjicC/IBUqFCBWzfvh3ly5cPC4DYq/zZF2Kv8gfnaFcRe/X/7Z0L2FVVue/f7wZ8XLxBbAsrM/PzbCvMMk2gi53UMuuYJRVgJZadsjrU7iKGIqQny3PYFuo2L+UGMkpNK7di5TYRNSoLj27FEu9ZFilKQHy384z1MWF+65trrTnGGnO+c83xW8/Tk8AY73zHb7zzff9rrDHHbERIRDNfNfYumxYI3gwFbzZTFpZV87CVeQOWedKejx4BMw9bTu6S42/uk+sS9ugOeTYou3e1DXvpReSx+bWid25n5dQR84pj82Xwqrd2yNtf3C77frdXXrpbm/zinc0J3on/3qv6kKfmT4Q+BK9edJXnyuSrYswl+arxPGjmq8beZdMCwYvgzSayPFk1r7V1fTWyJxcws+MhlP6Pdsn0H/XJmj8nf/toNyu8bW2Jr+g1P/U+PadT/rBJxDysYdaIL5rWIbNf0S57fKdXDp7UJrc2KXjHXtGbuLqc1wRqFhAEb16zXP865KtizIP5Qk2+qj8XmvlKK0oQvAherdhLdd1xHSJ/r36LQqqeNPJJwGxJeO7DnZWXTtz/bLLljrZB6R9MfgjNvPHswRM7Ky+uOP6n/RVhet7r2+Uzr+yQzst65Yh/ErntuOb28HZc2lsR0lofzQKC4NWa9eHXJV8VYx7IV43nQTNfNfYumxYIXgRvNpHlyap52Mmc0KApZDwNpaXNmJ8IH35/p7zmh33y1JbkobTJoAxKsuCd0CXyq//RKQ9uGpQ5tw6d4/vl17TL517VLi9Y1ieHTGqTX+54MYULqG19gzL+O32V/d5aH80CguDVmvXh1yVfFWMeyFeN50EzXzX2LpsWCF4EbzaR5cnqBCN4+4ceXOOjR8AI1t8c3ymHXNsnm/vs/TBvPDOvFl6/aXDnOb4n97TLvFe2y2HX9cn+u4usO8F9hfcvWwflJVf1qR4DqFlAELz2MZlFD/JVFlTtbZKvGjPTzFeNvcumBYIXwZtNZHmyulunyNYBTmnwhNPZzO6jRG45trPywJnLdw/T//qjOuSBZwfls3cOVL7EvOPFbfKpg9rlvT/tlxeNE3lwprvg3fDcoEy9xk2MO0Op6qhZQBC8vmaxOTvkq+b4+epNvmpMUjNfNfYumxYIXgRvNpHlyar5pm5eh+v6Sl1PbgRvZo9RIsvf3C7v+dmA01yYFd4VR3bI/c8Oyvy1A9I7KHLoC9rkYwe2y6fW9MsLukUe2/EmNhfY92wclBk/7lN9I59mAUHwukSN/z7kK/9MXSySrxpT08xXjb3LpgWCF8GbTWR5smoKyPb+oaPJ+OgRMCsmXz+svbI667KlwczjpTM65L5nBmXxb4cmc78JUjmlYdHdAzJ5jMifd7yJzWWUa/40IMeuGtobrPXRLCAIXq1ZH35d8lUx5oF81XgeNPNVY++yaYHgRfBmE1merJoCYl46wSuaPQF1NGPm4QtT2+X8ewacRKU5peEbb+iQuzcOykX/NSR4zeHw/31Km6zcMCimQD37IfctDTc9PiDvvwXB28yLJxxDg24xAuSrYoQD+arxPCB4GzMKpgUrJsWYagpIMebBPPX80QPb5MrfDzoJXnMO79cOa5dfPj0oVz00tAvY/N3BE9tk7V8GJToo3nW0P9gwIKfc1s+WhibetObKnn67CJCvihEN5KvG84DgbcwomBYI3mJM9fgukf4BUX2hQDFI6HphzrU8cb82+fFjg/J8r5svX3lde+WlFTc+PiR4zeHwLxwr8uQWkejVw26WRa5YPyCfvqNf9SUlmgWEfOUaOX77ka/88nS1Rr5qTE4zXzX2LpsWbGmowZUCkk3A2Vo151qaI8nMiwr46BI4Zp82+cVTg85z8cWp7bL6T4Nyx443tZlVGPPK6Gh/9uBH3bc0XHBvv3zxlwOqe701Cwj5SvfeiK5OvirGPBgvyFf150IzX2lFCYIXwasVe6mua17VOTg4dBYvH10Cr5vUJr/+q8uhZEN+z+0xWxoG5N5nhv5sziw1X2T6BodWeM2b3LrNfzh8vvLbflnwa90nGzULCILXIWgy6EK+ygCqo0nyFYK3mgCCF8HrmE7y6WYKiFkFZIU3H971rvLy3UQees7djxNe1ia/+cugPLJ5yIb5+XdgYOjLzOgOkT9+sFP2GuMmeL/wy375+j0IXh5ac49PHz3JVz4o+rFBvkLwInhT3kusmKQElXGzsR1SedEBgjdj0CnMv2CMyF+2pWhYo8nbprTJ7zYO7rRh5tZ8jOA1//37mZ3yonFugvfkX/TLtx9E8CJ43ePTR0/ylQ+KfmyQrxC8CN6U9xKCNyWojJuN6RAxEgjBmzHoFObN/kSXM3gj04dNbpP7/ja404Y5pcF8zEtFjO3fndApL9/NTfAef3OfXPeo+3aLFMNv2IQtDQ0Rlb4B+ao4U0y+QvAieGME1qxZI9OnT6/8zaJFi2TBggU7/xXBW4zEZX7qNroIwas/H0agNvPGu1fuKfLAs0N7ds3HzGu0Jrtbl8iad3XKK/dyE7xH/qRP/vMpXcG7+rhOOWLyoGzbtk3Gjh3rfcLIV96RejdIvvKO1Nkg+ao+uqzzlfPEZdgx2D2869evl4ULF8rSpUsrxemss86SuXPnSk9PTwU3gjfDqLMwbZJWRxuC1wJZZk3jAtXlIi8dJ/LY34e2qFR/zIsnfvqODjn0BTuWfS0v8Lof9slvmnigzvJyic2zXOElX/mYoextkK+yZ5z2CuSr+qSyzFdp5yjvdsEK3hUrVlRYz5o1K5E5gjfvUEy+XlebSEc7b1orxmw058Wk0VI5wzfpNdFG8P7oqA554wvdBG/P93vlwU3N+dds7ywLCPmq2dnJpz/5Kh/OeVyFfJUH5XyvEbTgXbdundx8881i/j9pS8P8+fOlo2PHkzU75uXUU0+VUaNGyYZntsuB14/Kd7YCvJpZ3TVFZJvu80gBkk8aslmbddtyYKyZJ9jN5+99I23v3iWy4s0iR01xQ73v90X+uMWtr69et75D5PBJAzW3NHR1uZ8zbAQv+crXTGVnh3yVHVt7y+SresyyzFf2c5VPj2AF7+LFi+XJJ5+UJUuWyJYtWyorvWYP77Rp0yrkzQrvSSedJAPm3KTYx/Tr7u6uCN5//vGYfGYp4KuY9b6u9uRVwYCxtOTQzRG73Z3mTW0jRbPZw3vZtAF510vchrb399rk2e3uYtztqsN73XLMoBw+qb+m4B09erTzZchXzuhy7Ui+yhV3phcjX7nnq0wnpgnjwQpes2KyYcOGisjdunWrzJs3T2bMmLFziwNbGpqIKs9dm334wLM7mGuCgNm6sGn7SAMTukQumd4hH9jfbUtD9xW9sk355SRZb2kgXzUReDl2JV/lCDvjS5GvMgacs/lgBW/8IRDDPGmF9+GHHxbOtcw5IhMuRwHRnwMfHpife81RQZt6R1oz2x2+cUSHnNzjJnjbL+1NfBjOh99pbWQpeMlXaWdBvx35Sn8OfHhAvvJBsVg2ghW8ZhrMKu/s2bMrM7J8+fJhD7CxwlucQDU/LUVHWRXHKzyxJWCEgDm2yTy4Vv0Z0y5y/uHt8smDhu+ZT3ONbX2DsseVfYkPw6Xp76tNloKXfOVrlrK3Q77KnnEeVyBf5UE532sELXjroUbw5huI9a5mvmn36x6xWhwYLeyJEbtmLrckPLRmRML/fn27/Mur7QXvk38flAO+35doN09cWQte8lWes+l+LfKVO7si9SRfFWk2/PiC4K3BEcHrJ8B8WDGPIqF3fZDUtWFWcc08Jh1LZjxb9Np2WXCIveD97V8H5S0/6UvcKpHniBG8edIu7rXIV8WdGxvPyFc2tFqjLYIXwdsakYqXLU/ArJj8o86DZacf3C7nHmoveG96fEA+cEu/PJvwMFye0DTfXMQX9DxnmmuFQIB8Vb5ZRvAieMsX1YyokAQaPczzP/9bu1w03V7w/vuDA/LJNf2yOWGrRJ4gWOHNkzbXgkC2BMhX2fLVsI7gRfBqxB3XDJCAkbL1Tg476RXtcuWb7QXv+ff0y/y1A9KrvO8FwRtgUDPk0hIgX5VvahG8CN7yRTUjakkC79m3Ta55247XsVmMYN6d/fKv9+q/io8tDRaTRlMItDgB8lXrTSCCF8HbelGLx6UkcPQ+bXLT2+0F73t/1ifXPKy8vCsirPCWMiwZFAQSCZCvWi8wELwI3taLWjwuJYEZe7fJbcfZC94jru+TO59G8PKinFLeFgyqoATIVwWdmDpuIXgRvK0XtXhcSgKvm9QmvzreXvDu/71eeeh5fSSs8OrPAR5AIC8C5Ku8SPu7DoIXwesvmrAEgSYIHLSnyL3v7bK2sNeVvfKM8pFkxmkEr/XU0QECLUuAfNV6U4fgRfC2XtTicSkJ7DdB5KH32wvezst6C/EmPgRvKcOSQUEgkQD5qvUCA8GL4G29qMXjUhKYMlbkiVl2gnfT9kGZvKxPtusf0sAKbymjkkFBIJkA+ar1IgPBi+BtvajF41ISmDRa5C8n2Qne328alNf+sE+e79VHwgqv/hzgAQTyIkC+you0v+sgeBG8/qIJSxBogsCELpHnPmwneNf8aUCOXdUvm9jDK5zS0ETw0RUClgTIV5bACtAcwYvgLUAY4gIERMy767edbCd4f/jIgHz41n55jhVeBC83EQRyJEC+yhG2p0sheBG8nkIJMxBojkBHm0jfKXaC99/+q18+e9eAbK33zuLm3Erdmy0NqVHREAItT4B81XpTiOBF8LZe1OJxaQn0n9Ip7W1tqce36O5+Oes3BXhijWPJUs8ZDSFQFgLkq9aaSQQvgre1IhZvS0ugs03k2Q91yriu9IJ37i/65YoHEbx77rknWxpKe2cwsCISIF8VcVbq+4TgRfC2XtTicSkJjOkQefyDnTJpTHrBe/R/9MnNT+q/VthMCFsaShmWDAoCiQTIV60XGAheBG/rRS0el5LAuE6R+9/XKS8en17wHnxNr6z7WzFwIHiLMQ94AYE8CJCv8qDs9xoIXgSv34jCGgQcCZhjfn59fKccsHt6wbvPil55covjBT13Q/B6Boo5CBSYAPmqwJNTwzUEL4K39aIWj0tJYLcukduO65SpE9ML3nHf7pUtfcXAgeAtxjzgBQTyIEC+yoOy32sgeBG8fiMKaxBwJLD7KJGbjumQw/+pPZWF/oFB6bq8T4qxg5c9vKkmjUYQKAkB8lXrTSSCF8HbelGLx6UkYArID9/WIW95UTrB++ctAzL12n7589Zi4Fh9XKccMXlQtm3bJmPHjs3VKU5pyBU3F4OAkK9aLwgQvAje1otaPC4lAVNAvvuWDnnHS9IJ3jv+PCDH3tQvzxbgtcJmQtjSUMqwZFAQSCRAvmq9wEDwInhbL2rxuJQEzJ64K97UISe8LJ3gvfLBATltTb9sZg+vsMJbyluCQRWYAPmqwJNTwzUEL4K39aIWj0tJYHynyMXTO2T2K9IJ3jN+1S/n/q4YL51ghbeUIcmgIFCTAPmq9YIDwYvgbb2oxeNSEhjbIfKvR3TIRw9MJ3jffmOf3PREUR5ZY0tDKYOSQUGgBgHyVeuFBoIXwdt6UYvHpSQwul3k64e1y6de2ZFqfC//Xq9seD5V01wasYc3F8xcBAKFIEC+KsQ0WDmB4EXwWgUMjSGQFQHzbvpzDm2XL0xNJ3hHX94r24uzo4GH1rIKDOxCoIAEyFcFnJQGLiF4EbytF7V4XFoCCw9pl7NeOyR4n9s+KP92/0CiAP7TlkHZ73t9srW/OCg4lqw4c4EnEMiDAPkqD8r+rpG74F2/fr3MnDlT1q1bN2IURx99tKxYsUImTpzob4SOlnjq2REc3SDQBIHPvqpd/s/hQ4L3vHX9sug3A3LGa9pl/muGr/qufmpAjru5XzZlfSTZn9aLfGuWyBP3jBzVQUeJzL1SZPxQvmJLQxMTT1cItCCBwuUrC4aa+crCTa9NcxW8W7dulXnz5smUKVNkwYIFXgfi2xiC1zdR7EGgMYEvTm2Tr76+s9LwrTf0yS1/HBTzNPTKtw4/n/eK9QPy6Tv65e9ZHkm2favI9/9FZI8XibzzjIbOs8LbEBENIFAqAoXKV5ZkNfOVpavemucqeDdu3CizZs2qiN1p06Z5G0QWhhC8WVDFJgTqEzhwd5H7T+yqNNrjyt6dK7j7jBN5/INDf28+X1rbL+ety3gD7+aNIpd/SOTY+SL7H9Fw6jRXTMhXDaeHBhDwTqBQ+cpydJr5ytJVb81zFbzRCu+cOXMQvN6mEEMQKA8B8yDIsx/qrLw97YDv98mWHSu4ZpX3+Y/sErxv+48++dmTGR9JFq3wHj4LwVueEGMkEPBGoFD5ynJUCF5LYC7N16xZI4sXLy7MXt1aY2DFxGV26QOB5gjs3iXynTd3yMCgyMm/6JdNvUP2zMm82+Z2Sld7W+XP+17VK49ubu5aqXr/4Q6RG84dtle3Vj/NAkK+SjWbNIKAVwKFy1cWo9PMVxZuem2a+QpvtI1h1apVDR3nobWGiGgAgdITmNvTLruNElny/3ZtWRjXKXLveztl3wlDgrfrsl7py2KBN9rGcN/NjTnz0FpjRrSAQMkJqOarJtgieJuAV7aurJiUbUYZT6sQeGG3yORukXV/2+WxWUm54ZgOmbZ3uzyxeVB6frBru0NRxqVZQMhXRYkC/AiNAPmqdWY88xXe1kEx3FMKSKvOHH63OgGzmrutX6Q/toI7oUvk0hkdMvPl7fKffxyQ43+aw5FkliARvJbAaA6BEhAgX7XOJGYueKMtDfvuu68sWbJEuru7W4IOgrclpgknS0ige8eRu/GXSpiHQ847rF0++6oO+db9A/K/7uzP5qUT0ZaGiS8VOfF8kVHp8xWCt4TByJAg0ICAar5qYnY081UTbjfVNXPBG3lX/cKJ5cuXV44oK+oHwVvUmcGvEAiMaRfZVnXq2Cf/uV2WTuuonL/7zfsyPpKs+oUT5gUTh32gLnrNcy3JVyHcFYyxqATU85UDGM185eCuly65Cd5qb80b1WbPnl3566lTp8rKlSulp6fHy6B8GKGA+KCIDQj4I3DMPm1y49s75c0/6ZNfPJXFE2t1fP3lVUNn8prPPq8W+dgKkb2H5yvNFRPylb84wxIEfBBQzVcpBqCZr1K4l0kTNcEbH010Pu8jjzxSmOPKKCCZxBtGIeBM4KA9zUkNXbLPil55couzmeY7RufzbnyUVws3TxMLECglgcLkqxp0EbylDDu3QSF43bjRCwJZEZg0WuQvJ3VJx2W9lXN6i/bRLCDkq6JFA/6EToB8VbwIyH2Ft3ovbxwJ5/AWL0DwCAJFIWDeObFhZqccdHWf/H3HG9gy9616L2/8gpzDmzl+LgCBViWgkq8sYGl+Qbdw02vTXAVvtHVhypQpsmDBAq8D8W2MFRPfRLEHgeYIjOkQWfbmdjll9YBs2t6crVS9o60Le7xI5J1nNOyiWUDIVw2nhwYQyJVA7vnKcnSa+crSVW/NcxW80RFlRuxOmzbN2yCyMEQByYIqNiHgTmC3LpHTDmqX/3vPwIgTHNyt1ukZHVF27HyR/Y9oeAnNAkK+ajg9NIBArgRyz1eWo9PMV5auemueq+CNVnjnzJmD4PU2hRiCQBgETAGZsXeb3PB4Tht4oxXew2cheMMIMUYJAW8Ecs9Xlp4jeC2BuTRfs2aNLF68uDCnMdQaAysmLrNLHwhkR8Ac8P6isSIPPZ/dNUZY/sMdIjecO+w0hlpX1ywg5KscY4JLQSAFAZV8lcKvqIlmvrJw02vTzFd4o20Mq1ataug4D601REQDCARNwLzGM9MH1qJtDPfd3JgzD601ZkQLCARMIPN81QRbBG8T8Gp1jQSv+XfzsomJEydmcBX/Jlkx8c8UixAoPIFI8BpHzdvVxqfPV5oFhHxV+MjCQQgUioBmvtICkfkKrxmY2cJw5plnDhtjkVZzk+BTQLRCkutCoDaBNhHJfAfvT84R+dHZw52oWs1N8lDzVZ3kK+4aCBSPQC75ynHYmvnK0eWmu+UieKu9TDqLt2gCmALSdGxhAALlIJB0Fm+CANZcMSFflSPUGAUE8iKgma/yGmP1dVQEb9JgzXaHZcuWFWbbAwVEKyS5LgRagMAvrxK5awWvFm6BqcJFCEBgJAEEb45RER1Rdskll1Sueuqpp8qSJUuku7s7Ry9qXwrBW4hpwAkIFINAdETZbZcO+fPGj4qceL7IqF35SrOAkK+KESZ4AYFWIaCZr7QY5b7CG9/PW7RtDPFJoIBohSTXhUCBCMT38zbYx6tZQMhXBYoZXIFACxDQzFdaeHIRvGa7wuzZsytjnDp1qqxcuVJ6enq0xpzquhSQVJhoBIHyETDbFS7/0NC49nm1yMdWiOzdOF9pFhDyVfnCkBFBIEsCmvkqy3HVs5254G2l1wmzwqsVhlwXAgUhYPk64bjXmgUEwVuQ+MENCLQIAc18pYUoc8FrBhbfr1vkbQwIXq0w5LoQKBCB+H7dFMeRRZ5rFhAEb4HiB1cg0AIENPOVFp5cBG98cPEjyYr2oBqCVysMuS4ECkogfiRZwoNqrPAWdN5wCwIQqEsAwZtzgMT39i5fvlxmzZqVswe1L8eKSWGmAkcgUAwC8b295i1sh31gmF+aBYR8VYwQwQsItAoBzXylxSj3Fd5aA+UcXq0Q4LoQgIA1Ac7htUZGBwhAoDgEELw5zQVvWssJNJeBAASaJ8Cb1ppniAUIQKBQBBC8GUxH9QsmoksU/eE1fiLMIBgwCYGiE6h+wUTkb4qH1zQLCPmq6IGFfxAoFgHNfKVFIvMtDdGxZGaAZtvCxIkTtcZqdV0KiBUuGkOgHASiY8nMaMw+3fHp85VmASFflSP8GAUE8iKgma/yGmP1dTIXvFoDa/a6FJBmCdIfAmER0Cwg5KuwYo3RQqBZApr5qlnfXfsjeGuQo4C4hhT9IBAmAc0CQr4KM+YYNQRcCWjmK1efm+2Xm+CtfuPa4sWL5cwzz9zp/6JFi2TBggXNjsdbfwqIN5QYgkDrEah+49pPzhH50dm7xvGus0TeecawcWkWEPJV64UYHkNAk4BmvtIady6CNzqV4fOf//zOs3aN4AL2MtcAACAASURBVDUfI3K1Xz8c9yWaCAqIVkhyXQgoE4hOZTj6c7vO2jWC13yMyK3x+uG8Cgj5Sjk+uDwESkAgr3xVJFS5CN6kBF39d+aBttWrV8uSJUuku7s7N0Zr1qyR6dOnS/UKM4I3tyngQhAoFoG4uI08q/47cw7v728XOfF8kVFD+SqPAkK+Klao4A0EWpVAHvmqaGwyF7y1Vm+rBa9J5Obv8jzJwfh2xhlnSE9Pj2zevHnYlgoEb9FCFX8gkAOBGqu3Ui14/3CHyA3nDjvJIesCQr7KYf65BAQCIZB1vioiRjXBWw1DQ/AagX3kkUfKI488Ihs2bBgheA855BDZtm3bMFevu+46GT9+vGx4Zru88oaxRZxTfIIABFwJ1BK81fYSBO/Pj+6Xwyb2V3LG2LEjc0Ozv1yRr1wnlX4QgEA1gazzVRGJZy54oxdPzJgxY+f+3SQQeW9pMAL7lltuqYhcc+0kwbty5UoZPXr0MHff8IY3SEdHhzz0t39Iz3VdRZxTfIIABFwJRC+eeMX0Xft3k2wlbGm47Z3tcvikgZqC1+QN1w/5ypUc/SAAgSQCWearohLPXPCagRtBuWzZsprbFTQeWqs+JcL4Gd/Hy5aGooYsfkEgYwJGzN61ovaLJxQeWiNfZTznmIdAYATY0pDhhJuEfc0114hZNTV7ZqNPdILDCSecoHYsWa0V3ocfflj22GOPRCpmhXf/a9ozJIZpCEBAjYDZs3v3D0U+tkJk7135SqITHA45Xu1YMvKVWlRwYQiUhgCCN+OpjMTtunXrdl5p6tSpI0Rwxm6MME8ByZs414NACxCIxO0T9+xydp9XjxTBO/41rwJCvmqB2MFFCBScQF75qkgYctnSUKQBp/WFLQ1pSdEOAhAwBDQLCPmKGIQABGwIaOYrGz99tkXw1qBJAfEZZtiCQPkJaBYQ8lX544sRQsAnAc185XMcNrYQvAhem3ihLQQgUIOAZgFB8BKWEICADQHNfGXjp8+2CF4Er894whYEgiWgWUAQvMGGHQOHgBMBzXzl5LCHTgheBK+HMMIEBCCgWUAQvMQfBCBgQ0AzX9n46bMtghfB6zOesAWBYAloFhAEb7Bhx8Ah4ERAM185OeyhE4IXweshjDABAQhoFhAEL/EHAQjYENDMVzZ++myL4EXw+ownbEEgWAKaBQTBG2zYMXAIOBHQzFdODnvohOBF8HoII0xAAAKaBQTBS/xBAAI2BDTzlY2fPtsieBG8PuMJWxAIloBmAUHwBht2DBwCTgQ085WTwx46IXgRvB7CCBMQgIBmAUHwEn8QgIANAc18ZeOnz7YIXgSvz3jCFgSCJaBZQBC8wYYdA4eAEwHNfOXksIdOCF4Er4cwwgQEIKBZQBC8xB8EIGBDQDNf2fjpsy2CF8HrM56wBYFgCWgWEARvsGHHwCHgREAzXzk57KETghfB6yGMMAEBCGgWEAQv8QcBCNgQ0MxXNn76bIvgRfD6jCdsQSBYApoFBMEbbNgxcAg4EdDMV04Oe+iE4EXweggjTEAAApoFBMFL/EEAAjYENPOVjZ8+2yJ4Ebw+4wlbEAiWgGYBQfAGG3YMHAJOBDTzlZPDHjoheBG8HsIIExCAgGYBQfASfxCAgA0BzXxl46fPtgheBK/PeMIWBIIloFlAELzBhh0Dh4ATAc185eSwh04IXgSvhzDCBAQgoFlAELzEHwQgYENAM1/Z+OmzLYIXwesznrAFgWAJaBYQBG+wYcfAIeBEQDNfOTnsoROCF8HrIYwwAQEIaBYQBC/xBwEI2BDQzFc2fvpsi+BF8PqMJ2xBIFgCmgUEwRts2DFwCDgR0MxXTg576ITgRfB6CCNMQAACmgUEwUv8QQACNgQ085WNnz7bIngRvD7jCVsQCJaAZgFB8AYbdgwcAk4ENPOVk8MeOiF4EbwewggTEICAZgFB8BJ/EICADQHNfGXjp8+2CF4Er894whYEgiWgWUAQvMGGHQOHgBMBzXzl5LCHTgheBK+HMMIEBCCgWUAQvMQfBCBgQ0AzX9n46bMtghfB6zOesAWBYAloFhAEb7Bhx8Ah4ERAM185OeyhE4IXweshjDABAQhoFhAEL/EHAQjYENDMVzZ++myL4EXw+ownbEEgWAKaBQTBG2zYMXAIOBHQzFdODnvohOBF8HoII0xAAAKaBQTBS/xBAAI2BDTzlY2fPtsieBG8PuMJWxAIloBmAUHwBht2DBwCTgQ085WTwx46IXgRvB7CCBMQgIBmAUHwEn8QgIANAc18ZeOnz7YIXgSvz3jCFgSCJaBZQBC8wYYdA4eAEwHNfOXksIdOCF4Er4cwwgQEIKBZQBC8xB8EIGBDQDNf2fjpsy2CF8HrM56wBYFgCWgWEARvsGHHwCHgREAzXzk57KETghfB6yGMMAEBCGgWEAQv8QcBCNgQ0MxXNn76bIvgRfD6jCdsQSBYApoFBMEbbNgxcAg4EdDMV04Oe+iE4EXweggjTEAAApoFBMFL/EEAAjYENPOVjZ8+2yJ4Ebw+4wlbEAiWgGYBQfAGG3YMHAJOBDTzlZPDHjoheBG8HsIIExCAgGYBQfASfxCAgA0BzXxl46fPtgheBK/PeMIWBIIloFlAELzBhh0Dh4ATAc185eSwh04IXgSvhzDCBAQgoFlAELzEHwQgYENAM1/Z+OmzLYIXwesznrAFgWAJaBYQBG+wYcfAIeBEQDNfOTnsoROCF8HrIYwwAQEIaBYQBC/xBwEI2BDQzFc2fvpsi+BF8PqMJ2xBIFgCmgUEwRts2DFwCDgR0MxXTg576ITgRfB6CCNMQAACmgUEwUv8QQACNgQ085WNnz7bIngRvD7jCVsQCJaAZgFB8AYbdgwcAk4ENPOVk8MeOiF4EbwewggTEICAZgFB8BJ/EICADQHNfGXjp8+2CF4Er894whYEgiWgWUAQvMGGHQOHgBMBzXzl5LCHTgheBK+HMMIEBCCgWUAQvMQfBCBgQ0AzX9n46bMtghfB6zOesAWBYAloFhAEb7Bhx8Ah4ERAM185OeyhE4IXweshjDABAQhoFhAEL/EHAQjYENDMVzZ++myL4EXw+ownbEEgWAKaBQTBG2zYMXAIOBHQzFdODnvohOBF8HoII0xAAAKaBQTBS/xBAAI2BDTzlY2fPtsieBG8PuMJWxAIloBmAUHwBht2DBwCTgQ085WTwx46IXgRvB7CCBMQgIBmAUHwEn8QgIANAc18ZeOnz7YIXgSvz3jCFgSCJaBZQBC8wYYdA4eAEwHNfOXksIdOCF4Er4cwwgQEIKBZQBC8xB8EIGBDQDNf2fjpsy2CF8HrM56wBYFgCWgWEARvsGHHwCHgREAzXzk57KETghfB6yGMMAEBCGgWEAQv8QcBCNgQ0MxXNn76bIvgRfD6jCdsQSBYApoFBMEbbNgxcAg4EdDMV04Oe+iE4EXweggjTEAAApoFBMFL/EEAAjYENPOVjZ8+2yJ4Ebw+4wlbEAiWgGYBQfAGG3YMHAJOBDTzlZPDHjoheBG8HsIIExCAgGYBQfASfxCAgA0BzXxl46fPtsEK3o0bN8qsWbNk1apVFZ7Lly+v/Dn6UEB8hhm2IFB+AlkWEPJV+eOHEUIgTwJZ5qs8x2FzrWAF7+LFi2W//fariNz169fLzJkz5cILL5Rp06ZV+CF4bcKIthCAQJYFhHxFfEEAAj4JZJmvfPrp01awgjcOcevWrTJv3jyZM2cOgtdndGELAgERyKuAkK8CCiqGCoGMCOSVrzJy38ksglekssK7cOFCWbp0qUycOHHnCu/atWtlwoQJw8BOnjxZ2tra5KG//UNecW2HE3Q6QQAC5SOw+rgOecMLBmXbtm0yduzYEQM0ecPHh3zlgyI2IBA2gbzyVZEoBy94zd640047rSJ4e3p6ds6N2dKw1157yebNm4fN1+9+9zvZbbfdZMMz2+XVN44v0lziCwQgoEjgZ0f1yev36qspeMeNG9e0d+SrphFiAAIQEJE88lXRQActeJNWSqIJYg9v0UIVfyBQbAJZ/0RIvir2/OMdBFqJQNb5qogsghW8pnhcfvnlcvbZZ0t3d/eIuUHwFjFc8QkCxSWQZQEhXxV33vEMAq1IIMt8VVQeQQre6KGPSy65ZNi83H777Ty0VtRIxS8IFJxAVgWEfFXwicc9CLQggazyVZFRBCl400wIK7xpKNEGAhCICGgWEPIVcQgBCNgQ0MxXNn76bIvgrUGTAuIzzLAFgfIT0Cwg5KvyxxcjhIBPApr5yuc4bGwheBG8NvFCWwhAoAYBzQKC4CUsIQABGwKa+crGT59tEbwIXp/xhC0IBEtAs4AgeIMNOwYOAScCmvnKyWEPnRC8CF4PYYQJCEBAs4AgeIk/CEDAhoBmvrLx02dbBC+C12c8YQsCwRLQLCAI3mDDjoFDwImAZr5ycthDJwQvgtdDGGECAhDQLCAIXuIPAhCwIaCZr2z89NkWwYvg9RlP2IJAsAQ0CwiCN9iwY+AQcCKgma+cHPbQCcGL4PUQRpiAAAQ0CwiCl/iDAARsCGjmKxs/fbZF8CJ4fcYTtiAQLAHNAoLgDTbsGDgEnAho5isnhz10QvAieD2EESYgAAHNAoLgJf4gAAEbApr5ysZPn20RvAhen/GELQgES0CzgCB4gw07Bg4BJwKa+crJYQ+dELwIXg9hhAkIQECzgCB4iT8IQMCGgGa+svHTZ1sEL4LXZzxhCwLBEtAsIAjeYMOOgUPAiYBmvnJy2EMnBC+C10MYYQICENAsIAhe4g8CELAhoJmvbPz02RbBi+D1GU/YgkCwBDQLCII32LBj4BBwIqCZr5wc9tAJwYvg9RBGmIAABDQLCIKX+IMABGwIaOYrGz99tkXwInh9xhO2IBAsAc0CguANNuwYOAScCGjmKyeHPXRC8CJ4PYQRJiAAAc0CguAl/iAAARsCmvnKxk+fbRG8CF6f8YQtCARLQLOAIHiDDTsGDgEnApr5yslhD50QvAheD2GECQhAQLOAIHiJPwhAwIaAZr6y8dNnWwQvgtdnPGELAsES0CwgCN5gw46BQ8CJgGa+cnLYQycEL4LXQxhhAgIQ0CwgCF7iDwIQsCGgma9s/PTZFsGL4PUZT9iCQLAENAsIgjfYsGPgEHAioJmvnBz20AnBi+D1EEaYgAAENAsIgpf4gwAEbAho5isbP322RfAieH3GE7YgECwBzQKC4A027Bg4BJwIaOYrJ4c9dELwIng9hBEmIAABzQKC4CX+IAABGwKa+crGT59tEbwIXp/xhC0IBEtAs4AgeIMNOwYOAScCmvnKyWEPnRC8CF4PYYQJCEBAs4AgeIk/CEDAhoBmvrLx02dbBC+C12c8YQsCwRLQLCAI3mDDjoFDwImAZr5ycthDJwQvgtdDGGECAhDQLCAIXuIPAhCwIaCZr2z89NkWwYvg9RlP2IJAsAQ0CwiCN9iwY+AQcCKgma+cHPbQCcGL4PUQRpiAAAQ0CwiCl/iDAARsCGjmKxs/fbZF8CJ4fcYTtiAQLAHNAoLgDTbsGDgEnAho5isnhz10QvAieD2EESYgAAHNAoLgJf4gAAEbApr5ysZPn20RvAhen/GELQgES0CzgCB4gw07Bg4BJwKa+crJYQ+dELwIXg9hhAkIQECzgCB4iT8IQMCGgGa+svHTZ1sEL4LXZzxhCwLBEtAsIAjeYMOOgUPAiYBmvnJy2EMnBC+C10MYYQICENAsIAhe4g8CELAhoJmvbPz02RbBi+D1GU/YgkCwBDQLCII32LBj4BBwIqCZr5wc9tAJwYvg9RBGmIAABDQLCIKX+IMABGwIaOYrGz99tkXwInh9xhO2IBAsAc0CguANNuwYOAScCGjmKyeHPXRC8CJ4PYQRJiAAAc0CguAl/iAAARsCmvnKxk+fbRG8CF6f8YQtCARLQLOAIHiDDTsGDgEnApr5yslhD50QvAheD2GECQhAQLOAIHiJPwhAwIaAZr6y8dNnWwQvgtdnPGELAsES0CwgCN5gw46BQ8CJgGa+cnLYQycEL4LXQxhhAgIQ0CwgCF7iDwIQsCGgma9s/PTZFsGL4PUZT9iCQLAENAsIgjfYsGPgEHAioJmvnBz20AnBi+D1EEaYgAAENAsIgpf4gwAEbAho5isbP322RfAieH3GE7YgECwBzQKC4A027Bg4BJwIaOYrJ4c9dELwIng9hBEmIAABzQKC4CX+IAABGwKa+crGT59tEbwIXp/xhC0IBEtAs4AgeIMNOwYOAScCmvnKyWEPnRC8CF4PYYQJCEBAs4AgeIk/CEDAhoBmvrLx02dbBC+C12c8YQsCwRLQLCAI3mDDjoFDwImAZr5ycthDJwQvgtdDGGECAhDQLCAIXuIPAhCwIaCZr2z89NkWwYvg9RlP2IJAsAQ0CwiCN9iwY+AQcCKgma+cHPbQCcGL4PUQRpiAAAQ0CwiCl/iDAARsCGjmKxs/fbZF8CJ4fcYTtiAQLAHNAoLgDTbsGDgEnAho5isnhz10QvAieD2EESYgAAHNAoLgJf4gAAEbApr5ysZPn20RvAhen/GELQgES0CzgCB4gw07Bg4BJwKa+crJYQ+dELwIXg9hhAkIQECzgCB4iT8IQMCGgGa+svHTZ1sEL4LXZzxhCwLBEtAsIAjeYMOOgUPAiYBmvnJy2EMnBC+C10MYYQICENAsIAhe4g8CELAhoJmvbPz02RbBi+D1GU/YgkCwBDQLCII32LBj4BBwIqCZr5wc9tAJwYvg9RBGmIAABDQLCIKX+IMABGwIaOYrGz99tkXwInh9xhO2IBAsAc0CguANNuwYOAScCGjmKyeHPXRC8CJ4PYQRJiAAAc0CguAl/iAAARsCmvnKxk+fbRG8CF6f8YQtCARLQLOAIHiDDTsGDgEnApr5yslhD52CFrwrVqyQ2bNnVzDefvvtMm3atJ1IKSAeogsTEAiIQNYFhHwVUDAxVAhkTCDrfJWx+07mgxW869evl4ULF8rSpUvlgQcekGXLlsmSJUuku7u7AhLB6xRPdIJAsASyLCDkq2DDioFDIBMCWearTBz2YDRYwWtWS1avXl0RuVu2bJHTTjutIoB7enoQvB4CCxMQCI1AlgWEfBVaNDFeCGRLIMt8la3n7taDFrwbNmyQBQsWyMaNG2XWrFmV/462NZgV3vnz50tHR8cwuqeeeqqMGjVKNjyzXQ68fpQ7eXpCAAKlInDrO0QOnzQg27Ztk7Fjx44YW1dXl/N4jeAlXznjoyMEIFBFIMt8VVTYCN46gvekk06SgYGBYXO3ePHiyrYHU9Q6Ozsr/wv5s3nzZhk/fnzICKS3t7cSJ6NHjw6ag/mlZMyYMdLe3h4sBxMHtQRvM/GRRvCSrxqHHflKyFc7woR8JZW6lUW+anwn6rQIWvA2s6UBwTsUsBQQCkiUuigg9QtIMym+2S0N5CvyVRR/fEEfIkG+yi5fNZPrsuwbrOBt9iEQCggFhAIyPDVRQLIrIOQrP2WQL+h8QecL+q57qd4Kr587rlhWghW8ZhqiY36mTp0qK1eu3PnAmvm3Rqc0IHgRvAheBG91Os+ygJCvmi+eCF4EL4IXwdt8JimZBQRvugmlgFBAKCD6BYR8Rb5KR4B8Rb7Sz1dpY9V3u6BXeOvBbFRAzjnnHDn44IPl2GOP9T0nLWPPrGYdeeSRcuutt7aMz1k4evXVV8ujjz4qn/vc57Iw3zI2P/KRj8jpp58uBxxwQMv47NvR++67Ty644AL51re+5dt0XXvkq8a4yVdDjMhXQxzIVyJa+arx3ZpNCwRvDa6NCoh5IvpNb3qTzJ07N5uZaQGr/f39lZMJ+vr6WsDb7Fz8xje+Iffff79cfPHF2V2kBSybrUHf/va35ZBDDmkBb7Nx8c4775TPfOYzsnbt2mwuQL5y5kq+GkJHvhriQL4S0cpXzjdxkx0RvBQQ5xCigFBA4sFDAdErIHxBb5zGyFfkK/LV8PsEwds4bwTRggLSeJopIBQQCkgxCgj5inzVmAD5inxVjHyVNlZ9t2OFlxVe55hC8FJAKCDFKCAI3sZpjHxFviJfFSNfNb5bs2mB4K3B1bxi2LwKtK2tLbGFOXPUvGXNvGY45M8zzzxTOcIt5M8//vEPMcU06XWyIXF5/vnnKwyqX8cdEgOzn33r1q0yYcKEEcO+8cYbK2+iy+JDvkpHlXwlQr4aihXylVSev9HIV+nuVv+tELw1mN5+++3BP4zlP9ywCIFwCcyYMSOzLwPkq3DjipFDIAsCWearLPxNYxPBm4YSbSAAAQhAAAIQgAAEWpYAgrdlpw7HIQABCEAAAhCAAATSEEDwpqFEGwhAAAIQgAAEIACBliWA4G3ZqcNxCEAAAhCAAAQgAIE0BEoleDdu3CizZs2SVatWVca+fPnyyp/NZ8WKFTJ79uzKf5sHPMxTzebpxHnz5skll1xS+ftFixbJggULhnEz/VavXi1LliyR7u7uEUzXrFkj06dPH3E98xeR/Tlz5lSuV/2p5+/ixYvlzDPPTLTbaGLjYz366KMrY584ceKw8cb/Pj4G8/KAlStXSk9Pz7DLGH/Mp5pPfJyGo63dev3Nv8U5RPPWaPzVNqvnttac1eIWXW/9+vXy6U9/uvKmomo+po2r3fh46sVMo1hM4lJvbpPuiXoxGdlv5Ier3WqG8VhM41e9uKg1t3G7p5566s77vNE9EfUz90Ojeztu18TQzJkzZd26dfKWt7ylcgrMLbfcMuI+N/fSxz/+8crfv/vd75arrrqq8t/xfGVe6/3zn/+cfEW+GpZ3yVdDNZ98tauG+8hX8dpeT8vE8118DjZs2JCoH9LUc19tSiV4jTjab7/9KiI3KiwXXnihTJo0SRYuXChLly6VBx54QJYtW1YpbNdee61EkxAFhBGnkUiObBx++OGJgtf0Oe200yq2zSe6hhGX8UJaS6jV8jcSeqZIm2OeTJGrJZqrA8H4HPfDXOPJJ58cMd7o2sccc8zOMRgRZ65p+EQiOS5Ckr4QmH83bSOONnaTboY4k7hdM67LL79czj777MQvHtUc4n3jcxsfb3zO/vrXv9bkZr7oREL0rrvuSvxCUCsWGtmN+10vZhrFYlJCiPtUPbdxv+L3xPnnn594D0WirpEf8fizsWv8r+fvRRddVNevegmx3j0Rjfc973nPzvvswAMPbHhPRF/EGt3bcbvmlcvxe/mtb31r5Ui/q6++ekS+et/73ief+MQn5IADDqj4YnLXU089VbnPzMd8Gd5///0rMUu+Il/F8zz56sKdX0LJVxMr+cJHvqq36BXV7Xi+i2pGdO1a+sGXmE1jp1SCNz7g+ErZI488snOV1pyfG4nUpFXMSDCb/meddValqNx9992JgtesApnJrBamprCZQmpWcsyKYK1VoHr+xr8NxUVgmkmNtzE+GgF77rnnyvz588UcNWIKZPT31SvX1eLAiJAzzjijsqK5efPmEd/QIs62diMfa/U3/n71q1+VuXPnJq6m2nKIGO67776Jc1a9SlfNx8zx008/LWvXrq2IjOrYqRULjezGOdSKmTSxmIZHfG5vuummhvdE9WpzGj/iq7+17rVGv3xEY6mOxeqYSfslsJpNNLdf/vKX5ZRTTtl5f8a/JMX7VPth+l9//fXy3HPPJX4RrV5NqWU3fl/Hmdx7773yla98Ra688koxq9zHHXecHHrooXLBBRdUco2JYbMqfOutt8rJJ59cuZ/TzA35atevbuSr5NpFvhpawIrnd/LVUDaspUPq5bt4vjI2kn4hTlO7fLUpreCtLu7VK7nVIjRpdclANsUlWhGu3tIQF0WmrVm9iRJptGJlilEawVu9MlYtpKdMmeIULLW+ecWLn1mRjj7Vxdn0Nz+dmi8NST9JVCeDtHZriZeo/2WXXVbZOmA+X//61yv/b7OlIX6DxOfWrGxG85k0Z1G/6tV3s7psvrx8/vOfryl4be0m3cRJPz2ZOWkUi2kSQnxuk1bAq+O0Wuil8cPFbi3f0wrQNGOPt6n3K0TS9qXqMZkvgEYsG1GaJLqTckncbrTqtPfee+/8JSXO2qz4ml+mfvCDH1R+nTL338te9rLKtoYoB51++ulyww03VNpEq/eNYoR8NXKbGflqSeXWqK5dSXmQfLW0sjWQfDWcQaN8F4llBK9tpUrZPmkC6gneatEW//ncrO5mLXir/Y0CxPxsaVZ4jjrqqMqbm2y/HcULdRphWr2qaf5sVpLMdWuJDxe78Wms1f+b3/ymfOpTn6oIimhFOvoSUC/pVIdIkv1GwrSam1npNyvNRnzU+nWgkZgwftViWC3O41+S0sZio1sjacW63j1RHZNp/WgkeJNiPcn3Wr9ApO2fpiilSdTVfkRfAKu3J9T6ghWJ0SQhHYktE+vmXo9Wlsz+3XqC18T0G9/4Rjn44IPl0ksvrWyHiLb7kK/IV+SrntT3BPkqeStZvXwV3+5o8l6aPFpvO0Sj2uXz30u3wpv0M2i9n1mTCmj8AZcIttmIfeKJJ4rZd2c+Zj+KWXlJ2tIQ/SxUvVqX9ABWrZ9tk1akor16aQKg+ueHRlsPksRY3N/omkb8mp/2TVE2Ytz87HrxxRfX3CpRbTf+oGC9/tEWjGgFrdEDY7VWH6oFaqOtB9Xc4g8ZRdcwfpvtFl/60pcqDx9FsfG1r31txPaW+D6maLuMsRN/KCq+tynp56HoYct4LNZ6iDKJQ9Lc1rsnat1DSX5Mnjy5cg+Yj1mBr7d9KMlu0j2R9cpudB812npQ7Uf1g3MR6+9+97ty3nnn7YwFm60S5ouUeUW5+eXhvvvuq8TSQQcdJCaWkrY0RPnKcDdfwKIvo0lzQ74a+gmVfEW+MvequbfIVyLN5CvzK6f5NSBe+9LkOwRvGtVm2abWg021HqQxewzNz5PnnHNOzZ8qaq00VX+zMX+OPywW/Xu9LQ21/I1f87HHHqt7C8a8vgAABPlJREFUMkASomgVqno/VryAVz8cZuzUE9T1ViebsVu98lnrobVaPz3WCpFo73H13NZ70LAWt+ga9VYXm7FbvTpYK2bqxWK9Fc2kua11T5h4a/RwYD0/mrEbxUItfxv5VS9d1JrbWlt+ou0bte6JRvv6kuyaVeFo9c2s/Jo92+YkGfMryl577bXTfcMw6aE180UrylfmIT7zqf7Vh3w1hJF8NXLlrTrP1HrgulEeJF/tIlArT9g+ZF2du4qYr+KLJNXbO+s9tGbGhuC1FLONmlcfMRa1j/Z9Rqu28aOOklYw40eZGRuNREZ8pa56j2nSfszIr0b+Jq18NWIQ+Rsdkxa1j44JMX+OjjWK/s4InOiYpKh90vEj9QpIfCy2ds01k/rHnzSOVpOTjkurxaTe3CbNWfzvqrlFN3ejn9Nd7WZVQJJWp+NzW31PvOQlLxl27FX1PRT9udE94Wq3lr9mP7fZLxsdH1jLr1qxUG9uzZfe6CjDaKW9Ebd4zKY5cjC+gh+3vc8++8gTTzwxzO0oh8SPJTOrKuaBNfLVEiFfDR2pSb5aKeSroWNU88pXaY8lSzqNAcGbRr3RBgIQgAAEIAABCEAAAk0SKN0e3iZ50B0CEIAABCAAAQhAoGQEELwlm1CGAwEIQAACEIAABCAwnACCl4iAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1AQRvqaeXwUEAAhCAAAQgAAEIIHiJAQhAAAIQgAAEIACBUhNA8JZ6ehkcBCAAAQhAAAIQgACClxiAAAQgAAEIQAACECg1gf8PrKjod3Yd6g4AAAAASUVORK5CYII=", + "image/svg+xml": [ + "2024-01-292024-02-062024-02-142024-02-222024-03-01024682024-01-292024-02-062024-02-142024-02-222024-03-0102468y1y1GWh/hGWh/hSupplyDemand" + ], + "text/html": [ + "
\n", + " \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.plotly.v1+json": { + "data": [ + { + "colorbar": { + "len": 0.9231408573928259, + "title": "", + "x": 0.9950787401574803, + "y": 0.4916666666666667 + }, + "fill": "tozeroy", + "fillcolor": "rgba(0, 154, 250, 1.000)", + "legendgroup": "Total", + "line": { + "color": "rgba(0, 154, 250, 1.000)", + "dash": "solid", + "shape": "linear", + "width": 1 + }, + "mode": "lines", + "name": "Total", + "showlegend": true, + "type": "scatter", + "x": [ + 63842169600000, + 63842256000000, + 63842342400000, + 63842428800000, + 63842515200000, + 63842601600000, + 63842688000000, + 63842774400000, + 63842860800000, + 63842947200000, + 63843033600000, + 63843120000000, + 63843206400000, + 63843292800000, + 63843379200000, + 63843465600000, + 63843552000000, + 63843638400000, + 63843724800000, + 63843811200000, + 63843897600000, + 63843984000000, + 63844070400000, + 63844156800000, + 63844243200000, + 63844329600000, + 63844416000000, + 63844502400000, + 63844588800000, + 63844675200000, + 63844761600000, + 63844848000000 + ], + "xaxis": "x", + "y": [ + 14.409031274336677, + 14.36262495225929, + 14.330842384122917, + 14.294818689739392, + 14.243065911083718, + 14.207218407343296, + 14.190789608248169, + 14.155870351812858, + 14.10644191060808, + 14.055599828366002, + 13.998144476354637, + 13.968770460057417, + 13.98375136399022, + 13.983376035310599, + 13.928849322243597, + 13.87020102280702, + 13.811810294351298, + 13.750929231499354, + 13.689344505660742, + 13.652756202388481, + 13.642955885586733, + 13.597977460971473, + 13.567305422156048, + 13.574377487146075, + 13.599006307037294, + 13.659088028108538, + 13.740597265866741, + 13.817289123775776, + 13.838191083395875, + 13.853051374017568, + 13.850012291700734, + 13.834597819421704 + ], + "yaxis": "y" + } + ], + "layout": { + "annotations": [ + { + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 20 + }, + "rotation": 0, + "showarrow": false, + "text": "Reservoir levels", + "x": 0.5206597222222222, + "xanchor": "center", + "xref": "paper", + "y": 1, + "yanchor": "top", + "yref": "paper" + } + ], + "height": 500, + "legend": { + "bgcolor": "rgba(255, 255, 255, 1.000)", + "bordercolor": "rgba(0, 0, 0, 1.000)", + "borderwidth": 1, + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "title": { + "font": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "text": "" + }, + "tracegroupgap": 0, + "traceorder": "normal", + "x": 1, + "xanchor": "auto", + "y": 1, + "yanchor": "auto" + }, + "margin": { + "b": 20, + "l": 0, + "r": 0, + "t": 20 + }, + "paper_bgcolor": "rgba(255, 255, 255, 1.000)", + "plot_bgcolor": "rgba(255, 255, 255, 1.000)", + "showlegend": true, + "width": 800, + "xaxis": { + "anchor": "y", + "domain": [ + 0.046240704286964134, + 0.9950787401574803 + ], + "gridcolor": "rgba(0, 0, 0, 0.100)", + "gridwidth": 0.5, + "linecolor": "rgba(0, 0, 0, 1.000)", + "mirror": false, + "range": [ + 63842089248000, + 63844928352000 + ], + "showgrid": true, + "showline": true, + "showticklabels": true, + "tickangle": 0, + "tickcolor": "rgb(0, 0, 0)", + "tickfont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "tickmode": "array", + "ticks": "inside", + "ticktext": [ + "2024-01-29", + "2024-02-06", + "2024-02-14", + "2024-02-22" + ], + "tickvals": [ + 63842169600000, + 63842860800000, + 63843552000000, + 63844243200000 + ], + "title": "", + "titlefont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "type": "-", + "visible": true, + "zeroline": false, + "zerolinecolor": "rgba(0, 0, 0, 1.000)" + }, + "yaxis": { + "anchor": "x", + "domain": [ + 0.030096237970253722, + 0.9532370953630797 + ], + "gridcolor": "rgba(0, 0, 0, 0.100)", + "gridwidth": 0.5, + "linecolor": "rgba(0, 0, 0, 1.000)", + "mirror": false, + "range": [ + -0.43227093823010065, + 14.841302212566777 + ], + "showgrid": true, + "showline": true, + "showticklabels": true, + "tickangle": 0, + "tickcolor": "rgb(0, 0, 0)", + "tickfont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 11 + }, + "tickmode": "array", + "ticks": "inside", + "ticktext": [ + "0", + "3", + "6", + "9", + "12" + ], + "tickvals": [ + 0, + 3, + 6, + 9, + 12 + ], + "title": "TWh", + "titlefont": { + "color": "rgba(0, 0, 0, 1.000)", + "family": "sans-serif", + "size": 15 + }, + "type": "-", + "visible": true, + "zeroline": false, + "zerolinecolor": "rgba(0, 0, 0, 1.000)" + } + } + }, + "image/png": "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", + "image/svg+xml": [ + "2024-01-292024-02-062024-02-142024-02-22036912TotalTWhReservoir levels" + ], + "text/html": [ + "
\n", + " \n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "┌────────────────────────────────────────┬───────────────────┬─────────────────────────────────┬───────────────────┐\n", + "│\u001b[1m Supplyname \u001b[0m│\u001b[1m Yearly_supply_TWh \u001b[0m│\u001b[1m Demandname \u001b[0m│\u001b[1m Yearly_demand_TWh \u001b[0m│\n", + "│\u001b[90m String? \u001b[0m│\u001b[90m Float64? \u001b[0m│\u001b[90m String? \u001b[0m│\u001b[90m Float64? \u001b[0m│\n", + "├────────────────────────────────────────┼───────────────────┼─────────────────────────────────┼───────────────────┤\n", + "│ Plant_SORLAND_hydro_reservoir │ 36.7721 │ Demand_SORLAND_BYGG │ 14.8538 │\n", + "│ Plant_SORLAND_hydro_RoR │ 13.6804 │ Transm_SORLAND->DANM-DK1 │ 12.5196 │\n", + "│ Transm_TELEMARK->SORLAND │ 7.2327 │ Transm_SORLAND->UK │ 11.388 │\n", + "│ Fixed_EMPS4_wind_onshore_stock │ 4.48969 │ Transm_SORLAND->TYSKLAND │ 8.91056 │\n", + "│ Transm_DANM-DK1->SORLAND │ 0.447081 │ Transm_SORLAND->NEDERLAND │ 5.4312 │\n", + "│ Fixed_NO2_CHP_Pub │ 0.181956 │ Transm_SORLAND->HAUGESUND │ 3.32798 │\n", + "│ Plant_NO2_NY │ 0.170294 │ Transm_SORLAND->SOROST │ 1.21162 │\n", + "│ Transm_TYSKLAND->SORLAND │ 0.155527 │ Demand_SORLAND_ALU_LISTA01 │ 1.1388 │\n", + "│ Fixed_EMPS4_solar_stock │ 0.0532551 │ Demand_SORLAND_BOLIDEN_ODDA │ 1.03368 │\n", + "│ Transm_HAUGESUND->SORLAND │ 0.023192 │ Demand_SORLAND_ERAMET_KVINESDAL │ 0.877905 │\n", + "│ PlantResponse_SORLAND_GLENCORE │ 0.0 │ Demand_SORLAND_TRANSPORT │ 0.61272 │\n", + "│ PlantResponse_SORLAND_FIVEN_NORGE │ 0.0 │ Demand_SORLAND_GLENCORE │ 0.568056 │\n", + "│ Transm_SOROST->SORLAND │ 0.0 │ Demand_SORLAND_VALHALL │ 0.413472 │\n", + "│ PlantResponse_SORLAND_VALHALL │ 0.0 │ Demand_SORLAND_TIZIR │ 0.382147 │\n", + "│ PlantResponse_SORLAND_HYDROGEN_91 │ 0.0 │ Demand_SORLAND_DATASENTER │ 0.221628 │\n", + "│ PlantResponse_SORLAND_ALU_LISTA01 │ 0.0 │ Demand_SORLAND_FIVEN_NORGE │ 0.185909 │\n", + "│ PlantResponse_SORLAND_ELKEM_CARBON │ 0.0 │ Demand_SORLAND_ELKEM_CARBON │ 0.103283 │\n", + "│ PlantResponse_SORLAND_BOLIDEN_ODDA │ 0.0 │ Demand_SORLAND_HYDROGEN_IND2 │ 0.0258207 │\n", + "│ PlantResponse_SORLAND_ERAMET_KVINESDAL │ 0.0 │ SlackVar_PowerBalance_SORLAND │ 0.0 │\n", + "│ PlantResponse_SORLAND_HYDROGEN_IND │ 0.0 │ Transm_SORLAND->TELEMARK │ 0.0 │\n", + "│ PlantResponse_SORLAND_BYGG │ 0.0 │ missing │ missing │\n", + "│ PlantResponse_SORLAND_MORROW │ 0.0 │ missing │ missing │\n", + "│ PlantResponse_SORLAND_TIZIR │ 0.0 │ missing │ missing │\n", + "│ Transm_UK->SORLAND │ 0.0 │ missing │ missing │\n", + "│ PlantResponse_SORLAND_TRANSPORT │ 0.0 │ missing │ missing │\n", + "│ PlantResponse_SORLAND_HYDROGEN_IND2 │ 0.0 │ missing │ missing │\n", + "│ Transm_NEDERLAND->SORLAND │ 0.0 │ missing │ missing │\n", + "│ PlantResponse_SORLAND_DATASENTER │ 0.0 │ missing │ missing │\n", + "└────────────────────────────────────────┴───────────────────┴─────────────────────────────────┴───────────────────┘\n", + "┌───────────────────────────────────┬───────────────────────────────────┐\n", + "│\u001b[1m Yearly_supply_TWh_sum_skipmissing \u001b[0m│\u001b[1m Yearly_demand_TWh_sum_skipmissing \u001b[0m│\n", + "│\u001b[90m Float64 \u001b[0m│\u001b[90m Float64 \u001b[0m│\n", + "├───────────────────────────────────┼───────────────────────────────────┤\n", + "│ 63.2062 │ 63.2062 │\n", + "└───────────────────────────────────┴───────────────────────────────────┘\n", + "┌──────────────────────────────────┬───────────────────────────────────┐\n", + "│\u001b[1m Yearly_rev_mill€_sum_skipmissing \u001b[0m│\u001b[1m Yearly_cost_mill€_sum_skipmissing \u001b[0m│\n", + "│\u001b[90m Float64 \u001b[0m│\u001b[90m Float64 \u001b[0m│\n", + "├──────────────────────────────────┼───────────────────────────────────┤\n", + "│ 25.3962 │ 25.3962 │\n", + "└──────────────────────────────────┴───────────────────────────────────┘\n" + ] + } + ], "source": [ "# Plot prices\n", "idxwohub = findall(x -> !occursin(\"HUB\", x), powerbalancenames) # remove hubs, not active in 2025 dataset\n", From 5c8d21c9e2ee2d5919a6292a6fd82fd824c94ea6 Mon Sep 17 00:00:00 2001 From: marynve Date: Mon, 24 Jun 2024 14:13:00 +0200 Subject: [PATCH 04/28] Added function _distribute_subsystems_storage_greedy! to generic_io.jl --- Manifest.toml | 911 ++++- Project.toml | 6 + demos/Demo prognosis.ipynb | 3707 ++------------------- demos/data/config_jules_prognose_demo.yml | 267 ++ src/generic_io.jl | 169 +- src/io.jl | 4 +- 6 files changed, 1564 insertions(+), 3500 deletions(-) create mode 100644 demos/data/config_jules_prognose_demo.yml diff --git a/Manifest.toml b/Manifest.toml index 1c51e64..8954446 100644 --- a/Manifest.toml +++ b/Manifest.toml @@ -2,7 +2,7 @@ julia_version = "1.9.2" manifest_format = "2.0" -project_hash = "49a205d078655d367d44b537f9c9d50e1f50fea8" +project_hash = "9413acc349fc2382bfd2dc9d791c1b227118d92e" [[deps.Adapt]] deps = ["LinearAlgebra", "Requires"] @@ -21,6 +21,12 @@ version = "1.1.1" [[deps.Artifacts]] uuid = "56f22d72-fd6d-98f1-02f0-08ddc0907c33" +[[deps.AssetRegistry]] +deps = ["Distributed", "JSON", "Pidfile", "SHA", "Test"] +git-tree-sha1 = "b25e88db7944f98789130d7b503276bc34bc098e" +uuid = "bf4720bc-e11a-5d0c-854e-bdca1663c893" +version = "0.1.0" + [[deps.AxisAlgorithms]] deps = ["LinearAlgebra", "Random", "SparseArrays", "WoodburyMatrices"] git-tree-sha1 = "01b8ccb13d68535d73d2b0c23e39bd23155fb712" @@ -36,6 +42,17 @@ git-tree-sha1 = "f1dff6729bc61f4d49e140da1af55dcd1ac97b2f" uuid = "6e4b80f9-dd63-53aa-95a3-0cdb28fa8baf" version = "1.5.0" +[[deps.BitFlags]] +git-tree-sha1 = "0691e34b3bb8be9307330f88d1a3c3f25466c24d" +uuid = "d1d4a3ce-64b1-5f1a-9ba4-7e7e69966f35" +version = "0.1.9" + +[[deps.Blink]] +deps = ["Base64", "Distributed", "HTTP", "JSExpr", "JSON", "Lazy", "Logging", "MacroTools", "Mustache", "Mux", "Pkg", "Reexport", "Sockets", "WebIO"] +git-tree-sha1 = "bc93511973d1f949d45b0ea17878e6cb0ad484a1" +uuid = "ad839575-38b3-5650-b840-f874b8c74a25" +version = "0.12.9" + [[deps.Bzip2_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "9e2a6b69137e6969bab0152632dcb3bc108c8bdd" @@ -44,9 +61,15 @@ version = "1.0.8+1" [[deps.CSV]] deps = ["CodecZlib", "Dates", "FilePathsBase", "InlineStrings", "Mmap", "Parsers", "PooledArrays", "PrecompileTools", "SentinelArrays", "Tables", "Unicode", "WeakRefStrings", "WorkerUtilities"] -git-tree-sha1 = "a44910ceb69b0d44fe262dd451ab11ead3ed0be8" +git-tree-sha1 = "6c834533dc1fabd820c1db03c839bf97e45a3fab" uuid = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" -version = "0.10.13" +version = "0.10.14" + +[[deps.Cairo_jll]] +deps = ["Artifacts", "Bzip2_jll", "CompilerSupportLibraries_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "JLLWrappers", "LZO_jll", "Libdl", "Pixman_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "a2f1c8c668c8e3cb4cca4e57a8efdb09067bb3fd" +uuid = "83423d85-b0ee-5818-9007-b63ccbeb887a" +version = "1.18.0+2" [[deps.Calculus]] deps = ["LinearAlgebra"] @@ -70,6 +93,12 @@ git-tree-sha1 = "9ebb045901e9bbf58767a9f34ff89831ed711aae" uuid = "aaaa29a8-35af-508c-8bc3-b662a17a0fe5" version = "0.15.7" +[[deps.CodeTracking]] +deps = ["InteractiveUtils", "UUIDs"] +git-tree-sha1 = "c0216e792f518b39b22212127d4a84dc31e4e386" +uuid = "da1fd8a2-8d9e-5ec2-8556-3022fb5608a2" +version = "1.3.5" + [[deps.CodecBzip2]] deps = ["Bzip2_jll", "Libdl", "TranscodingStreams"] git-tree-sha1 = "c0ae2a86b162fb5d7acc65269b469ff5b8a73594" @@ -82,6 +111,34 @@ git-tree-sha1 = "cd67fc487743b2f0fd4380d4cbd3a24660d0eec8" uuid = "944b1d66-785c-5afd-91f1-9de20f533193" version = "0.7.3" +[[deps.ColorSchemes]] +deps = ["ColorTypes", "ColorVectorSpace", "Colors", "FixedPointNumbers", "PrecompileTools", "Random"] +git-tree-sha1 = "4b270d6465eb21ae89b732182c20dc165f8bf9f2" +uuid = "35d6a980-a343-548e-a6ea-1d62b119f2f4" +version = "3.25.0" + +[[deps.ColorTypes]] +deps = ["FixedPointNumbers", "Random"] +git-tree-sha1 = "b10d0b65641d57b8b4d5e234446582de5047050d" +uuid = "3da002f7-5984-5a60-b8a6-cbb66c0b333f" +version = "0.11.5" + +[[deps.ColorVectorSpace]] +deps = ["ColorTypes", "FixedPointNumbers", "LinearAlgebra", "Requires", "Statistics", "TensorCore"] +git-tree-sha1 = "a1f44953f2382ebb937d60dafbe2deea4bd23249" +uuid = "c3611d14-8923-5661-9e6a-0046d554d3a4" +version = "0.10.0" +weakdeps = ["SpecialFunctions"] + + [deps.ColorVectorSpace.extensions] + SpecialFunctionsExt = "SpecialFunctions" + +[[deps.Colors]] +deps = ["ColorTypes", "FixedPointNumbers", "Reexport"] +git-tree-sha1 = "362a287c3aa50601b0bc359053d5c2468f0e7ce0" +uuid = "5ae59095-9a9b-59fe-a467-6f913c188581" +version = "0.12.11" + [[deps.CommonSubexpressions]] deps = ["MacroTools", "Test"] git-tree-sha1 = "7b8a93dba8af7e3b42fecabf646260105ac373f7" @@ -103,6 +160,23 @@ deps = ["Artifacts", "Libdl"] uuid = "e66e0078-7015-5450-92f7-15fbd957f2ae" version = "1.0.5+0" +[[deps.ConcurrentUtilities]] +deps = ["Serialization", "Sockets"] +git-tree-sha1 = "6cbbd4d241d7e6579ab354737f4dd95ca43946e1" +uuid = "f0e56b4a-5159-44fe-b623-3e5288b988bb" +version = "2.4.1" + +[[deps.Conda]] +deps = ["Downloads", "JSON", "VersionParsing"] +git-tree-sha1 = "51cab8e982c5b598eea9c8ceaced4b58d9dd37c9" +uuid = "8f4d0f93-b110-5947-807f-2305c1781a2d" +version = "1.10.0" + +[[deps.Contour]] +git-tree-sha1 = "439e35b0b36e2e5881738abc8857bd92ad6ff9a8" +uuid = "d38c429a-6771-53c6-b99e-75d170b6e991" +version = "0.6.3" + [[deps.Crayons]] git-tree-sha1 = "249fe38abf76d48563e2f4556bebd215aa317e15" uuid = "a8cc5b0e-0ffa-5ad4-8c14-923d3ee1735f" @@ -134,6 +208,12 @@ version = "1.0.0" deps = ["Printf"] uuid = "ade2ca70-3891-5945-98fb-dc099432e06a" +[[deps.DelimitedFiles]] +deps = ["Mmap"] +git-tree-sha1 = "9e2f36d3c96a820c678f2f1f1782582fcf685bae" +uuid = "8bb1440f-4735-579b-a4ab-409b98df4dab" +version = "1.9.1" + [[deps.DiffResults]] deps = ["StaticArraysCore"] git-tree-sha1 = "782dd5f4561f5d267313f23853baaaa4c52ea621" @@ -200,6 +280,36 @@ git-tree-sha1 = "5837a837389fccf076445fce071c8ddaea35a566" uuid = "fa6b7ba4-c1ee-5f82-b5fc-ecf0adba8f74" version = "0.6.8" +[[deps.EpollShim_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8e9441ee83492030ace98f9789a654a6d0b1f643" +uuid = "2702e6a9-849d-5ed8-8c21-79e8b8f9ee43" +version = "0.0.20230411+0" + +[[deps.ExceptionUnwrapping]] +deps = ["Test"] +git-tree-sha1 = "dcb08a0d93ec0b1cdc4af184b26b591e9695423a" +uuid = "460bff9d-24e4-43bc-9d9f-a8973cb893f4" +version = "0.1.10" + +[[deps.Expat_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1c6317308b9dc757616f0b5cb379db10494443a7" +uuid = "2e619515-83b5-522b-bb60-26c02a35a201" +version = "2.6.2+0" + +[[deps.FFMPEG]] +deps = ["FFMPEG_jll"] +git-tree-sha1 = "b57e3acbe22f8484b4b5ff66a7499717fe1a9cc8" +uuid = "c87230d0-a227-11e9-1b43-d7ebe4e7570a" +version = "0.4.1" + +[[deps.FFMPEG_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "JLLWrappers", "LAME_jll", "Libdl", "Ogg_jll", "OpenSSL_jll", "Opus_jll", "PCRE2_jll", "Zlib_jll", "libaom_jll", "libass_jll", "libfdk_aac_jll", "libvorbis_jll", "x264_jll", "x265_jll"] +git-tree-sha1 = "466d45dc38e15794ec7d5d63ec03d776a9aff36e" +uuid = "b22a6f82-2f65-5046-a5b2-351ab43fb4e5" +version = "4.4.4+1" + [[deps.FilePathsBase]] deps = ["Compat", "Dates", "Mmap", "Printf", "Test", "UUIDs"] git-tree-sha1 = "9f00e42f8d99fdde64d40c8ea5d14269a2e2c1aa" @@ -221,6 +331,23 @@ weakdeps = ["PDMats", "SparseArrays", "Statistics"] FillArraysSparseArraysExt = "SparseArrays" FillArraysStatisticsExt = "Statistics" +[[deps.FixedPointNumbers]] +deps = ["Statistics"] +git-tree-sha1 = "05882d6995ae5c12bb5f36dd2ed3f61c98cbb172" +uuid = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" +version = "0.8.5" + +[[deps.Fontconfig_jll]] +deps = ["Artifacts", "Bzip2_jll", "Expat_jll", "FreeType2_jll", "JLLWrappers", "Libdl", "Libuuid_jll", "Zlib_jll"] +git-tree-sha1 = "db16beca600632c95fc8aca29890d83788dd8b23" +uuid = "a3f928ae-7b40-5064-980b-68af3947d34b" +version = "2.13.96+0" + +[[deps.Format]] +git-tree-sha1 = "9c68794ef81b08086aeb32eeaf33531668d5f5fc" +uuid = "1fa38f19-a742-5d3f-a2b9-30dd87b9d5f8" +version = "1.3.7" + [[deps.ForwardDiff]] deps = ["CommonSubexpressions", "DiffResults", "DiffRules", "LinearAlgebra", "LogExpFunctions", "NaNMath", "Preferences", "Printf", "Random", "SpecialFunctions"] git-tree-sha1 = "cf0fe81336da9fb90944683b8c41984b08793dad" @@ -231,10 +358,81 @@ weakdeps = ["StaticArrays"] [deps.ForwardDiff.extensions] ForwardDiffStaticArraysExt = "StaticArrays" +[[deps.FreeType2_jll]] +deps = ["Artifacts", "Bzip2_jll", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "5c1d8ae0efc6c2e7b1fc502cbe25def8f661b7bc" +uuid = "d7e528f0-a631-5988-bf34-fe36492bcfd7" +version = "2.13.2+0" + +[[deps.FriBidi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1ed150b39aebcc805c26b93a8d0122c940f64ce2" +uuid = "559328eb-81f9-559d-9380-de523a88c83c" +version = "1.0.14+0" + +[[deps.FunctionalCollections]] +deps = ["Test"] +git-tree-sha1 = "04cb9cfaa6ba5311973994fe3496ddec19b6292a" +uuid = "de31a74c-ac4f-5751-b3fd-e18cd04993ca" +version = "0.5.0" + [[deps.Future]] deps = ["Random"] uuid = "9fa8497b-333b-5362-9e8d-4d0656e87820" +[[deps.GLFW_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libglvnd_jll", "Xorg_libXcursor_jll", "Xorg_libXi_jll", "Xorg_libXinerama_jll", "Xorg_libXrandr_jll"] +git-tree-sha1 = "ff38ba61beff76b8f4acad8ab0c97ef73bb670cb" +uuid = "0656b61e-2033-5cc2-a64a-77c0f6c09b89" +version = "3.3.9+0" + +[[deps.GR]] +deps = ["Artifacts", "Base64", "DelimitedFiles", "Downloads", "GR_jll", "HTTP", "JSON", "Libdl", "LinearAlgebra", "Preferences", "Printf", "Random", "Serialization", "Sockets", "TOML", "Tar", "Test", "p7zip_jll"] +git-tree-sha1 = "3e527447a45901ea392fe12120783ad6ec222803" +uuid = "28b8d3ca-fb5f-59d9-8090-bfdbd6d07a71" +version = "0.73.6" + +[[deps.GR_jll]] +deps = ["Artifacts", "Bzip2_jll", "Cairo_jll", "FFMPEG_jll", "Fontconfig_jll", "FreeType2_jll", "GLFW_jll", "JLLWrappers", "JpegTurbo_jll", "Libdl", "Libtiff_jll", "Pixman_jll", "Qt6Base_jll", "Zlib_jll", "libpng_jll"] +git-tree-sha1 = "182c478a179b267dd7a741b6f8f4c3e0803795d6" +uuid = "d2c73de3-f751-5644-a686-071e5b155ba9" +version = "0.73.6+0" + +[[deps.Gettext_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Libiconv_jll", "Pkg", "XML2_jll"] +git-tree-sha1 = "9b02998aba7bf074d14de89f9d37ca24a1a0b046" +uuid = "78b55507-aeef-58d4-861c-77aaff3498b1" +version = "0.21.0+0" + +[[deps.Glib_jll]] +deps = ["Artifacts", "Gettext_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Libiconv_jll", "Libmount_jll", "PCRE2_jll", "Zlib_jll"] +git-tree-sha1 = "7c82e6a6cd34e9d935e9aa4051b66c6ff3af59ba" +uuid = "7746bdde-850d-59dc-9ae8-88ece973131d" +version = "2.80.2+0" + +[[deps.Graphite2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "344bf40dcab1073aca04aa0df4fb092f920e4011" +uuid = "3b182d85-2403-5c21-9c21-1e1f0cc25472" +version = "1.3.14+0" + +[[deps.Grisu]] +git-tree-sha1 = "53bb909d1151e57e2484c3d1b53e19552b887fb2" +uuid = "42e2da0e-8278-4e71-bc24-59509adca0fe" +version = "1.0.2" + +[[deps.HTTP]] +deps = ["Base64", "CodecZlib", "ConcurrentUtilities", "Dates", "ExceptionUnwrapping", "Logging", "LoggingExtras", "MbedTLS", "NetworkOptions", "OpenSSL", "Random", "SimpleBufferStream", "Sockets", "URIs", "UUIDs"] +git-tree-sha1 = "d1d712be3164d61d1fb98e7ce9bcbc6cc06b45ed" +uuid = "cd3eb016-35fb-5094-929b-558a96fad6f3" +version = "1.10.8" + +[[deps.HarfBuzz_jll]] +deps = ["Artifacts", "Cairo_jll", "Fontconfig_jll", "FreeType2_jll", "Glib_jll", "Graphite2_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg"] +git-tree-sha1 = "129acf094d168394e80ee1dc4bc06ec835e510a3" +uuid = "2e76f6c2-a576-52d4-95c1-20adfe4de566" +version = "2.8.1+1" + [[deps.HiGHS]] deps = ["HiGHS_jll", "MathOptInterface", "PrecompileTools", "SparseArrays"] git-tree-sha1 = "2b650f670ad691b94f506e88b4f3ab591a13f809" @@ -247,12 +445,24 @@ git-tree-sha1 = "10bf0ecdf70f643bfc1948a6af0a98be3950a3fc" uuid = "8fd58aa0-07eb-5a78-9b36-339c94fd15ea" version = "1.6.0+0" +[[deps.Hiccup]] +deps = ["MacroTools", "Test"] +git-tree-sha1 = "6187bb2d5fcbb2007c39e7ac53308b0d371124bd" +uuid = "9fb69e20-1954-56bb-a84f-559cc56a8ff7" +version = "0.2.2" + [[deps.HypergeometricFunctions]] deps = ["DualNumbers", "LinearAlgebra", "OpenLibm_jll", "SpecialFunctions"] git-tree-sha1 = "f218fe3736ddf977e0e772bc9a586b2383da2685" uuid = "34004b35-14d8-5ef3-9330-4cdb6864b03a" version = "0.3.23" +[[deps.IJulia]] +deps = ["Base64", "Conda", "Dates", "InteractiveUtils", "JSON", "Libdl", "Logging", "Markdown", "MbedTLS", "Pkg", "Printf", "REPL", "Random", "SoftGlobalScope", "Test", "UUIDs", "ZMQ"] +git-tree-sha1 = "47ac8cc196b81001a711f4b2c12c97372338f00c" +uuid = "7073ff75-c697-5162-941a-fcdaad2a7d2a" +version = "1.24.2" + [[deps.InlineStrings]] deps = ["Parsers"] git-tree-sha1 = "9cc2baf75c6d09f9da536ddf58eb2f29dedaf461" @@ -273,13 +483,11 @@ deps = ["Adapt", "AxisAlgorithms", "ChainRulesCore", "LinearAlgebra", "OffsetArr git-tree-sha1 = "88a101217d7cb38a7b481ccd50d21876e1d1b0e0" uuid = "a98d9a8b-a2ab-59e6-89dd-64a1c18fca59" version = "0.15.1" +weakdeps = ["Unitful"] [deps.Interpolations.extensions] InterpolationsUnitfulExt = "Unitful" - [deps.Interpolations.weakdeps] - Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" - [[deps.InvertedIndices]] git-tree-sha1 = "0dc7b50b8d436461be01300fd8cd45aa0274b038" uuid = "41ab1584-1d38-5bbf-9106-f11c6c58b48f" @@ -295,18 +503,36 @@ git-tree-sha1 = "a3f24677c21f5bbe9d2a714f95dcd58337fb2856" uuid = "82899510-4779-5014-852e-03e436cf321d" version = "1.0.0" +[[deps.JLFzf]] +deps = ["Pipe", "REPL", "Random", "fzf_jll"] +git-tree-sha1 = "a53ebe394b71470c7f97c2e7e170d51df21b17af" +uuid = "1019f520-868f-41f5-a6de-eb00f4b6a39c" +version = "0.1.7" + [[deps.JLLWrappers]] deps = ["Artifacts", "Preferences"] git-tree-sha1 = "7e5d6779a1e09a36db2a7b6cff50942a0a7d0fca" uuid = "692b3bcd-3c85-4b1f-b108-f13ce0eb3210" version = "1.5.0" +[[deps.JSExpr]] +deps = ["JSON", "MacroTools", "Observables", "WebIO"] +git-tree-sha1 = "b413a73785b98474d8af24fd4c8a975e31df3658" +uuid = "97c1335a-c9c5-57fe-bc5d-ec35cebe8660" +version = "0.5.4" + [[deps.JSON]] deps = ["Dates", "Mmap", "Parsers", "Unicode"] git-tree-sha1 = "31e996f0a15c7b280ba9f76636b3ff9e2ae58c9a" uuid = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" version = "0.21.4" +[[deps.JpegTurbo_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "c84a835e1a09b289ffcd2271bf2a337bbdda6637" +uuid = "aacddb02-875f-59d6-b918-886e6ef4fbf8" +version = "3.0.3+0" + [[deps.JuMP]] deps = ["LinearAlgebra", "MacroTools", "MathOptInterface", "MutableArithmetics", "OrderedCollections", "PrecompileTools", "Printf", "SparseArrays"] git-tree-sha1 = "adef1dfbafeab635664fb3249b58be8d290ed49d" @@ -319,11 +545,67 @@ version = "1.18.1" [deps.JuMP.weakdeps] DimensionalData = "0703355e-b756-11e9-17c0-8b28908087d0" +[[deps.JuliaInterpreter]] +deps = ["CodeTracking", "InteractiveUtils", "Random", "UUIDs"] +git-tree-sha1 = "a6adc2dcfe4187c40dc7c2c9d2128e326360e90a" +uuid = "aa1ae85d-cabe-5617-a682-6adf51b2e16a" +version = "0.9.32" + +[[deps.Kaleido_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "43032da5832754f58d14a91ffbe86d5f176acda9" +uuid = "f7e6163d-2fa5-5f23-b69c-1db539e41963" +version = "0.2.1+0" + +[[deps.LAME_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "170b660facf5df5de098d866564877e119141cbd" +uuid = "c1c5ebd0-6772-5130-a774-d5fcae4a789d" +version = "3.100.2+0" + +[[deps.LERC_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "bf36f528eec6634efc60d7ec062008f171071434" +uuid = "88015f11-f218-50d7-93a8-a6af411a945d" +version = "3.0.0+1" + +[[deps.LLVMOpenMP_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "d986ce2d884d49126836ea94ed5bfb0f12679713" +uuid = "1d63c593-3942-5779-bab2-d838dc0a180e" +version = "15.0.7+0" + +[[deps.LZO_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "70c5da094887fd2cae843b8db33920bac4b6f07d" +uuid = "dd4b983a-f0e5-5f8d-a1b7-129d4a5fb1ac" +version = "2.10.2+0" + [[deps.LaTeXStrings]] git-tree-sha1 = "50901ebc375ed41dbf8058da26f9de442febbbec" uuid = "b964fa9f-0449-5b57-a5c2-d3ea65f4040f" version = "1.3.1" +[[deps.Latexify]] +deps = ["Format", "InteractiveUtils", "LaTeXStrings", "MacroTools", "Markdown", "OrderedCollections", "Requires"] +git-tree-sha1 = "e0b5cd21dc1b44ec6e64f351976f961e6f31d6c4" +uuid = "23fbe1c1-3f47-55db-b15f-69d7ec21a316" +version = "0.16.3" + + [deps.Latexify.extensions] + DataFramesExt = "DataFrames" + SymEngineExt = "SymEngine" + + [deps.Latexify.weakdeps] + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + SymEngine = "123dc426-2d89-5057-bbad-38513e3affd8" + +[[deps.Lazy]] +deps = ["MacroTools"] +git-tree-sha1 = "1370f8202dac30758f3c345f9909b97f53d87d3f" +uuid = "50d2b5c4-7a5e-59d5-8109-a42b560f39c0" +version = "0.15.1" + [[deps.LibCURL]] deps = ["LibCURL_jll", "MozillaCACerts_jll"] uuid = "b27032c2-a3e7-50c8-80cd-2d36dbcbfd21" @@ -346,12 +628,54 @@ version = "1.10.2+0" [[deps.Libdl]] uuid = "8f399da3-3557-5675-b5ff-fb832c97cbdb" +[[deps.Libffi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "0b4a5d71f3e5200a7dff793393e09dfc2d874290" +uuid = "e9f186c6-92d2-5b65-8a66-fee21dc1b490" +version = "3.2.2+1" + +[[deps.Libgcrypt_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgpg_error_jll"] +git-tree-sha1 = "9fd170c4bbfd8b935fdc5f8b7aa33532c991a673" +uuid = "d4300ac3-e22c-5743-9152-c294e39db1e4" +version = "1.8.11+0" + +[[deps.Libglvnd_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll", "Xorg_libXext_jll"] +git-tree-sha1 = "6f73d1dd803986947b2c750138528a999a6c7733" +uuid = "7e76a0d4-f3c7-5321-8279-8d96eeed0f29" +version = "1.6.0+0" + +[[deps.Libgpg_error_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "fbb1f2bef882392312feb1ede3615ddc1e9b99ed" +uuid = "7add5ba3-2f88-524e-9cd5-f83b8a55f7b8" +version = "1.49.0+0" + [[deps.Libiconv_jll]] deps = ["Artifacts", "JLLWrappers", "Libdl"] git-tree-sha1 = "f9557a255370125b405568f9767d6d195822a175" uuid = "94ce4f54-9a6c-5748-9c1c-f9c7231a4531" version = "1.17.0+0" +[[deps.Libmount_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "0c4f9c4f1a50d8f35048fa0532dabbadf702f81e" +uuid = "4b2f31a3-9ecc-558c-b454-b3730dcb73e9" +version = "2.40.1+0" + +[[deps.Libtiff_jll]] +deps = ["Artifacts", "JLLWrappers", "JpegTurbo_jll", "LERC_jll", "Libdl", "XZ_jll", "Zlib_jll", "Zstd_jll"] +git-tree-sha1 = "2da088d113af58221c52828a80378e16be7d037a" +uuid = "89763e89-9b03-5906-acba-b20f662cd828" +version = "4.5.1+1" + +[[deps.Libuuid_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "5ee6203157c120d79034c748a2acba45b82b8807" +uuid = "38a345b3-de98-5d2b-a5d3-14cd9215e700" +version = "2.40.1+0" + [[deps.LinearAlgebra]] deps = ["Libdl", "OpenBLAS_jll", "libblastrampoline_jll"] uuid = "37e2e46d-f89d-539d-b4ee-838fcccc9c8e" @@ -375,6 +699,18 @@ version = "0.3.26" [[deps.Logging]] uuid = "56ddb016-857b-54e1-b83d-db4d58db5568" +[[deps.LoggingExtras]] +deps = ["Dates", "Logging"] +git-tree-sha1 = "c1dd6d7978c12545b4179fb6153b9250c96b0075" +uuid = "e6f89c97-d47a-5376-807f-9c37f3926c36" +version = "1.0.3" + +[[deps.LoweredCodeUtils]] +deps = ["JuliaInterpreter"] +git-tree-sha1 = "c6a36b22d2cca0e1a903f00f600991f97bf5f426" +uuid = "6f1432cf-f94c-5a45-995e-cdbf5db27b0b" +version = "2.4.6" + [[deps.MacroTools]] deps = ["Markdown", "Random"] git-tree-sha1 = "2fa9ee3e63fd3a4f7a9a4f4744a52f4856de82df" @@ -391,11 +727,22 @@ git-tree-sha1 = "e2ae8cf5ac6daf5a3959f7f6ded9c2028b61d09d" uuid = "b8f27783-ece8-5eb3-8dc8-9495eed66fee" version = "1.25.1" +[[deps.MbedTLS]] +deps = ["Dates", "MbedTLS_jll", "MozillaCACerts_jll", "NetworkOptions", "Random", "Sockets"] +git-tree-sha1 = "c067a280ddc25f196b5e7df3877c6b226d390aaf" +uuid = "739be429-bea8-5141-9913-cc70e7f3736d" +version = "1.1.9" + [[deps.MbedTLS_jll]] deps = ["Artifacts", "Libdl"] uuid = "c8ffd9c3-330d-5841-b78e-0817d7145fa1" version = "2.28.2+0" +[[deps.Measures]] +git-tree-sha1 = "c13304c81eec1ed3af7fc20e75fb6b26092a1102" +uuid = "442fdcdd-2543-5da2-b0f3-8c86c306513e" +version = "0.3.2" + [[deps.Missings]] deps = ["DataAPI"] git-tree-sha1 = "f66bdc5de519e8f8ae43bdc598782d35a25b1272" @@ -409,12 +756,24 @@ uuid = "a63ad114-7e13-5084-954f-fe012c677804" uuid = "14a3606d-f60d-562e-9121-12d972cd8159" version = "2022.10.11" +[[deps.Mustache]] +deps = ["Printf", "Tables"] +git-tree-sha1 = "a7cefa21a2ff993bff0456bf7521f46fc077ddf1" +uuid = "ffc61752-8dc7-55ee-8c37-f3e9cdd09e70" +version = "1.0.19" + [[deps.MutableArithmetics]] deps = ["LinearAlgebra", "SparseArrays", "Test"] git-tree-sha1 = "806eea990fb41f9b36f1253e5697aa645bf6a9f8" uuid = "d8a4904e-b15c-11e9-3269-09a3773c0cb0" version = "1.4.0" +[[deps.Mux]] +deps = ["AssetRegistry", "Base64", "HTTP", "Hiccup", "MbedTLS", "Pkg", "Sockets"] +git-tree-sha1 = "7295d849103ac4fcbe3b2e439f229c5cc77b9b69" +uuid = "a975b10e-0019-58db-a62f-e48ff68538c9" +version = "1.0.2" + [[deps.NaNMath]] deps = ["OpenLibm_jll"] git-tree-sha1 = "0877504529a3e5c3343c6f8b4c0381e57e4387e4" @@ -431,6 +790,11 @@ version = "0.4.16" uuid = "ca575930-c2e3-43a9-ace4-1e988b2c1908" version = "1.2.0" +[[deps.Observables]] +git-tree-sha1 = "7438a59546cf62428fc9d1bc94729146d37a7225" +uuid = "510215fc-4207-5dde-b226-833fc4488ee2" +version = "0.5.5" + [[deps.OffsetArrays]] git-tree-sha1 = "6a731f2b5c03157418a20c12195eb4b74c8f8621" uuid = "6fe1bfb0-de20-5000-8ca7-80f57d26f881" @@ -440,6 +804,12 @@ weakdeps = ["Adapt"] [deps.OffsetArrays.extensions] OffsetArraysAdaptExt = "Adapt" +[[deps.Ogg_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "887579a3eb005446d514ab7aeac5d1d027658b8f" +uuid = "e7412a2a-1a6e-54c0-be00-318e2571c051" +version = "1.3.5+1" + [[deps.OpenBLAS_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "Libdl"] uuid = "4536629a-c528-5b80-bd46-f80d51c5b363" @@ -450,34 +820,142 @@ deps = ["Artifacts", "Libdl"] uuid = "05823500-19ac-5b8b-9628-191a04bc5112" version = "0.8.1+0" +[[deps.OpenSSL]] +deps = ["BitFlags", "Dates", "MozillaCACerts_jll", "OpenSSL_jll", "Sockets"] +git-tree-sha1 = "38cb508d080d21dc1128f7fb04f20387ed4c0af4" +uuid = "4d8831e6-92b7-49fb-bdf8-b643e874388c" +version = "1.4.3" + +[[deps.OpenSSL_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a028ee3cb5641cccc4c24e90c36b0a4f7707bdf5" +uuid = "458c3c95-2e84-50aa-8efc-19380b2a3a95" +version = "3.0.14+0" + [[deps.OpenSpecFun_jll]] deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "Libdl", "Pkg"] git-tree-sha1 = "13652491f6856acfd2db29360e1bbcd4565d04f1" uuid = "efe28fd5-8261-553b-a9e1-b2916fc3738e" version = "0.5.5+0" +[[deps.Opus_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "51a08fb14ec28da2ec7a927c4337e4332c2a4720" +uuid = "91d4177d-7536-5919-b921-800302f37372" +version = "1.3.2+0" + [[deps.OrderedCollections]] git-tree-sha1 = "dfdf5519f235516220579f949664f1bf44e741c5" uuid = "bac558e1-5e72-5ebc-8fee-abe8a469f55d" version = "1.6.3" +[[deps.PCRE2_jll]] +deps = ["Artifacts", "Libdl"] +uuid = "efcefdf7-47ab-520b-bdef-62a2eaa19f15" +version = "10.42.0+0" + [[deps.PDMats]] deps = ["LinearAlgebra", "SparseArrays", "SuiteSparse"] git-tree-sha1 = "949347156c25054de2db3b166c52ac4728cbad65" uuid = "90014a1f-27ba-587c-ab20-58faa44d9150" version = "0.11.31" +[[deps.Parameters]] +deps = ["OrderedCollections", "UnPack"] +git-tree-sha1 = "34c0e9ad262e5f7fc75b10a9952ca7692cfc5fbe" +uuid = "d96e819e-fc66-5662-9728-84c9c7592b0a" +version = "0.12.3" + [[deps.Parsers]] deps = ["Dates", "PrecompileTools", "UUIDs"] git-tree-sha1 = "8489905bcdbcfac64d1daa51ca07c0d8f0283821" uuid = "69de0a69-1ddd-5017-9359-2bf0b02dc9f0" version = "2.8.1" +[[deps.Pidfile]] +deps = ["FileWatching", "Test"] +git-tree-sha1 = "2d8aaf8ee10df53d0dfb9b8ee44ae7c04ced2b03" +uuid = "fa939f87-e72e-5be4-a000-7fc836dbe307" +version = "1.3.0" + +[[deps.Pipe]] +git-tree-sha1 = "6842804e7867b115ca9de748a0cf6b364523c16d" +uuid = "b98c9c47-44ae-5843-9183-064241ee97a0" +version = "1.3.0" + +[[deps.Pixman_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "JLLWrappers", "LLVMOpenMP_jll", "Libdl"] +git-tree-sha1 = "35621f10a7531bc8fa58f74610b1bfb70a3cfc6b" +uuid = "30392449-352a-5448-841d-b1acce4e97dc" +version = "0.43.4+0" + [[deps.Pkg]] deps = ["Artifacts", "Dates", "Downloads", "FileWatching", "LibGit2", "Libdl", "Logging", "Markdown", "Printf", "REPL", "Random", "SHA", "Serialization", "TOML", "Tar", "UUIDs", "p7zip_jll"] uuid = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f" version = "1.9.2" +[[deps.PlotThemes]] +deps = ["PlotUtils", "Statistics"] +git-tree-sha1 = "6e55c6841ce3411ccb3457ee52fc48cb698d6fb0" +uuid = "ccf2f8ad-2431-5c83-bf29-c5338b663b6a" +version = "3.2.0" + +[[deps.PlotUtils]] +deps = ["ColorSchemes", "Colors", "Dates", "PrecompileTools", "Printf", "Random", "Reexport", "Statistics"] +git-tree-sha1 = "7b1a9df27f072ac4c9c7cbe5efb198489258d1f5" +uuid = "995b91a9-d308-5afd-9ec6-746e21dbc043" +version = "1.4.1" + +[[deps.PlotlyBase]] +deps = ["ColorSchemes", "Dates", "DelimitedFiles", "DocStringExtensions", "JSON", "LaTeXStrings", "Logging", "Parameters", "Pkg", "REPL", "Requires", "Statistics", "UUIDs"] +git-tree-sha1 = "56baf69781fc5e61607c3e46227ab17f7040ffa2" +uuid = "a03496cd-edff-5a9b-9e67-9cda94a718b5" +version = "0.8.19" + +[[deps.PlotlyJS]] +deps = ["Base64", "Blink", "DelimitedFiles", "JSExpr", "JSON", "Kaleido_jll", "Markdown", "Pkg", "PlotlyBase", "PlotlyKaleido", "REPL", "Reexport", "Requires", "WebIO"] +git-tree-sha1 = "e62d886d33b81c371c9d4e2f70663c0637f19459" +uuid = "f0f68f2c-4968-5e81-91da-67840de0976a" +version = "0.18.13" + + [deps.PlotlyJS.extensions] + CSVExt = "CSV" + DataFramesExt = ["DataFrames", "CSV"] + IJuliaExt = "IJulia" + JSON3Ext = "JSON3" + + [deps.PlotlyJS.weakdeps] + CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" + DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" + IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" + JSON3 = "0f8b85d8-7281-11e9-16c2-39a750bddbf1" + +[[deps.PlotlyKaleido]] +deps = ["Base64", "JSON", "Kaleido_jll"] +git-tree-sha1 = "2650cd8fb83f73394996d507b3411a7316f6f184" +uuid = "f2990250-8cf9-495f-b13a-cce12b45703c" +version = "2.2.4" + +[[deps.Plots]] +deps = ["Base64", "Contour", "Dates", "Downloads", "FFMPEG", "FixedPointNumbers", "GR", "JLFzf", "JSON", "LaTeXStrings", "Latexify", "LinearAlgebra", "Measures", "NaNMath", "Pkg", "PlotThemes", "PlotUtils", "PrecompileTools", "Printf", "REPL", "Random", "RecipesBase", "RecipesPipeline", "Reexport", "RelocatableFolders", "Requires", "Scratch", "Showoff", "SparseArrays", "Statistics", "StatsBase", "UUIDs", "UnicodeFun", "UnitfulLatexify", "Unzip"] +git-tree-sha1 = "442e1e7ac27dd5ff8825c3fa62fbd1e86397974b" +uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" +version = "1.40.4" + + [deps.Plots.extensions] + FileIOExt = "FileIO" + GeometryBasicsExt = "GeometryBasics" + IJuliaExt = "IJulia" + ImageInTerminalExt = "ImageInTerminal" + UnitfulExt = "Unitful" + + [deps.Plots.weakdeps] + FileIO = "5789e2e9-d7fb-5bc7-8068-2c6fae9b9549" + GeometryBasics = "5c1252a2-5f33-56bf-86c9-59e7332b4326" + IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" + ImageInTerminal = "d8c32880-2388-543b-8c61-d9f865259254" + Unitful = "1986cc42-f94f-5a68-af5c-568840ba703d" + [[deps.PooledArrays]] deps = ["DataAPI", "Future"] git-tree-sha1 = "36d8b4b899628fb92c2749eb488d884a926614d3" @@ -498,9 +976,9 @@ version = "1.4.1" [[deps.PrettyTables]] deps = ["Crayons", "LaTeXStrings", "Markdown", "PrecompileTools", "Printf", "Reexport", "StringManipulation", "Tables"] -git-tree-sha1 = "88b895d13d53b5577fd53379d913b9ab9ac82660" +git-tree-sha1 = "66b20dd35966a748321d3b2537c4584cf40387c7" uuid = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" -version = "2.3.1" +version = "2.3.2" [[deps.Primes]] deps = ["IntegerMathUtils"] @@ -516,6 +994,12 @@ uuid = "de0858da-6303-5e67-8744-51eddeeeb8d7" deps = ["Printf"] uuid = "9abbd945-dff8-562f-b5e8-e1ebf5ef1b79" +[[deps.Qt6Base_jll]] +deps = ["Artifacts", "CompilerSupportLibraries_jll", "Fontconfig_jll", "Glib_jll", "JLLWrappers", "Libdl", "Libglvnd_jll", "OpenSSL_jll", "Vulkan_Loader_jll", "Xorg_libSM_jll", "Xorg_libXext_jll", "Xorg_libXrender_jll", "Xorg_libxcb_jll", "Xorg_xcb_util_cursor_jll", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_keysyms_jll", "Xorg_xcb_util_renderutil_jll", "Xorg_xcb_util_wm_jll", "Zlib_jll", "libinput_jll", "xkbcommon_jll"] +git-tree-sha1 = "492601870742dcd38f233b23c3ec629628c1d724" +uuid = "c0090381-4147-56d7-9ebc-da0b1113ec56" +version = "6.7.1+1" + [[deps.QuadGK]] deps = ["DataStructures", "LinearAlgebra"] git-tree-sha1 = "9b23c31e76e333e6fb4c1595ae6afa74966a729e" @@ -535,24 +1019,46 @@ deps = ["Requires"] git-tree-sha1 = "1342a47bf3260ee108163042310d26f2be5ec90b" uuid = "c84ed2f1-dad5-54f0-aa8e-dbefe2724439" version = "0.4.5" +weakdeps = ["FixedPointNumbers"] [deps.Ratios.extensions] RatiosFixedPointNumbersExt = "FixedPointNumbers" - [deps.Ratios.weakdeps] - FixedPointNumbers = "53c48c17-4a7d-5ca2-90c5-79b7896eea93" +[[deps.RecipesBase]] +deps = ["PrecompileTools"] +git-tree-sha1 = "5c3d09cc4f31f5fc6af001c250bf1278733100ff" +uuid = "3cdcf5f2-1ef4-517c-9805-6587b60abb01" +version = "1.3.4" + +[[deps.RecipesPipeline]] +deps = ["Dates", "NaNMath", "PlotUtils", "PrecompileTools", "RecipesBase"] +git-tree-sha1 = "45cf9fd0ca5839d06ef333c8201714e888486342" +uuid = "01d81517-befc-4cb6-b9ec-a95719d0359c" +version = "0.6.12" [[deps.Reexport]] git-tree-sha1 = "45e428421666073eab6f2da5c9d310d99bb12f9b" uuid = "189a3867-3050-52da-a836-e630ba90ab69" version = "1.2.2" +[[deps.RelocatableFolders]] +deps = ["SHA", "Scratch"] +git-tree-sha1 = "ffdaf70d81cf6ff22c2b6e733c900c3321cab864" +uuid = "05181044-ff0b-4ac5-8273-598c1e38db00" +version = "1.0.1" + [[deps.Requires]] deps = ["UUIDs"] git-tree-sha1 = "838a3a4188e2ded87a4f9f184b4b0d78a1e91cb7" uuid = "ae029012-a4dd-5104-9daa-d747884805df" version = "1.3.0" +[[deps.Revise]] +deps = ["CodeTracking", "Distributed", "FileWatching", "JuliaInterpreter", "LibGit2", "LoweredCodeUtils", "OrderedCollections", "Pkg", "REPL", "Requires", "UUIDs", "Unicode"] +git-tree-sha1 = "12aa2d7593df490c407a3bbd8b86b8b515017f3e" +uuid = "295af30f-e4ad-537b-8983-00126c2a3abe" +version = "3.5.14" + [[deps.Rmath]] deps = ["Random", "Rmath_jll"] git-tree-sha1 = "f65dcb5fa46aee0cf9ed6274ccbd597adc49aa7b" @@ -569,6 +1075,12 @@ version = "0.4.0+0" uuid = "ea8e919c-243c-51af-8825-aaa63cd721ce" version = "0.7.0" +[[deps.Scratch]] +deps = ["Dates"] +git-tree-sha1 = "3bac05bc7e74a75fd9cba4295cde4045d9fe2386" +uuid = "6c6a2e73-6563-6170-7368-637461726353" +version = "1.2.1" + [[deps.SentinelArrays]] deps = ["Dates", "Random"] git-tree-sha1 = "0e7508ff27ba32f26cd459474ca2ede1bc10991f" @@ -582,9 +1094,26 @@ uuid = "9e88b42a-f829-5b0c-bbe9-9e923198166b" deps = ["Distributed", "Mmap", "Random", "Serialization"] uuid = "1a1011a3-84de-559e-8e89-a11a2f7dc383" +[[deps.Showoff]] +deps = ["Dates", "Grisu"] +git-tree-sha1 = "91eddf657aca81df9ae6ceb20b959ae5653ad1de" +uuid = "992d4aef-0814-514b-bc4d-f2e9a6c4116f" +version = "1.0.3" + +[[deps.SimpleBufferStream]] +git-tree-sha1 = "874e8867b33a00e784c8a7e4b60afe9e037b74e1" +uuid = "777ac1f9-54b0-4bf8-805c-2214025038e7" +version = "1.1.0" + [[deps.Sockets]] uuid = "6462fe0b-24de-5631-8697-dd941f90decc" +[[deps.SoftGlobalScope]] +deps = ["REPL"] +git-tree-sha1 = "986ec2b6162ccb95de5892ed17832f95badf770c" +uuid = "b85f4697-e234-5449-a836-ec8e2f98b302" +version = "1.1.0" + [[deps.SortingAlgorithms]] deps = ["DataStructures"] git-tree-sha1 = "66e0a8e672a0bdfca2c3f5937efb8538b9ddc085" @@ -695,6 +1224,12 @@ deps = ["ArgTools", "SHA"] uuid = "a4e569a6-e804-4fa4-b0f3-eef7a1d5b13e" version = "1.10.0" +[[deps.TensorCore]] +deps = ["LinearAlgebra"] +git-tree-sha1 = "1feb45f88d133a655e001435632f019a9a1bcdb6" +uuid = "62fd8b95-f654-4bbd-a8a5-9c27f68ccd50" +version = "0.1.1" + [[deps.Test]] deps = ["InteractiveUtils", "Logging", "Random", "Serialization"] uuid = "8dfed614-e22c-5e08-85e1-65c5234f0b40" @@ -710,25 +1245,107 @@ weakdeps = ["Random", "Test"] [[deps.TuLiPa]] deps = ["CSV", "Clustering", "DataFrames", "Dates", "HiGHS", "Interpolations", "JSON", "JuMP", "PrecompileTools", "Random", "Statistics", "Test"] -git-tree-sha1 = "30da06b5e7cedad3de6912d12b8af3be78d3679a" -repo-rev = "master" +git-tree-sha1 = "c8b2f0ecdd81fd3f72495c77cb072c0cd50ecc70" +repo-rev = "redesign_JulES" repo-url = "https://github.com/NVE/TuLiPa.git" uuid = "970f5c25-cd7d-4f04-b50d-7a4fe2af6639" version = "0.1.0" +[[deps.URIs]] +git-tree-sha1 = "67db6cc7b3821e19ebe75791a9dd19c9b1188f2b" +uuid = "5c2747f8-b7ea-4ff2-ba2e-563bfd36b1d4" +version = "1.5.1" + [[deps.UUIDs]] deps = ["Random", "SHA"] uuid = "cf7118a7-6976-5b1a-9a39-7adc72f591a4" +[[deps.UnPack]] +git-tree-sha1 = "387c1f73762231e86e0c9c5443ce3b4a0a9a0c2b" +uuid = "3a884ed6-31ef-47d7-9d2a-63182c4928ed" +version = "1.0.2" + [[deps.Unicode]] uuid = "4ec0a83e-493e-50e2-b9ac-8f72acf5a8f5" +[[deps.UnicodeFun]] +deps = ["REPL"] +git-tree-sha1 = "53915e50200959667e78a92a418594b428dffddf" +uuid = "1cfade01-22cf-5700-b092-accc4b62d6e1" +version = "0.4.1" + +[[deps.Unitful]] +deps = ["Dates", "LinearAlgebra", "Random"] +git-tree-sha1 = "dd260903fdabea27d9b6021689b3cd5401a57748" +uuid = "1986cc42-f94f-5a68-af5c-568840ba703d" +version = "1.20.0" + + [deps.Unitful.extensions] + ConstructionBaseUnitfulExt = "ConstructionBase" + InverseFunctionsUnitfulExt = "InverseFunctions" + + [deps.Unitful.weakdeps] + ConstructionBase = "187b0558-2788-49d3-abe0-74a17ed4e7c9" + InverseFunctions = "3587e190-3f89-42d0-90ee-14403ec27112" + +[[deps.UnitfulLatexify]] +deps = ["LaTeXStrings", "Latexify", "Unitful"] +git-tree-sha1 = "e2d817cc500e960fdbafcf988ac8436ba3208bfd" +uuid = "45397f5d-5981-4c77-b2b3-fc36d6e9b728" +version = "1.6.3" + +[[deps.Unzip]] +git-tree-sha1 = "ca0969166a028236229f63514992fc073799bb78" +uuid = "41fe7b60-77ed-43a1-b4f0-825fd5a5650d" +version = "0.2.0" + +[[deps.VersionParsing]] +git-tree-sha1 = "58d6e80b4ee071f5efd07fda82cb9fbe17200868" +uuid = "81def892-9a0e-5fdd-b105-ffc91e053289" +version = "1.3.0" + +[[deps.Vulkan_Loader_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Wayland_jll", "Xorg_libX11_jll", "Xorg_libXrandr_jll", "xkbcommon_jll"] +git-tree-sha1 = "2f0486047a07670caad3a81a075d2e518acc5c59" +uuid = "a44049a8-05dd-5a78-86c9-5fde0876e88c" +version = "1.3.243+0" + +[[deps.Wayland_jll]] +deps = ["Artifacts", "EpollShim_jll", "Expat_jll", "JLLWrappers", "Libdl", "Libffi_jll", "Pkg", "XML2_jll"] +git-tree-sha1 = "7558e29847e99bc3f04d6569e82d0f5c54460703" +uuid = "a2964d1f-97da-50d4-b82a-358c7fce9d89" +version = "1.21.0+1" + +[[deps.Wayland_protocols_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "93f43ab61b16ddfb2fd3bb13b3ce241cafb0e6c9" +uuid = "2381bf8a-dfd0-557d-9999-79630e7b1b91" +version = "1.31.0+0" + [[deps.WeakRefStrings]] deps = ["DataAPI", "InlineStrings", "Parsers"] git-tree-sha1 = "b1be2855ed9ed8eac54e5caff2afcdb442d52c23" uuid = "ea10d353-3f73-51f8-a26c-33c1cb351aa5" version = "1.4.2" +[[deps.WebIO]] +deps = ["AssetRegistry", "Base64", "Distributed", "FunctionalCollections", "JSON", "Logging", "Observables", "Pkg", "Random", "Requires", "Sockets", "UUIDs", "WebSockets", "Widgets"] +git-tree-sha1 = "0eef0765186f7452e52236fa42ca8c9b3c11c6e3" +uuid = "0f1e0344-ec1d-5b48-a673-e5cf874b6c29" +version = "0.8.21" + +[[deps.WebSockets]] +deps = ["Base64", "Dates", "HTTP", "Logging", "Sockets"] +git-tree-sha1 = "4162e95e05e79922e44b9952ccbc262832e4ad07" +uuid = "104b5d7c-a370-577a-8038-80a2059c5097" +version = "1.6.0" + +[[deps.Widgets]] +deps = ["Colors", "Dates", "Observables", "OrderedCollections"] +git-tree-sha1 = "fcdae142c1cfc7d89de2d11e08721d0f2f86c98a" +uuid = "cc8bc4a8-27d6-5769-a93b-9d913e69aa62" +version = "0.6.6" + [[deps.WoodburyMatrices]] deps = ["LinearAlgebra", "SparseArrays"] git-tree-sha1 = "c1a7aa6219628fcd757dede0ca95e245c5cd9511" @@ -740,22 +1357,274 @@ git-tree-sha1 = "cd1659ba0d57b71a464a29e64dbc67cfe83d54e7" uuid = "76eceee3-57b5-4d4a-8e66-0e911cebbf60" version = "1.6.1" +[[deps.XML2_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libiconv_jll", "Zlib_jll"] +git-tree-sha1 = "52ff2af32e591541550bd753c0da8b9bc92bb9d9" +uuid = "02c8fc9c-b97f-50b9-bbe4-9be30ff0a78a" +version = "2.12.7+0" + +[[deps.XSLT_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Libgcrypt_jll", "Libgpg_error_jll", "Libiconv_jll", "Pkg", "XML2_jll", "Zlib_jll"] +git-tree-sha1 = "91844873c4085240b95e795f692c4cec4d805f8a" +uuid = "aed1982a-8fda-507f-9586-7b0439959a61" +version = "1.1.34+0" + +[[deps.XZ_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "ac88fb95ae6447c8dda6a5503f3bafd496ae8632" +uuid = "ffd25f8a-64ca-5728-b0f7-c24cf3aae800" +version = "5.4.6+0" + +[[deps.Xorg_libICE_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "326b4fea307b0b39892b3e85fa451692eda8d46c" +uuid = "f67eecfb-183a-506d-b269-f58e52b52d7c" +version = "1.1.1+0" + +[[deps.Xorg_libSM_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libICE_jll"] +git-tree-sha1 = "3796722887072218eabafb494a13c963209754ce" +uuid = "c834827a-8449-5923-a945-d239c165b7dd" +version = "1.2.4+0" + +[[deps.Xorg_libX11_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxcb_jll", "Xorg_xtrans_jll"] +git-tree-sha1 = "afead5aba5aa507ad5a3bf01f58f82c8d1403495" +uuid = "4f6342f7-b3d2-589e-9d20-edeb45f2b2bc" +version = "1.8.6+0" + +[[deps.Xorg_libXau_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "6035850dcc70518ca32f012e46015b9beeda49d8" +uuid = "0c0b7dd1-d40b-584c-a123-a41640f87eec" +version = "1.0.11+0" + +[[deps.Xorg_libXcursor_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXfixes_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "12e0eb3bc634fa2080c1c37fccf56f7c22989afd" +uuid = "935fb764-8cf2-53bf-bb30-45bb1f8bf724" +version = "1.2.0+4" + +[[deps.Xorg_libXdmcp_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "34d526d318358a859d7de23da945578e8e8727b7" +uuid = "a3789734-cfe1-5b06-b2d0-1dd0d9d62d05" +version = "1.1.4+0" + +[[deps.Xorg_libXext_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "d2d1a5c49fae4ba39983f63de6afcbea47194e85" +uuid = "1082639a-0dae-5f34-9b06-72781eeb8cb3" +version = "1.3.6+0" + +[[deps.Xorg_libXfixes_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libX11_jll"] +git-tree-sha1 = "0e0dc7431e7a0587559f9294aeec269471c991a4" +uuid = "d091e8ba-531a-589c-9de9-94069b037ed8" +version = "5.0.3+4" + +[[deps.Xorg_libXi_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXfixes_jll"] +git-tree-sha1 = "89b52bc2160aadc84d707093930ef0bffa641246" +uuid = "a51aa0fd-4e3c-5386-b890-e753decda492" +version = "1.7.10+4" + +[[deps.Xorg_libXinerama_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll"] +git-tree-sha1 = "26be8b1c342929259317d8b9f7b53bf2bb73b123" +uuid = "d1454406-59df-5ea1-beac-c340f2130bc3" +version = "1.1.4+4" + +[[deps.Xorg_libXrandr_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libXext_jll", "Xorg_libXrender_jll"] +git-tree-sha1 = "34cea83cb726fb58f325887bf0612c6b3fb17631" +uuid = "ec84b674-ba8e-5d96-8ba1-2a689ba10484" +version = "1.5.2+4" + +[[deps.Xorg_libXrender_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "47e45cd78224c53109495b3e324df0c37bb61fbe" +uuid = "ea2f1a96-1ddc-540d-b46f-429655e07cfa" +version = "0.9.11+0" + +[[deps.Xorg_libpthread_stubs_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "8fdda4c692503d44d04a0603d9ac0982054635f9" +uuid = "14d82f49-176c-5ed1-bb49-ad3f5cbd8c74" +version = "0.1.1+0" + +[[deps.Xorg_libxcb_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "XSLT_jll", "Xorg_libXau_jll", "Xorg_libXdmcp_jll", "Xorg_libpthread_stubs_jll"] +git-tree-sha1 = "b4bfde5d5b652e22b9c790ad00af08b6d042b97d" +uuid = "c7cfdc94-dc32-55de-ac96-5a1b8d977c5b" +version = "1.15.0+0" + +[[deps.Xorg_libxkbfile_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libX11_jll"] +git-tree-sha1 = "730eeca102434283c50ccf7d1ecdadf521a765a4" +uuid = "cc61e674-0454-545c-8b26-ed2c68acab7a" +version = "1.1.2+0" + +[[deps.Xorg_xcb_util_cursor_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xcb_util_image_jll", "Xorg_xcb_util_jll", "Xorg_xcb_util_renderutil_jll"] +git-tree-sha1 = "04341cb870f29dcd5e39055f895c39d016e18ccd" +uuid = "e920d4aa-a673-5f3a-b3d7-f755a4d47c43" +version = "0.1.4+0" + +[[deps.Xorg_xcb_util_image_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"] +git-tree-sha1 = "0fab0a40349ba1cba2c1da699243396ff8e94b97" +uuid = "12413925-8142-5f55-bb0e-6d7ca50bb09b" +version = "0.4.0+1" + +[[deps.Xorg_xcb_util_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_libxcb_jll"] +git-tree-sha1 = "e7fd7b2881fa2eaa72717420894d3938177862d1" +uuid = "2def613f-5ad1-5310-b15b-b15d46f528f5" +version = "0.4.0+1" + +[[deps.Xorg_xcb_util_keysyms_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"] +git-tree-sha1 = "d1151e2c45a544f32441a567d1690e701ec89b00" +uuid = "975044d2-76e6-5fbe-bf08-97ce7c6574c7" +version = "0.4.0+1" + +[[deps.Xorg_xcb_util_renderutil_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"] +git-tree-sha1 = "dfd7a8f38d4613b6a575253b3174dd991ca6183e" +uuid = "0d47668e-0667-5a69-a72c-f761630bfb7e" +version = "0.3.9+1" + +[[deps.Xorg_xcb_util_wm_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Xorg_xcb_util_jll"] +git-tree-sha1 = "e78d10aab01a4a154142c5006ed44fd9e8e31b67" +uuid = "c22f9ab0-d5fe-5066-847c-f4bb1cd4e361" +version = "0.4.1+1" + +[[deps.Xorg_xkbcomp_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_libxkbfile_jll"] +git-tree-sha1 = "330f955bc41bb8f5270a369c473fc4a5a4e4d3cb" +uuid = "35661453-b289-5fab-8a00-3d9160c6a3a4" +version = "1.4.6+0" + +[[deps.Xorg_xkeyboard_config_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Xorg_xkbcomp_jll"] +git-tree-sha1 = "691634e5453ad362044e2ad653e79f3ee3bb98c3" +uuid = "33bec58e-1273-512f-9401-5d533626f822" +version = "2.39.0+0" + +[[deps.Xorg_xtrans_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e92a1a012a10506618f10b7047e478403a046c77" +uuid = "c5fb5394-a638-5e4d-96e5-b29de1b5cf10" +version = "1.5.0+0" + [[deps.YAML]] deps = ["Base64", "Dates", "Printf", "StringEncodings"] git-tree-sha1 = "e6330e4b731a6af7959673621e91645eb1356884" uuid = "ddb6d928-2868-570f-bddf-ab3f9cf99eb6" version = "0.4.9" +[[deps.ZMQ]] +deps = ["FileWatching", "PrecompileTools", "Sockets", "ZeroMQ_jll"] +git-tree-sha1 = "ad6944a6b3dfd8e95920e48355d3baf510319262" +uuid = "c2297ded-f4af-51ae-bb23-16f91089e4e1" +version = "1.2.6" + +[[deps.ZeroMQ_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "libsodium_jll"] +git-tree-sha1 = "42f97fb27394378591666ab0e9cee369e6d0e1f9" +uuid = "8f1865be-045e-5c20-9c9f-bfbfb0764568" +version = "4.3.5+0" + [[deps.Zlib_jll]] deps = ["Libdl"] uuid = "83775a58-1f1d-513f-b197-d71354ab007a" version = "1.2.13+0" +[[deps.Zstd_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "e678132f07ddb5bfa46857f0d7620fb9be675d3b" +uuid = "3161d3a3-bdf6-5164-811a-617609db77b4" +version = "1.5.6+0" + +[[deps.eudev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "gperf_jll"] +git-tree-sha1 = "431b678a28ebb559d224c0b6b6d01afce87c51ba" +uuid = "35ca27e7-8b34-5b7f-bca9-bdc33f59eb06" +version = "3.2.9+0" + +[[deps.fzf_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "a68c9655fbe6dfcab3d972808f1aafec151ce3f8" +uuid = "214eeab7-80f7-51ab-84ad-2988db7cef09" +version = "0.43.0+0" + +[[deps.gperf_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "3516a5630f741c9eecb3720b1ec9d8edc3ecc033" +uuid = "1a1c6b14-54f6-533d-8383-74cd7377aa70" +version = "3.1.1+0" + +[[deps.libaom_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl"] +git-tree-sha1 = "1827acba325fdcdf1d2647fc8d5301dd9ba43a9d" +uuid = "a4ae2306-e953-59d6-aa16-d00cac43593b" +version = "3.9.0+0" + +[[deps.libass_jll]] +deps = ["Artifacts", "Bzip2_jll", "FreeType2_jll", "FriBidi_jll", "HarfBuzz_jll", "JLLWrappers", "Libdl", "Pkg", "Zlib_jll"] +git-tree-sha1 = "5982a94fcba20f02f42ace44b9894ee2b140fe47" +uuid = "0ac62f75-1d6f-5e53-bd7c-93b484bb37c0" +version = "0.15.1+0" + [[deps.libblastrampoline_jll]] deps = ["Artifacts", "Libdl"] uuid = "8e850b90-86db-534c-a0d3-1478176c7d93" version = "5.8.0+0" +[[deps.libevdev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "141fe65dc3efabb0b1d5ba74e91f6ad26f84cc22" +uuid = "2db6ffa8-e38f-5e21-84af-90c45d0032cc" +version = "1.11.0+0" + +[[deps.libfdk_aac_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "daacc84a041563f965be61859a36e17c4e4fcd55" +uuid = "f638f0a6-7fb0-5443-88ba-1cc74229b280" +version = "2.0.2+0" + +[[deps.libinput_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "eudev_jll", "libevdev_jll", "mtdev_jll"] +git-tree-sha1 = "ad50e5b90f222cfe78aa3d5183a20a12de1322ce" +uuid = "36db933b-70db-51c0-b978-0f229ee0e533" +version = "1.18.0+0" + +[[deps.libpng_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Zlib_jll"] +git-tree-sha1 = "d7015d2e18a5fd9a4f47de711837e980519781a4" +uuid = "b53b4c65-9356-5827-b1ea-8c7a1a84506f" +version = "1.6.43+1" + +[[deps.libsodium_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "848ab3d00fe39d6fbc2a8641048f8f272af1c51e" +uuid = "a9144af2-ca23-56d9-984f-0d03f7b5ccf8" +version = "1.0.20+0" + +[[deps.libvorbis_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Ogg_jll", "Pkg"] +git-tree-sha1 = "b910cb81ef3fe6e78bf6acee440bda86fd6ae00c" +uuid = "f27f6e37-5d2b-51aa-960f-b287f2bc3b7a" +version = "1.3.7+1" + +[[deps.mtdev_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "814e154bdb7be91d78b6802843f76b6ece642f11" +uuid = "009596ad-96f7-51b1-9f1b-5ce2d5e8a71e" +version = "1.1.6+0" + [[deps.nghttp2_jll]] deps = ["Artifacts", "Libdl"] uuid = "8e850ede-7688-5339-a07c-302acd2aaf8d" @@ -765,3 +1634,21 @@ version = "1.48.0+0" deps = ["Artifacts", "Libdl"] uuid = "3f19e933-33d8-53b3-aaab-bd5110c3b7a0" version = "17.4.0+0" + +[[deps.x264_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "4fea590b89e6ec504593146bf8b988b2c00922b2" +uuid = "1270edf5-f2f9-52d2-97e9-ab00b5d0237a" +version = "2021.5.5+0" + +[[deps.x265_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg"] +git-tree-sha1 = "ee567a171cce03570d77ad3a43e90218e38937a9" +uuid = "dfaa095f-4041-5dcd-9319-2fabd8486b76" +version = "3.5.0+0" + +[[deps.xkbcommon_jll]] +deps = ["Artifacts", "JLLWrappers", "Libdl", "Pkg", "Wayland_jll", "Wayland_protocols_jll", "Xorg_libxcb_jll", "Xorg_xkeyboard_config_jll"] +git-tree-sha1 = "9c304562909ab2bab0262639bd4f444d7bc2be37" +uuid = "d8fb68d0-12a3-5cfd-a85a-d49703b185fd" +version = "1.4.1+1" diff --git a/Project.toml b/Project.toml index 14e3720..d97c15b 100644 --- a/Project.toml +++ b/Project.toml @@ -4,14 +4,20 @@ repo = "https://github.com/NVE/JulES.jl.git" version = "0.1.0" [deps] +CSV = "336ed68f-0bac-5ca0-87d4-7b16caf5d00b" Clustering = "aaaa29a8-35af-508c-8bc3-b662a17a0fe5" DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0" Dates = "ade2ca70-3891-5945-98fb-dc099432e06a" Distributed = "8ba89e20-285c-5b6f-9357-94700520ee1b" DistributedArrays = "aaf54ef3-cdf8-58ed-94cc-d582ad619b94" Distributions = "31c24e10-a181-5473-b8eb-7969acd0382f" +IJulia = "7073ff75-c697-5162-941a-fcdaad2a7d2a" JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6" +PlotlyJS = "f0f68f2c-4968-5e81-91da-67840de0976a" +Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" PrecompileTools = "aea7be01-6a6a-4083-8856-8a6e6704d82a" +PrettyTables = "08abe8d2-0d0c-5749-adfa-8a2ac140af0d" +Revise = "295af30f-e4ad-537b-8983-00126c2a3abe" Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2" TuLiPa = "970f5c25-cd7d-4f04-b50d-7a4fe2af6639" YAML = "ddb6d928-2868-570f-bddf-ab3f9cf99eb6" diff --git a/demos/Demo prognosis.ipynb b/demos/Demo prognosis.ipynb index 35484ff..a8208ae 100644 --- a/demos/Demo prognosis.ipynb +++ b/demos/Demo prognosis.ipynb @@ -18,7 +18,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 14, "id": "6d67dd8b", "metadata": {}, "outputs": [ @@ -50,51 +50,23 @@ } ], "source": [ + "#Pkg.instantiate()\n", "using Pkg; Pkg.status()\n", - "Pkg.add(\"CSV\"); Pkg.add(\"Revise\"); Pkg.add(\"Plots\"); Pkg.add(\"PlotlyJS\"); Pkg.add(\"PrettyTables\")\n", + "#Pkg.add(\"CSV\"); Pkg.add(\"Revise\"); Pkg.add(\"Plots\"); Pkg.add(\"PlotlyJS\"); Pkg.add(\"PrettyTables\")\n", "# Pkg.update(\"TuLiPa\") # uncomment to update TuLiPa to latest version\n", "# Pkg.develop(path=joinpath(dirname(dirname(pwd())),\"TuLiPa\")); Pkg.status() # go to development version\n", - "# Pkg.undo(); Pkg.status() # go back to main package version\n", + "#Pkg.undo(); Pkg.status() # go back to main package version\n", "#Pkg.add(url=\"https://github.com/NVE/TuLiPa.git\", rev=\"redesign_JulES\"); Pkg.status() # alternative go back to latest version" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 15, "id": "ecbf4aa8", "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "application/vnd.webio.node+json": { - "children": [], - "instanceArgs": { - "namespace": "html", - "tag": "div" - }, - "nodeType": "DOM", - "props": {}, - "type": "node" - }, - "text/html": [ - "
\n", - "

The WebIO Jupyter extension was not detected. See the\n", - "\n", - " WebIO Jupyter integration documentation\n", - "\n", - "for more information.\n", - "

\n" - ], - "text/plain": [ - "WebIO._IJuliaInit()" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "using DataFrames, Statistics, JSON, Distributed, Clustering, YAML, Distributions, Revise, Plots, PrettyTables, Random\n", "plotlyjs(); # uncomment for interactive plots" @@ -102,7 +74,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 16, "id": "a8a9f2cf", "metadata": {}, "outputs": [ @@ -112,7 +84,7 @@ "2024" ] }, - "execution_count": 32, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" } @@ -120,7 +92,6 @@ "source": [ "# config = YAML.load_file(joinpath(\"data\", \"config_jules_prognose.yml\")) # config without datasets\n", "config = YAML.load_file(joinpath(\"data\", \"config_jules_prognose_demo.yml\")) # config with NVE datasets\n", - "config = YAML.load_file(joinpath(dirname(dirname(pwd())), \"JulESIO\", \"config_jules_la_demo.yml\")) # config with NVE datasets\n", "weatheryear = config[\"main\"][\"weatheryears\"][1]\n", "datayear = config[\"main\"][\"datayears\"][1]" ] @@ -135,7 +106,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 17, "id": "3971d0bb", "metadata": {}, "outputs": [ @@ -143,7 +114,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "nprocs() = 5\n" + "nprocs() = 10\n" ] } ], @@ -159,7 +130,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 18, "id": "696e5ec2", "metadata": {}, "outputs": [], @@ -170,7 +141,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 19, "id": "d2448075", "metadata": {}, "outputs": [], @@ -180,7 +151,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 20, "id": "35482c34", "metadata": {}, "outputs": [ @@ -190,7 +161,7 @@ "getdataset (generic function with 1 method)" ] }, - "execution_count": 35, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" } @@ -267,7 +238,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 28, "id": "ca8bc8dd", "metadata": {}, "outputs": [ @@ -276,253 +247,254 @@ "output_type": "stream", "text": [ "Time parameters\n", - " 0.000133 seconds (89 allocations: 3.844 KiB)\n", + " 0.000046 seconds (56 allocations: 2.250 KiB)\n", "Handle elements\n", - " 0.000790 seconds (14.37 k allocations: 716.344 KiB)\n", + " 0.000959 seconds (14.37 k allocations: 716.344 KiB)\n", "Add local dbs\n", - " 0.011243 seconds (390 allocations: 21.234 KiB)\n", + " 0.011866 seconds (721 allocations: 33.375 KiB)\n", "Add local cores\n", - " 0.000571 seconds (318 allocations: 14.078 KiB)\n", + " 0.011610 seconds (661 allocations: 25.875 KiB)\n", "Add local input\n", - " 1.150356 seconds (163.52 k allocations: 5.548 MiB)\n", + " 2.818573 seconds (368.17 k allocations: 12.482 MiB)\n", "Add local dummyobjects\n", - " 0.369161 seconds (1.13 M allocations: 89.254 MiB)\n", + " 0.474567 seconds (1.13 M allocations: 89.280 MiB)\n", "Add local subsystems\n", "Number of shortterm storagesystems 0\n", "Number of longterm storagesystems 19\n", - " 0.105985 seconds (1.29 M allocations: 38.495 MiB)\n", + " 0.120413 seconds (1.29 M allocations: 38.654 MiB)\n", "Add local scenmod\n", - " 0.000755 seconds (321 allocations: 17.375 KiB)\n", + " 0.012252 seconds (770 allocations: 41.453 KiB)\n", "Add local problem distribution\n", "[(1, 1), (2, 2), (3, 3), (4, 4)]\n", "[(1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, 4), (1, 2, 1), (2, 2, 2), (3, 2, 3), (4, 2, 4), (1, 3, 1), (2, 3, 2), (3, 3, 3), (4, 3, 4), (1, 4, 1), (2, 4, 2), (3, 4, 3), (4, 4, 4), (1, 5, 1), (2, 5, 2), (3, 5, 3), (4, 5, 4), (1, 6, 1), (2, 6, 2), (3, 6, 3), (4, 6, 4), (1, 7, 1), (2, 7, 2), (3, 7, 3), (4, 7, 4), (1, 8, 1), (2, 8, 2), (3, 8, 3), (4, 8, 4), (1, 9, 1), (2, 9, 2), (3, 9, 3), (4, 9, 4), (1, 10, 1), (2, 10, 2), (3, 10, 3), (4, 10, 4), (1, 11, 1), (2, 11, 2), (3, 11, 3), (4, 11, 4), (1, 12, 1), (2, 12, 2), (3, 12, 3), (4, 12, 4), (1, 13, 1), (2, 13, 2), (3, 13, 3), (4, 13, 4), (1, 14, 1), (2, 14, 2), (3, 14, 3), (4, 14, 4), (1, 15, 1), (2, 15, 2), (3, 15, 3), (4, 15, 4), (1, 16, 1), (2, 16, 2), (3, 16, 3), (4, 16, 4), (1, 17, 1), (2, 17, 2), (3, 17, 3), (4, 17, 4), (1, 18, 1), (2, 18, 2), (3, 18, 3), (4, 18, 4), (1, 19, 1), (2, 19, 2), (3, 19, 3), (4, 19, 4)]\n", - "[(19, 1), (17, 5), (16, 2), (15, 1), (14, 5), (12, 2), (11, 5), (10, 5), (7, 1), (6, 1), (5, 5), (4, 3), (3, 2), (2, 1), (1, 3), (18, 4), (13, 3), (9, 4), (8, 1)]\n", - "[(1, 19, 1), (1, 17, 5), (1, 16, 2), (1, 15, 1), (1, 14, 5), (1, 12, 2), (1, 11, 5), (1, 10, 5), (1, 7, 1), (1, 6, 1), (1, 5, 5), (1, 4, 3), (1, 3, 2), (1, 2, 1), (1, 1, 3), (1, 18, 4), (1, 13, 3), (1, 9, 4), (1, 8, 1), (2, 19, 1), (2, 17, 5), (2, 16, 2), (2, 15, 1), (2, 14, 5), (2, 12, 2), (2, 11, 5), (2, 10, 5), (2, 7, 1), (2, 6, 1), (2, 5, 5), (2, 4, 3), (2, 3, 2), (2, 2, 1), (2, 1, 3), (2, 18, 4), (2, 13, 3), (2, 9, 4), (2, 8, 1), (3, 19, 1), (3, 17, 5), (3, 16, 2), (3, 15, 1), (3, 14, 5), (3, 12, 2), (3, 11, 5), (3, 10, 5), (3, 7, 1), (3, 6, 1), (3, 5, 5), (3, 4, 3), (3, 3, 2), (3, 2, 1), (3, 1, 3), (3, 18, 4), (3, 13, 3), (3, 9, 4), (3, 8, 1), (4, 19, 1), (4, 17, 5), (4, 16, 2), (4, 15, 1), (4, 14, 5), (4, 12, 2), (4, 11, 5), (4, 10, 5), (4, 7, 1), (4, 6, 1), (4, 5, 5), (4, 4, 3), (4, 3, 2), (4, 2, 1), (4, 1, 3), (4, 18, 4), (4, 13, 3), (4, 9, 4), (4, 8, 1)]\n", - " 0.444825 seconds (205.19 k allocations: 12.704 MiB, 43.43% compilation time: 51% of which was recompilation)\n", + "Number of subsystems: 19\n", + "[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9), (10, 10), (11, 1), (12, 2), (13, 3), (14, 4), (15, 5), (16, 6), (17, 7), (18, 8), (19, 9)]\n", + "[(1, 1, 1), (1, 2, 2), (1, 3, 3), (1, 4, 4), (1, 5, 5), (1, 6, 6), (1, 7, 7), (1, 8, 8), (1, 9, 9), (1, 10, 10), (1, 11, 1), (1, 12, 2), (1, 13, 3), (1, 14, 4), (1, 15, 5), (1, 16, 6), (1, 17, 7), (1, 18, 8), (1, 19, 9), (2, 1, 1), (2, 2, 2), (2, 3, 3), (2, 4, 4), (2, 5, 5), (2, 6, 6), (2, 7, 7), (2, 8, 8), (2, 9, 9), (2, 10, 10), (2, 11, 1), (2, 12, 2), (2, 13, 3), (2, 14, 4), (2, 15, 5), (2, 16, 6), (2, 17, 7), (2, 18, 8), (2, 19, 9), (3, 1, 1), (3, 2, 2), (3, 3, 3), (3, 4, 4), (3, 5, 5), (3, 6, 6), (3, 7, 7), (3, 8, 8), (3, 9, 9), (3, 10, 10), (3, 11, 1), (3, 12, 2), (3, 13, 3), (3, 14, 4), (3, 15, 5), (3, 16, 6), (3, 17, 7), (3, 18, 8), (3, 19, 9), (4, 1, 1), (4, 2, 2), (4, 3, 3), (4, 4, 4), (4, 5, 5), (4, 6, 6), (4, 7, 7), (4, 8, 8), (4, 9, 9), (4, 10, 10), (4, 11, 1), (4, 12, 2), (4, 13, 3), (4, 14, 4), (4, 15, 5), (4, 16, 6), (4, 17, 7), (4, 18, 8), (4, 19, 9)]\n", + " 0.612303 seconds (329.94 k allocations: 21.166 MiB, 59.16% compilation time: 100% of which was recompilation)\n", "Add local horizons\n", - " 1.375227 seconds (604.83 k allocations: 39.495 MiB, 56.43% compilation time)\n", + " 0.003992 seconds (2.53 k allocations: 183.188 KiB)\n", "Add local problems\n", - " 27.314695 seconds (13.43 M allocations: 906.464 MiB, 0.80% gc time, 45.76% compilation time)\n", + " 1.350118 seconds (4.07 M allocations: 304.237 MiB)\n", "Add local output\n", - " 0.360472 seconds (190.06 k allocations: 12.035 MiB, 99.83% compilation time: 13% of which was recompilation)\n", + " 0.000262 seconds (723 allocations: 117.453 KiB)\n", "PrognosisTime(DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-29T00:00:00\"), DateTime(\"1991-01-28T00:00:00\"))\n", "Startstates\n", - " 1.610177 seconds (370.98 k allocations: 24.247 MiB, 30.05% compilation time)\n", + " 0.026397 seconds (74.66 k allocations: 4.640 MiB)\n", "Price prognosis problems\n", - " 31.884334 seconds (19.03 M allocations: 1.182 GiB, 1.17% gc time, 47.95% compilation time)\n", + " 1.061236 seconds (1.38 M allocations: 45.367 MiB, 19.21% gc time)\n", "End value problems\n", - " 2.220010 seconds (801.47 k allocations: 51.108 MiB, 55.07% compilation time)\n", + " 0.015989 seconds (37.14 k allocations: 1.295 MiB)\n", "Subsystem problems\n", - " 5.418691 seconds (1.97 M allocations: 127.483 MiB, 43.95% compilation time)\n", + " 0.154062 seconds (63.82 k allocations: 3.151 MiB, 35.19% compilation time)\n", "Clearing problem\n", - " 1.523355 seconds (472.82 k allocations: 28.987 MiB, 53.91% compilation time)\n", + " 0.044352 seconds (86.81 k allocations: 2.954 MiB)\n", "Update output\n", - " 3.002423 seconds (1.96 M allocations: 128.172 MiB, 84.48% compilation time)\n", + " 0.031259 seconds (29.67 k allocations: 1.494 MiB)\n", "PrognosisTime(DateTime(\"2024-01-31T00:00:00\"), DateTime(\"2024-01-31T00:00:00\"), DateTime(\"1991-01-30T00:00:00\"))\n", "Startstates\n", - " 0.221641 seconds (68.51 k allocations: 4.678 MiB, 71.31% compilation time)\n", + " 0.002994 seconds (3.92 k allocations: 216.930 KiB)\n", "Price prognosis problems\n", - " 0.365376 seconds (274.94 k allocations: 8.969 MiB, 22.93% compilation time)\n", + " 0.192823 seconds (246.41 k allocations: 7.049 MiB)\n", "End value problems\n", - " 0.033307 seconds (744 allocations: 34.680 KiB, 32.55% compilation time)\n", + " 0.001709 seconds (1.02 k allocations: 34.578 KiB)\n", "Subsystem problems\n", - " 0.001457 seconds (945 allocations: 37.188 KiB)\n", + " 0.003198 seconds (2.11 k allocations: 85.344 KiB)\n", "Clearing problem\n", - " 0.027292 seconds (78.65 k allocations: 2.961 MiB)\n", + " 0.037549 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.117519 seconds (93.23 k allocations: 5.995 MiB, 81.29% compilation time)\n", + " 0.030511 seconds (21.93 k allocations: 1003.016 KiB)\n", "PrognosisTime(DateTime(\"2024-02-02T00:00:00\"), DateTime(\"2024-02-02T00:00:00\"), DateTime(\"1991-02-01T00:00:00\"))\n", "Startstates\n", - " 0.001728 seconds (2.04 k allocations: 104.031 KiB)\n", + " 0.013317 seconds (3.91 k allocations: 212.227 KiB)\n", "Price prognosis problems\n", - " 0.305750 seconds (247.26 k allocations: 7.143 MiB, 36.86% gc time)\n", + " 0.180536 seconds (246.41 k allocations: 7.048 MiB)\n", "End value problems\n", - " 0.000654 seconds (494 allocations: 18.141 KiB)\n", + " 0.012431 seconds (1.15 k allocations: 46.219 KiB)\n", "Subsystem problems\n", - " 0.011659 seconds (945 allocations: 36.492 KiB)\n", + " 0.013578 seconds (1.99 k allocations: 73.984 KiB)\n", "Clearing problem\n", - " 0.026986 seconds (78.66 k allocations: 2.963 MiB)\n", + " 0.026342 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.022008 seconds (8.15 k allocations: 381.344 KiB)\n", + " 0.027756 seconds (21.93 k allocations: 1004.844 KiB)\n", "PrognosisTime(DateTime(\"2024-02-04T00:00:00\"), DateTime(\"2024-02-04T00:00:00\"), DateTime(\"1991-02-03T00:00:00\"))\n", "Startstates\n", - " 0.012131 seconds (2.05 k allocations: 105.078 KiB)\n", + " 0.003079 seconds (3.92 k allocations: 212.164 KiB)\n", "Price prognosis problems\n", - " 0.185098 seconds (245.53 k allocations: 7.019 MiB)\n", + " 0.190999 seconds (246.41 k allocations: 7.048 MiB)\n", "End value problems\n", - " 0.000755 seconds (493 allocations: 17.531 KiB)\n", + " 0.012273 seconds (1.15 k allocations: 46.219 KiB)\n", "Subsystem problems\n", - " 0.001569 seconds (945 allocations: 37.188 KiB)\n", + " 0.013628 seconds (1.99 k allocations: 73.984 KiB)\n", "Clearing problem\n", - " 0.036923 seconds (78.65 k allocations: 2.961 MiB)\n", + " 0.027861 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.010894 seconds (8.15 k allocations: 381.281 KiB)\n", + " 0.039568 seconds (21.93 k allocations: 1017.406 KiB)\n", "PrognosisTime(DateTime(\"2024-02-06T00:00:00\"), DateTime(\"2024-02-06T00:00:00\"), DateTime(\"1991-02-05T00:00:00\"))\n", "Startstates\n", - " 0.011642 seconds (2.05 k allocations: 240.312 KiB)\n", + " 0.003061 seconds (3.92 k allocations: 212.945 KiB)\n", "Price prognosis problems\n", - " 0.171500 seconds (245.53 k allocations: 7.018 MiB)\n", + " 0.180896 seconds (246.42 k allocations: 7.049 MiB)\n", "End value problems\n", - " 0.011080 seconds (500 allocations: 18.484 KiB)\n", + " 0.001750 seconds (1.03 k allocations: 35.797 KiB)\n", "Subsystem problems\n", - " 0.011829 seconds (1.06 k allocations: 46.969 KiB)\n", + " 0.003150 seconds (2.10 k allocations: 85.250 KiB)\n", "Clearing problem\n", - " 0.037338 seconds (78.65 k allocations: 2.962 MiB)\n", + " 0.026678 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.010998 seconds (8.15 k allocations: 384.609 KiB)\n", + " 0.029559 seconds (21.92 k allocations: 991.172 KiB)\n", "PrognosisTime(DateTime(\"2024-02-08T00:00:00\"), DateTime(\"2024-02-08T00:00:00\"), DateTime(\"1991-02-07T00:00:00\"))\n", "Startstates\n", - " 0.011945 seconds (2.05 k allocations: 105.141 KiB)\n", + " 0.003198 seconds (3.90 k allocations: 211.930 KiB)\n", "Price prognosis problems\n", - " 0.171793 seconds (245.53 k allocations: 7.019 MiB)\n", + " 0.186489 seconds (246.42 k allocations: 7.049 MiB)\n", "End value problems\n", - " 0.000758 seconds (492 allocations: 17.281 KiB)\n", + " 0.001371 seconds (1.02 k allocations: 34.578 KiB)\n", "Subsystem problems\n", - " 0.001204 seconds (945 allocations: 37.188 KiB)\n", + " 0.002668 seconds (1.99 k allocations: 74.844 KiB)\n", "Clearing problem\n", - " 0.037033 seconds (78.78 k allocations: 2.973 MiB)\n", + " 0.037681 seconds (79.30 k allocations: 2.990 MiB)\n", "Update output\n", - " 0.021820 seconds (8.15 k allocations: 377.969 KiB)\n", + " 0.029603 seconds (21.92 k allocations: 992.031 KiB)\n", "PrognosisTime(DateTime(\"2024-02-10T00:00:00\"), DateTime(\"2024-02-10T00:00:00\"), DateTime(\"1991-02-09T00:00:00\"))\n", "Startstates\n", - " 0.012474 seconds (2.04 k allocations: 104.125 KiB)\n", + " 0.013235 seconds (3.91 k allocations: 212.258 KiB)\n", "Price prognosis problems\n", - " 0.182394 seconds (245.54 k allocations: 7.025 MiB)\n", + " 0.175568 seconds (246.42 k allocations: 7.048 MiB)\n", "End value problems\n", - " 0.001002 seconds (620 allocations: 28.734 KiB)\n", + " 0.012223 seconds (1.15 k allocations: 45.359 KiB)\n", "Subsystem problems\n", - " 0.001482 seconds (943 allocations: 36.328 KiB)\n", + " 0.002829 seconds (1.99 k allocations: 74.203 KiB)\n", "Clearing problem\n", - " 0.025064 seconds (78.65 k allocations: 2.962 MiB)\n", + " 0.026126 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.022105 seconds (8.15 k allocations: 378.031 KiB)\n", + " 0.039923 seconds (21.93 k allocations: 992.172 KiB)\n", "PrognosisTime(DateTime(\"2024-02-12T00:00:00\"), DateTime(\"2024-02-12T00:00:00\"), DateTime(\"1991-02-11T00:00:00\"))\n", "Startstates\n", - " 0.001295 seconds (2.04 k allocations: 104.828 KiB)\n", + " 0.002950 seconds (3.91 k allocations: 262.555 KiB)\n", "Price prognosis problems\n", - " 0.179196 seconds (245.61 k allocations: 7.022 MiB)\n", + " 0.183914 seconds (246.54 k allocations: 7.058 MiB)\n", "End value problems\n", - " 0.011657 seconds (617 allocations: 28.047 KiB)\n", + " 0.011988 seconds (1.03 k allocations: 35.688 KiB)\n", "Subsystem problems\n", - " 0.001624 seconds (950 allocations: 37.312 KiB)\n", + " 0.003021 seconds (1.98 k allocations: 73.844 KiB)\n", "Clearing problem\n", - " 0.037453 seconds (79.28 k allocations: 3.006 MiB)\n", + " 0.027039 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.021211 seconds (8.15 k allocations: 384.547 KiB)\n", + " 0.029117 seconds (21.92 k allocations: 992.094 KiB)\n", "PrognosisTime(DateTime(\"2024-02-14T00:00:00\"), DateTime(\"2024-02-14T00:00:00\"), DateTime(\"1991-02-13T00:00:00\"))\n", "Startstates\n", - " 0.011688 seconds (2.05 k allocations: 104.281 KiB)\n", + " 0.013206 seconds (3.90 k allocations: 212.758 KiB)\n", "Price prognosis problems\n", - " 0.560941 seconds (1.07 M allocations: 32.176 MiB, 4.95% compilation time)\n", + " 0.692403 seconds (1.08 M allocations: 32.369 MiB)\n", "End value problems\n", - " 0.026427 seconds (27.45 k allocations: 925.703 KiB)\n", + " 0.008420 seconds (27.69 k allocations: 927.953 KiB)\n", "Subsystem problems\n", - " 0.175272 seconds (96.09 k allocations: 3.878 MiB, 35.10% compilation time)\n", + " 0.052619 seconds (45.41 k allocations: 1.727 MiB, 17.75% compilation time)\n", "Clearing problem\n", - " 0.041502 seconds (88.22 k allocations: 3.323 MiB)\n", + " 0.031864 seconds (88.55 k allocations: 3.329 MiB)\n", "Update output\n", - " 0.011113 seconds (8.15 k allocations: 378.172 KiB)\n", + " 0.029058 seconds (21.92 k allocations: 991.172 KiB)\n", "PrognosisTime(DateTime(\"2024-02-16T00:00:00\"), DateTime(\"2024-02-16T00:00:00\"), DateTime(\"1991-02-15T00:00:00\"))\n", "Startstates\n", - " 0.001472 seconds (2.05 k allocations: 104.188 KiB)\n", + " 0.013385 seconds (3.92 k allocations: 212.258 KiB)\n", "Price prognosis problems\n", - " 0.197297 seconds (245.65 k allocations: 7.028 MiB)\n", + " 0.176355 seconds (246.42 k allocations: 7.049 MiB)\n", "End value problems\n", - " 0.013930 seconds (495 allocations: 18.391 KiB)\n", + " 0.001603 seconds (1.03 k allocations: 34.938 KiB)\n", "Subsystem problems\n", - " 0.001779 seconds (948 allocations: 36.453 KiB)\n", + " 0.002571 seconds (1.99 k allocations: 74.703 KiB)\n", "Clearing problem\n", - " 0.026273 seconds (78.65 k allocations: 2.962 MiB)\n", + " 0.027535 seconds (79.31 k allocations: 2.990 MiB)\n", "Update output\n", - " 0.021669 seconds (8.15 k allocations: 378.031 KiB)\n", + " 0.028547 seconds (21.93 k allocations: 992.172 KiB)\n", "PrognosisTime(DateTime(\"2024-02-18T00:00:00\"), DateTime(\"2024-02-18T00:00:00\"), DateTime(\"1991-02-17T00:00:00\"))\n", "Startstates\n", - " 0.011880 seconds (2.05 k allocations: 105.047 KiB)\n", + " 0.003110 seconds (3.91 k allocations: 212.086 KiB)\n", "Price prognosis problems\n", - " 0.184789 seconds (245.53 k allocations: 7.019 MiB)\n", + " 0.177676 seconds (246.41 k allocations: 7.048 MiB)\n", "End value problems\n", - " 0.011659 seconds (617 allocations: 28.047 KiB)\n", + " 0.001447 seconds (1.03 k allocations: 34.719 KiB)\n", "Subsystem problems\n", - " 0.011887 seconds (950 allocations: 37.312 KiB)\n", + " 0.002570 seconds (1.99 k allocations: 73.984 KiB)\n", "Clearing problem\n", - " 0.026922 seconds (78.65 k allocations: 2.961 MiB)\n", + " 0.026778 seconds (79.31 k allocations: 2.991 MiB)\n", "Update output\n", - " 0.022157 seconds (8.15 k allocations: 403.344 KiB)\n", + " 0.039075 seconds (21.93 k allocations: 992.375 KiB)\n", "PrognosisTime(DateTime(\"2024-02-20T00:00:00\"), DateTime(\"2024-02-20T00:00:00\"), DateTime(\"1991-02-19T00:00:00\"))\n", "Startstates\n", - " 0.001506 seconds (2.04 k allocations: 104.125 KiB)\n", + " 0.003138 seconds (3.93 k allocations: 212.414 KiB)\n", "Price prognosis problems\n", - " 0.191408 seconds (245.53 k allocations: 7.019 MiB)\n", + " 0.174779 seconds (246.41 k allocations: 7.048 MiB)\n", "End value problems\n", - " 0.011459 seconds (617 allocations: 28.047 KiB)\n", + " 0.001415 seconds (1.03 k allocations: 35.688 KiB)\n", "Subsystem problems\n", - " 0.001526 seconds (944 allocations: 36.391 KiB)\n", + " 0.013840 seconds (2.10 k allocations: 84.484 KiB)\n", "Clearing problem\n", - " 0.037827 seconds (78.65 k allocations: 2.961 MiB)\n", + " 0.027833 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.011273 seconds (8.15 k allocations: 377.906 KiB)\n", + " 0.028226 seconds (21.93 k allocations: 992.172 KiB)\n", "PrognosisTime(DateTime(\"2024-02-22T00:00:00\"), DateTime(\"2024-02-22T00:00:00\"), DateTime(\"1991-02-21T00:00:00\"))\n", "Startstates\n", - " 0.001389 seconds (2.04 k allocations: 104.828 KiB)\n", + " 0.013461 seconds (3.93 k allocations: 213.180 KiB)\n", "Price prognosis problems\n", - " 0.192499 seconds (245.53 k allocations: 7.018 MiB)\n", + " 0.185336 seconds (246.54 k allocations: 7.058 MiB)\n", "End value problems\n", - " 0.000776 seconds (492 allocations: 17.281 KiB)\n", + " 0.001834 seconds (1.02 k allocations: 35.438 KiB)\n", "Subsystem problems\n", - " 0.011879 seconds (1.07 k allocations: 47.859 KiB)\n", + " 0.013663 seconds (1.99 k allocations: 73.984 KiB)\n", "Clearing problem\n", - " 0.038007 seconds (78.65 k allocations: 2.961 MiB)\n", + " 0.027898 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.011997 seconds (8.15 k allocations: 377.906 KiB)\n", + " 0.029331 seconds (21.93 k allocations: 1.066 MiB)\n", "PrognosisTime(DateTime(\"2024-02-24T00:00:00\"), DateTime(\"2024-02-24T00:00:00\"), DateTime(\"1991-02-23T00:00:00\"))\n", "Startstates\n", - " 0.012040 seconds (2.05 k allocations: 104.219 KiB)\n", + " 0.003197 seconds (3.92 k allocations: 213.227 KiB)\n", "Price prognosis problems\n", - " 0.191848 seconds (245.65 k allocations: 7.029 MiB)\n", + " 0.192056 seconds (246.54 k allocations: 7.058 MiB)\n", "End value problems\n", - " 0.000843 seconds (492 allocations: 17.281 KiB)\n", + " 0.011925 seconds (1.03 k allocations: 34.938 KiB)\n", "Subsystem problems\n", - " 0.001309 seconds (946 allocations: 37.250 KiB)\n", + " 0.002828 seconds (1.98 k allocations: 73.922 KiB)\n", "Clearing problem\n", - " 0.038207 seconds (78.65 k allocations: 2.961 MiB)\n", + " 0.038227 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.010469 seconds (8.15 k allocations: 378.891 KiB)\n", + " 0.029124 seconds (21.93 k allocations: 992.172 KiB)\n", "PrognosisTime(DateTime(\"2024-02-26T00:00:00\"), DateTime(\"2024-02-26T00:00:00\"), DateTime(\"1991-02-25T00:00:00\"))\n", "Startstates\n", - " 0.001550 seconds (2.05 k allocations: 105.141 KiB)\n", + " 0.014054 seconds (4.04 k allocations: 225.227 KiB)\n", "Price prognosis problems\n", - " 0.176722 seconds (245.53 k allocations: 7.019 MiB)\n", + " 0.177562 seconds (246.41 k allocations: 7.047 MiB)\n", "End value problems\n", - " 0.011612 seconds (619 allocations: 28.094 KiB)\n", + " 0.001333 seconds (1.02 k allocations: 34.578 KiB)\n", "Subsystem problems\n", - " 0.001350 seconds (943 allocations: 36.328 KiB)\n", + " 0.002524 seconds (1.99 k allocations: 73.984 KiB)\n", "Clearing problem\n", - " 0.036140 seconds (78.65 k allocations: 2.961 MiB)\n", + " 0.037508 seconds (79.31 k allocations: 2.990 MiB)\n", "Update output\n", - " 0.020744 seconds (8.15 k allocations: 378.031 KiB)\n", + " 0.028984 seconds (21.92 k allocations: 992.031 KiB)\n", "PrognosisTime(DateTime(\"2024-02-28T00:00:00\"), DateTime(\"2024-02-28T00:00:00\"), DateTime(\"1991-02-27T00:00:00\"))\n", "Startstates\n", - " 0.011884 seconds (2.04 k allocations: 104.125 KiB)\n", + " 0.013809 seconds (3.91 k allocations: 211.961 KiB)\n", "Price prognosis problems\n", - " 0.175584 seconds (245.53 k allocations: 7.019 MiB)\n", + " 0.182281 seconds (246.41 k allocations: 7.048 MiB)\n", "End value problems\n", - " 0.011913 seconds (612 allocations: 27.953 KiB)\n", + " 0.012152 seconds (1.15 k allocations: 46.109 KiB)\n", "Subsystem problems\n", - " 0.001342 seconds (945 allocations: 37.188 KiB)\n", + " 0.013567 seconds (1.99 k allocations: 74.125 KiB)\n", "Clearing problem\n", - " 0.041911 seconds (78.65 k allocations: 2.961 MiB)\n", + " 0.037927 seconds (79.18 k allocations: 2.979 MiB)\n", "Update output\n", - " 0.010780 seconds (8.15 k allocations: 377.906 KiB)\n", + " 0.028271 seconds (21.93 k allocations: 992.172 KiB)\n", "\n", - "The simulation took: 0.87 minutes\n", - "Time usage per simulation step: 3.27 seconds\n", + "The simulation took: 0.1 minutes\n", + "Time usage per simulation step: 0.37 seconds\n", "\n" ] }, { "data": { "text/html": [ - "
5×5 DataFrame
Rowmodelupdatesolveothertotal
StringFloat64Float64Float64Float64
1long37.67610.5073570.37723938.5607
2med0.7907350.3741930.7177131.88264
3short0.03500680.06291770.02217220.120097
4evp0.008929610.001131920.07817260.0882341
5clearing0.007783470.01606140.07901480.10286
" + "
7×5 DataFrame
Rowmodelupdatesolveothertotal
StringFloat64Float64Float64Float64
1long0.06220570.06248440.0001458750.124836
2med0.1598050.04624970.000248150.206303
3short0.02131060.06374180.002122060.0871744
4evp0.0005649390.001115450.0004091210.00208951
5mp0.0005253530.0004083760.006374470.0073082
6sp0.003921610.001461340.01759140.0229744
7clearing0.007264040.01635910.002973840.026597
" ], "text/latex": [ "\\begin{tabular}{r|ccccc}\n", @@ -530,23 +502,27 @@ "\t\\hline\n", "\t& String & Float64 & Float64 & Float64 & Float64\\\\\n", "\t\\hline\n", - "\t1 & long & 37.6761 & 0.507357 & 0.377239 & 38.5607 \\\\\n", - "\t2 & med & 0.790735 & 0.374193 & 0.717713 & 1.88264 \\\\\n", - "\t3 & short & 0.0350068 & 0.0629177 & 0.0221722 & 0.120097 \\\\\n", - "\t4 & evp & 0.00892961 & 0.00113192 & 0.0781726 & 0.0882341 \\\\\n", - "\t5 & clearing & 0.00778347 & 0.0160614 & 0.0790148 & 0.10286 \\\\\n", + "\t1 & long & 0.0622057 & 0.0624844 & 0.000145875 & 0.124836 \\\\\n", + "\t2 & med & 0.159805 & 0.0462497 & 0.00024815 & 0.206303 \\\\\n", + "\t3 & short & 0.0213106 & 0.0637418 & 0.00212206 & 0.0871744 \\\\\n", + "\t4 & evp & 0.000564939 & 0.00111545 & 0.000409121 & 0.00208951 \\\\\n", + "\t5 & mp & 0.000525353 & 0.000408376 & 0.00637447 & 0.0073082 \\\\\n", + "\t6 & sp & 0.00392161 & 0.00146134 & 0.0175914 & 0.0229744 \\\\\n", + "\t7 & clearing & 0.00726404 & 0.0163591 & 0.00297384 & 0.026597 \\\\\n", "\\end{tabular}\n" ], "text/plain": [ - "\u001b[1m5×5 DataFrame\u001b[0m\n", - "\u001b[1m Row \u001b[0m│\u001b[1m model \u001b[0m\u001b[1m update \u001b[0m\u001b[1m solve \u001b[0m\u001b[1m other \u001b[0m\u001b[1m total \u001b[0m\n", - " │\u001b[90m String \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", - "─────┼──────────────────────────────────────────────────────────\n", - " 1 │ long 37.6761 0.507357 0.377239 38.5607\n", - " 2 │ med 0.790735 0.374193 0.717713 1.88264\n", - " 3 │ short 0.0350068 0.0629177 0.0221722 0.120097\n", - " 4 │ evp 0.00892961 0.00113192 0.0781726 0.0882341\n", - " 5 │ clearing 0.00778347 0.0160614 0.0790148 0.10286" + "\u001b[1m7×5 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m model \u001b[0m\u001b[1m update \u001b[0m\u001b[1m solve \u001b[0m\u001b[1m other \u001b[0m\u001b[1m total \u001b[0m\n", + " │\u001b[90m String \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", + "─────┼─────────────────────────────────────────────────────────────\n", + " 1 │ long 0.0622057 0.0624844 0.000145875 0.124836\n", + " 2 │ med 0.159805 0.0462497 0.00024815 0.206303\n", + " 3 │ short 0.0213106 0.0637418 0.00212206 0.0871744\n", + " 4 │ evp 0.000564939 0.00111545 0.000409121 0.00208951\n", + " 5 │ mp 0.000525353 0.000408376 0.00637447 0.0073082\n", + " 6 │ sp 0.00392161 0.00146134 0.0175914 0.0229744\n", + " 7 │ clearing 0.00726404 0.0163591 0.00297384 0.026597" ] }, "metadata": {}, @@ -555,59 +531,104 @@ { "data": { "text/html": [ - "
19×4 DataFrame
Rowsubixupdate_sumsolve_sumtotal_sum
AnyFloat64Float64Float64
11.00.1587090.001819651.63415
24.00.00063560.00142480.00646285
32.00.00075690.00135240.00347545
48.00.00065470.0012960.0024052
53.00.000648250.00129940.0023433
67.00.00056920.00141910.00233
717.00.000594850.001365550.0023151
814.00.00058670.001387950.0023136
912.00.00057540.00141770.00230505
1013.00.000584650.00119130.00219825
1118.00.000603550.001144550.002122
129.00.000594550.001164650.0020836
135.00.00060150.00085560.00193725
1416.00.000593650.00084870.00181405
1515.00.000604450.000733250.0017801
1610.00.000595950.00068910.00163875
1711.00.000588850.000741350.00163475
1819.00.000581050.0006860.00158395
196.00.00058380.00066950.00155635
" + "
10×15 DataFrame
Rowcoretotevp_totmp_totsp_totevp_uevp_sevp_omp_ump_smp_finmp_osp_usp_ssp_o
AnyFloat64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?
15.0missingmissing0.003668850.047041missingmissingmissing0.000160650.001041451.07e-50.002456050.0019530.00328950.0417985
26.0missingmissing0.007849250.0445661missingmissingmissing0.004339550.00088839.7e-60.00261170.01641440.00269510.0254566
37.0missingmissing0.00394870.0476137missingmissingmissing0.000166050.00096031.285e-50.00280950.001812550.004358950.0414422
48.0missingmissing0.00432770.0468604missingmissingmissing0.00013750.000678451.19e-50.003499850.001593850.002988750.0422778
59.0missingmissing0.008641050.0524199missingmissingmissing0.00442090.001084951.05e-50.00312470.01723640.003801750.0313817
610.0missingmissing0.00249940.0048249missingmissingmissing8.01e-50.000363254.25e-60.00205180.000736850.000827050.003261
71.00.09360670.01050240.001663750.08144050.00270770.00532140.0003091690.00014780.00066071.685e-50.00083840.01463420.0024080.0643983
82.00.09354970.00929670.0354340.0488190.00261950.00497440.000212850.00016230.0007081.27e-50.0345510.01666020.003187050.0289718
93.00.09004640.01015390.03514550.0447470.002732850.005616450.0002255750.000203250.000678951.045e-50.03425290.0017610.001800950.0411851
104.00.06360580.00974760.03567760.01818060.00267380.005281250.0002240690.00016360.00069489.85e-60.03480930.001708050.00240840.0140641
" ], "text/latex": [ - "\\begin{tabular}{r|cccc}\n", - "\t& subix & update\\_sum & solve\\_sum & total\\_sum\\\\\n", + "\\begin{tabular}{r|ccccccccc}\n", + "\t& core & tot & evp\\_tot & mp\\_tot & sp\\_tot & evp\\_u & evp\\_s & evp\\_o & \\\\\n", "\t\\hline\n", - "\t& Any & Float64 & Float64 & Float64\\\\\n", + "\t& Any & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & \\\\\n", "\t\\hline\n", - "\t1 & 1.0 & 0.158709 & 0.00181965 & 1.63415 \\\\\n", - "\t2 & 4.0 & 0.0006356 & 0.0014248 & 0.00646285 \\\\\n", - "\t3 & 2.0 & 0.0007569 & 0.0013524 & 0.00347545 \\\\\n", - "\t4 & 8.0 & 0.0006547 & 0.001296 & 0.0024052 \\\\\n", - "\t5 & 3.0 & 0.00064825 & 0.0012994 & 0.0023433 \\\\\n", - "\t6 & 7.0 & 0.0005692 & 0.0014191 & 0.00233 \\\\\n", - "\t7 & 17.0 & 0.00059485 & 0.00136555 & 0.0023151 \\\\\n", - "\t8 & 14.0 & 0.0005867 & 0.00138795 & 0.0023136 \\\\\n", - "\t9 & 12.0 & 0.0005754 & 0.0014177 & 0.00230505 \\\\\n", - "\t10 & 13.0 & 0.00058465 & 0.0011913 & 0.00219825 \\\\\n", - "\t11 & 18.0 & 0.00060355 & 0.00114455 & 0.002122 \\\\\n", - "\t12 & 9.0 & 0.00059455 & 0.00116465 & 0.0020836 \\\\\n", - "\t13 & 5.0 & 0.0006015 & 0.0008556 & 0.00193725 \\\\\n", - "\t14 & 16.0 & 0.00059365 & 0.0008487 & 0.00181405 \\\\\n", - "\t15 & 15.0 & 0.00060445 & 0.00073325 & 0.0017801 \\\\\n", - "\t16 & 10.0 & 0.00059595 & 0.0006891 & 0.00163875 \\\\\n", - "\t17 & 11.0 & 0.00058885 & 0.00074135 & 0.00163475 \\\\\n", - "\t18 & 19.0 & 0.00058105 & 0.000686 & 0.00158395 \\\\\n", - "\t19 & 6.0 & 0.0005838 & 0.0006695 & 0.00155635 \\\\\n", + "\t1 & 5.0 & \\emph{missing} & \\emph{missing} & 0.00366885 & 0.047041 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t2 & 6.0 & \\emph{missing} & \\emph{missing} & 0.00784925 & 0.0445661 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t3 & 7.0 & \\emph{missing} & \\emph{missing} & 0.0039487 & 0.0476137 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t4 & 8.0 & \\emph{missing} & \\emph{missing} & 0.0043277 & 0.0468604 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t5 & 9.0 & \\emph{missing} & \\emph{missing} & 0.00864105 & 0.0524199 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t6 & 10.0 & \\emph{missing} & \\emph{missing} & 0.0024994 & 0.0048249 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t7 & 1.0 & 0.0936067 & 0.0105024 & 0.00166375 & 0.0814405 & 0.0027077 & 0.0053214 & 0.000309169 & $\\dots$ \\\\\n", + "\t8 & 2.0 & 0.0935497 & 0.0092967 & 0.035434 & 0.048819 & 0.0026195 & 0.0049744 & 0.00021285 & $\\dots$ \\\\\n", + "\t9 & 3.0 & 0.0900464 & 0.0101539 & 0.0351455 & 0.044747 & 0.00273285 & 0.00561645 & 0.000225575 & $\\dots$ \\\\\n", + "\t10 & 4.0 & 0.0636058 & 0.0097476 & 0.0356776 & 0.0181806 & 0.0026738 & 0.00528125 & 0.000224069 & $\\dots$ \\\\\n", "\\end{tabular}\n" ], "text/plain": [ - "\u001b[1m19×4 DataFrame\u001b[0m\n", - "\u001b[1m Row \u001b[0m│\u001b[1m subix \u001b[0m\u001b[1m update_sum \u001b[0m\u001b[1m solve_sum \u001b[0m\u001b[1m total_sum \u001b[0m\n", - " │\u001b[90m Any \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", - "─────┼───────────────────────────────────────────\n", - " 1 │ 1.0 0.158709 0.00181965 1.63415\n", - " 2 │ 4.0 0.0006356 0.0014248 0.00646285\n", - " 3 │ 2.0 0.0007569 0.0013524 0.00347545\n", - " 4 │ 8.0 0.0006547 0.001296 0.0024052\n", - " 5 │ 3.0 0.00064825 0.0012994 0.0023433\n", - " 6 │ 7.0 0.0005692 0.0014191 0.00233\n", - " 7 │ 17.0 0.00059485 0.00136555 0.0023151\n", - " 8 │ 14.0 0.0005867 0.00138795 0.0023136\n", - " 9 │ 12.0 0.0005754 0.0014177 0.00230505\n", - " 10 │ 13.0 0.00058465 0.0011913 0.00219825\n", - " 11 │ 18.0 0.00060355 0.00114455 0.002122\n", - " 12 │ 9.0 0.00059455 0.00116465 0.0020836\n", - " 13 │ 5.0 0.0006015 0.0008556 0.00193725\n", - " 14 │ 16.0 0.00059365 0.0008487 0.00181405\n", - " 15 │ 15.0 0.00060445 0.00073325 0.0017801\n", - " 16 │ 10.0 0.00059595 0.0006891 0.00163875\n", - " 17 │ 11.0 0.00058885 0.00074135 0.00163475\n", - " 18 │ 19.0 0.00058105 0.000686 0.00158395\n", - " 19 │ 6.0 0.0005838 0.0006695 0.00155635" + "\u001b[1m10×15 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m core \u001b[0m\u001b[1m tot \u001b[0m\u001b[1m evp_tot \u001b[0m\u001b[1m mp_tot \u001b[0m\u001b[1m sp_tot \u001b[0m\u001b[1m evp_u \u001b[0m ⋯\n", + " │\u001b[90m Any \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64?\u001b[0m ⋯\n", + "─────┼──────────────────────────────────────────────────────────────────────────\n", + " 1 │ 5.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00366885 0.047041 \u001b[90m missing \u001b[0m ⋯\n", + " 2 │ 6.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00784925 0.0445661 \u001b[90m missing \u001b[0m\n", + " 3 │ 7.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0039487 0.0476137 \u001b[90m missing \u001b[0m\n", + " 4 │ 8.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0043277 0.0468604 \u001b[90m missing \u001b[0m\n", + " 5 │ 9.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00864105 0.0524199 \u001b[90m missing \u001b[0m ⋯\n", + " 6 │ 10.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0024994 0.0048249 \u001b[90m missing \u001b[0m\n", + " 7 │ 1.0 0.0936067 0.0105024 0.00166375 0.0814405 0.\n", + " 8 │ 2.0 0.0935497 0.0092967 0.035434 0.048819 0.\n", + " 9 │ 3.0 0.0900464 0.0101539 0.0351455 0.044747 0. ⋯\n", + " 10 │ 4.0 0.0636058 0.0097476 0.0356776 0.0181806 0.\n", + "\u001b[36m 10 columns omitted\u001b[0m" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
19×15 DataFrame
Rowsubixtotevp_totmp_totsp_totevp_uevp_sevp_omp_ump_smp_finmp_osp_usp_ssp_o
AnyFloat64Float64?Float64?Float64?Float64?Float64?Float64?AnyAnyAnyAnyFloat64?Float64?Float64?
19.00.05266010.002163950.00738930.04310690.00054530.001219254.9925e-50.004356450.000732856.75e-60.002293250.01645830.002192950.0244556
216.00.04648310.00207180.006128550.03828270.000529850.00116844.66937e-50.004256050.00056684.35e-60.001301350.0156620.00185780.020763
31.00.04588360.00344090.000668850.04177390.00084840.00177550.0001021257.105e-50.000348659.6e-60.000239550.01363790.00160860.0265274
42.00.04559450.002620750.03368770.009286050.00062420.00138537.64063e-50.000100350.00036246.0e-60.0332190.000850.00158990.00684615
518.00.04450890.00231090.0017610.0404370.00054430.00137214.93125e-56.215e-50.000334.95e-60.00136390.000816350.00151640.0381043
612.00.04342710.00214780.001746250.0395330.00053970.001193855.17812e-56.195e-50.00034566.7e-60.0013320.01581020.001597150.0221257
717.00.04310380.0022720.00166430.03916750.000541150.00136584.56312e-58.25e-50.000400054.9e-60.001176850.00093840.00159870.0366304
813.00.04268110.001710150.00155480.03941610.000549550.000837854.03438e-50.00010240.000317554.25e-60.00113060.000900950.00079960.0377156
911.00.0422310.00156960.00099490.03966660.00054190.0006994.10875e-57.675e-50.000312057.25e-60.000598850.00099620.00079940.037871
1015.00.04160530.001687750.00151810.03839950.00054870.00069755.51937e-58.235e-50.000302854.35e-60.001128550.000974850.00079350.0366311
114.00.04130810.001653250.03393670.00571810.00053780.000714155.01625e-59.7e-50.0003195.0e-60.03351570.00086240.00077560.0040801
123.00.04087580.00195420.03359070.005330850.000570850.000734058.11625e-50.000100850.00036146.2e-60.03312230.000860050.001001350.00346945
1314.00.01639920.00219590.001740850.01246240.000533150.0013813.52187e-56.66e-50.00037584.85e-60.00129360.000845650.00163280.009984
147.00.01293210.00220140.00228440.008446250.000523650.00139823.49437e-58.355e-50.000560257.95e-60.001632650.000874150.002760250.00481185
1519.00.01291720.002352450.001251750.0093130.00055810.00139245.02437e-56.445e-50.00035213.75e-60.000831450.00077810.00160880.0069261
165.00.01287530.002082950.002150750.008641550.00053410.001275053.4225e-57.83e-50.00073866.35e-60.00132750.000978150.0024960.0051674
178.00.0111550.002164950.00256670.006423350.00057310.001203354.85625e-57.535e-50.000348456.95e-60.002135950.00077750.001472350.0041735
186.00.00954720.00154310.00172070.00628340.00054890.00069683.7175e-58.35e-50.00032155.35e-60.001310350.000752450.00083730.00469365
1910.00.008881150.001556850.00249940.00482490.000541150.000683954.14687e-58.01e-50.000363254.25e-60.00205180.000736850.000827050.003261
" + ], + "text/latex": [ + "\\begin{tabular}{r|ccccccccc}\n", + "\t& subix & tot & evp\\_tot & mp\\_tot & sp\\_tot & evp\\_u & evp\\_s & evp\\_o & \\\\\n", + "\t\\hline\n", + "\t& Any & Float64 & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & \\\\\n", + "\t\\hline\n", + "\t1 & 9.0 & 0.0526601 & 0.00216395 & 0.0073893 & 0.0431069 & 0.0005453 & 0.00121925 & 4.9925e-5 & $\\dots$ \\\\\n", + "\t2 & 16.0 & 0.0464831 & 0.0020718 & 0.00612855 & 0.0382827 & 0.00052985 & 0.0011684 & 4.66937e-5 & $\\dots$ \\\\\n", + "\t3 & 1.0 & 0.0458836 & 0.0034409 & 0.00066885 & 0.0417739 & 0.0008484 & 0.0017755 & 0.000102125 & $\\dots$ \\\\\n", + "\t4 & 2.0 & 0.0455945 & 0.00262075 & 0.0336877 & 0.00928605 & 0.0006242 & 0.0013853 & 7.64063e-5 & $\\dots$ \\\\\n", + "\t5 & 18.0 & 0.0445089 & 0.0023109 & 0.001761 & 0.040437 & 0.0005443 & 0.0013721 & 4.93125e-5 & $\\dots$ \\\\\n", + "\t6 & 12.0 & 0.0434271 & 0.0021478 & 0.00174625 & 0.039533 & 0.0005397 & 0.00119385 & 5.17812e-5 & $\\dots$ \\\\\n", + "\t7 & 17.0 & 0.0431038 & 0.002272 & 0.0016643 & 0.0391675 & 0.00054115 & 0.0013658 & 4.56312e-5 & $\\dots$ \\\\\n", + "\t8 & 13.0 & 0.0426811 & 0.00171015 & 0.0015548 & 0.0394161 & 0.00054955 & 0.00083785 & 4.03438e-5 & $\\dots$ \\\\\n", + "\t9 & 11.0 & 0.042231 & 0.0015696 & 0.0009949 & 0.0396666 & 0.0005419 & 0.000699 & 4.10875e-5 & $\\dots$ \\\\\n", + "\t10 & 15.0 & 0.0416053 & 0.00168775 & 0.0015181 & 0.0383995 & 0.0005487 & 0.0006975 & 5.51937e-5 & $\\dots$ \\\\\n", + "\t11 & 4.0 & 0.0413081 & 0.00165325 & 0.0339367 & 0.0057181 & 0.0005378 & 0.00071415 & 5.01625e-5 & $\\dots$ \\\\\n", + "\t12 & 3.0 & 0.0408758 & 0.0019542 & 0.0335907 & 0.00533085 & 0.00057085 & 0.00073405 & 8.11625e-5 & $\\dots$ \\\\\n", + "\t13 & 14.0 & 0.0163992 & 0.0021959 & 0.00174085 & 0.0124624 & 0.00053315 & 0.001381 & 3.52187e-5 & $\\dots$ \\\\\n", + "\t14 & 7.0 & 0.0129321 & 0.0022014 & 0.0022844 & 0.00844625 & 0.00052365 & 0.0013982 & 3.49437e-5 & $\\dots$ \\\\\n", + "\t15 & 19.0 & 0.0129172 & 0.00235245 & 0.00125175 & 0.009313 & 0.0005581 & 0.0013924 & 5.02437e-5 & $\\dots$ \\\\\n", + "\t16 & 5.0 & 0.0128753 & 0.00208295 & 0.00215075 & 0.00864155 & 0.0005341 & 0.00127505 & 3.4225e-5 & $\\dots$ \\\\\n", + "\t17 & 8.0 & 0.011155 & 0.00216495 & 0.0025667 & 0.00642335 & 0.0005731 & 0.00120335 & 4.85625e-5 & $\\dots$ \\\\\n", + "\t18 & 6.0 & 0.0095472 & 0.0015431 & 0.0017207 & 0.0062834 & 0.0005489 & 0.0006968 & 3.7175e-5 & $\\dots$ \\\\\n", + "\t19 & 10.0 & 0.00888115 & 0.00155685 & 0.0024994 & 0.0048249 & 0.00054115 & 0.00068395 & 4.14687e-5 & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m19×15 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m subix \u001b[0m\u001b[1m tot \u001b[0m\u001b[1m evp_tot \u001b[0m\u001b[1m mp_tot \u001b[0m\u001b[1m sp_tot \u001b[0m\u001b[1m evp_u \u001b[0m\u001b[1m evp_\u001b[0m ⋯\n", + " │\u001b[90m Any \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Floa\u001b[0m ⋯\n", + "─────┼──────────────────────────────────────────────────────────────────────────\n", + " 1 │ 9.0 0.0526601 0.00216395 0.0073893 0.0431069 0.0005453 0.00 ⋯\n", + " 2 │ 16.0 0.0464831 0.0020718 0.00612855 0.0382827 0.00052985 0.00\n", + " 3 │ 1.0 0.0458836 0.0034409 0.00066885 0.0417739 0.0008484 0.00\n", + " 4 │ 2.0 0.0455945 0.00262075 0.0336877 0.00928605 0.0006242 0.00\n", + " 5 │ 18.0 0.0445089 0.0023109 0.001761 0.040437 0.0005443 0.00 ⋯\n", + " 6 │ 12.0 0.0434271 0.0021478 0.00174625 0.039533 0.0005397 0.00\n", + " 7 │ 17.0 0.0431038 0.002272 0.0016643 0.0391675 0.00054115 0.00\n", + " 8 │ 13.0 0.0426811 0.00171015 0.0015548 0.0394161 0.00054955 0.00\n", + " 9 │ 11.0 0.042231 0.0015696 0.0009949 0.0396666 0.0005419 0.00 ⋯\n", + " 10 │ 15.0 0.0416053 0.00168775 0.0015181 0.0383995 0.0005487 0.00\n", + " 11 │ 4.0 0.0413081 0.00165325 0.0339367 0.0057181 0.0005378 0.00\n", + " 12 │ 3.0 0.0408758 0.0019542 0.0335907 0.00533085 0.00057085 0.00\n", + " 13 │ 14.0 0.0163992 0.0021959 0.00174085 0.0124624 0.00053315 0.00 ⋯\n", + " 14 │ 7.0 0.0129321 0.0022014 0.0022844 0.00844625 0.00052365 0.00\n", + " 15 │ 19.0 0.0129172 0.00235245 0.00125175 0.009313 0.0005581 0.00\n", + " 16 │ 5.0 0.0128753 0.00208295 0.00215075 0.00864155 0.0005341 0.00\n", + " 17 │ 8.0 0.011155 0.00216495 0.0025667 0.00642335 0.0005731 0.00 ⋯\n", + " 18 │ 6.0 0.0095472 0.0015431 0.0017207 0.0062834 0.0005489 0.00\n", + " 19 │ 10.0 0.00888115 0.00155685 0.0024994 0.0048249 0.00054115 0.00\n", + "\u001b[36m 9 columns omitted\u001b[0m" ] }, "metadata": {}, @@ -616,9 +637,9 @@ { "data": { "text/plain": [ - "Dict{Any, Any} with 21 entries:\n", + "Dict{Any, Any} with 23 entries:\n", " \"demandbalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", - " \"endvaluetimes\" => Dict{Any, Any}((1, 12)=>[0.0001711 0.0005423 0.000804…\n", + " \"endvaluetimes\" => Dict{Any, Any}((1, 12)=>[0.000158 0.0004999 0.00078; …\n", " \"resindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", " \"areanames\" => [\"SORLAND\"]\n", " \"priceindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-2…\n", @@ -629,18 +650,20 @@ " \"resnames\" => [\"Reservoir_SORLAND_hydro_reservoir\"]\n", " \"demandvalues\" => [0.0 0.0 … 0.0831064 1.40595; 0.0 0.94242 … 0.0476586…\n", " \"batindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", - " \"resmatrix\" => [14.409; 14.3628; … ; 13.6008; 13.5783;;]\n", + " \"resmatrix\" => [14.4029; 14.3558; … ; 13.7965; 13.7811;;]\n", " \"supplybalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", - " \"supplynames\" => [\"PlantResponse_SORLAND_BOLIDEN_ODDA\", \"PlantResponse…\n", + " \"supplynames\" => [\"PlantResponse_SORLAND_VALHALL\", \"Transm_SOROST->SOR…\n", " \"demandnames\" => [\"Transm_SORLAND->TELEMARK\", \"Transm_SORLAND->HAUGESU…\n", - " \"clearingtimes\" => [0.0075346 0.017705 1.24733; 0.008654 0.0155684 0.026…\n", + " \"sptimes\" => Dict{Any, Any}((1, 12)=>[0.030148 0.0006478 0.0248725…\n", + " \"clearingtimes\" => [0.0072952 0.0178427 0.0421154; 0.0071026 0.0161368 0…\n", " \"supplyvalues\" => [0.0 0.0 … 0.0 0.254503; 0.0 0.0 … 0.00267863 0.22869…\n", " \"batnames\" => String[]\n", - " \"prognosistimes\" => [11.8098 0.105411 12.0116; 11.8098 0.105411 12.0116; …\n", - " \"pricematrix\" => [0.341822; 0.341822; … ; 0.359592; 0.359592;;]" + " \"prognosistimes\" => [0.0794489 0.0940269 0.173628; 0.0 0.0 0.0; … ; 0.0 0…\n", + " \"pricematrix\" => [0.319439; 0.319439; … ; 0.320662; 0.320662;;]\n", + " \"mptimes\" => Dict{Any, Any}(5=>[8.05e-5 0.0008683 7.6e-6 0.0012767…" ] }, - "execution_count": 36, + "execution_count": 28, "metadata": {}, "output_type": "execute_result" } @@ -664,7 +687,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "9a7c42ff", "metadata": {}, "outputs": [], @@ -702,3224 +725,32 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "d7715824", "metadata": {}, "outputs": [], "source": [ - "a = 0.5\n", - "b = -4\n", - "c = 10\n", - "# a = 1\n", - "# b = 0\n", - "# c = 5\n", - "# a = 0\n", - "# b = 0\n", - "# c = 1\n", - "numscen = 7\n", - "x = collect(-numscen+1:2:numscen-1)\n", - "y = a .* x .^ 2 .+ x .* b .+ c\n", - "display(y/sum(y)) # show chosen weights" + "# a = 0.5\n", + "# b = -4\n", + "# c = 10\n", + "# # a = 1\n", + "# # b = 0\n", + "# # c = 5\n", + "# # a = 0\n", + "# # b = 0\n", + "# # c = 1\n", + "# numscen = 7\n", + "# x = collect(-numscen+1:2:numscen-1)\n", + "# y = a .* x .^ 2 .+ x .* b .+ c\n", + "# display(y/sum(y)) # show chosen weights" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "91928a2e", "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.plotly.v1+json": { - "data": [ - { - "colorbar": { - "len": 0.9231408573928259, - "title": "", - "x": 0.9950787401574803, - "y": 0.4916666666666667 - }, - "legendgroup": "SORLAND", - "line": { - "color": "rgba(0, 154, 250, 1.000)", - "dash": "solid", - "shape": "linear", - "width": 1 - }, - "mode": "lines", - "name": "SORLAND", - "showlegend": true, - "type": "scatter", - "x": [ - 63842169600000, - 63842191200000, - 63842212800000, - 63842234400000, - 63842256000000, - 63842277600000, - 63842299200000, - 63842320800000, - 63842342400000, - 63842364000000, - 63842385600000, - 63842407200000, - 63842428800000, - 63842450400000, - 63842472000000, - 63842493600000, - 63842515200000, - 63842536800000, - 63842558400000, - 63842580000000, - 63842601600000, - 63842623200000, - 63842644800000, - 63842666400000, - 63842688000000, - 63842709600000, - 63842731200000, - 63842752800000, - 63842774400000, - 63842796000000, - 63842817600000, - 63842839200000, - 63842860800000, - 63842882400000, - 63842904000000, - 63842925600000, - 63842947200000, - 63842968800000, - 63842990400000, - 63843012000000, - 63843033600000, - 63843055200000, - 63843076800000, - 63843098400000, - 63843120000000, - 63843141600000, - 63843163200000, - 63843184800000, - 63843206400000, - 63843228000000, - 63843249600000, - 63843271200000, - 63843292800000, - 63843314400000, - 63843336000000, - 63843357600000, - 63843379200000, - 63843400800000, - 63843422400000, - 63843444000000, - 63843465600000, - 63843487200000, - 63843508800000, - 63843530400000, - 63843552000000, - 63843573600000, - 63843595200000, - 63843616800000, - 63843638400000, - 63843660000000, - 63843681600000, - 63843703200000, - 63843724800000, - 63843746400000, - 63843768000000, - 63843789600000, - 63843811200000, - 63843832800000, - 63843854400000, - 63843876000000, - 63843897600000, - 63843919200000, - 63843940800000, - 63843962400000, - 63843984000000, - 63844005600000, - 63844027200000, - 63844048800000, - 63844070400000, - 63844092000000, - 63844113600000, - 63844135200000, - 63844156800000, - 63844178400000, - 63844200000000, - 63844221600000, - 63844243200000, - 63844264800000, - 63844286400000, - 63844308000000, - 63844329600000, - 63844351200000, - 63844372800000, - 63844394400000, - 63844416000000, - 63844437600000, - 63844459200000, - 63844480800000, - 63844502400000, - 63844524000000, - 63844545600000, - 63844567200000, - 63844588800000, - 63844610400000, - 63844632000000, - 63844653600000, - 63844675200000, - 63844696800000, - 63844718400000, - 63844740000000, - 63844761600000, - 63844783200000, - 63844804800000, - 63844826400000, - 63844848000000, - 63844869600000, - 63844891200000, - 63844912800000 - ], - "xaxis": "x", - "y": [ - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 36.077913759149105, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 41.02378198198199, - 43.408885585585594, - 44.25154555444965, - 44.25154555444965, - 42.33296535000001, - 44.25154555444965, - 40.5084825376739, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146, - 44.798763073389146 - ], - "yaxis": "y" - } - ], - "layout": { - "annotations": [ - { - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 20 - }, - "rotation": 0, - "showarrow": false, - "text": "Prices", - "x": 0.5206597222222222, - "xanchor": "center", - "xref": "paper", - "y": 1, - "yanchor": "top", - "yref": "paper" - } - ], - "height": 500, - "legend": { - "bgcolor": "rgba(255, 255, 255, 1.000)", - "bordercolor": "rgba(0, 0, 0, 1.000)", - "borderwidth": 1, - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "title": { - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "text": "" - }, - "tracegroupgap": 0, - "traceorder": "normal", - "x": 1, - "xanchor": "auto", - "y": 1, - "yanchor": "auto" - }, - "margin": { - "b": 20, - "l": 0, - "r": 0, - "t": 20 - }, - "paper_bgcolor": "rgba(255, 255, 255, 1.000)", - "plot_bgcolor": "rgba(255, 255, 255, 1.000)", - "showlegend": true, - "width": 800, - "xaxis": { - "anchor": "y", - "domain": [ - 0.046240704286964134, - 0.9950787401574803 - ], - "gridcolor": "rgba(0, 0, 0, 0.100)", - "gridwidth": 0.5, - "linecolor": "rgba(0, 0, 0, 1.000)", - "mirror": false, - "range": [ - 63842087304000, - 63844995096000 - ], - "showgrid": true, - "showline": true, - "showticklabels": true, - "tickangle": 0, - "tickcolor": "rgb(0, 0, 0)", - "tickfont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "tickmode": "array", - "ticks": "inside", - "ticktext": [ - "2024-01-29", - "2024-02-06", - "2024-02-14", - "2024-02-22", - "2024-03-01" - ], - "tickvals": [ - 63842169600000, - 63842860800000, - 63843552000000, - 63844243200000, - 63844934400000 - ], - "title": "", - "titlefont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "type": "-", - "visible": true, - "zeroline": false, - "zerolinecolor": "rgba(0, 0, 0, 1.000)" - }, - "yaxis": { - "anchor": "x", - "domain": [ - 0.030096237970253722, - 0.9532370953630797 - ], - "gridcolor": "rgba(0, 0, 0, 0.100)", - "gridwidth": 0.5, - "linecolor": "rgba(0, 0, 0, 1.000)", - "mirror": false, - "range": [ - 35.8162882797219, - 45.06038855281635 - ], - "showgrid": true, - "showline": true, - "showticklabels": true, - "tickangle": 0, - "tickcolor": "rgb(0, 0, 0)", - "tickfont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "tickmode": "array", - "ticks": "inside", - "ticktext": [ - "36", - "38", - "40", - "42", - "44" - ], - "tickvals": [ - 36, - 38, - 40, - 42, - 44 - ], - "title": "€/MWh", - "titlefont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "type": "-", - "visible": true, - "zeroline": false, - "zerolinecolor": "rgba(0, 0, 0, 1.000)" - } - } - }, - "image/png": "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", - "image/svg+xml": [ - "2024-01-292024-02-062024-02-142024-02-222024-03-013638404244SORLAND€/MWhPrices" - ], - "text/html": [ - "
\n", - " \n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.plotly.v1+json": { - "data": [ - { - "colorbar": { - "len": 0.9231408573928259, - "title": "", - "x": 0.4950787401574803, - "y": 0.4916666666666667 - }, - "fill": "tozeroy", - "fillcolor": "rgba(0, 154, 250, 1.000)", - "legendgroup": "y1", - "line": { - "color": "rgba(0, 154, 250, 1.000)", - "dash": "solid", - "shape": "linear", - "width": 1 - }, - "mode": "lines", - "name": "y1", - "showlegend": true, - "type": "scatter", - "x": [ - 63842169600000, - 63842191200000, - 63842212800000, - 63842234400000, - 63842256000000, - 63842277600000, - 63842299200000, - 63842320800000, - 63842342400000, - 63842364000000, - 63842385600000, - 63842407200000, - 63842428800000, - 63842450400000, - 63842472000000, - 63842493600000, - 63842515200000, - 63842536800000, - 63842558400000, - 63842580000000, - 63842601600000, - 63842623200000, - 63842644800000, - 63842666400000, - 63842688000000, - 63842709600000, - 63842731200000, - 63842752800000, - 63842774400000, - 63842796000000, - 63842817600000, - 63842839200000, - 63842860800000, - 63842882400000, - 63842904000000, - 63842925600000, - 63842947200000, - 63842968800000, - 63842990400000, - 63843012000000, - 63843033600000, - 63843055200000, - 63843076800000, - 63843098400000, - 63843120000000, - 63843141600000, - 63843163200000, - 63843184800000, - 63843206400000, - 63843228000000, - 63843249600000, - 63843271200000, - 63843292800000, - 63843314400000, - 63843336000000, - 63843357600000, - 63843379200000, - 63843400800000, - 63843422400000, - 63843444000000, - 63843465600000, - 63843487200000, - 63843508800000, - 63843530400000, - 63843552000000, - 63843573600000, - 63843595200000, - 63843616800000, - 63843638400000, - 63843660000000, - 63843681600000, - 63843703200000, - 63843724800000, - 63843746400000, - 63843768000000, - 63843789600000, - 63843811200000, - 63843832800000, - 63843854400000, - 63843876000000, - 63843897600000, - 63843919200000, - 63843940800000, - 63843962400000, - 63843984000000, - 63844005600000, - 63844027200000, - 63844048800000, - 63844070400000, - 63844092000000, - 63844113600000, - 63844135200000, - 63844156800000, - 63844178400000, - 63844200000000, - 63844221600000, - 63844243200000, - 63844264800000, - 63844286400000, - 63844308000000, - 63844329600000, - 63844351200000, - 63844372800000, - 63844394400000, - 63844416000000, - 63844437600000, - 63844459200000, - 63844480800000, - 63844502400000, - 63844524000000, - 63844545600000, - 63844567200000, - 63844588800000, - 63844610400000, - 63844632000000, - 63844653600000, - 63844675200000, - 63844696800000, - 63844718400000, - 63844740000000, - 63844761600000, - 63844783200000, - 63844804800000, - 63844826400000, - 63844848000000, - 63844869600000, - 63844891200000, - 63844912800000 - ], - "xaxis": "x1", - "y": [ - 6.574205001267109, - 8.127919975707236, - 7.297916032490041, - 7.794421672298373, - 6.535733359200007, - 7.279753035145999, - 7.98648688425669, - 7.454511335063038, - 7.289926181087705, - 7.516003694108415, - 6.986900627306799, - 6.898543303852239, - 6.563634872115653, - 7.387050279804364, - 7.789243229326251, - 6.976999506360899, - 7.502311081114395, - 7.627640670767589, - 8.21850218315144, - 7.18260706913734, - 6.743482923077907, - 7.017688007951819, - 7.683371670725411, - 7.926854064373792, - 7.284295041326425, - 7.686308431687609, - 6.953761089821539, - 6.9953709233147885, - 6.719525351819637, - 8.421679954245427, - 8.499619927870189, - 7.380382548030014, - 6.697823548703533, - 8.431385948166096, - 7.444637666505756, - 8.23656454472441, - 7.515128305836559, - 7.970056510241287, - 7.895675065481881, - 8.432618937817635, - 6.798251960742744, - 8.255303607756796, - 8.652108072562427, - 8.751871399483404, - 5.829770178693131, - 8.97735578120521, - 8.288987918649218, - 7.181288867720242, - 7.186063889814587, - 6.95277436631325, - 7.600249645158159, - 7.009546747479446, - 6.719434650714582, - 6.826962776557851, - 7.4569206418999405, - 7.812353827019493, - 6.767945446962029, - 8.434716816571342, - 8.547076808128832, - 7.488950184166062, - 6.793727822671071, - 8.366870970869615, - 8.463500233791162, - 7.299184968131016, - 7.3491578787414396, - 7.65660128496186, - 7.5899434751239365, - 8.210120829778774, - 7.345358693892994, - 7.864706115128738, - 7.693700337994396, - 8.565632135580547, - 7.4805555279776685, - 7.937981160294842, - 8.171315997331787, - 7.211249540520038, - 6.606935739274011, - 6.820735356426445, - 7.386804576813753, - 7.527179647959425, - 6.897741918731258, - 6.668495942219161, - 7.3585494049598354, - 6.79610455846497, - 6.621825130418569, - 8.033228941596228, - 7.116877588749005, - 7.59844128352876, - 7.359249069165777, - 7.199152090788555, - 6.845672990191558, - 7.007578637183952, - 5.996867163607161, - 6.768583820448072, - 7.022827052680558, - 7.503226679763787, - 6.422560628573476, - 6.769130573215708, - 7.489405588144041, - 6.900518623098074, - 5.752346279637653, - 6.821999189451523, - 6.087309092418224, - 6.582419033174865, - 5.030316214581194, - 4.827968972274853, - 5.0824851119626455, - 5.029103164702669, - 4.5195876442824385, - 4.902683820448072, - 5.267007210516158, - 5.8967680357068195, - 6.972298824359173, - 7.2898262194792505, - 6.68446086842047, - 6.689328580606076, - 7.010743521313239, - 6.988276518401495, - 7.607733953383641, - 6.748083562155154, - 7.16674218872149, - 7.6115482147834435, - 7.0215813858160745, - 7.028653865720258, - 7.261733447811021, - 7.401695852068862, - 7.989287844795312, - 7.107355316565722 - ], - "yaxis": "y1" - }, - { - "colorbar": { - "len": 0.9231408573928259, - "title": "", - "x": 0.9950787401574803, - "y": 0.4916666666666667 - }, - "fill": "tozeroy", - "fillcolor": "rgba(0, 154, 250, 1.000)", - "legendgroup": "y1", - "line": { - "color": "rgba(0, 154, 250, 1.000)", - "dash": "solid", - "shape": "linear", - "width": 1 - }, - "mode": "lines", - "name": "y1", - "showlegend": true, - "type": "scatter", - "x": [ - 63842169600000, - 63842191200000, - 63842212800000, - 63842234400000, - 63842256000000, - 63842277600000, - 63842299200000, - 63842320800000, - 63842342400000, - 63842364000000, - 63842385600000, - 63842407200000, - 63842428800000, - 63842450400000, - 63842472000000, - 63842493600000, - 63842515200000, - 63842536800000, - 63842558400000, - 63842580000000, - 63842601600000, - 63842623200000, - 63842644800000, - 63842666400000, - 63842688000000, - 63842709600000, - 63842731200000, - 63842752800000, - 63842774400000, - 63842796000000, - 63842817600000, - 63842839200000, - 63842860800000, - 63842882400000, - 63842904000000, - 63842925600000, - 63842947200000, - 63842968800000, - 63842990400000, - 63843012000000, - 63843033600000, - 63843055200000, - 63843076800000, - 63843098400000, - 63843120000000, - 63843141600000, - 63843163200000, - 63843184800000, - 63843206400000, - 63843228000000, - 63843249600000, - 63843271200000, - 63843292800000, - 63843314400000, - 63843336000000, - 63843357600000, - 63843379200000, - 63843400800000, - 63843422400000, - 63843444000000, - 63843465600000, - 63843487200000, - 63843508800000, - 63843530400000, - 63843552000000, - 63843573600000, - 63843595200000, - 63843616800000, - 63843638400000, - 63843660000000, - 63843681600000, - 63843703200000, - 63843724800000, - 63843746400000, - 63843768000000, - 63843789600000, - 63843811200000, - 63843832800000, - 63843854400000, - 63843876000000, - 63843897600000, - 63843919200000, - 63843940800000, - 63843962400000, - 63843984000000, - 63844005600000, - 63844027200000, - 63844048800000, - 63844070400000, - 63844092000000, - 63844113600000, - 63844135200000, - 63844156800000, - 63844178400000, - 63844200000000, - 63844221600000, - 63844243200000, - 63844264800000, - 63844286400000, - 63844308000000, - 63844329600000, - 63844351200000, - 63844372800000, - 63844394400000, - 63844416000000, - 63844437600000, - 63844459200000, - 63844480800000, - 63844502400000, - 63844524000000, - 63844545600000, - 63844567200000, - 63844588800000, - 63844610400000, - 63844632000000, - 63844653600000, - 63844675200000, - 63844696800000, - 63844718400000, - 63844740000000, - 63844761600000, - 63844783200000, - 63844804800000, - 63844826400000, - 63844848000000, - 63844869600000, - 63844891200000, - 63844912800000 - ], - "xaxis": "x2", - "y": [ - 6.57420500126711, - 8.127919975707234, - 7.297916032490039, - 7.794421672298372, - 6.535733359200007, - 7.279753035145998, - 7.986486884256689, - 7.454511335063038, - 7.289926181087706, - 7.516003694108413, - 6.986900627306799, - 6.898543303852239, - 6.563634872115653, - 7.387050279804364, - 7.789243229326251, - 6.976999506360899, - 7.502311081114395, - 7.627640670767587, - 8.21850218315144, - 7.182607069137341, - 6.743482923077907, - 7.01768800795182, - 7.683371670725411, - 7.926854064373793, - 7.284295041326425, - 7.686308431687608, - 6.95376108982154, - 6.9953709233147885, - 6.719525351819638, - 8.421679954245427, - 8.49961992787019, - 7.380382548030014, - 6.697823548703532, - 8.431385948166094, - 7.444637666505754, - 8.23656454472441, - 7.51512830583656, - 7.970056510241287, - 7.895675065481881, - 8.432618937817635, - 6.7982519607427445, - 8.255303607756796, - 8.652108072562427, - 8.751871399483402, - 5.82977017869313, - 8.97735578120521, - 8.288987918649218, - 7.181288867720241, - 7.186063889814587, - 6.95277436631325, - 7.600249645158159, - 7.009546747479446, - 6.719434650714582, - 6.826962776557852, - 7.4569206418999405, - 7.812353827019493, - 6.76794544696203, - 8.43471681657134, - 8.547076808128832, - 7.488950184166062, - 6.793727822671071, - 8.366870970869615, - 8.463500233791164, - 7.299184968131016, - 7.3491578787414396, - 7.656601284961859, - 7.5899434751239365, - 8.210120829778774, - 7.345358693892994, - 7.8647061151287385, - 7.693700337994396, - 8.56563213558055, - 7.4805555279776685, - 7.937981160294842, - 8.171315997331789, - 7.211249540520037, - 6.60693573927401, - 6.820735356426446, - 7.386804576813753, - 7.527179647959424, - 6.897741918731257, - 6.66849594221916, - 7.358549404959835, - 6.79610455846497, - 6.621825130418568, - 8.033228941596228, - 7.116877588749005, - 7.59844128352876, - 7.359249069165777, - 7.199152090788554, - 6.845672990191558, - 7.007578637183953, - 5.9968671636071615, - 6.768583820448072, - 7.022827052680558, - 7.503226679763787, - 6.422560628573476, - 6.769130573215709, - 7.489405588144042, - 6.900518623098073, - 5.752346279637653, - 6.821999189451522, - 6.087309092418223, - 6.582419033174864, - 5.030316214581195, - 4.827968972274853, - 5.082485111962646, - 5.02910316470267, - 4.5195876442824385, - 4.902683820448071, - 5.267007210516157, - 5.896768035706819, - 6.972298824359174, - 7.2898262194792505, - 6.68446086842047, - 6.689328580606076, - 7.01074352131324, - 6.988276518401497, - 7.607733953383642, - 6.748083562155154, - 7.16674218872149, - 7.6115482147834435, - 7.0215813858160745, - 7.028653865720258, - 7.261733447811021, - 7.40169585206886, - 7.989287844795312, - 7.107355316565721 - ], - "yaxis": "y2" - } - ], - "layout": { - "annotations": [ - { - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 20 - }, - "rotation": 0, - "showarrow": false, - "text": "Supply", - "x": 0.2651041666666667, - "xanchor": "center", - "xref": "paper", - "y": 1, - "yanchor": "top", - "yref": "paper" - }, - { - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 20 - }, - "rotation": 0, - "showarrow": false, - "text": "Demand", - "x": 0.7651041666666667, - "xanchor": "center", - "xref": "paper", - "y": 1, - "yanchor": "top", - "yref": "paper" - } - ], - "height": 500, - "legend": { - "bgcolor": "rgba(255, 255, 255, 1.000)", - "bordercolor": "rgba(0, 0, 0, 1.000)", - "borderwidth": 1, - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "title": { - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "text": "" - }, - "tracegroupgap": 0, - "traceorder": "normal", - "x": 1, - "xanchor": "auto", - "y": 1, - "yanchor": "auto" - }, - "margin": { - "b": 20, - "l": 0, - "r": 0, - "t": 20 - }, - "paper_bgcolor": "rgba(255, 255, 255, 1.000)", - "plot_bgcolor": "rgba(255, 255, 255, 1.000)", - "showlegend": true, - "width": 800, - "xaxis1": { - "anchor": "y1", - "domain": [ - 0.03512959317585302, - 0.4950787401574803 - ], - "gridcolor": "rgba(0, 0, 0, 0.100)", - "gridwidth": 0.5, - "linecolor": "rgba(0, 0, 0, 1.000)", - "mirror": false, - "range": [ - 63842087304000, - 63844995096000 - ], - "showgrid": true, - "showline": true, - "showticklabels": true, - "tickangle": 0, - "tickcolor": "rgb(0, 0, 0)", - "tickfont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "tickmode": "array", - "ticks": "inside", - "ticktext": [ - "2024-01-29", - "2024-02-06", - "2024-02-14", - "2024-02-22", - "2024-03-01" - ], - "tickvals": [ - 63842169600000, - 63842860800000, - 63843552000000, - 63844243200000, - 63844934400000 - ], - "title": "", - "titlefont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "type": "-", - "visible": true, - "zeroline": false, - "zerolinecolor": "rgba(0, 0, 0, 1.000)" - }, - "xaxis2": { - "anchor": "y2", - "domain": [ - 0.5351295931758531, - 0.9950787401574803 - ], - "gridcolor": "rgba(0, 0, 0, 0.100)", - "gridwidth": 0.5, - "linecolor": "rgba(0, 0, 0, 1.000)", - "mirror": false, - "range": [ - 63842087304000, - 63844995096000 - ], - "showgrid": true, - "showline": true, - "showticklabels": true, - "tickangle": 0, - "tickcolor": "rgb(0, 0, 0)", - "tickfont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "tickmode": "array", - "ticks": "inside", - "ticktext": [ - "2024-01-29", - "2024-02-06", - "2024-02-14", - "2024-02-22", - "2024-03-01" - ], - "tickvals": [ - 63842169600000, - 63842860800000, - 63843552000000, - 63844243200000, - 63844934400000 - ], - "title": "", - "titlefont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "type": "-", - "visible": true, - "zeroline": false, - "zerolinecolor": "rgba(0, 0, 0, 1.000)" - }, - "yaxis1": { - "anchor": "x1", - "domain": [ - 0.030096237970253722, - 0.9532370953630797 - ], - "gridcolor": "rgba(0, 0, 0, 0.100)", - "gridwidth": 0.5, - "linecolor": "rgba(0, 0, 0, 1.000)", - "mirror": false, - "range": [ - -0.2693206734361562, - 9.246676454641367 - ], - "showgrid": true, - "showline": true, - "showticklabels": true, - "tickangle": 0, - "tickcolor": "rgb(0, 0, 0)", - "tickfont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "tickmode": "array", - "ticks": "inside", - "ticktext": [ - "0", - "2", - "4", - "6", - "8" - ], - "tickvals": [ - 0, - 2, - 4, - 6, - 8 - ], - "title": "GWh/h", - "titlefont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "type": "-", - "visible": true, - "zeroline": false, - "zerolinecolor": "rgba(0, 0, 0, 1.000)" - }, - "yaxis2": { - "anchor": "x2", - "domain": [ - 0.030096237970253722, - 0.9532370953630797 - ], - "gridcolor": "rgba(0, 0, 0, 0.100)", - "gridwidth": 0.5, - "linecolor": "rgba(0, 0, 0, 1.000)", - "mirror": false, - "range": [ - -0.2693206734361562, - 9.246676454641367 - ], - "showgrid": true, - "showline": true, - "showticklabels": true, - "tickangle": 0, - "tickcolor": "rgb(0, 0, 0)", - "tickfont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "tickmode": "array", - "ticks": "inside", - "ticktext": [ - "0", - "2", - "4", - "6", - "8" - ], - "tickvals": [ - 0, - 2, - 4, - 6, - 8 - ], - "title": "GWh/h", - "titlefont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "type": "-", - "visible": true, - "zeroline": false, - "zerolinecolor": "rgba(0, 0, 0, 1.000)" - } - } - }, - "image/png": "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", - "image/svg+xml": [ - "2024-01-292024-02-062024-02-142024-02-222024-03-01024682024-01-292024-02-062024-02-142024-02-222024-03-0102468y1y1GWh/hGWh/hSupplyDemand" - ], - "text/html": [ - "
\n", - " \n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.plotly.v1+json": { - "data": [ - { - "colorbar": { - "len": 0.9231408573928259, - "title": "", - "x": 0.9950787401574803, - "y": 0.4916666666666667 - }, - "fill": "tozeroy", - "fillcolor": "rgba(0, 154, 250, 1.000)", - "legendgroup": "Total", - "line": { - "color": "rgba(0, 154, 250, 1.000)", - "dash": "solid", - "shape": "linear", - "width": 1 - }, - "mode": "lines", - "name": "Total", - "showlegend": true, - "type": "scatter", - "x": [ - 63842169600000, - 63842256000000, - 63842342400000, - 63842428800000, - 63842515200000, - 63842601600000, - 63842688000000, - 63842774400000, - 63842860800000, - 63842947200000, - 63843033600000, - 63843120000000, - 63843206400000, - 63843292800000, - 63843379200000, - 63843465600000, - 63843552000000, - 63843638400000, - 63843724800000, - 63843811200000, - 63843897600000, - 63843984000000, - 63844070400000, - 63844156800000, - 63844243200000, - 63844329600000, - 63844416000000, - 63844502400000, - 63844588800000, - 63844675200000, - 63844761600000, - 63844848000000 - ], - "xaxis": "x", - "y": [ - 14.409031274336677, - 14.36262495225929, - 14.330842384122917, - 14.294818689739392, - 14.243065911083718, - 14.207218407343296, - 14.190789608248169, - 14.155870351812858, - 14.10644191060808, - 14.055599828366002, - 13.998144476354637, - 13.968770460057417, - 13.98375136399022, - 13.983376035310599, - 13.928849322243597, - 13.87020102280702, - 13.811810294351298, - 13.750929231499354, - 13.689344505660742, - 13.652756202388481, - 13.642955885586733, - 13.597977460971473, - 13.567305422156048, - 13.574377487146075, - 13.599006307037294, - 13.659088028108538, - 13.740597265866741, - 13.817289123775776, - 13.838191083395875, - 13.853051374017568, - 13.850012291700734, - 13.834597819421704 - ], - "yaxis": "y" - } - ], - "layout": { - "annotations": [ - { - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 20 - }, - "rotation": 0, - "showarrow": false, - "text": "Reservoir levels", - "x": 0.5206597222222222, - "xanchor": "center", - "xref": "paper", - "y": 1, - "yanchor": "top", - "yref": "paper" - } - ], - "height": 500, - "legend": { - "bgcolor": "rgba(255, 255, 255, 1.000)", - "bordercolor": "rgba(0, 0, 0, 1.000)", - "borderwidth": 1, - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "title": { - "font": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "text": "" - }, - "tracegroupgap": 0, - "traceorder": "normal", - "x": 1, - "xanchor": "auto", - "y": 1, - "yanchor": "auto" - }, - "margin": { - "b": 20, - "l": 0, - "r": 0, - "t": 20 - }, - "paper_bgcolor": "rgba(255, 255, 255, 1.000)", - "plot_bgcolor": "rgba(255, 255, 255, 1.000)", - "showlegend": true, - "width": 800, - "xaxis": { - "anchor": "y", - "domain": [ - 0.046240704286964134, - 0.9950787401574803 - ], - "gridcolor": "rgba(0, 0, 0, 0.100)", - "gridwidth": 0.5, - "linecolor": "rgba(0, 0, 0, 1.000)", - "mirror": false, - "range": [ - 63842089248000, - 63844928352000 - ], - "showgrid": true, - "showline": true, - "showticklabels": true, - "tickangle": 0, - "tickcolor": "rgb(0, 0, 0)", - "tickfont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "tickmode": "array", - "ticks": "inside", - "ticktext": [ - "2024-01-29", - "2024-02-06", - "2024-02-14", - "2024-02-22" - ], - "tickvals": [ - 63842169600000, - 63842860800000, - 63843552000000, - 63844243200000 - ], - "title": "", - "titlefont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "type": "-", - "visible": true, - "zeroline": false, - "zerolinecolor": "rgba(0, 0, 0, 1.000)" - }, - "yaxis": { - "anchor": "x", - "domain": [ - 0.030096237970253722, - 0.9532370953630797 - ], - "gridcolor": "rgba(0, 0, 0, 0.100)", - "gridwidth": 0.5, - "linecolor": "rgba(0, 0, 0, 1.000)", - "mirror": false, - "range": [ - -0.43227093823010065, - 14.841302212566777 - ], - "showgrid": true, - "showline": true, - "showticklabels": true, - "tickangle": 0, - "tickcolor": "rgb(0, 0, 0)", - "tickfont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 11 - }, - "tickmode": "array", - "ticks": "inside", - "ticktext": [ - "0", - "3", - "6", - "9", - "12" - ], - "tickvals": [ - 0, - 3, - 6, - 9, - 12 - ], - "title": "TWh", - "titlefont": { - "color": "rgba(0, 0, 0, 1.000)", - "family": "sans-serif", - "size": 15 - }, - "type": "-", - "visible": true, - "zeroline": false, - "zerolinecolor": "rgba(0, 0, 0, 1.000)" - } - } - }, - "image/png": "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", - "image/svg+xml": [ - "2024-01-292024-02-062024-02-142024-02-22036912TotalTWhReservoir levels" - ], - "text/html": [ - "
\n", - " \n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "┌────────────────────────────────────────┬───────────────────┬─────────────────────────────────┬───────────────────┐\n", - "│\u001b[1m Supplyname \u001b[0m│\u001b[1m Yearly_supply_TWh \u001b[0m│\u001b[1m Demandname \u001b[0m│\u001b[1m Yearly_demand_TWh \u001b[0m│\n", - "│\u001b[90m String? \u001b[0m│\u001b[90m Float64? \u001b[0m│\u001b[90m String? \u001b[0m│\u001b[90m Float64? \u001b[0m│\n", - "├────────────────────────────────────────┼───────────────────┼─────────────────────────────────┼───────────────────┤\n", - "│ Plant_SORLAND_hydro_reservoir │ 36.7721 │ Demand_SORLAND_BYGG │ 14.8538 │\n", - "│ Plant_SORLAND_hydro_RoR │ 13.6804 │ Transm_SORLAND->DANM-DK1 │ 12.5196 │\n", - "│ Transm_TELEMARK->SORLAND │ 7.2327 │ Transm_SORLAND->UK │ 11.388 │\n", - "│ Fixed_EMPS4_wind_onshore_stock │ 4.48969 │ Transm_SORLAND->TYSKLAND │ 8.91056 │\n", - "│ Transm_DANM-DK1->SORLAND │ 0.447081 │ Transm_SORLAND->NEDERLAND │ 5.4312 │\n", - "│ Fixed_NO2_CHP_Pub │ 0.181956 │ Transm_SORLAND->HAUGESUND │ 3.32798 │\n", - "│ Plant_NO2_NY │ 0.170294 │ Transm_SORLAND->SOROST │ 1.21162 │\n", - "│ Transm_TYSKLAND->SORLAND │ 0.155527 │ Demand_SORLAND_ALU_LISTA01 │ 1.1388 │\n", - "│ Fixed_EMPS4_solar_stock │ 0.0532551 │ Demand_SORLAND_BOLIDEN_ODDA │ 1.03368 │\n", - "│ Transm_HAUGESUND->SORLAND │ 0.023192 │ Demand_SORLAND_ERAMET_KVINESDAL │ 0.877905 │\n", - "│ PlantResponse_SORLAND_GLENCORE │ 0.0 │ Demand_SORLAND_TRANSPORT │ 0.61272 │\n", - "│ PlantResponse_SORLAND_FIVEN_NORGE │ 0.0 │ Demand_SORLAND_GLENCORE │ 0.568056 │\n", - "│ Transm_SOROST->SORLAND │ 0.0 │ Demand_SORLAND_VALHALL │ 0.413472 │\n", - "│ PlantResponse_SORLAND_VALHALL │ 0.0 │ Demand_SORLAND_TIZIR │ 0.382147 │\n", - "│ PlantResponse_SORLAND_HYDROGEN_91 │ 0.0 │ Demand_SORLAND_DATASENTER │ 0.221628 │\n", - "│ PlantResponse_SORLAND_ALU_LISTA01 │ 0.0 │ Demand_SORLAND_FIVEN_NORGE │ 0.185909 │\n", - "│ PlantResponse_SORLAND_ELKEM_CARBON │ 0.0 │ Demand_SORLAND_ELKEM_CARBON │ 0.103283 │\n", - "│ PlantResponse_SORLAND_BOLIDEN_ODDA │ 0.0 │ Demand_SORLAND_HYDROGEN_IND2 │ 0.0258207 │\n", - "│ PlantResponse_SORLAND_ERAMET_KVINESDAL │ 0.0 │ SlackVar_PowerBalance_SORLAND │ 0.0 │\n", - "│ PlantResponse_SORLAND_HYDROGEN_IND │ 0.0 │ Transm_SORLAND->TELEMARK │ 0.0 │\n", - "│ PlantResponse_SORLAND_BYGG │ 0.0 │ missing │ missing │\n", - "│ PlantResponse_SORLAND_MORROW │ 0.0 │ missing │ missing │\n", - "│ PlantResponse_SORLAND_TIZIR │ 0.0 │ missing │ missing │\n", - "│ Transm_UK->SORLAND │ 0.0 │ missing │ missing │\n", - "│ PlantResponse_SORLAND_TRANSPORT │ 0.0 │ missing │ missing │\n", - "│ PlantResponse_SORLAND_HYDROGEN_IND2 │ 0.0 │ missing │ missing │\n", - "│ Transm_NEDERLAND->SORLAND │ 0.0 │ missing │ missing │\n", - "│ PlantResponse_SORLAND_DATASENTER │ 0.0 │ missing │ missing │\n", - "└────────────────────────────────────────┴───────────────────┴─────────────────────────────────┴───────────────────┘\n", - "┌───────────────────────────────────┬───────────────────────────────────┐\n", - "│\u001b[1m Yearly_supply_TWh_sum_skipmissing \u001b[0m│\u001b[1m Yearly_demand_TWh_sum_skipmissing \u001b[0m│\n", - "│\u001b[90m Float64 \u001b[0m│\u001b[90m Float64 \u001b[0m│\n", - "├───────────────────────────────────┼───────────────────────────────────┤\n", - "│ 63.2062 │ 63.2062 │\n", - "└───────────────────────────────────┴───────────────────────────────────┘\n", - "┌──────────────────────────────────┬───────────────────────────────────┐\n", - "│\u001b[1m Yearly_rev_mill€_sum_skipmissing \u001b[0m│\u001b[1m Yearly_cost_mill€_sum_skipmissing \u001b[0m│\n", - "│\u001b[90m Float64 \u001b[0m│\u001b[90m Float64 \u001b[0m│\n", - "├──────────────────────────────────┼───────────────────────────────────┤\n", - "│ 25.3962 │ 25.3962 │\n", - "└──────────────────────────────────┴───────────────────────────────────┘\n" - ] - } - ], + "outputs": [], "source": [ "# Plot prices\n", "idxwohub = findall(x -> !occursin(\"HUB\", x), powerbalancenames) # remove hubs, not active in 2025 dataset\n", @@ -4013,14 +844,6 @@ "metadata": {}, "outputs": [], "source": [] - }, - { - "cell_type": "code", - "execution_count": null, - "id": "9f7dd342", - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { diff --git a/demos/data/config_jules_prognose_demo.yml b/demos/data/config_jules_prognose_demo.yml new file mode 100644 index 0000000..0fb8b51 --- /dev/null +++ b/demos/data/config_jules_prognose_demo.yml @@ -0,0 +1,267 @@ +main: + inputpath: "\\\\e-srv10\\X\\Prosjekter\\2022_FoU_markedsmodell_julia\\prognosemodell\\prognoser" + numcores: 10 #8 #6 #5 # kjerner per scenario + + datayears: [2024] + weatheryears: [1991, 1991] + weekstart: 5 + # simulationyears: 1 + # extrasteps: 0 # see steplength_hours + + # settings: fast # fast, threehour, sixhour + + simulationyears: 0 + extrasteps: 16 # see steplength_hours + + settings: fast # fast, threehour + + outputformat: "juliadict" # hdf5 hvis du kjører gjennom JulESIO + outputindex: datayear # standard for paralellsimulering + + +############################################################# +threehour: + time: + weatheryearstart: 1991 + weatheryearstop: 2021 + probtime: + normaltime: PrognosisTime + phaseintime: PhaseinPrognosisTime + phaseindelta_days: 7 + phaseinsteps: 7 + + skipmax: 4 # how many steps should the watervalues be reused / at what interval should new watervalues be calculated + problems: + prognosis: + aggsupplyn: 4 + residualarealist: [] + shorttermstoragecutoff_hours: 10 + long: + solver: HighsSimplexMethod() + med: + solver: HighsSimplexMethod() + short: + solver: HighsSimplexMethod(warmstart=false) + startstorages: + function: aggstartmagdict + endvalue: + solver: HighsSimplexMethod() + startstorages: + function: startmagdict + stochastic: + maxcuts: 13 + lb: -100000.0 + reltol: 0.0001 + master: + solver: HighsSimplexMethod() + subs: + solver: HighsSimplexMethod() + startstorages: + function: startmagdict + + distribution_method: greedy #random #by_size #greedy + clearing: + solver: HighsSimplexMethod(warmstart=false) + statedependentprod: true + statedependentpump: true + headlosscost: true + scenariogeneration: + stochastic: + function: InflowClusteringMethod + numscen: 7 + scendelta_days: 365 + parts: 4 + # function: SumInflowQuantileMethod + # numscen: 7 + # scendelta_days: 365 + # maxquantile: 0.95 + # usedensity: true + # a: 0.5 + # b: -4 + # c: 10 + # a: 1 + # b: 0 + # c: 5 + # a: 0 + # b: 0 + # c: 1 + subsystems: + function: twostorageduration # dataset, twostorageduration + shorttermstoragecutoff_hours: 10 + shortstochduration_hours: 168 + longstochduration_days: 91 + longevduration_days: 721 + + + horizons: + commodities: ["Hydro", "Power"] + shrinkable: + startafter_days: 91 # clear + short + med + shrinkatleast_days: 360 # (longperiod - clear)*9 + long: + termduration_weeks: 198 # 42*33 = 198 weeks (211 total) + shrinkable: true + Hydro: + function: SequentialHorizon + periodduration_days: 42 + Power: + function: AdaptiveHorizon + macro: Hydro + rhsdata: + function: DynamicExogenPriceAHData + balance: PowerBalance_TYSKLAND + rhsmethod: KMeansAHMethod() + clusters: 4 + unitduration_hours: 6 + med: + termduration_days: 84 # 7*12 = 42*2 = 12 weeks (13 total) + Hydro: + function: SequentialHorizon + periodduration_days: 7 + Power: + function: AdaptiveHorizon + macro: Hydro + rhsdata: + function: DynamicExogenPriceAHData + balance: PowerBalance_TYSKLAND + rhsmethod: KMeansAHMethod() + clusters: 4 + unitduration_hours: 4 + short: + termduration_hours: 120 # 5 days (7 total) + Hydro: + function: SequentialHorizon + periodduration_hours: 24 + Power: + function: SequentialHorizon + periodduration_hours: 3 + clearing: + termduration_hours: 48 # 2 days + Hydro: + function: SequentialHorizon + periodduration_hours: 6 + Power: + function: SequentialHorizon + periodduration_hours: 3 + results: + mainresults: ["SORLAND"] + times: true + storagevalues: true + memory: false + + + +############################################################# +fast: # 24 hour steps, 7 static scenarios, aggregated hydro, shrinkablehorizon, no phasein, 1 year long, 18 week med, 2 day short + time: + weatheryearstart: 1991 + weatheryearstop: 2021 + probtime: + normaltime: PrognosisTime + phaseintime: PrognosisTime + phaseindelta_days: 7 + phaseinsteps: 7 + + skipmax: 8 # how many steps should the watervalues be reused / at what interval should new watervalues be calculated + problems: + onlyagghydro: true + prognosis: + aggsupplyn: 4 + residualarealist: [] + shorttermstoragecutoff_hours: 10 + long: + solver: HighsSimplexMethod() + med: + solver: HighsSimplexMethod() + short: + solver: HighsSimplexMethod(warmstart=false) + startstorages: + function: aggstartmagdict + endvalue: + solver: HighsSimplexMethod() + startstorages: + function: startmagdict + stochastic: + maxcuts: 13 + lb: -100000.0 + reltol: 0.0001 + master: + solver: HighsSimplexMethod() + subs: + solver: HighsSimplexMethod() + startstorages: + function: startmagdict + distribution_method: storage #random #by_size #greedy + clearing: + solver: HighsSimplexMethod(warmstart=false) + statedependentprod: false + statedependentpump: false + headlosscost: false + scenariogeneration: + simulation: + function: InflowClusteringMethod + numscen: 4 #5 #7 + scendelta_days: 1095 + parts: 4 + subsystems: + function: twostorageduration # dataset, twostorageduration + shorttermstoragecutoff_hours: 10 + shortstochduration_hours: 168 + longstochduration_days: 91 + longevduration_days: 343 + + horizons: + commodities: ["Hydro", "Power"] + shrinkable: + startafter_days: 91 # clear + short + med + shrinkatleast_days: 160 # (longperiod - clear)*4 + long: + termduration_weeks: 54 # 9*42 = 54 weeks (67 total) + shrinkable: true + Hydro: + function: SequentialHorizon + periodduration_days: 42 + Power: + function: AdaptiveHorizon + macro: Hydro + rhsdata: + function: DynamicExogenPriceAHData + balance: PowerBalance_TYSKLAND + rhsmethod: KMeansAHMethod() + clusters: 4 + unitduration_hours: 12 + med: + termduration_days: 84 # 7*12 = 42*2 = 12 weeks (13 total) + Hydro: + function: SequentialHorizon + periodduration_days: 7 + Power: + function: AdaptiveHorizon + macro: Hydro + rhsdata: + function: DynamicExogenPriceAHData + balance: PowerBalance_TYSKLAND + rhsmethod: KMeansAHMethod() + clusters: 4 + unitduration_hours: 6 + short: + termduration_hours: 120 # 5 days (7 total) + Hydro: + function: SequentialHorizon + periodduration_hours: 24 + Power: + function: SequentialHorizon + periodduration_hours: 6 + clearing: + termduration_hours: 48 # 2 days + Hydro: + function: SequentialHorizon + periodduration_hours: 24 + Power: + function: SequentialHorizon + periodduration_hours: 6 + results: + mainresults: ["SORLAND"] + times: true + storagevalues: true + memory: false \ No newline at end of file diff --git a/src/generic_io.jl b/src/generic_io.jl index 42394f9..1c07199 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -14,7 +14,7 @@ function get_dist_ppp(input::AbstractJulESInput) for s in 1:S j = (s - 1) % N + 1 - #println("j in get_dist_ppp is $j") + dist[s] = (s, cores[j]) end @@ -31,9 +31,7 @@ function get_dist_evp(input::AbstractJulESInput, subsystems::Vector{Tuple{Subsys S = get_numscen_sim(input) #number of scenarios Y = length(subsystems) - # println("Y is $Y") - # println("N is $N") - # println("S is $S") + out = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, S*Y) @@ -94,15 +92,16 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs subsystems_desc = get_subsystem_ids_by_decending_size(subsystems) distribution_method = get_distribution_method(input) - # println(method) - #distribution_method = config[method]["subsystems"]["distribution_function"] + if distribution_method == "random" dist_mp = _distribute_subsystems_randomly!(subsystems_desc, cores) elseif distribution_method == "by_size" dist_mp = _distribute_subsystems_by_size!(subsystems_desc, cores) elseif distribution_method == "greedy" - _distribute_subsystems_elements_smarter!(subsystems, cores) + dist_mp = _distribute_subsystems_elements_greedy!(subsystems, cores) + elseif distribution_method == "storage" + dist_mp = _distribute_subsystems_storage_greedy!(input, subsystems, cores) end N = get_numscen_stoch(input) @@ -124,16 +123,16 @@ end function _distribute_subsystems_randomly!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) - #println("subsystems: $subsystems") + dist = Tuple{SubsystemIx, CoreId}[] - for sub in subsystems + for sub_ix in subsystems # Randomly select a core core = rand(cores) - #println("sub is $sub, core is $core") + # Assign the subsystem to the randomly selected core - push!(dist, (sub, core)) + push!(dist, (sub_ix, core)) end return dist @@ -150,11 +149,10 @@ function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores: while length(subsystems) > 0 K = length(subsystems) M = min(K, N) - # println("M is $M") - # println("K is $K") + if loop_forward for i in 1:M - #println("i is $i") + push!(dist, (subsystems[i], cores[i])) end @@ -174,19 +172,122 @@ function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores: end -# elements_all = get_elements(input) +# elements = get_elements(input) # elements_ix_in_subsystem = get_dataelements(s) -# elements_in_subsystem = elements[elements_ix] +# elements_in_subsystem = elements[elements_ix_in_subsystem] # for element in elements_in_subsystem # if element.conceptname == "Storage" +# function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) + +# elements = get_elements(input) + +# dist = Tuple{SubsystemIx, CoreId}[] + +# num_cores = length(cores) + +# println(length(subsystems)) + +# has_storage = Tuple{SubsystemIx, AbstractSubsystem}[] +# not_storage = Tuple{SubsystemIx, AbstractSubsystem}[] + +# # Initialize an array to hold the load (number of data elements) for each core +# core_loads = fill(0, num_cores) + +# for (ix, s) in subsystems +# elements_ix_in_subsystem = get_dataelements(s) +# elements_in_subsystem = elements[elements_ix_in_subsystem] +# println("subsystem $ix") +# #println("elements: $elements_in_subsystem") +# storage = false +# for element in elements_in_subsystem +# println("element: $element") +# if element.conceptname == "Storage" +# storage = true +# end +# end +# if storage == true +# push!(has_storage, (ix, s)) +# else +# push!(not_storage, (ix,s)) +# end + +# end + + + + + + +# return dist +# end + +function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) + elements = get_elements(input) + + dist = Tuple{SubsystemIx, CoreId}[] + + num_cores = length(cores) + + println("Number of subsystems: ", length(subsystems)) + + has_storage = Tuple{SubsystemIx, AbstractSubsystem, Int}[] + not_storage = Tuple{SubsystemIx, AbstractSubsystem, Int}[] + + # Initialize an array to hold the load (number of data elements) for each core + core_loads = fill(0, num_cores) + + for (ix, s) in subsystems + + elements_ix_in_subsystem = get_dataelements(s) + elements_in_subsystem = elements[elements_ix_in_subsystem] + + storage = false + num_storage = 0 + + #iterating through elements in the subsystem to check number of Storage elements. Adding subsystem and number of Storage elements into has_storage and not_storage + for element in elements_in_subsystem + + if element.conceptname == "Storage" + num_storage += 1 + storage = true + end + end + if storage == true + push!(has_storage, (ix, s, num_storage)) + else + push!(not_storage, (ix, s, length(get_dataelements(s)))) + end + end + #sorting has_storage from largest number of Storage elements to lowest + sort!(has_storage, by=x -> x[3], rev=true) + #sorting not_storage from largest number of data elements to lowest + sort!(not_storage, by=x -> x[3], rev=true) + + #function to distribute subsystems on cores greedy + function assign_subsystems!(subsystems, core_loads, dist) + for (ix, s, num) in subsystems + min_load_core_index = argmin(core_loads) + push!(dist, (ix, min_load_core_index)) + core_loads[min_load_core_index] += num + end + end + + assign_subsystems!(has_storage, core_loads, dist) + assign_subsystems!(not_storage, core_loads, dist) + + return dist +end + + + function get_subsystem_ids_by_decending_size(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) subsystems = [(length(get_dataelements(s)), ix) for (ix, s) in subsystems] sort!(subsystems, rev=true) return [ix for (n, ix) in subsystems] end -function _distribute_subsystems_elements_smarter!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) +function _distribute_subsystems_elements_greedy!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) num_cores = length(cores) @@ -194,11 +295,9 @@ function _distribute_subsystems_elements_smarter!(subsystems::Vector{Tuple{Subsy dist = Tuple{SubsystemIx, CoreId}[] # Initialize an array to hold the load (number of data elements) for each core core_loads = fill(0, num_cores) - println("1") - sorted_elements = get_sorted_subsystem_number_of_elements(subsystems) - println(typeof(sorted_elements)) - println(sorted_elements) - for (subsystem_index, num_elements) in sorted_elements + dataelements_in_each_subsystem = sort(get_subsystem_number_of_elements(subsystems), by=x -> x[2], rev=true) + + for (subsystem_index, num_elements) in dataelements_in_each_subsystem # Find the core with the least load min_load_core_index = argmin(core_loads) # Assign the subsystem to this core @@ -212,8 +311,7 @@ end #function to get a tuple(subsystem index, number of data elements) that is sorted from highest to lowest number of data elements in the subsystem -#function get_sorted_subsystem_number_of_elements(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) -function get_sorted_subsystem_number_of_elements(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) +function get_subsystem_number_of_elements(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) dataelements_in_each_subsystem = Tuple{SubsystemIx, Int}[] @@ -230,31 +328,12 @@ function get_sorted_subsystem_number_of_elements(subsystems::Vector{Tuple{Subsys end - #want to sort the tuple by the number of data_elements in each subsystem: - sorted_dataelements = sort(dataelements_in_each_subsystem, by = x -> x[2], rev=true) + - return sorted_dataelements + return dataelements_in_each_subsystem end -function distribute_subsystems_cores(sorted_subsystems::Vector{Tuple{Int, Int}}, num_cores::Int) - # Initialize an array to hold the load (number of data elements) for each core - core_loads = fill(0, num_cores) - # Initialize an array to hold the subsystems assigned to each core - core_assignments = [Vector{Int}() for _ in 1:num_cores] - - for (subsystem_index, num_elements) in sorted_subsystems - # Find the core with the least load - min_load_core = argmin(core_loads) - # Assign the subsystem to this core - push!(core_assignments[min_load_core], subsystem_index) - # Update the load for this core - core_loads[min_load_core] += num_elements - end - - return core_assignments -end - """ Find which subsystems should have evp and stoch problems """ diff --git a/src/io.jl b/src/io.jl index 03dc6d9..1f5256f 100644 --- a/src/io.jl +++ b/src/io.jl @@ -97,7 +97,7 @@ get_phaseinsteps(input::DefaultJulESInput) = input.phaseinsteps get_horizons(input::DefaultJulESInput) = input.horizons -get_distribution_method(input::DefaultJulESInput) = get_mainconfig(input)["distribution_method"] +get_distribution_method(input::DefaultJulESInput) = get_settings(input)["problems"]["stochastic"]["distribution_method"] function get_datascenarios(datayear::Int64, weatheryear::Int64, weekstart::Int64, datanumscen::Int64, simtimetype::String) # Standard time for market clearing - perfect information so simple time type @@ -887,6 +887,8 @@ function get_output_cp_local() data["demandvalues"] = demandvalues data["demandnames"] = demandnames data["demandbalancenames"] = demandbalancenames + + #data[] end return data From 291db80b0f1ae428de503acf0914c19512e41ca2 Mon Sep 17 00:00:00 2001 From: marynve Date: Tue, 25 Jun 2024 08:31:01 +0200 Subject: [PATCH 05/28] test --- demos/data/config_jules_prognose.yml | 2 ++ src/generic_io.jl | 8 ++++++-- 2 files changed, 8 insertions(+), 2 deletions(-) diff --git a/demos/data/config_jules_prognose.yml b/demos/data/config_jules_prognose.yml index 148cb8e..3c21215 100644 --- a/demos/data/config_jules_prognose.yml +++ b/demos/data/config_jules_prognose.yml @@ -59,6 +59,7 @@ threehour: solver: HighsSimplexMethod() startstorages: function: startmagdict + distribution_method: storage #random #by_size #greedy clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true @@ -185,6 +186,7 @@ fast: solver: HighsSimplexMethod() startstorages: function: startmagdict + distribution_method: storage #random #by_size #greedy clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true diff --git a/src/generic_io.jl b/src/generic_io.jl index 1c07199..4aaf98a 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -5,6 +5,12 @@ Generic fallbacks for AbstractJulESInput and AbstractJulESOutput """ How price prognosis problems (ppp) are distributed on cores initially """ + + +function testing() + println("test") +end + function get_dist_ppp(input::AbstractJulESInput) cores = get_cores(input) N = length(cores) @@ -229,8 +235,6 @@ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsy num_cores = length(cores) - println("Number of subsystems: ", length(subsystems)) - has_storage = Tuple{SubsystemIx, AbstractSubsystem, Int}[] not_storage = Tuple{SubsystemIx, AbstractSubsystem, Int}[] From 7d84f0fc00aac02e3e3c45aabffcfe199dd6da3a Mon Sep 17 00:00:00 2001 From: Ingrid Wiig Arnesen Date: Tue, 25 Jun 2024 08:52:25 +0200 Subject: [PATCH 06/28] hei Maria --- src/generic_io.jl | 1 + start_julia_v1.9.bat | 1 + 2 files changed, 2 insertions(+) create mode 100644 start_julia_v1.9.bat diff --git a/src/generic_io.jl b/src/generic_io.jl index 4aaf98a..34195bc 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -9,6 +9,7 @@ How price prognosis problems (ppp) are distributed on cores initially function testing() println("test") + println("hei maria") end function get_dist_ppp(input::AbstractJulESInput) diff --git a/start_julia_v1.9.bat b/start_julia_v1.9.bat new file mode 100644 index 0000000..3281f9e --- /dev/null +++ b/start_julia_v1.9.bat @@ -0,0 +1 @@ +"X:\Programmer\Julia\Julia-1.9.2\bin\julia.exe" \ No newline at end of file From 297d56f167829849dd40837f35d23667fd741072 Mon Sep 17 00:00:00 2001 From: Ingrid Wiig Arnesen Date: Tue, 25 Jun 2024 09:03:05 +0200 Subject: [PATCH 07/28] hei maria --- src/generic_io.jl | 1 + 1 file changed, 1 insertion(+) diff --git a/src/generic_io.jl b/src/generic_io.jl index 4aaf98a..3323df5 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -9,6 +9,7 @@ How price prognosis problems (ppp) are distributed on cores initially function testing() println("test") + println("Hei maria") end function get_dist_ppp(input::AbstractJulESInput) From 0771716ee08b42126da7525cda347769275215ff Mon Sep 17 00:00:00 2001 From: marynve Date: Tue, 25 Jun 2024 09:14:30 +0200 Subject: [PATCH 08/28] changes --- demos/Demo prognosis.ipynb | 509 +------------------------------------ src/generic_io.jl | 54 +--- 2 files changed, 20 insertions(+), 543 deletions(-) diff --git a/demos/Demo prognosis.ipynb b/demos/Demo prognosis.ipynb index a8208ae..1636b8e 100644 --- a/demos/Demo prognosis.ipynb +++ b/demos/Demo prognosis.ipynb @@ -18,37 +18,10 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "id": "6d67dd8b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[36m\u001b[1mProject\u001b[22m\u001b[39m JulES v0.1.0\n", - "\u001b[32m\u001b[1mStatus\u001b[22m\u001b[39m `X:\\Prosjekter\\2022_FoU_markedsmodell_julia\\Brukere\\mary\\JulES\\Project.toml`\n", - " \u001b[90m[336ed68f] \u001b[39mCSV v0.10.14\n", - " \u001b[90m[aaaa29a8] \u001b[39mClustering v0.15.7\n", - " \u001b[90m[a93c6f00] \u001b[39mDataFrames v1.6.1\n", - " \u001b[90m[aaf54ef3] \u001b[39mDistributedArrays v0.6.7\n", - "\u001b[32m⌃\u001b[39m \u001b[90m[31c24e10] \u001b[39mDistributions v0.25.107\n", - " \u001b[90m[7073ff75] \u001b[39mIJulia v1.24.2\n", - " \u001b[90m[682c06a0] \u001b[39mJSON v0.21.4\n", - " \u001b[90m[f0f68f2c] \u001b[39mPlotlyJS v0.18.13\n", - " \u001b[90m[91a5bcdd] \u001b[39mPlots v1.40.4\n", - "\u001b[32m⌃\u001b[39m \u001b[90m[aea7be01] \u001b[39mPrecompileTools v1.2.0\n", - " \u001b[90m[08abe8d2] \u001b[39mPrettyTables v2.3.2\n", - " \u001b[90m[295af30f] \u001b[39mRevise v3.5.14\n", - " \u001b[90m[970f5c25] \u001b[39mTuLiPa v0.1.0 `https://github.com/NVE/TuLiPa.git#redesign_JulES`\n", - "\u001b[32m⌃\u001b[39m \u001b[90m[ddb6d928] \u001b[39mYAML v0.4.9\n", - " \u001b[90m[ade2ca70] \u001b[39mDates\n", - " \u001b[90m[8ba89e20] \u001b[39mDistributed\n", - " \u001b[90m[10745b16] \u001b[39mStatistics v1.9.0\n", - "\u001b[36m\u001b[1mInfo\u001b[22m\u001b[39m Packages marked with \u001b[32m⌃\u001b[39m have new versions available and may be upgradable.\n" - ] - } - ], + "outputs": [], "source": [ "#Pkg.instantiate()\n", "using Pkg; Pkg.status()\n", @@ -61,7 +34,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "id": "ecbf4aa8", "metadata": { "scrolled": false @@ -74,21 +47,10 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "id": "a8a9f2cf", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2024" - ] - }, - "execution_count": 16, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# config = YAML.load_file(joinpath(\"data\", \"config_jules_prognose.yml\")) # config without datasets\n", "config = YAML.load_file(joinpath(\"data\", \"config_jules_prognose_demo.yml\")) # config with NVE datasets\n", @@ -106,18 +68,10 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "id": "3971d0bb", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nprocs() = 10\n" - ] - } - ], + "outputs": [], "source": [ "const numcores = config[\"main\"][\"numcores\"]\n", "\n", @@ -130,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "id": "696e5ec2", "metadata": {}, "outputs": [], @@ -141,7 +95,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "id": "d2448075", "metadata": {}, "outputs": [], @@ -151,21 +105,10 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "id": "35482c34", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "getdataset (generic function with 1 method)" - ] - }, - "execution_count": 20, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "function getdataset(config, weatheryear)\n", " settings = config[config[\"main\"][\"settings\"]]\n", @@ -238,436 +181,10 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "id": "ca8bc8dd", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time parameters\n", - " 0.000046 seconds (56 allocations: 2.250 KiB)\n", - "Handle elements\n", - " 0.000959 seconds (14.37 k allocations: 716.344 KiB)\n", - "Add local dbs\n", - " 0.011866 seconds (721 allocations: 33.375 KiB)\n", - "Add local cores\n", - " 0.011610 seconds (661 allocations: 25.875 KiB)\n", - "Add local input\n", - " 2.818573 seconds (368.17 k allocations: 12.482 MiB)\n", - "Add local dummyobjects\n", - " 0.474567 seconds (1.13 M allocations: 89.280 MiB)\n", - "Add local subsystems\n", - "Number of shortterm storagesystems 0\n", - "Number of longterm storagesystems 19\n", - " 0.120413 seconds (1.29 M allocations: 38.654 MiB)\n", - "Add local scenmod\n", - " 0.012252 seconds (770 allocations: 41.453 KiB)\n", - "Add local problem distribution\n", - "[(1, 1), (2, 2), (3, 3), (4, 4)]\n", - "[(1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, 4), (1, 2, 1), (2, 2, 2), (3, 2, 3), (4, 2, 4), (1, 3, 1), (2, 3, 2), (3, 3, 3), (4, 3, 4), (1, 4, 1), (2, 4, 2), (3, 4, 3), (4, 4, 4), (1, 5, 1), (2, 5, 2), (3, 5, 3), (4, 5, 4), (1, 6, 1), (2, 6, 2), (3, 6, 3), (4, 6, 4), (1, 7, 1), (2, 7, 2), (3, 7, 3), (4, 7, 4), (1, 8, 1), (2, 8, 2), (3, 8, 3), (4, 8, 4), (1, 9, 1), (2, 9, 2), (3, 9, 3), (4, 9, 4), (1, 10, 1), (2, 10, 2), (3, 10, 3), (4, 10, 4), (1, 11, 1), (2, 11, 2), (3, 11, 3), (4, 11, 4), (1, 12, 1), (2, 12, 2), (3, 12, 3), (4, 12, 4), (1, 13, 1), (2, 13, 2), (3, 13, 3), (4, 13, 4), (1, 14, 1), (2, 14, 2), (3, 14, 3), (4, 14, 4), (1, 15, 1), (2, 15, 2), (3, 15, 3), (4, 15, 4), (1, 16, 1), (2, 16, 2), (3, 16, 3), (4, 16, 4), (1, 17, 1), (2, 17, 2), (3, 17, 3), (4, 17, 4), (1, 18, 1), (2, 18, 2), (3, 18, 3), (4, 18, 4), (1, 19, 1), (2, 19, 2), (3, 19, 3), (4, 19, 4)]\n", - "Number of subsystems: 19\n", - "[(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9), (10, 10), (11, 1), (12, 2), (13, 3), (14, 4), (15, 5), (16, 6), (17, 7), (18, 8), (19, 9)]\n", - "[(1, 1, 1), (1, 2, 2), (1, 3, 3), (1, 4, 4), (1, 5, 5), (1, 6, 6), (1, 7, 7), (1, 8, 8), (1, 9, 9), (1, 10, 10), (1, 11, 1), (1, 12, 2), (1, 13, 3), (1, 14, 4), (1, 15, 5), (1, 16, 6), (1, 17, 7), (1, 18, 8), (1, 19, 9), (2, 1, 1), (2, 2, 2), (2, 3, 3), (2, 4, 4), (2, 5, 5), (2, 6, 6), (2, 7, 7), (2, 8, 8), (2, 9, 9), (2, 10, 10), (2, 11, 1), (2, 12, 2), (2, 13, 3), (2, 14, 4), (2, 15, 5), (2, 16, 6), (2, 17, 7), (2, 18, 8), (2, 19, 9), (3, 1, 1), (3, 2, 2), (3, 3, 3), (3, 4, 4), (3, 5, 5), (3, 6, 6), (3, 7, 7), (3, 8, 8), (3, 9, 9), (3, 10, 10), (3, 11, 1), (3, 12, 2), (3, 13, 3), (3, 14, 4), (3, 15, 5), (3, 16, 6), (3, 17, 7), (3, 18, 8), (3, 19, 9), (4, 1, 1), (4, 2, 2), (4, 3, 3), (4, 4, 4), (4, 5, 5), (4, 6, 6), (4, 7, 7), (4, 8, 8), (4, 9, 9), (4, 10, 10), (4, 11, 1), (4, 12, 2), (4, 13, 3), (4, 14, 4), (4, 15, 5), (4, 16, 6), (4, 17, 7), (4, 18, 8), (4, 19, 9)]\n", - " 0.612303 seconds (329.94 k allocations: 21.166 MiB, 59.16% compilation time: 100% of which was recompilation)\n", - "Add local horizons\n", - " 0.003992 seconds (2.53 k allocations: 183.188 KiB)\n", - "Add local problems\n", - " 1.350118 seconds (4.07 M allocations: 304.237 MiB)\n", - "Add local output\n", - " 0.000262 seconds (723 allocations: 117.453 KiB)\n", - "PrognosisTime(DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-29T00:00:00\"), DateTime(\"1991-01-28T00:00:00\"))\n", - "Startstates\n", - " 0.026397 seconds (74.66 k allocations: 4.640 MiB)\n", - "Price prognosis problems\n", - " 1.061236 seconds (1.38 M allocations: 45.367 MiB, 19.21% gc time)\n", - "End value problems\n", - " 0.015989 seconds (37.14 k allocations: 1.295 MiB)\n", - "Subsystem problems\n", - " 0.154062 seconds (63.82 k allocations: 3.151 MiB, 35.19% compilation time)\n", - "Clearing problem\n", - " 0.044352 seconds (86.81 k allocations: 2.954 MiB)\n", - "Update output\n", - " 0.031259 seconds (29.67 k allocations: 1.494 MiB)\n", - "PrognosisTime(DateTime(\"2024-01-31T00:00:00\"), DateTime(\"2024-01-31T00:00:00\"), DateTime(\"1991-01-30T00:00:00\"))\n", - "Startstates\n", - " 0.002994 seconds (3.92 k allocations: 216.930 KiB)\n", - "Price prognosis problems\n", - " 0.192823 seconds (246.41 k allocations: 7.049 MiB)\n", - "End value problems\n", - " 0.001709 seconds (1.02 k allocations: 34.578 KiB)\n", - "Subsystem problems\n", - " 0.003198 seconds (2.11 k allocations: 85.344 KiB)\n", - "Clearing problem\n", - " 0.037549 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.030511 seconds (21.93 k allocations: 1003.016 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-02T00:00:00\"), DateTime(\"2024-02-02T00:00:00\"), DateTime(\"1991-02-01T00:00:00\"))\n", - "Startstates\n", - " 0.013317 seconds (3.91 k allocations: 212.227 KiB)\n", - "Price prognosis problems\n", - " 0.180536 seconds (246.41 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.012431 seconds (1.15 k allocations: 46.219 KiB)\n", - "Subsystem problems\n", - " 0.013578 seconds (1.99 k allocations: 73.984 KiB)\n", - "Clearing problem\n", - " 0.026342 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.027756 seconds (21.93 k allocations: 1004.844 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-04T00:00:00\"), DateTime(\"2024-02-04T00:00:00\"), DateTime(\"1991-02-03T00:00:00\"))\n", - "Startstates\n", - " 0.003079 seconds (3.92 k allocations: 212.164 KiB)\n", - "Price prognosis problems\n", - " 0.190999 seconds (246.41 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.012273 seconds (1.15 k allocations: 46.219 KiB)\n", - "Subsystem problems\n", - " 0.013628 seconds (1.99 k allocations: 73.984 KiB)\n", - "Clearing problem\n", - " 0.027861 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.039568 seconds (21.93 k allocations: 1017.406 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-06T00:00:00\"), DateTime(\"2024-02-06T00:00:00\"), DateTime(\"1991-02-05T00:00:00\"))\n", - "Startstates\n", - " 0.003061 seconds (3.92 k allocations: 212.945 KiB)\n", - "Price prognosis problems\n", - " 0.180896 seconds (246.42 k allocations: 7.049 MiB)\n", - "End value problems\n", - " 0.001750 seconds (1.03 k allocations: 35.797 KiB)\n", - "Subsystem problems\n", - " 0.003150 seconds (2.10 k allocations: 85.250 KiB)\n", - "Clearing problem\n", - " 0.026678 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.029559 seconds (21.92 k allocations: 991.172 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-08T00:00:00\"), DateTime(\"2024-02-08T00:00:00\"), DateTime(\"1991-02-07T00:00:00\"))\n", - "Startstates\n", - " 0.003198 seconds (3.90 k allocations: 211.930 KiB)\n", - "Price prognosis problems\n", - " 0.186489 seconds (246.42 k allocations: 7.049 MiB)\n", - "End value problems\n", - " 0.001371 seconds (1.02 k allocations: 34.578 KiB)\n", - "Subsystem problems\n", - " 0.002668 seconds (1.99 k allocations: 74.844 KiB)\n", - "Clearing problem\n", - " 0.037681 seconds (79.30 k allocations: 2.990 MiB)\n", - "Update output\n", - " 0.029603 seconds (21.92 k allocations: 992.031 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-10T00:00:00\"), DateTime(\"2024-02-10T00:00:00\"), DateTime(\"1991-02-09T00:00:00\"))\n", - "Startstates\n", - " 0.013235 seconds (3.91 k allocations: 212.258 KiB)\n", - "Price prognosis problems\n", - " 0.175568 seconds (246.42 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.012223 seconds (1.15 k allocations: 45.359 KiB)\n", - "Subsystem problems\n", - " 0.002829 seconds (1.99 k allocations: 74.203 KiB)\n", - "Clearing problem\n", - " 0.026126 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.039923 seconds (21.93 k allocations: 992.172 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-12T00:00:00\"), DateTime(\"2024-02-12T00:00:00\"), DateTime(\"1991-02-11T00:00:00\"))\n", - "Startstates\n", - " 0.002950 seconds (3.91 k allocations: 262.555 KiB)\n", - "Price prognosis problems\n", - " 0.183914 seconds (246.54 k allocations: 7.058 MiB)\n", - "End value problems\n", - " 0.011988 seconds (1.03 k allocations: 35.688 KiB)\n", - "Subsystem problems\n", - " 0.003021 seconds (1.98 k allocations: 73.844 KiB)\n", - "Clearing problem\n", - " 0.027039 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.029117 seconds (21.92 k allocations: 992.094 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-14T00:00:00\"), DateTime(\"2024-02-14T00:00:00\"), DateTime(\"1991-02-13T00:00:00\"))\n", - "Startstates\n", - " 0.013206 seconds (3.90 k allocations: 212.758 KiB)\n", - "Price prognosis problems\n", - " 0.692403 seconds (1.08 M allocations: 32.369 MiB)\n", - "End value problems\n", - " 0.008420 seconds (27.69 k allocations: 927.953 KiB)\n", - "Subsystem problems\n", - " 0.052619 seconds (45.41 k allocations: 1.727 MiB, 17.75% compilation time)\n", - "Clearing problem\n", - " 0.031864 seconds (88.55 k allocations: 3.329 MiB)\n", - "Update output\n", - " 0.029058 seconds (21.92 k allocations: 991.172 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-16T00:00:00\"), DateTime(\"2024-02-16T00:00:00\"), DateTime(\"1991-02-15T00:00:00\"))\n", - "Startstates\n", - " 0.013385 seconds (3.92 k allocations: 212.258 KiB)\n", - "Price prognosis problems\n", - " 0.176355 seconds (246.42 k allocations: 7.049 MiB)\n", - "End value problems\n", - " 0.001603 seconds (1.03 k allocations: 34.938 KiB)\n", - "Subsystem problems\n", - " 0.002571 seconds (1.99 k allocations: 74.703 KiB)\n", - "Clearing problem\n", - " 0.027535 seconds (79.31 k allocations: 2.990 MiB)\n", - "Update output\n", - " 0.028547 seconds (21.93 k allocations: 992.172 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-18T00:00:00\"), DateTime(\"2024-02-18T00:00:00\"), DateTime(\"1991-02-17T00:00:00\"))\n", - "Startstates\n", - " 0.003110 seconds (3.91 k allocations: 212.086 KiB)\n", - "Price prognosis problems\n", - " 0.177676 seconds (246.41 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.001447 seconds (1.03 k allocations: 34.719 KiB)\n", - "Subsystem problems\n", - " 0.002570 seconds (1.99 k allocations: 73.984 KiB)\n", - "Clearing problem\n", - " 0.026778 seconds (79.31 k allocations: 2.991 MiB)\n", - "Update output\n", - " 0.039075 seconds (21.93 k allocations: 992.375 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-20T00:00:00\"), DateTime(\"2024-02-20T00:00:00\"), DateTime(\"1991-02-19T00:00:00\"))\n", - "Startstates\n", - " 0.003138 seconds (3.93 k allocations: 212.414 KiB)\n", - "Price prognosis problems\n", - " 0.174779 seconds (246.41 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.001415 seconds (1.03 k allocations: 35.688 KiB)\n", - "Subsystem problems\n", - " 0.013840 seconds (2.10 k allocations: 84.484 KiB)\n", - "Clearing problem\n", - " 0.027833 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.028226 seconds (21.93 k allocations: 992.172 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-22T00:00:00\"), DateTime(\"2024-02-22T00:00:00\"), DateTime(\"1991-02-21T00:00:00\"))\n", - "Startstates\n", - " 0.013461 seconds (3.93 k allocations: 213.180 KiB)\n", - "Price prognosis problems\n", - " 0.185336 seconds (246.54 k allocations: 7.058 MiB)\n", - "End value problems\n", - " 0.001834 seconds (1.02 k allocations: 35.438 KiB)\n", - "Subsystem problems\n", - " 0.013663 seconds (1.99 k allocations: 73.984 KiB)\n", - "Clearing problem\n", - " 0.027898 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.029331 seconds (21.93 k allocations: 1.066 MiB)\n", - "PrognosisTime(DateTime(\"2024-02-24T00:00:00\"), DateTime(\"2024-02-24T00:00:00\"), DateTime(\"1991-02-23T00:00:00\"))\n", - "Startstates\n", - " 0.003197 seconds (3.92 k allocations: 213.227 KiB)\n", - "Price prognosis problems\n", - " 0.192056 seconds (246.54 k allocations: 7.058 MiB)\n", - "End value problems\n", - " 0.011925 seconds (1.03 k allocations: 34.938 KiB)\n", - "Subsystem problems\n", - " 0.002828 seconds (1.98 k allocations: 73.922 KiB)\n", - "Clearing problem\n", - " 0.038227 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.029124 seconds (21.93 k allocations: 992.172 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-26T00:00:00\"), DateTime(\"2024-02-26T00:00:00\"), DateTime(\"1991-02-25T00:00:00\"))\n", - "Startstates\n", - " 0.014054 seconds (4.04 k allocations: 225.227 KiB)\n", - "Price prognosis problems\n", - " 0.177562 seconds (246.41 k allocations: 7.047 MiB)\n", - "End value problems\n", - " 0.001333 seconds (1.02 k allocations: 34.578 KiB)\n", - "Subsystem problems\n", - " 0.002524 seconds (1.99 k allocations: 73.984 KiB)\n", - "Clearing problem\n", - " 0.037508 seconds (79.31 k allocations: 2.990 MiB)\n", - "Update output\n", - " 0.028984 seconds (21.92 k allocations: 992.031 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-28T00:00:00\"), DateTime(\"2024-02-28T00:00:00\"), DateTime(\"1991-02-27T00:00:00\"))\n", - "Startstates\n", - " 0.013809 seconds (3.91 k allocations: 211.961 KiB)\n", - "Price prognosis problems\n", - " 0.182281 seconds (246.41 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.012152 seconds (1.15 k allocations: 46.109 KiB)\n", - "Subsystem problems\n", - " 0.013567 seconds (1.99 k allocations: 74.125 KiB)\n", - "Clearing problem\n", - " 0.037927 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.028271 seconds (21.93 k allocations: 992.172 KiB)\n", - "\n", - "The simulation took: 0.1 minutes\n", - "Time usage per simulation step: 0.37 seconds\n", - "\n" - ] - }, - { - "data": { - "text/html": [ - "
7×5 DataFrame
Rowmodelupdatesolveothertotal
StringFloat64Float64Float64Float64
1long0.06220570.06248440.0001458750.124836
2med0.1598050.04624970.000248150.206303
3short0.02131060.06374180.002122060.0871744
4evp0.0005649390.001115450.0004091210.00208951
5mp0.0005253530.0004083760.006374470.0073082
6sp0.003921610.001461340.01759140.0229744
7clearing0.007264040.01635910.002973840.026597
" - ], - "text/latex": [ - "\\begin{tabular}{r|ccccc}\n", - "\t& model & update & solve & other & total\\\\\n", - "\t\\hline\n", - "\t& String & Float64 & Float64 & Float64 & Float64\\\\\n", - "\t\\hline\n", - "\t1 & long & 0.0622057 & 0.0624844 & 0.000145875 & 0.124836 \\\\\n", - "\t2 & med & 0.159805 & 0.0462497 & 0.00024815 & 0.206303 \\\\\n", - "\t3 & short & 0.0213106 & 0.0637418 & 0.00212206 & 0.0871744 \\\\\n", - "\t4 & evp & 0.000564939 & 0.00111545 & 0.000409121 & 0.00208951 \\\\\n", - "\t5 & mp & 0.000525353 & 0.000408376 & 0.00637447 & 0.0073082 \\\\\n", - "\t6 & sp & 0.00392161 & 0.00146134 & 0.0175914 & 0.0229744 \\\\\n", - "\t7 & clearing & 0.00726404 & 0.0163591 & 0.00297384 & 0.026597 \\\\\n", - "\\end{tabular}\n" - ], - "text/plain": [ - "\u001b[1m7×5 DataFrame\u001b[0m\n", - "\u001b[1m Row \u001b[0m│\u001b[1m model \u001b[0m\u001b[1m update \u001b[0m\u001b[1m solve \u001b[0m\u001b[1m other \u001b[0m\u001b[1m total \u001b[0m\n", - " │\u001b[90m String \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", - "─────┼─────────────────────────────────────────────────────────────\n", - " 1 │ long 0.0622057 0.0624844 0.000145875 0.124836\n", - " 2 │ med 0.159805 0.0462497 0.00024815 0.206303\n", - " 3 │ short 0.0213106 0.0637418 0.00212206 0.0871744\n", - " 4 │ evp 0.000564939 0.00111545 0.000409121 0.00208951\n", - " 5 │ mp 0.000525353 0.000408376 0.00637447 0.0073082\n", - " 6 │ sp 0.00392161 0.00146134 0.0175914 0.0229744\n", - " 7 │ clearing 0.00726404 0.0163591 0.00297384 0.026597" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
10×15 DataFrame
Rowcoretotevp_totmp_totsp_totevp_uevp_sevp_omp_ump_smp_finmp_osp_usp_ssp_o
AnyFloat64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?
15.0missingmissing0.003668850.047041missingmissingmissing0.000160650.001041451.07e-50.002456050.0019530.00328950.0417985
26.0missingmissing0.007849250.0445661missingmissingmissing0.004339550.00088839.7e-60.00261170.01641440.00269510.0254566
37.0missingmissing0.00394870.0476137missingmissingmissing0.000166050.00096031.285e-50.00280950.001812550.004358950.0414422
48.0missingmissing0.00432770.0468604missingmissingmissing0.00013750.000678451.19e-50.003499850.001593850.002988750.0422778
59.0missingmissing0.008641050.0524199missingmissingmissing0.00442090.001084951.05e-50.00312470.01723640.003801750.0313817
610.0missingmissing0.00249940.0048249missingmissingmissing8.01e-50.000363254.25e-60.00205180.000736850.000827050.003261
71.00.09360670.01050240.001663750.08144050.00270770.00532140.0003091690.00014780.00066071.685e-50.00083840.01463420.0024080.0643983
82.00.09354970.00929670.0354340.0488190.00261950.00497440.000212850.00016230.0007081.27e-50.0345510.01666020.003187050.0289718
93.00.09004640.01015390.03514550.0447470.002732850.005616450.0002255750.000203250.000678951.045e-50.03425290.0017610.001800950.0411851
104.00.06360580.00974760.03567760.01818060.00267380.005281250.0002240690.00016360.00069489.85e-60.03480930.001708050.00240840.0140641
" - ], - "text/latex": [ - "\\begin{tabular}{r|ccccccccc}\n", - "\t& core & tot & evp\\_tot & mp\\_tot & sp\\_tot & evp\\_u & evp\\_s & evp\\_o & \\\\\n", - "\t\\hline\n", - "\t& Any & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & \\\\\n", - "\t\\hline\n", - "\t1 & 5.0 & \\emph{missing} & \\emph{missing} & 0.00366885 & 0.047041 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t2 & 6.0 & \\emph{missing} & \\emph{missing} & 0.00784925 & 0.0445661 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t3 & 7.0 & \\emph{missing} & \\emph{missing} & 0.0039487 & 0.0476137 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t4 & 8.0 & \\emph{missing} & \\emph{missing} & 0.0043277 & 0.0468604 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t5 & 9.0 & \\emph{missing} & \\emph{missing} & 0.00864105 & 0.0524199 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t6 & 10.0 & \\emph{missing} & \\emph{missing} & 0.0024994 & 0.0048249 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t7 & 1.0 & 0.0936067 & 0.0105024 & 0.00166375 & 0.0814405 & 0.0027077 & 0.0053214 & 0.000309169 & $\\dots$ \\\\\n", - "\t8 & 2.0 & 0.0935497 & 0.0092967 & 0.035434 & 0.048819 & 0.0026195 & 0.0049744 & 0.00021285 & $\\dots$ \\\\\n", - "\t9 & 3.0 & 0.0900464 & 0.0101539 & 0.0351455 & 0.044747 & 0.00273285 & 0.00561645 & 0.000225575 & $\\dots$ \\\\\n", - "\t10 & 4.0 & 0.0636058 & 0.0097476 & 0.0356776 & 0.0181806 & 0.0026738 & 0.00528125 & 0.000224069 & $\\dots$ \\\\\n", - "\\end{tabular}\n" - ], - "text/plain": [ - "\u001b[1m10×15 DataFrame\u001b[0m\n", - "\u001b[1m Row \u001b[0m│\u001b[1m core \u001b[0m\u001b[1m tot \u001b[0m\u001b[1m evp_tot \u001b[0m\u001b[1m mp_tot \u001b[0m\u001b[1m sp_tot \u001b[0m\u001b[1m evp_u \u001b[0m ⋯\n", - " │\u001b[90m Any \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64?\u001b[0m ⋯\n", - "─────┼──────────────────────────────────────────────────────────────────────────\n", - " 1 │ 5.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00366885 0.047041 \u001b[90m missing \u001b[0m ⋯\n", - " 2 │ 6.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00784925 0.0445661 \u001b[90m missing \u001b[0m\n", - " 3 │ 7.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0039487 0.0476137 \u001b[90m missing \u001b[0m\n", - " 4 │ 8.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0043277 0.0468604 \u001b[90m missing \u001b[0m\n", - " 5 │ 9.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00864105 0.0524199 \u001b[90m missing \u001b[0m ⋯\n", - " 6 │ 10.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0024994 0.0048249 \u001b[90m missing \u001b[0m\n", - " 7 │ 1.0 0.0936067 0.0105024 0.00166375 0.0814405 0.\n", - " 8 │ 2.0 0.0935497 0.0092967 0.035434 0.048819 0.\n", - " 9 │ 3.0 0.0900464 0.0101539 0.0351455 0.044747 0. ⋯\n", - " 10 │ 4.0 0.0636058 0.0097476 0.0356776 0.0181806 0.\n", - "\u001b[36m 10 columns omitted\u001b[0m" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
19×15 DataFrame
Rowsubixtotevp_totmp_totsp_totevp_uevp_sevp_omp_ump_smp_finmp_osp_usp_ssp_o
AnyFloat64Float64?Float64?Float64?Float64?Float64?Float64?AnyAnyAnyAnyFloat64?Float64?Float64?
19.00.05266010.002163950.00738930.04310690.00054530.001219254.9925e-50.004356450.000732856.75e-60.002293250.01645830.002192950.0244556
216.00.04648310.00207180.006128550.03828270.000529850.00116844.66937e-50.004256050.00056684.35e-60.001301350.0156620.00185780.020763
31.00.04588360.00344090.000668850.04177390.00084840.00177550.0001021257.105e-50.000348659.6e-60.000239550.01363790.00160860.0265274
42.00.04559450.002620750.03368770.009286050.00062420.00138537.64063e-50.000100350.00036246.0e-60.0332190.000850.00158990.00684615
518.00.04450890.00231090.0017610.0404370.00054430.00137214.93125e-56.215e-50.000334.95e-60.00136390.000816350.00151640.0381043
612.00.04342710.00214780.001746250.0395330.00053970.001193855.17812e-56.195e-50.00034566.7e-60.0013320.01581020.001597150.0221257
717.00.04310380.0022720.00166430.03916750.000541150.00136584.56312e-58.25e-50.000400054.9e-60.001176850.00093840.00159870.0366304
813.00.04268110.001710150.00155480.03941610.000549550.000837854.03438e-50.00010240.000317554.25e-60.00113060.000900950.00079960.0377156
911.00.0422310.00156960.00099490.03966660.00054190.0006994.10875e-57.675e-50.000312057.25e-60.000598850.00099620.00079940.037871
1015.00.04160530.001687750.00151810.03839950.00054870.00069755.51937e-58.235e-50.000302854.35e-60.001128550.000974850.00079350.0366311
114.00.04130810.001653250.03393670.00571810.00053780.000714155.01625e-59.7e-50.0003195.0e-60.03351570.00086240.00077560.0040801
123.00.04087580.00195420.03359070.005330850.000570850.000734058.11625e-50.000100850.00036146.2e-60.03312230.000860050.001001350.00346945
1314.00.01639920.00219590.001740850.01246240.000533150.0013813.52187e-56.66e-50.00037584.85e-60.00129360.000845650.00163280.009984
147.00.01293210.00220140.00228440.008446250.000523650.00139823.49437e-58.355e-50.000560257.95e-60.001632650.000874150.002760250.00481185
1519.00.01291720.002352450.001251750.0093130.00055810.00139245.02437e-56.445e-50.00035213.75e-60.000831450.00077810.00160880.0069261
165.00.01287530.002082950.002150750.008641550.00053410.001275053.4225e-57.83e-50.00073866.35e-60.00132750.000978150.0024960.0051674
178.00.0111550.002164950.00256670.006423350.00057310.001203354.85625e-57.535e-50.000348456.95e-60.002135950.00077750.001472350.0041735
186.00.00954720.00154310.00172070.00628340.00054890.00069683.7175e-58.35e-50.00032155.35e-60.001310350.000752450.00083730.00469365
1910.00.008881150.001556850.00249940.00482490.000541150.000683954.14687e-58.01e-50.000363254.25e-60.00205180.000736850.000827050.003261
" - ], - "text/latex": [ - "\\begin{tabular}{r|ccccccccc}\n", - "\t& subix & tot & evp\\_tot & mp\\_tot & sp\\_tot & evp\\_u & evp\\_s & evp\\_o & \\\\\n", - "\t\\hline\n", - "\t& Any & Float64 & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & \\\\\n", - "\t\\hline\n", - "\t1 & 9.0 & 0.0526601 & 0.00216395 & 0.0073893 & 0.0431069 & 0.0005453 & 0.00121925 & 4.9925e-5 & $\\dots$ \\\\\n", - "\t2 & 16.0 & 0.0464831 & 0.0020718 & 0.00612855 & 0.0382827 & 0.00052985 & 0.0011684 & 4.66937e-5 & $\\dots$ \\\\\n", - "\t3 & 1.0 & 0.0458836 & 0.0034409 & 0.00066885 & 0.0417739 & 0.0008484 & 0.0017755 & 0.000102125 & $\\dots$ \\\\\n", - "\t4 & 2.0 & 0.0455945 & 0.00262075 & 0.0336877 & 0.00928605 & 0.0006242 & 0.0013853 & 7.64063e-5 & $\\dots$ \\\\\n", - "\t5 & 18.0 & 0.0445089 & 0.0023109 & 0.001761 & 0.040437 & 0.0005443 & 0.0013721 & 4.93125e-5 & $\\dots$ \\\\\n", - "\t6 & 12.0 & 0.0434271 & 0.0021478 & 0.00174625 & 0.039533 & 0.0005397 & 0.00119385 & 5.17812e-5 & $\\dots$ \\\\\n", - "\t7 & 17.0 & 0.0431038 & 0.002272 & 0.0016643 & 0.0391675 & 0.00054115 & 0.0013658 & 4.56312e-5 & $\\dots$ \\\\\n", - "\t8 & 13.0 & 0.0426811 & 0.00171015 & 0.0015548 & 0.0394161 & 0.00054955 & 0.00083785 & 4.03438e-5 & $\\dots$ \\\\\n", - "\t9 & 11.0 & 0.042231 & 0.0015696 & 0.0009949 & 0.0396666 & 0.0005419 & 0.000699 & 4.10875e-5 & $\\dots$ \\\\\n", - "\t10 & 15.0 & 0.0416053 & 0.00168775 & 0.0015181 & 0.0383995 & 0.0005487 & 0.0006975 & 5.51937e-5 & $\\dots$ \\\\\n", - "\t11 & 4.0 & 0.0413081 & 0.00165325 & 0.0339367 & 0.0057181 & 0.0005378 & 0.00071415 & 5.01625e-5 & $\\dots$ \\\\\n", - "\t12 & 3.0 & 0.0408758 & 0.0019542 & 0.0335907 & 0.00533085 & 0.00057085 & 0.00073405 & 8.11625e-5 & $\\dots$ \\\\\n", - "\t13 & 14.0 & 0.0163992 & 0.0021959 & 0.00174085 & 0.0124624 & 0.00053315 & 0.001381 & 3.52187e-5 & $\\dots$ \\\\\n", - "\t14 & 7.0 & 0.0129321 & 0.0022014 & 0.0022844 & 0.00844625 & 0.00052365 & 0.0013982 & 3.49437e-5 & $\\dots$ \\\\\n", - "\t15 & 19.0 & 0.0129172 & 0.00235245 & 0.00125175 & 0.009313 & 0.0005581 & 0.0013924 & 5.02437e-5 & $\\dots$ \\\\\n", - "\t16 & 5.0 & 0.0128753 & 0.00208295 & 0.00215075 & 0.00864155 & 0.0005341 & 0.00127505 & 3.4225e-5 & $\\dots$ \\\\\n", - "\t17 & 8.0 & 0.011155 & 0.00216495 & 0.0025667 & 0.00642335 & 0.0005731 & 0.00120335 & 4.85625e-5 & $\\dots$ \\\\\n", - "\t18 & 6.0 & 0.0095472 & 0.0015431 & 0.0017207 & 0.0062834 & 0.0005489 & 0.0006968 & 3.7175e-5 & $\\dots$ \\\\\n", - "\t19 & 10.0 & 0.00888115 & 0.00155685 & 0.0024994 & 0.0048249 & 0.00054115 & 0.00068395 & 4.14687e-5 & $\\dots$ \\\\\n", - "\\end{tabular}\n" - ], - "text/plain": [ - "\u001b[1m19×15 DataFrame\u001b[0m\n", - "\u001b[1m Row \u001b[0m│\u001b[1m subix \u001b[0m\u001b[1m tot \u001b[0m\u001b[1m evp_tot \u001b[0m\u001b[1m mp_tot \u001b[0m\u001b[1m sp_tot \u001b[0m\u001b[1m evp_u \u001b[0m\u001b[1m evp_\u001b[0m ⋯\n", - " │\u001b[90m Any \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Floa\u001b[0m ⋯\n", - "─────┼──────────────────────────────────────────────────────────────────────────\n", - " 1 │ 9.0 0.0526601 0.00216395 0.0073893 0.0431069 0.0005453 0.00 ⋯\n", - " 2 │ 16.0 0.0464831 0.0020718 0.00612855 0.0382827 0.00052985 0.00\n", - " 3 │ 1.0 0.0458836 0.0034409 0.00066885 0.0417739 0.0008484 0.00\n", - " 4 │ 2.0 0.0455945 0.00262075 0.0336877 0.00928605 0.0006242 0.00\n", - " 5 │ 18.0 0.0445089 0.0023109 0.001761 0.040437 0.0005443 0.00 ⋯\n", - " 6 │ 12.0 0.0434271 0.0021478 0.00174625 0.039533 0.0005397 0.00\n", - " 7 │ 17.0 0.0431038 0.002272 0.0016643 0.0391675 0.00054115 0.00\n", - " 8 │ 13.0 0.0426811 0.00171015 0.0015548 0.0394161 0.00054955 0.00\n", - " 9 │ 11.0 0.042231 0.0015696 0.0009949 0.0396666 0.0005419 0.00 ⋯\n", - " 10 │ 15.0 0.0416053 0.00168775 0.0015181 0.0383995 0.0005487 0.00\n", - " 11 │ 4.0 0.0413081 0.00165325 0.0339367 0.0057181 0.0005378 0.00\n", - " 12 │ 3.0 0.0408758 0.0019542 0.0335907 0.00533085 0.00057085 0.00\n", - " 13 │ 14.0 0.0163992 0.0021959 0.00174085 0.0124624 0.00053315 0.00 ⋯\n", - " 14 │ 7.0 0.0129321 0.0022014 0.0022844 0.00844625 0.00052365 0.00\n", - " 15 │ 19.0 0.0129172 0.00235245 0.00125175 0.009313 0.0005581 0.00\n", - " 16 │ 5.0 0.0128753 0.00208295 0.00215075 0.00864155 0.0005341 0.00\n", - " 17 │ 8.0 0.011155 0.00216495 0.0025667 0.00642335 0.0005731 0.00 ⋯\n", - " 18 │ 6.0 0.0095472 0.0015431 0.0017207 0.0062834 0.0005489 0.00\n", - " 19 │ 10.0 0.00888115 0.00155685 0.0024994 0.0048249 0.00054115 0.00\n", - "\u001b[36m 9 columns omitted\u001b[0m" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Dict{Any, Any} with 23 entries:\n", - " \"demandbalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", - " \"endvaluetimes\" => Dict{Any, Any}((1, 12)=>[0.000158 0.0004999 0.00078; …\n", - " \"resindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", - " \"areanames\" => [\"SORLAND\"]\n", - " \"priceindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-2…\n", - " \"batmatrix\" => Matrix{Float64}(undef, 128, 0)\n", - " \"stateindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", - " \"statematrix\" => [547.673 4078.56 … 0.174767 0.0; 547.673 4078.56 … 0.…\n", - " \"statenames\" => [\"Reservoir_FINNMARK_hydro_reservoir_max\", \"Reservoir…\n", - " \"resnames\" => [\"Reservoir_SORLAND_hydro_reservoir\"]\n", - " \"demandvalues\" => [0.0 0.0 … 0.0831064 1.40595; 0.0 0.94242 … 0.0476586…\n", - " \"batindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", - " \"resmatrix\" => [14.4029; 14.3558; … ; 13.7965; 13.7811;;]\n", - " \"supplybalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", - " \"supplynames\" => [\"PlantResponse_SORLAND_VALHALL\", \"Transm_SOROST->SOR…\n", - " \"demandnames\" => [\"Transm_SORLAND->TELEMARK\", \"Transm_SORLAND->HAUGESU…\n", - " \"sptimes\" => Dict{Any, Any}((1, 12)=>[0.030148 0.0006478 0.0248725…\n", - " \"clearingtimes\" => [0.0072952 0.0178427 0.0421154; 0.0071026 0.0161368 0…\n", - " \"supplyvalues\" => [0.0 0.0 … 0.0 0.254503; 0.0 0.0 … 0.00267863 0.22869…\n", - " \"batnames\" => String[]\n", - " \"prognosistimes\" => [0.0794489 0.0940269 0.173628; 0.0 0.0 0.0; … ; 0.0 0…\n", - " \"pricematrix\" => [0.319439; 0.319439; … ; 0.320662; 0.320662;;]\n", - " \"mptimes\" => Dict{Any, Any}(5=>[8.05e-5 0.0008683 7.6e-6 0.0012767…" - ] - }, - "execution_count": 28, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\n", "dataset = getdataset(config, weatheryear)\n", diff --git a/src/generic_io.jl b/src/generic_io.jl index 4aaf98a..8aab407 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -124,7 +124,14 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs end +function _distribute_subsystems_big_small!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) + dist = Tuple{SubsystemIx, CoreId}[] + + + return dist + +end function _distribute_subsystems_randomly!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) @@ -178,55 +185,8 @@ function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores: end -# elements = get_elements(input) -# elements_ix_in_subsystem = get_dataelements(s) -# elements_in_subsystem = elements[elements_ix_in_subsystem] -# for element in elements_in_subsystem -# if element.conceptname == "Storage" - -# function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) - -# elements = get_elements(input) - -# dist = Tuple{SubsystemIx, CoreId}[] - -# num_cores = length(cores) - -# println(length(subsystems)) - -# has_storage = Tuple{SubsystemIx, AbstractSubsystem}[] -# not_storage = Tuple{SubsystemIx, AbstractSubsystem}[] - -# # Initialize an array to hold the load (number of data elements) for each core -# core_loads = fill(0, num_cores) - -# for (ix, s) in subsystems -# elements_ix_in_subsystem = get_dataelements(s) -# elements_in_subsystem = elements[elements_ix_in_subsystem] -# println("subsystem $ix") -# #println("elements: $elements_in_subsystem") -# storage = false -# for element in elements_in_subsystem -# println("element: $element") -# if element.conceptname == "Storage" -# storage = true -# end -# end -# if storage == true -# push!(has_storage, (ix, s)) -# else -# push!(not_storage, (ix,s)) -# end - -# end - - - - -# return dist -# end function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) elements = get_elements(input) From 0bc74d4de9d878dd3d9d01d203ba05a43a6cdf82 Mon Sep 17 00:00:00 2001 From: marynve Date: Tue, 25 Jun 2024 11:56:02 +0200 Subject: [PATCH 09/28] distribute subsystems big small function --- demos/Demo prognosis.ipynb | 549 +++++++++++++++++++++- demos/data/config_jules_prognose_demo.yml | 4 +- src/generic_io.jl | 32 +- 3 files changed, 566 insertions(+), 19 deletions(-) diff --git a/demos/Demo prognosis.ipynb b/demos/Demo prognosis.ipynb index 1636b8e..5ce91f0 100644 --- a/demos/Demo prognosis.ipynb +++ b/demos/Demo prognosis.ipynb @@ -18,10 +18,37 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "id": "6d67dd8b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1mProject\u001b[22m\u001b[39m JulES v0.1.0\n", + "\u001b[32m\u001b[1mStatus\u001b[22m\u001b[39m `X:\\Prosjekter\\2022_FoU_markedsmodell_julia\\Brukere\\mary\\JulES\\Project.toml`\n", + " \u001b[90m[336ed68f] \u001b[39mCSV v0.10.14\n", + " \u001b[90m[aaaa29a8] \u001b[39mClustering v0.15.7\n", + " \u001b[90m[a93c6f00] \u001b[39mDataFrames v1.6.1\n", + " \u001b[90m[aaf54ef3] \u001b[39mDistributedArrays v0.6.7\n", + "\u001b[32m⌃\u001b[39m \u001b[90m[31c24e10] \u001b[39mDistributions v0.25.107\n", + " \u001b[90m[7073ff75] \u001b[39mIJulia v1.24.2\n", + " \u001b[90m[682c06a0] \u001b[39mJSON v0.21.4\n", + " \u001b[90m[f0f68f2c] \u001b[39mPlotlyJS v0.18.13\n", + " \u001b[90m[91a5bcdd] \u001b[39mPlots v1.40.4\n", + "\u001b[32m⌃\u001b[39m \u001b[90m[aea7be01] \u001b[39mPrecompileTools v1.2.0\n", + " \u001b[90m[08abe8d2] \u001b[39mPrettyTables v2.3.2\n", + " \u001b[90m[295af30f] \u001b[39mRevise v3.5.14\n", + " \u001b[90m[970f5c25] \u001b[39mTuLiPa v0.1.0 `https://github.com/NVE/TuLiPa.git#redesign_JulES`\n", + "\u001b[32m⌃\u001b[39m \u001b[90m[ddb6d928] \u001b[39mYAML v0.4.9\n", + " \u001b[90m[ade2ca70] \u001b[39mDates\n", + " \u001b[90m[8ba89e20] \u001b[39mDistributed\n", + " \u001b[90m[10745b16] \u001b[39mStatistics v1.9.0\n", + "\u001b[36m\u001b[1mInfo\u001b[22m\u001b[39m Packages marked with \u001b[32m⌃\u001b[39m have new versions available and may be upgradable.\n" + ] + } + ], "source": [ "#Pkg.instantiate()\n", "using Pkg; Pkg.status()\n", @@ -34,12 +61,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "ecbf4aa8", "metadata": { "scrolled": false }, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.webio.node+json": { + "children": [], + "instanceArgs": { + "namespace": "html", + "tag": "div" + }, + "nodeType": "DOM", + "props": {}, + "type": "node" + }, + "text/html": [ + "
\n", + "

The WebIO Jupyter extension was not detected. See the\n", + "\n", + " WebIO Jupyter integration documentation\n", + "\n", + "for more information.\n", + "

\n" + ], + "text/plain": [ + "WebIO._IJuliaInit()" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "using DataFrames, Statistics, JSON, Distributed, Clustering, YAML, Distributions, Revise, Plots, PrettyTables, Random\n", "plotlyjs(); # uncomment for interactive plots" @@ -47,10 +103,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "a8a9f2cf", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "2024" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "# config = YAML.load_file(joinpath(\"data\", \"config_jules_prognose.yml\")) # config without datasets\n", "config = YAML.load_file(joinpath(\"data\", \"config_jules_prognose_demo.yml\")) # config with NVE datasets\n", @@ -68,10 +135,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "3971d0bb", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "nprocs() = 10\n" + ] + } + ], "source": [ "const numcores = config[\"main\"][\"numcores\"]\n", "\n", @@ -84,7 +159,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "696e5ec2", "metadata": {}, "outputs": [], @@ -95,20 +170,39 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "d2448075", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling JulES [05c5cb9d-dcc3-436a-b9c7-df36424a75d6]\n" + ] + } + ], "source": [ "@everywhere using JulES" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "35482c34", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "getdataset (generic function with 1 method)" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "function getdataset(config, weatheryear)\n", " settings = config[config[\"main\"][\"settings\"]]\n", @@ -181,10 +275,435 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "ca8bc8dd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Time parameters\n", + " 0.000052 seconds (56 allocations: 2.250 KiB)\n", + "Handle elements\n", + " 0.000833 seconds (14.37 k allocations: 716.344 KiB)\n", + "Add local dbs\n", + " 0.011991 seconds (720 allocations: 33.359 KiB)\n", + "Add local cores\n", + " 0.001156 seconds (655 allocations: 25.734 KiB)\n", + "Add local input\n", + " 2.642034 seconds (368.41 k allocations: 12.495 MiB)\n", + "Add local dummyobjects\n", + " 0.521665 seconds (1.43 M allocations: 120.557 MiB, 21.19% gc time)\n", + "Add local subsystems\n", + "Number of shortterm storagesystems 0\n", + "Number of longterm storagesystems 19\n", + " 0.116675 seconds (1.29 M allocations: 38.739 MiB)\n", + "Add local scenmod\n", + " 0.011731 seconds (645 allocations: 30.266 KiB)\n", + "Add local problem distribution\n", + "[(1, 1), (2, 2), (3, 3), (4, 4)]\n", + "[(1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, 4), (1, 2, 1), (2, 2, 2), (3, 2, 3), (4, 2, 4), (1, 3, 1), (2, 3, 2), (3, 3, 3), (4, 3, 4), (1, 4, 1), (2, 4, 2), (3, 4, 3), (4, 4, 4), (1, 5, 1), (2, 5, 2), (3, 5, 3), (4, 5, 4), (1, 6, 1), (2, 6, 2), (3, 6, 3), (4, 6, 4), (1, 7, 1), (2, 7, 2), (3, 7, 3), (4, 7, 4), (1, 8, 1), (2, 8, 2), (3, 8, 3), (4, 8, 4), (1, 9, 1), (2, 9, 2), (3, 9, 3), (4, 9, 4), (1, 10, 1), (2, 10, 2), (3, 10, 3), (4, 10, 4), (1, 11, 1), (2, 11, 2), (3, 11, 3), (4, 11, 4), (1, 12, 1), (2, 12, 2), (3, 12, 3), (4, 12, 4), (1, 13, 1), (2, 13, 2), (3, 13, 3), (4, 13, 4), (1, 14, 1), (2, 14, 2), (3, 14, 3), (4, 14, 4), (1, 15, 1), (2, 15, 2), (3, 15, 3), (4, 15, 4), (1, 16, 1), (2, 16, 2), (3, 16, 3), (4, 16, 4), (1, 17, 1), (2, 17, 2), (3, 17, 3), (4, 17, 4), (1, 18, 1), (2, 18, 2), (3, 18, 3), (4, 18, 4), (1, 19, 1), (2, 19, 2), (3, 19, 3), (4, 19, 4)]\n", + "[(19, 1), (6, 1), (18, 2), (9, 2), (17, 3), (10, 3), (16, 4), (13, 4), (15, 5), (1, 5), (14, 6), (2, 6), (12, 7), (3, 7), (11, 8), (4, 8), (8, 9), (5, 9), (7, 10)]\n", + "[(1, 19, 1), (1, 6, 1), (1, 18, 2), (1, 9, 2), (1, 17, 3), (1, 10, 3), (1, 16, 4), (1, 13, 4), (1, 15, 5), (1, 1, 5), (1, 14, 6), (1, 2, 6), (1, 12, 7), (1, 3, 7), (1, 11, 8), (1, 4, 8), (1, 8, 9), (1, 5, 9), (1, 7, 10), (2, 19, 1), (2, 6, 1), (2, 18, 2), (2, 9, 2), (2, 17, 3), (2, 10, 3), (2, 16, 4), (2, 13, 4), (2, 15, 5), (2, 1, 5), (2, 14, 6), (2, 2, 6), (2, 12, 7), (2, 3, 7), (2, 11, 8), (2, 4, 8), (2, 8, 9), (2, 5, 9), (2, 7, 10), (3, 19, 1), (3, 6, 1), (3, 18, 2), (3, 9, 2), (3, 17, 3), (3, 10, 3), (3, 16, 4), (3, 13, 4), (3, 15, 5), (3, 1, 5), (3, 14, 6), (3, 2, 6), (3, 12, 7), (3, 3, 7), (3, 11, 8), (3, 4, 8), (3, 8, 9), (3, 5, 9), (3, 7, 10), (4, 19, 1), (4, 6, 1), (4, 18, 2), (4, 9, 2), (4, 17, 3), (4, 10, 3), (4, 16, 4), (4, 13, 4), (4, 15, 5), (4, 1, 5), (4, 14, 6), (4, 2, 6), (4, 12, 7), (4, 3, 7), (4, 11, 8), (4, 4, 8), (4, 8, 9), (4, 5, 9), (4, 7, 10)]\n", + " 0.206719 seconds (15.64 k allocations: 538.281 KiB)\n", + "Add local horizons\n", + " 0.013800 seconds (2.54 k allocations: 183.312 KiB)\n", + "Add local problems\n", + " 1.471939 seconds (4.06 M allocations: 303.887 MiB, 6.87% gc time)\n", + "Add local output\n", + " 0.010589 seconds (862 allocations: 125.172 KiB)\n", + "PrognosisTime(DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-29T00:00:00\"), DateTime(\"1991-01-28T00:00:00\"))\n", + "Startstates\n", + " 0.014167 seconds (75.06 k allocations: 4.659 MiB)\n", + "Price prognosis problems\n", + " 0.812310 seconds (1.38 M allocations: 45.189 MiB)\n", + "End value problems\n", + " 0.026359 seconds (37.13 k allocations: 1.292 MiB)\n", + "Subsystem problems\n", + " 0.037614 seconds (39.62 k allocations: 1.540 MiB)\n", + "Clearing problem\n", + " 0.042919 seconds (86.81 k allocations: 2.954 MiB)\n", + "Update output\n", + " 0.040589 seconds (29.99 k allocations: 1.506 MiB)\n", + "PrognosisTime(DateTime(\"2024-01-31T00:00:00\"), DateTime(\"2024-01-31T00:00:00\"), DateTime(\"1991-01-30T00:00:00\"))\n", + "Startstates\n", + " 0.002867 seconds (3.91 k allocations: 217.695 KiB)\n", + "Price prognosis problems\n", + " 0.180159 seconds (246.40 k allocations: 7.047 MiB)\n", + "End value problems\n", + " 0.011978 seconds (1.14 k allocations: 45.250 KiB)\n", + "Subsystem problems\n", + " 0.002743 seconds (1.99 k allocations: 73.969 KiB)\n", + "Clearing problem\n", + " 0.037058 seconds (79.18 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.037716 seconds (21.97 k allocations: 1017.062 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-02T00:00:00\"), DateTime(\"2024-02-02T00:00:00\"), DateTime(\"1991-02-01T00:00:00\"))\n", + "Startstates\n", + " 0.013215 seconds (3.90 k allocations: 213.023 KiB)\n", + "Price prognosis problems\n", + " 0.183031 seconds (246.40 k allocations: 7.048 MiB)\n", + "End value problems\n", + " 0.001289 seconds (1.02 k allocations: 34.578 KiB)\n", + "Subsystem problems\n", + " 0.002947 seconds (2.11 k allocations: 86.188 KiB)\n", + "Clearing problem\n", + " 0.037629 seconds (79.18 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.027826 seconds (23.17 k allocations: 1.059 MiB)\n", + "PrognosisTime(DateTime(\"2024-02-04T00:00:00\"), DateTime(\"2024-02-04T00:00:00\"), DateTime(\"1991-02-03T00:00:00\"))\n", + "Startstates\n", + " 0.013509 seconds (3.91 k allocations: 212.086 KiB)\n", + "Price prognosis problems\n", + " 0.184199 seconds (246.40 k allocations: 7.048 MiB)\n", + "End value problems\n", + " 0.001719 seconds (1.15 k allocations: 46.234 KiB)\n", + "Subsystem problems\n", + " 0.013302 seconds (1.99 k allocations: 74.125 KiB)\n", + "Clearing problem\n", + " 0.037544 seconds (79.18 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.027669 seconds (21.97 k allocations: 1018.656 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-06T00:00:00\"), DateTime(\"2024-02-06T00:00:00\"), DateTime(\"1991-02-05T00:00:00\"))\n", + "Startstates\n", + " 0.003069 seconds (3.90 k allocations: 211.992 KiB)\n", + "Price prognosis problems\n", + " 0.185206 seconds (246.52 k allocations: 7.058 MiB)\n", + "End value problems\n", + " 0.001509 seconds (1.03 k allocations: 35.688 KiB)\n", + "Subsystem problems\n", + " 0.013451 seconds (1.99 k allocations: 73.969 KiB)\n", + "Clearing problem\n", + " 0.027630 seconds (79.18 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.037819 seconds (21.96 k allocations: 993.344 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-08T00:00:00\"), DateTime(\"2024-02-08T00:00:00\"), DateTime(\"1991-02-07T00:00:00\"))\n", + "Startstates\n", + " 0.004068 seconds (3.90 k allocations: 211.898 KiB)\n", + "Price prognosis problems\n", + " 0.175070 seconds (246.39 k allocations: 7.048 MiB)\n", + "End value problems\n", + " 0.001362 seconds (1.03 k allocations: 35.688 KiB)\n", + "Subsystem problems\n", + " 0.013801 seconds (2.10 k allocations: 84.484 KiB)\n", + "Clearing problem\n", + " 0.027748 seconds (79.19 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.038051 seconds (21.97 k allocations: 993.406 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-10T00:00:00\"), DateTime(\"2024-02-10T00:00:00\"), DateTime(\"1991-02-09T00:00:00\"))\n", + "Startstates\n", + " 0.003079 seconds (3.90 k allocations: 212.758 KiB)\n", + "Price prognosis problems\n", + " 0.174506 seconds (246.39 k allocations: 7.048 MiB)\n", + "End value problems\n", + " 0.001389 seconds (1.02 k allocations: 35.438 KiB)\n", + "Subsystem problems\n", + " 0.013947 seconds (2.10 k allocations: 84.484 KiB)\n", + "Clearing problem\n", + " 0.037525 seconds (79.19 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.027738 seconds (21.97 k allocations: 1.019 MiB)\n", + "PrognosisTime(DateTime(\"2024-02-12T00:00:00\"), DateTime(\"2024-02-12T00:00:00\"), DateTime(\"1991-02-11T00:00:00\"))\n", + "Startstates\n", + " 0.013268 seconds (3.91 k allocations: 212.086 KiB)\n", + "Price prognosis problems\n", + " 0.174359 seconds (246.40 k allocations: 7.049 MiB)\n", + "End value problems\n", + " 0.012279 seconds (1.14 k allocations: 45.250 KiB)\n", + "Subsystem problems\n", + " 0.014228 seconds (1.99 k allocations: 73.969 KiB)\n", + "Clearing problem\n", + " 0.038473 seconds (79.18 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.028195 seconds (21.97 k allocations: 993.406 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-14T00:00:00\"), DateTime(\"2024-02-14T00:00:00\"), DateTime(\"1991-02-13T00:00:00\"))\n", + "Startstates\n", + " 0.013216 seconds (3.91 k allocations: 212.148 KiB)\n", + "Price prognosis problems\n", + " 0.543111 seconds (1.08 M allocations: 32.358 MiB)\n", + "End value problems\n", + " 0.009253 seconds (27.68 k allocations: 927.562 KiB)\n", + "Subsystem problems\n", + " 0.041520 seconds (45.23 k allocations: 1.711 MiB)\n", + "Clearing problem\n", + " 0.042216 seconds (88.67 k allocations: 3.340 MiB)\n", + "Update output\n", + " 0.027969 seconds (21.97 k allocations: 992.719 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-16T00:00:00\"), DateTime(\"2024-02-16T00:00:00\"), DateTime(\"1991-02-15T00:00:00\"))\n", + "Startstates\n", + " 0.003132 seconds (3.91 k allocations: 212.055 KiB)\n", + "Price prognosis problems\n", + " 0.179695 seconds (246.40 k allocations: 7.049 MiB)\n", + "End value problems\n", + " 0.001429 seconds (1.02 k allocations: 34.828 KiB)\n", + "Subsystem problems\n", + " 0.002904 seconds (2.11 k allocations: 86.031 KiB)\n", + "Clearing problem\n", + " 0.027500 seconds (79.18 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.038229 seconds (21.97 k allocations: 993.375 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-18T00:00:00\"), DateTime(\"2024-02-18T00:00:00\"), DateTime(\"1991-02-17T00:00:00\"))\n", + "Startstates\n", + " 0.013236 seconds (3.90 k allocations: 211.961 KiB)\n", + "Price prognosis problems\n", + " 0.180282 seconds (246.40 k allocations: 7.048 MiB)\n", + "End value problems\n", + " 0.012301 seconds (1.14 k allocations: 45.250 KiB)\n", + "Subsystem problems\n", + " 0.013378 seconds (1.99 k allocations: 73.969 KiB)\n", + "Clearing problem\n", + " 0.027900 seconds (79.18 k allocations: 2.978 MiB)\n", + "Update output\n", + " 0.038815 seconds (21.96 k allocations: 993.344 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-20T00:00:00\"), DateTime(\"2024-02-20T00:00:00\"), DateTime(\"1991-02-19T00:00:00\"))\n", + "Startstates\n", + " 0.013752 seconds (3.91 k allocations: 212.148 KiB)\n", + "Price prognosis problems\n", + " 0.183366 seconds (246.39 k allocations: 7.047 MiB)\n", + "End value problems\n", + " 0.012219 seconds (1.15 k allocations: 46.141 KiB)\n", + "Subsystem problems\n", + " 0.013999 seconds (1.99 k allocations: 73.969 KiB)\n", + "Clearing problem\n", + " 0.038281 seconds (79.18 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.038132 seconds (21.96 k allocations: 993.344 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-22T00:00:00\"), DateTime(\"2024-02-22T00:00:00\"), DateTime(\"1991-02-21T00:00:00\"))\n", + "Startstates\n", + " 0.013626 seconds (4.03 k allocations: 324.133 KiB)\n", + "Price prognosis problems\n", + " 0.172365 seconds (246.39 k allocations: 7.046 MiB)\n", + "End value problems\n", + " 0.012259 seconds (1.03 k allocations: 35.781 KiB)\n", + "Subsystem problems\n", + " 0.004775 seconds (7.45 k allocations: 447.391 KiB)\n", + "Clearing problem\n", + " 0.038787 seconds (79.31 k allocations: 2.991 MiB)\n", + "Update output\n", + " 0.029311 seconds (21.97 k allocations: 993.406 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-24T00:00:00\"), DateTime(\"2024-02-24T00:00:00\"), DateTime(\"1991-02-23T00:00:00\"))\n", + "Startstates\n", + " 0.013358 seconds (3.92 k allocations: 212.211 KiB)\n", + "Price prognosis problems\n", + " 0.175818 seconds (246.40 k allocations: 7.048 MiB)\n", + "End value problems\n", + " 0.012411 seconds (1.15 k allocations: 46.109 KiB)\n", + "Subsystem problems\n", + " 0.002765 seconds (1.98 k allocations: 73.844 KiB)\n", + "Clearing problem\n", + " 0.028617 seconds (79.18 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.038745 seconds (21.96 k allocations: 993.344 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-26T00:00:00\"), DateTime(\"2024-02-26T00:00:00\"), DateTime(\"1991-02-25T00:00:00\"))\n", + "Startstates\n", + " 0.013417 seconds (3.91 k allocations: 212.914 KiB)\n", + "Price prognosis problems\n", + " 0.181561 seconds (246.40 k allocations: 7.048 MiB)\n", + "End value problems\n", + " 0.012065 seconds (1.15 k allocations: 46.203 KiB)\n", + "Subsystem problems\n", + " 0.003130 seconds (1.99 k allocations: 73.969 KiB)\n", + "Clearing problem\n", + " 0.026837 seconds (79.19 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.038092 seconds (21.97 k allocations: 993.406 KiB)\n", + "PrognosisTime(DateTime(\"2024-02-28T00:00:00\"), DateTime(\"2024-02-28T00:00:00\"), DateTime(\"1991-02-27T00:00:00\"))\n", + "Startstates\n", + " 0.013331 seconds (3.91 k allocations: 212.023 KiB)\n", + "Price prognosis problems\n", + " 0.172581 seconds (246.40 k allocations: 7.049 MiB)\n", + "End value problems\n", + " 0.011974 seconds (1.15 k allocations: 45.375 KiB)\n", + "Subsystem problems\n", + " 0.002989 seconds (1.99 k allocations: 73.969 KiB)\n", + "Clearing problem\n", + " 0.037813 seconds (79.18 k allocations: 2.979 MiB)\n", + "Update output\n", + " 0.028977 seconds (21.96 k allocations: 993.281 KiB)\n", + "\n", + "The simulation took: 0.09 minutes\n", + "Time usage per simulation step: 0.35 seconds\n", + "\n" + ] + }, + { + "data": { + "text/html": [ + "
7×5 DataFrame
Rowmodelupdatesolveothertotal
StringFloat64Float64Float64Float64
1long0.06009220.06137190.0001486750.121613
2med0.07642610.04462620.000244650.121297
3short0.02239610.06109560.002065020.0855567
4evp0.0005761420.001164880.0006906030.00243163
5mp6.78289e-50.0003867840.0009304580.00138507
6sp0.0008134180.001404620.004742060.00696009
7clearing0.007833460.01606170.002969880.0268651
" + ], + "text/latex": [ + "\\begin{tabular}{r|ccccc}\n", + "\t& model & update & solve & other & total\\\\\n", + "\t\\hline\n", + "\t& String & Float64 & Float64 & Float64 & Float64\\\\\n", + "\t\\hline\n", + "\t1 & long & 0.0600922 & 0.0613719 & 0.000148675 & 0.121613 \\\\\n", + "\t2 & med & 0.0764261 & 0.0446262 & 0.00024465 & 0.121297 \\\\\n", + "\t3 & short & 0.0223961 & 0.0610956 & 0.00206502 & 0.0855567 \\\\\n", + "\t4 & evp & 0.000576142 & 0.00116488 & 0.000690603 & 0.00243163 \\\\\n", + "\t5 & mp & 6.78289e-5 & 0.000386784 & 0.000930458 & 0.00138507 \\\\\n", + "\t6 & sp & 0.000813418 & 0.00140462 & 0.00474206 & 0.00696009 \\\\\n", + "\t7 & clearing & 0.00783346 & 0.0160617 & 0.00296988 & 0.0268651 \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m7×5 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m model \u001b[0m\u001b[1m update \u001b[0m\u001b[1m solve \u001b[0m\u001b[1m other \u001b[0m\u001b[1m total \u001b[0m\n", + " │\u001b[90m String \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", + "─────┼─────────────────────────────────────────────────────────────\n", + " 1 │ long 0.0600922 0.0613719 0.000148675 0.121613\n", + " 2 │ med 0.0764261 0.0446262 0.00024465 0.121297\n", + " 3 │ short 0.0223961 0.0610956 0.00206502 0.0855567\n", + " 4 │ evp 0.000576142 0.00116488 0.000690603 0.00243163\n", + " 5 │ mp 6.78289e-5 0.000386784 0.000930458 0.00138507\n", + " 6 │ sp 0.000813418 0.00140462 0.00474206 0.00696009\n", + " 7 │ clearing 0.00783346 0.0160617 0.00296988 0.0268651" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
10×15 DataFrame
Rowcoretotevp_totmp_totsp_totevp_uevp_sevp_omp_ump_smp_finmp_osp_usp_ssp_o
AnyFloat64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?
15.0missingmissing0.00252460.0108905missingmissingmissing0.00012360.000656258.1e-60.001736650.001537150.00160910.00774425
26.0missingmissing0.002662050.0123995missingmissingmissing0.00012490.00070147.15e-60.00182860.00156790.002449350.0083822
37.0missingmissing0.00281640.0150379missingmissingmissing0.00013610.000893859.6e-60.001776850.00157560.00284010.0106221
48.0missingmissing0.0031670.0149395missingmissingmissing0.000130350.00074251.07e-50.002283450.001572950.003124550.0102421
59.0missingmissing0.003071350.0155729missingmissingmissing0.00014480.00071771.075e-50.00219810.001572750.002690.0113101
610.0missingmissing0.002068150.0082357missingmissingmissing8.465e-50.00034665.6e-60.00163130.00080510.00079770.0066329
71.00.03210010.01624260.00146490.01439260.00290670.00559150.000968050.000137050.00084671.53e-50.000465850.001804250.002758350.00983
82.00.02836460.01030.002938350.01512610.00281050.00559540.0002367690.00014260.00092888.85e-60.00185810.00179040.003823150.0095126
93.00.02582260.0099170.00292420.01298150.002660850.005526650.0002161880.00013990.00072639.1e-60.00204890.00163180.0031060.00824365
104.00.02508630.009741250.002679350.01266570.002568650.00541920.0002191750.00012480.00078881.045e-50.00175530.001597050.00348940.00757925
" + ], + "text/latex": [ + "\\begin{tabular}{r|ccccccccc}\n", + "\t& core & tot & evp\\_tot & mp\\_tot & sp\\_tot & evp\\_u & evp\\_s & evp\\_o & \\\\\n", + "\t\\hline\n", + "\t& Any & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & \\\\\n", + "\t\\hline\n", + "\t1 & 5.0 & \\emph{missing} & \\emph{missing} & 0.0025246 & 0.0108905 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t2 & 6.0 & \\emph{missing} & \\emph{missing} & 0.00266205 & 0.0123995 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t3 & 7.0 & \\emph{missing} & \\emph{missing} & 0.0028164 & 0.0150379 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t4 & 8.0 & \\emph{missing} & \\emph{missing} & 0.003167 & 0.0149395 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t5 & 9.0 & \\emph{missing} & \\emph{missing} & 0.00307135 & 0.0155729 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t6 & 10.0 & \\emph{missing} & \\emph{missing} & 0.00206815 & 0.0082357 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", + "\t7 & 1.0 & 0.0321001 & 0.0162426 & 0.0014649 & 0.0143926 & 0.0029067 & 0.0055915 & 0.00096805 & $\\dots$ \\\\\n", + "\t8 & 2.0 & 0.0283646 & 0.0103 & 0.00293835 & 0.0151261 & 0.0028105 & 0.0055954 & 0.000236769 & $\\dots$ \\\\\n", + "\t9 & 3.0 & 0.0258226 & 0.009917 & 0.0029242 & 0.0129815 & 0.00266085 & 0.00552665 & 0.000216188 & $\\dots$ \\\\\n", + "\t10 & 4.0 & 0.0250863 & 0.00974125 & 0.00267935 & 0.0126657 & 0.00256865 & 0.0054192 & 0.000219175 & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m10×15 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m core \u001b[0m\u001b[1m tot \u001b[0m\u001b[1m evp_tot \u001b[0m\u001b[1m mp_tot \u001b[0m\u001b[1m sp_tot \u001b[0m\u001b[1m evp_u \u001b[0m ⋯\n", + " │\u001b[90m Any \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64\u001b[0m ⋯\n", + "─────┼──────────────────────────────────────────────────────────────────────────\n", + " 1 │ 5.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0025246 0.0108905 \u001b[90m missing\u001b[0m ⋯\n", + " 2 │ 6.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00266205 0.0123995 \u001b[90m missing\u001b[0m\n", + " 3 │ 7.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0028164 0.0150379 \u001b[90m missing\u001b[0m\n", + " 4 │ 8.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.003167 0.0149395 \u001b[90m missing\u001b[0m\n", + " 5 │ 9.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00307135 0.0155729 \u001b[90m missing\u001b[0m ⋯\n", + " 6 │ 10.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00206815 0.0082357 \u001b[90m missing\u001b[0m\n", + " 7 │ 1.0 0.0321001 0.0162426 0.0014649 0.0143926 0\n", + " 8 │ 2.0 0.0283646 0.0103 0.00293835 0.0151261 0\n", + " 9 │ 3.0 0.0258226 0.009917 0.0029242 0.0129815 0 ⋯\n", + " 10 │ 4.0 0.0250863 0.00974125 0.00267935 0.0126657 0\n", + "\u001b[36m 10 columns omitted\u001b[0m" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
19×15 DataFrame
Rowsubixtotevp_totmp_totsp_totevp_uevp_sevp_omp_ump_smp_finmp_osp_usp_ssp_o
AnyFloat64Float64?Float64?Float64?Float64?Float64?Float64?AnyAnyAnyAnyFloat64?Float64?Float64?
18.00.01406840.00241710.002225950.00942530.0005580.001450955.10188e-57.995e-50.000418256.7e-60.001721050.000799450.001845750.0067801
218.00.01368750.00223320.001482450.00997190.00055520.00135794.00125e-58.015e-50.00039644.35e-60.001001550.000923950.001692950.007355
31.00.01313880.007937950.0009790.00422180.00084330.000948750.0007682384.96e-50.0002924.05e-60.000633350.00075430.000792850.00267465
411.00.01286640.0021740.00227290.00841950.000545950.001293754.17875e-58.125e-50.00040526.6e-60.001779850.0008160.00158810.0060154
57.00.01204010.001736250.002068150.00823570.000565150.00085213.9875e-58.465e-50.00034665.6e-60.00163130.00080510.00079770.0066329
617.00.01190280.002382950.00139580.0081240.00056960.001416054.96625e-57.37e-50.000399855.9e-60.000916350.000831750.00164850.00564375
712.00.0118030.0016070.001807950.008388050.000561750.000701854.2925e-58.52e-50.000334954.95e-60.001382850.00080540.000776250.0068064
814.00.01179460.00229440.00175670.00774350.00056790.001429653.71063e-57.835e-50.000395053.65e-60.001279650.000799250.001604250.00534
916.00.01131240.00219240.001628350.00749170.000539450.0013623.63687e-56.805e-50.000453056.45e-60.00110080.000808450.00170010.00498315
1019.00.010350.00161090.000557750.00818140.0005550.00075113.81e-57.415e-50.000298658.75e-60.00017620.00091330.000773850.00649425
113.00.01007680.00241850.001008450.00664980.00054620.00145435.225e-55.09e-50.00055894.65e-60.0003940.00077020.002063850.00381575
124.00.01006020.0026460.00089410.006520050.00056530.00145257.8525e-54.91e-50.00033734.1e-60.00050360.000756950.001536450.00422665
1315.00.009915450.001701150.00154560.00666870.00056160.000721455.22625e-57.4e-50.000364254.05e-60.00110330.000782850.000816250.0050696
146.00.009346150.00222780.000907150.00621120.000564150.00128924.68062e-56.29e-50.000548056.55e-60.000289650.000890950.00198450.00333575
159.00.00897610.002365950.00145590.005154250.00056080.001365.56437e-56.245e-50.00053244.5e-60.000856550.000866450.00213020.0021576
165.00.008728850.00173590.00084540.006147550.000586050.000738155.14625e-56.485e-50.000299454.05e-60.000477050.00077330.000844250.00453
1710.00.008632850.0022470.00152840.004857450.00055910.001323654.55312e-56.62e-50.000326453.2e-60.001132550.000800050.00145750.0025999
1813.00.008571550.002346550.0010510.0051740.000538650.001414054.92313e-55.675e-50.000335754.0e-60.00065450.00078860.00178930.0025961
192.00.00748720.00192590.000905350.004655950.000603550.000815356.3375e-54.655e-50.000306353.5e-60.000548950.000768650.00084510.0030422
" + ], + "text/latex": [ + "\\begin{tabular}{r|ccccccccc}\n", + "\t& subix & tot & evp\\_tot & mp\\_tot & sp\\_tot & evp\\_u & evp\\_s & evp\\_o & \\\\\n", + "\t\\hline\n", + "\t& Any & Float64 & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & \\\\\n", + "\t\\hline\n", + "\t1 & 8.0 & 0.0140684 & 0.0024171 & 0.00222595 & 0.0094253 & 0.000558 & 0.00145095 & 5.10188e-5 & $\\dots$ \\\\\n", + "\t2 & 18.0 & 0.0136875 & 0.0022332 & 0.00148245 & 0.0099719 & 0.0005552 & 0.0013579 & 4.00125e-5 & $\\dots$ \\\\\n", + "\t3 & 1.0 & 0.0131388 & 0.00793795 & 0.000979 & 0.0042218 & 0.0008433 & 0.00094875 & 0.000768238 & $\\dots$ \\\\\n", + "\t4 & 11.0 & 0.0128664 & 0.002174 & 0.0022729 & 0.0084195 & 0.00054595 & 0.00129375 & 4.17875e-5 & $\\dots$ \\\\\n", + "\t5 & 7.0 & 0.0120401 & 0.00173625 & 0.00206815 & 0.0082357 & 0.00056515 & 0.0008521 & 3.9875e-5 & $\\dots$ \\\\\n", + "\t6 & 17.0 & 0.0119028 & 0.00238295 & 0.0013958 & 0.008124 & 0.0005696 & 0.00141605 & 4.96625e-5 & $\\dots$ \\\\\n", + "\t7 & 12.0 & 0.011803 & 0.001607 & 0.00180795 & 0.00838805 & 0.00056175 & 0.00070185 & 4.2925e-5 & $\\dots$ \\\\\n", + "\t8 & 14.0 & 0.0117946 & 0.0022944 & 0.0017567 & 0.0077435 & 0.0005679 & 0.00142965 & 3.71063e-5 & $\\dots$ \\\\\n", + "\t9 & 16.0 & 0.0113124 & 0.0021924 & 0.00162835 & 0.0074917 & 0.00053945 & 0.001362 & 3.63687e-5 & $\\dots$ \\\\\n", + "\t10 & 19.0 & 0.01035 & 0.0016109 & 0.00055775 & 0.0081814 & 0.000555 & 0.0007511 & 3.81e-5 & $\\dots$ \\\\\n", + "\t11 & 3.0 & 0.0100768 & 0.0024185 & 0.00100845 & 0.0066498 & 0.0005462 & 0.0014543 & 5.225e-5 & $\\dots$ \\\\\n", + "\t12 & 4.0 & 0.0100602 & 0.002646 & 0.0008941 & 0.00652005 & 0.0005653 & 0.0014525 & 7.8525e-5 & $\\dots$ \\\\\n", + "\t13 & 15.0 & 0.00991545 & 0.00170115 & 0.0015456 & 0.0066687 & 0.0005616 & 0.00072145 & 5.22625e-5 & $\\dots$ \\\\\n", + "\t14 & 6.0 & 0.00934615 & 0.0022278 & 0.00090715 & 0.0062112 & 0.00056415 & 0.0012892 & 4.68062e-5 & $\\dots$ \\\\\n", + "\t15 & 9.0 & 0.0089761 & 0.00236595 & 0.0014559 & 0.00515425 & 0.0005608 & 0.00136 & 5.56437e-5 & $\\dots$ \\\\\n", + "\t16 & 5.0 & 0.00872885 & 0.0017359 & 0.0008454 & 0.00614755 & 0.00058605 & 0.00073815 & 5.14625e-5 & $\\dots$ \\\\\n", + "\t17 & 10.0 & 0.00863285 & 0.002247 & 0.0015284 & 0.00485745 & 0.0005591 & 0.00132365 & 4.55312e-5 & $\\dots$ \\\\\n", + "\t18 & 13.0 & 0.00857155 & 0.00234655 & 0.001051 & 0.005174 & 0.00053865 & 0.00141405 & 4.92313e-5 & $\\dots$ \\\\\n", + "\t19 & 2.0 & 0.0074872 & 0.0019259 & 0.00090535 & 0.00465595 & 0.00060355 & 0.00081535 & 6.3375e-5 & $\\dots$ \\\\\n", + "\\end{tabular}\n" + ], + "text/plain": [ + "\u001b[1m19×15 DataFrame\u001b[0m\n", + "\u001b[1m Row \u001b[0m│\u001b[1m subix \u001b[0m\u001b[1m tot \u001b[0m\u001b[1m evp_tot \u001b[0m\u001b[1m mp_tot \u001b[0m\u001b[1m sp_tot \u001b[0m\u001b[1m evp_u \u001b[0m\u001b[1m evp_\u001b[0m ⋯\n", + " │\u001b[90m Any \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Floa\u001b[0m ⋯\n", + "─────┼──────────────────────────────────────────────────────────────────────────\n", + " 1 │ 8.0 0.0140684 0.0024171 0.00222595 0.0094253 0.000558 0.00 ⋯\n", + " 2 │ 18.0 0.0136875 0.0022332 0.00148245 0.0099719 0.0005552 0.00\n", + " 3 │ 1.0 0.0131388 0.00793795 0.000979 0.0042218 0.0008433 0.00\n", + " 4 │ 11.0 0.0128664 0.002174 0.0022729 0.0084195 0.00054595 0.00\n", + " 5 │ 7.0 0.0120401 0.00173625 0.00206815 0.0082357 0.00056515 0.00 ⋯\n", + " 6 │ 17.0 0.0119028 0.00238295 0.0013958 0.008124 0.0005696 0.00\n", + " 7 │ 12.0 0.011803 0.001607 0.00180795 0.00838805 0.00056175 0.00\n", + " 8 │ 14.0 0.0117946 0.0022944 0.0017567 0.0077435 0.0005679 0.00\n", + " 9 │ 16.0 0.0113124 0.0021924 0.00162835 0.0074917 0.00053945 0.00 ⋯\n", + " 10 │ 19.0 0.01035 0.0016109 0.00055775 0.0081814 0.000555 0.00\n", + " 11 │ 3.0 0.0100768 0.0024185 0.00100845 0.0066498 0.0005462 0.00\n", + " 12 │ 4.0 0.0100602 0.002646 0.0008941 0.00652005 0.0005653 0.00\n", + " 13 │ 15.0 0.00991545 0.00170115 0.0015456 0.0066687 0.0005616 0.00 ⋯\n", + " 14 │ 6.0 0.00934615 0.0022278 0.00090715 0.0062112 0.00056415 0.00\n", + " 15 │ 9.0 0.0089761 0.00236595 0.0014559 0.00515425 0.0005608 0.00\n", + " 16 │ 5.0 0.00872885 0.0017359 0.0008454 0.00614755 0.00058605 0.00\n", + " 17 │ 10.0 0.00863285 0.002247 0.0015284 0.00485745 0.0005591 0.00 ⋯\n", + " 18 │ 13.0 0.00857155 0.00234655 0.001051 0.005174 0.00053865 0.00\n", + " 19 │ 2.0 0.0074872 0.0019259 0.00090535 0.00465595 0.00060355 0.00\n", + "\u001b[36m 9 columns omitted\u001b[0m" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "Dict{Any, Any} with 23 entries:\n", + " \"demandbalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", + " \"endvaluetimes\" => Dict{Any, Any}((1, 12)=>[0.0001766 0.0002924 0.000578…\n", + " \"resindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", + " \"areanames\" => [\"SORLAND\"]\n", + " \"priceindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-2…\n", + " \"batmatrix\" => Matrix{Float64}(undef, 128, 0)\n", + " \"stateindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", + " \"statematrix\" => [547.673 4078.56 … 0.174767 0.0; 547.673 4078.56 … 0.…\n", + " \"statenames\" => [\"Reservoir_FINNMARK_hydro_reservoir_max\", \"Reservoir…\n", + " \"resnames\" => [\"Reservoir_SORLAND_hydro_reservoir\"]\n", + " \"demandvalues\" => [1.3 0.0 … 0.0831064 1.40595; 1.3 0.0 … 0.0476586 1.9…\n", + " \"batindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", + " \"resmatrix\" => [14.4024; 14.3551; … ; 13.769; 13.753;;]\n", + " \"supplybalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", + " \"supplynames\" => [\"PlantResponse_SORLAND_VALHALL\", \"Plant_SORLAND_hydr…\n", + " \"demandnames\" => [\"Transm_SORLAND->UK\", \"SlackVar_PowerBalance_SORLAND…\n", + " \"sptimes\" => Dict{Any, Any}((1, 12)=>[0.0002057 0.0003672 0.000905…\n", + " \"clearingtimes\" => [0.0073302 0.0181178 0.0310275; 0.0070494 0.0158453 0…\n", + " \"supplyvalues\" => [0.0 3.74366 … 0.0 0.254503; 0.0 6.29271 … 0.00267863…\n", + " \"batnames\" => String[]\n", + " \"prognosistimes\" => [0.0812614 0.0967173 0.178134; 0.0 0.0 0.0; … ; 0.0 0…\n", + " \"pricematrix\" => [0.256997; 0.256997; … ; 0.256799; 0.256799;;]\n", + " \"mptimes\" => Dict{Any, Any}(5=>[5.61e-5 0.0003233 3.4e-6 0.0004319…" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "\n", "dataset = getdataset(config, weatheryear)\n", diff --git a/demos/data/config_jules_prognose_demo.yml b/demos/data/config_jules_prognose_demo.yml index 0fb8b51..e4dc72d 100644 --- a/demos/data/config_jules_prognose_demo.yml +++ b/demos/data/config_jules_prognose_demo.yml @@ -59,7 +59,7 @@ threehour: startstorages: function: startmagdict - distribution_method: greedy #random #by_size #greedy + distribution_method: size_pairing #random #by_size #greedy clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true @@ -191,7 +191,7 @@ fast: # 24 hour steps, 7 static scenarios, aggregated hydro, shrinkablehorizon, solver: HighsSimplexMethod() startstorages: function: startmagdict - distribution_method: storage #random #by_size #greedy + distribution_method: size_pairing #storage #random #by_size #greedy clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: false diff --git a/src/generic_io.jl b/src/generic_io.jl index 9b9d9a6..a25f471 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -109,6 +109,8 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs dist_mp = _distribute_subsystems_elements_greedy!(subsystems, cores) elseif distribution_method == "storage" dist_mp = _distribute_subsystems_storage_greedy!(input, subsystems, cores) + elseif distribution_method == "size_pairing" + dist_mp = _distribute_subsystems_big_small!(subsystems, cores) end N = get_numscen_stoch(input) @@ -125,14 +127,40 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs end -function _distribute_subsystems_big_small!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) +function _distribute_subsystems_big_small!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) + sorted_subsystems = get_subsystem_ids_by_decending_size(subsystems) + + N = length(cores) dist = Tuple{SubsystemIx, CoreId}[] + while length(sorted_subsystems) > 0 + K = length(sorted_subsystems) + M = min(K, N) + for i in 1:M + if length(sorted_subsystems) == 0 + break + end + + # Assign the smallest subsystem to the current core + push!(dist, (sorted_subsystems[1], cores[i])) + deleteat!(sorted_subsystems, 1) + + if length(sorted_subsystems) == 0 + break + end + + # Assign the largest subsystem to the same core + push!(dist, (sorted_subsystems[end], cores[i])) + deleteat!(sorted_subsystems, length(sorted_subsystems)) + end + end return dist - end + + + function _distribute_subsystems_randomly!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) From 7356c1a5db3b03c7f03660ca76282056606d013d Mon Sep 17 00:00:00 2001 From: marynve Date: Thu, 27 Jun 2024 10:43:39 +0200 Subject: [PATCH 10/28] Remove test --- src/generic_io.jl | 4 ---- 1 file changed, 4 deletions(-) diff --git a/src/generic_io.jl b/src/generic_io.jl index a25f471..2cf2b53 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -7,10 +7,6 @@ How price prognosis problems (ppp) are distributed on cores initially """ -function testing() - println("test") - println("Hei maria") -end function get_dist_ppp(input::AbstractJulESInput) cores = get_cores(input) From 32945be2e8b82bff2376082fc6f4048eb2f4f88e Mon Sep 17 00:00:00 2001 From: marynve Date: Tue, 2 Jul 2024 08:11:58 +0200 Subject: [PATCH 11/28] Randdumb and random --- demos/data/config_jules_prognose.yml | 4 ++-- src/generic_io.jl | 34 +++++++++++++++++++++++++--- src/io.jl | 18 ++++++++++++++- 3 files changed, 50 insertions(+), 6 deletions(-) diff --git a/demos/data/config_jules_prognose.yml b/demos/data/config_jules_prognose.yml index 3c21215..5c19028 100644 --- a/demos/data/config_jules_prognose.yml +++ b/demos/data/config_jules_prognose.yml @@ -59,7 +59,7 @@ threehour: solver: HighsSimplexMethod() startstorages: function: startmagdict - distribution_method: storage #random #by_size #greedy + distribution_method: random #randdumb #storage #random #by_size #greedy clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true @@ -186,7 +186,7 @@ fast: solver: HighsSimplexMethod() startstorages: function: startmagdict - distribution_method: storage #random #by_size #greedy + distribution_method: #randdumb #storage #random #by_size #greedy #size-pairing clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true diff --git a/src/generic_io.jl b/src/generic_io.jl index 2cf2b53..3f32c07 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -97,8 +97,10 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs distribution_method = get_distribution_method(input) - if distribution_method == "random" - dist_mp = _distribute_subsystems_randomly!(subsystems_desc, cores) + if distribution_method == "randdumb" + dist_mp = _distribute_subsystems_randdumb!(subsystems_desc, cores) + elseif distribution_method == "random" + dist_mp = _distribute_subsystems_random!(subsystems_desc, cores) elseif distribution_method == "by_size" dist_mp = _distribute_subsystems_by_size!(subsystems_desc, cores) elseif distribution_method == "greedy" @@ -159,7 +161,7 @@ end -function _distribute_subsystems_randomly!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) +function _distribute_subsystems_randdumb!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) dist = Tuple{SubsystemIx, CoreId}[] @@ -176,6 +178,32 @@ function _distribute_subsystems_randomly!(subsystems::Vector{SubsystemIx}, cores return dist end +#Random but on different cores +function _distribute_subsystems_random!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) + + + dist = Tuple{SubsystemIx, CoreId}[] + + corelist = copy(cores) + + #print(corelist) + + for sub_ix in subsystems + if isempty(corelist) + corelist = copy(cores) + end + #for i in 1:length(cores) + # Randomly select a core + core = rand(corelist) + filter!(x -> x != core, corelist) # Remove the selected core from the list + print(corelist) + # Assign the subsystem to the randomly selected core + push!(dist, (sub_ix, core)) + + end + + return dist +end function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) diff --git a/src/io.jl b/src/io.jl index 1f5256f..6e92d73 100644 --- a/src/io.jl +++ b/src/io.jl @@ -710,6 +710,7 @@ function get_output_timing_local(data, steplength, skipmax) :mp_fin => sum => :mp_fin, :mp_o => sum => :mp_o, :mp_tot => sum => :mp_tot) + rename!(df_mp, :core => :core_mp) df_sp = DataFrame([name => [] for name in ["scenix", "subix", "update", "solve", "other", "core", "skipmed"]]) for (scenix, subix, core) in db.dist_sp @@ -735,7 +736,8 @@ function get_output_timing_local(data, steplength, skipmax) df_subix = outerjoin(df_evp_subix, df_mp, df_sp_subix, on = :subix) df_subix[!, :tot] = df_subix[!, :evp_tot] + df_subix[!, :mp_tot] + df_subix[!, :sp_tot] df_subix = sort(df_subix, :tot, rev=true) - df_subix = df_subix[!, [:subix, :tot, :evp_tot, :mp_tot, :sp_tot, :evp_u, :evp_s, :evp_o, :mp_u, :mp_s, :mp_fin, :mp_o, :sp_u, :sp_s, :sp_o]] + df_subix = df_subix[!, [:subix, :core_mp, :tot, :evp_tot, :mp_tot, :sp_tot, :evp_u, :evp_s, :evp_o, :mp_u, :mp_s, :mp_fin, :mp_o, :sp_u, :sp_s, :sp_o]] + df_core = outerjoin(df_evp_core, df_mp_core, df_sp_core, on = :core) df_core[!, :tot] = df_core[!, :evp_tot] + df_core[!, :mp_tot] + df_core[!, :sp_tot] @@ -757,6 +759,20 @@ function get_output_timing_local(data, steplength, skipmax) display(df_core) display(df_subix) + # # display number of elements of each type per subsystem + # unique_types = ["subix", "name_first_element", "name_second_element", "total_count"] # + # # loop gjennom get_elements(db.input) og legg til push!(unique_type, ) + # df_sub_element_type = DataFrame([name => [] for name in unique_type]) + # for (subix, subsystem) in enumerate(get_subsystems(db)) + # type_count = [] + # total_count = # sum av type_count + # name_first_element = # element.instancename + # name_second_element = + # push!(df_sub_element_type, [subix, name_first_element, name_second_element, total_count, type_count...]) + # end + # # sorter df_sub_element_type etter total_count + # display(df_sub_element_type) + if settings["results"]["times"] if haskey(settings["problems"], "prognosis") data["prognosistimes"] = timings_ppp1 From 0bfc5b6863476e204bf51e6c6bbe35b75611e0de Mon Sep 17 00:00:00 2001 From: marynve Date: Wed, 24 Jul 2024 11:02:21 +0200 Subject: [PATCH 12/28] default in get_distribution_method() and get_dist_stoch() --- src/generic_io.jl | 15 ++++++++++++--- src/io.jl | 16 +++++++++++++++- 2 files changed, 27 insertions(+), 4 deletions(-) diff --git a/src/generic_io.jl b/src/generic_io.jl index 3f32c07..019f2cf 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -94,13 +94,22 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs cores = get_cores(input) subsystems_desc = get_subsystem_ids_by_decending_size(subsystems) + distribution_method = get_distribution_method(input) - + default = "by_size" + + valid_methods = ["randdumb", "random", "by_size", "greedy", "storage", "size_pairing"] + + # Check if distribution_method is valid + if !(distribution_method in valid_methods) + println("distribution method $distribution_method is not valid. Using $default") + distribution_method = default + end if distribution_method == "randdumb" dist_mp = _distribute_subsystems_randdumb!(subsystems_desc, cores) elseif distribution_method == "random" - dist_mp = _distribute_subsystems_random!(subsystems_desc, cores) + dist_mp = _distribute_subsystems_random!(subsystems_desc, cores) elseif distribution_method == "by_size" dist_mp = _distribute_subsystems_by_size!(subsystems_desc, cores) elseif distribution_method == "greedy" @@ -124,7 +133,7 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs return (dist_mp, dist_sp) end - +#by_size function _distribute_subsystems_big_small!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) sorted_subsystems = get_subsystem_ids_by_decending_size(subsystems) diff --git a/src/io.jl b/src/io.jl index 6e92d73..6f3ba8a 100644 --- a/src/io.jl +++ b/src/io.jl @@ -97,7 +97,21 @@ get_phaseinsteps(input::DefaultJulESInput) = input.phaseinsteps get_horizons(input::DefaultJulESInput) = input.horizons -get_distribution_method(input::DefaultJulESInput) = get_settings(input)["problems"]["stochastic"]["distribution_method"] +# Define the function to get the distribution method with a default + +function get_distribution_method(input::DefaultJulESInput, default::String="by_size") + settings = get_settings(input) + + # Retrieve the distribution method value + method = settings["problems"]["stochastic"]["distribution_method"] + + # Check if the method is not nothing and not an empty string + if !isnothing(method) && !isempty(method) + return method + else + return default + end +end function get_datascenarios(datayear::Int64, weatheryear::Int64, weekstart::Int64, datanumscen::Int64, simtimetype::String) # Standard time for market clearing - perfect information so simple time type From ba13b229e19697abf88b1affa3c724b999785b54 Mon Sep 17 00:00:00 2001 From: marynve Date: Fri, 26 Jul 2024 10:16:17 +0200 Subject: [PATCH 13/28] added distribution methods for mp and sp --- demos/data/config_jules_prognose_demo.yml | 6 +- src/generic_io.jl | 222 +++++++++++++++++++--- src/io.jl | 21 +- 3 files changed, 220 insertions(+), 29 deletions(-) diff --git a/demos/data/config_jules_prognose_demo.yml b/demos/data/config_jules_prognose_demo.yml index e4dc72d..29ee5e3 100644 --- a/demos/data/config_jules_prognose_demo.yml +++ b/demos/data/config_jules_prognose_demo.yml @@ -59,7 +59,8 @@ threehour: startstorages: function: startmagdict - distribution_method: size_pairing #random #by_size #greedy + distribution_method_mp: size_pairing #random #by_size #greedy + distribution_method_sp: #greedy #with_mp clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true @@ -191,7 +192,8 @@ fast: # 24 hour steps, 7 static scenarios, aggregated hydro, shrinkablehorizon, solver: HighsSimplexMethod() startstorages: function: startmagdict - distribution_method: size_pairing #storage #random #by_size #greedy + distribution_method_mp: advanced #storage #random #by_size #greedy #advanced + distribution_method_sp: greedy #with_mp clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: false diff --git a/src/generic_io.jl b/src/generic_io.jl index 019f2cf..e371f0b 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -91,47 +91,226 @@ subsystems on cores by random choice. Scenario problems (sp) will be put on the same core as master problems (mp). """ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) + cores = get_cores(input) - subsystems_desc = get_subsystem_ids_by_decending_size(subsystems) + #Distributing the master problems/subsystems + subsystems_desc = get_subsystem_ids_by_decending_size(subsystems) - distribution_method = get_distribution_method(input) + distribution_method_mp = get_distribution_method_mp(input) default = "by_size" - valid_methods = ["randdumb", "random", "by_size", "greedy", "storage", "size_pairing"] + valid_methods_mp = ["randdumb", "random", "by_size", "greedy", "storage", "size_pairing", "advanced"] # Check if distribution_method is valid - if !(distribution_method in valid_methods) - println("distribution method $distribution_method is not valid. Using $default") - distribution_method = default + if !(distribution_method_mp in valid_methods_mp) + println("distribution method $distribution_method_mp is not valid. Using $default") + distribution_method_mp = default end - if distribution_method == "randdumb" + if distribution_method_mp == "randdumb" dist_mp = _distribute_subsystems_randdumb!(subsystems_desc, cores) - elseif distribution_method == "random" + elseif distribution_method_mp == "random" dist_mp = _distribute_subsystems_random!(subsystems_desc, cores) - elseif distribution_method == "by_size" + elseif distribution_method_mp == "by_size" dist_mp = _distribute_subsystems_by_size!(subsystems_desc, cores) - elseif distribution_method == "greedy" + elseif distribution_method_mp == "greedy" dist_mp = _distribute_subsystems_elements_greedy!(subsystems, cores) - elseif distribution_method == "storage" + elseif distribution_method_mp == "storage" dist_mp = _distribute_subsystems_storage_greedy!(input, subsystems, cores) - elseif distribution_method == "size_pairing" + elseif distribution_method_mp == "size_pairing" dist_mp = _distribute_subsystems_big_small!(subsystems, cores) + elseif distribution_method_mp == "advanced" + dist_mp = _distribute_subsystems_advanced(subsystems, cores) + dist_sp = _distribute_subscenarios_advanced!(dist_mp, cores, input) + return (dist_mp, dist_sp) + end + + + + + #Distributing scenarioproblems sp + distribution_method_sp = get_distribution_method_sp(input) + default = "with_mp" + valid_methods_sp = ["with_mp", "greedy"] + + # Check if distribution_method_sp is valid + if !(distribution_method_sp in valid_methods_sp) + println("distribution method $distribution_method_sp is not valid. Using $default") + distribution_method_sp = default + end + + if distribution_method_sp == "with_mp" + dist_sp = _distribute_sp_with_mp!(input, dist_mp) + elseif distribution_method_sp == "greedy" + core_loads = _get_core_load!(input, subsystems, dist_mp) + dist_sp = _distribute_scenarios_greedy!(input, subsystems, dist_mp, core_loads) + end + + + return (dist_mp, dist_sp) +end + +#function to get the distribution of data elements on the different cores after distributing master problems +function _get_core_load!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, dist_mp::Vector{Tuple{SubsystemIx, CoreId}}) + cores = get_cores(input) + + # Initialize a dictionary (CoreId => load) where load is initially zero + core_loads = Dict{CoreId, Int}() + for core in cores + core_loads[core] = 0 + end + + + # Create a dictionary to map SubsystemIx to AbstractSubsystem + subsystem_dict = Dict{SubsystemIx, AbstractSubsystem}() + for (ix, s) in subsystems + subsystem_dict[ix] = s end + + + for (sub_ix, core) in dist_mp + s = subsystem_dict[sub_ix] + num_elements = length(get_dataelements(s)) + + # Update the load for the core directly in the dictionary + if haskey(core_loads, core) + core_loads[core] += num_elements + + else + println("Warning: Core $core not found in core_loads dictionary. Skipping...") + end + + + end + return core_loads +end + +#The original way to distribute senario problems. Each sp is on the same core as its master problem +function _distribute_sp_with_mp!(input::AbstractJulESInput, dist_mp::Vector{Tuple{SubsystemIx, CoreId}}) + N = get_numscen_stoch(input) + dist_sp = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, N*length(dist_mp)) + i = 0 + for scen in 1:N + for (sub, core) in dist_mp + i += 1 + dist_sp[i] = (scen, sub, core) + end + end + return dist_sp +end + +#Function to distribute the scenarios on the core with least data elements +function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, dist_mp::Vector{Tuple{SubsystemIx, CoreId}}, core_loads::Dict{CoreId, Int}) + elements = get_elements(input) N = get_numscen_stoch(input) + dist_sp = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, N*length(dist_mp)) + + #vektor med tupler med subsystem id, subsystem og antall dataelementer + subsystem_elements = Tuple{SubsystemIx, Int}[] + + for (ix, s) in subsystems + push!(subsystem_elements, (ix, length(get_dataelements(s)))) + end + + #sorting subsystem_elements from largest number of data elements to lowest + sort!(subsystem_elements, by=x -> x[2], rev=true) + + #function to distribute subsystems on cores greedy + function assign_scenarios!(subsystem_elements, core_loads, dist_sp) + i=1 # Index to keep track of the position in dist_sp + for (ix, elements) in subsystem_elements + for scen in 1:N + + # Find the core with the minimum load + + min_load_core = findmin(core_loads)[2] + dist_sp[i] = (scen, ix, min_load_core) + core_loads[min_load_core] += elements + + i += 1 + end + end + end + + assign_scenarios!(subsystem_elements, core_loads, dist_sp) + + + return dist_sp +end + + + +#usikker her på om det største mp blir løst dobbelt på de to første kjernene +#koden gjør ivertfall slik at det største mp blir lagt på kjerne 1 og kjerne to, mens resten fordeles etter size på de resterende kjernene +function _distribute_subsystems_advanced(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) + + dist = Tuple{SubsystemIx, CoreId}[] + sorted_subsystems = get_subsystem_ids_by_decending_size(subsystems) #største subsystems først + + # Make a copy of the cores array to avoid modifying the original + cores_copy = copy(cores) + + #the first/largest masterproblem (subsystem) gets the two first cores + # Check if there are at least two cores + if length(cores) >= 2 + # Push the first two elements from core to dist + push!(dist, (sorted_subsystems[1], cores[1])) + push!(dist, (sorted_subsystems[1], cores[2])) + + # Remove the first subsystem and the first two cores + popfirst!(sorted_subsystems) + popfirst!(cores_copy) + popfirst!(cores_copy) + end + + #resten av mp fordeles by_size + dist_rest = _distribute_subsystems_by_size!(sorted_subsystems, cores_copy) + + # Append dist_rest to dist + append!(dist, dist_rest) + + return dist +end + +function _distribute_subscenarios_advanced!(dist_mp::Vector{Tuple{SubsystemIx, CoreId}}, cores::Vector{CoreId}, input::AbstractJulESInput) + N = get_numscen_stoch(input) + dist_sp = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, N * length(dist_mp)) i = 0 - for scen in 1:N - for (sub, core) in dist_mp + + # Split scenarios for the first subsystem across its two cores + (first_sub, first_core1) = dist_mp[1] + (first_sub, first_core2) = dist_mp[2] + + #itererer gjennom den første halvdelen av sp + for scen in 1:div(N, 2) + i += 1 + dist_sp[i] = (scen, first_sub, first_core1) + end + + #andre halvdel scenarioer får den neste kjernen + for scen in div(N, 2)+1:N + i += 1 + dist_sp[i] = (scen, first_sub, first_core2) + end + + # Distribute the rest of the scenarios as before + for j in 3:length(dist_mp) + (sub, core) = dist_mp[j] + for scen in 1:N i += 1 dist_sp[i] = (scen, sub, core) end end - return (dist_mp, dist_sp) + #fjerner uninizialiez items på slutten + dist_sp = dist_sp[1:i] + + return dist_sp end + #by_size function _distribute_subsystems_big_small!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) @@ -246,9 +425,6 @@ function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores: return dist end - - - function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) elements = get_elements(input) @@ -293,9 +469,10 @@ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsy #function to distribute subsystems on cores greedy function assign_subsystems!(subsystems, core_loads, dist) for (ix, s, num) in subsystems - min_load_core_index = argmin(core_loads) - push!(dist, (ix, min_load_core_index)) - core_loads[min_load_core_index] += num + min_load_core = argmin(core_loads) + core_id = cores[min_load_core] # Get the actual CoreId + push!(dist, (ix, core_id)) + core_loads[min_load_core] += num end end @@ -353,9 +530,6 @@ function get_subsystem_number_of_elements(subsystems::Vector{Tuple{SubsystemIx, push!(dataelements_in_each_subsystem, data_tuple) end - - - return dataelements_in_each_subsystem end diff --git a/src/io.jl b/src/io.jl index 6f3ba8a..3808bf7 100644 --- a/src/io.jl +++ b/src/io.jl @@ -97,13 +97,28 @@ get_phaseinsteps(input::DefaultJulESInput) = input.phaseinsteps get_horizons(input::DefaultJulESInput) = input.horizons -# Define the function to get the distribution method with a default +# Define the function to get the mp distribution method with a default -function get_distribution_method(input::DefaultJulESInput, default::String="by_size") +function get_distribution_method_mp(input::DefaultJulESInput, default::String="by_size") settings = get_settings(input) # Retrieve the distribution method value - method = settings["problems"]["stochastic"]["distribution_method"] + method = settings["problems"]["stochastic"]["distribution_method_mp"] + + # Check if the method is not nothing and not an empty string + if !isnothing(method) && !isempty(method) + return method + else + return default + end +end + +# Define the function to get the sp distribution method with a default +function get_distribution_method_sp(input::DefaultJulESInput, default::String="with_mp") + settings = get_settings(input) + + # Retrieve the distribution method value + method = settings["problems"]["stochastic"]["distribution_method_sp"] # Check if the method is not nothing and not an empty string if !isnothing(method) && !isempty(method) From 54e6f2d62e00768fb75601d7f58caa97cb8c8334 Mon Sep 17 00:00:00 2001 From: marynve Date: Fri, 26 Jul 2024 12:37:01 +0200 Subject: [PATCH 14/28] Fjerne bindestrek fra metodenavn --- demos/data/config_jules_prognose_demo.yml | 8 ++++---- src/generic_io.jl | 14 +++++++------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/demos/data/config_jules_prognose_demo.yml b/demos/data/config_jules_prognose_demo.yml index 29ee5e3..736cc0c 100644 --- a/demos/data/config_jules_prognose_demo.yml +++ b/demos/data/config_jules_prognose_demo.yml @@ -59,8 +59,8 @@ threehour: startstorages: function: startmagdict - distribution_method_mp: size_pairing #random #by_size #greedy - distribution_method_sp: #greedy #with_mp + distribution_method_mp: sizepairing #random #bysize #greedy + distribution_method_sp: #greedy #withmp clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true @@ -192,8 +192,8 @@ fast: # 24 hour steps, 7 static scenarios, aggregated hydro, shrinkablehorizon, solver: HighsSimplexMethod() startstorages: function: startmagdict - distribution_method_mp: advanced #storage #random #by_size #greedy #advanced - distribution_method_sp: greedy #with_mp + distribution_method_mp: advanced #storage #random #bysize #greedy #advanced + distribution_method_sp: greedy #withmp clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: false diff --git a/src/generic_io.jl b/src/generic_io.jl index e371f0b..4b9ad26 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -98,9 +98,9 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs subsystems_desc = get_subsystem_ids_by_decending_size(subsystems) distribution_method_mp = get_distribution_method_mp(input) - default = "by_size" + default = "bysize" - valid_methods_mp = ["randdumb", "random", "by_size", "greedy", "storage", "size_pairing", "advanced"] + valid_methods_mp = ["randdumb", "random", "bysize", "greedy", "storage", "sizepairing", "advanced"] # Check if distribution_method is valid if !(distribution_method_mp in valid_methods_mp) @@ -112,13 +112,13 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs dist_mp = _distribute_subsystems_randdumb!(subsystems_desc, cores) elseif distribution_method_mp == "random" dist_mp = _distribute_subsystems_random!(subsystems_desc, cores) - elseif distribution_method_mp == "by_size" + elseif distribution_method_mp == "bysize" dist_mp = _distribute_subsystems_by_size!(subsystems_desc, cores) elseif distribution_method_mp == "greedy" dist_mp = _distribute_subsystems_elements_greedy!(subsystems, cores) elseif distribution_method_mp == "storage" dist_mp = _distribute_subsystems_storage_greedy!(input, subsystems, cores) - elseif distribution_method_mp == "size_pairing" + elseif distribution_method_mp == "sizepairing" dist_mp = _distribute_subsystems_big_small!(subsystems, cores) elseif distribution_method_mp == "advanced" dist_mp = _distribute_subsystems_advanced(subsystems, cores) @@ -131,8 +131,8 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs #Distributing scenarioproblems sp distribution_method_sp = get_distribution_method_sp(input) - default = "with_mp" - valid_methods_sp = ["with_mp", "greedy"] + default = "withmp" + valid_methods_sp = ["withmp", "greedy"] # Check if distribution_method_sp is valid if !(distribution_method_sp in valid_methods_sp) @@ -140,7 +140,7 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs distribution_method_sp = default end - if distribution_method_sp == "with_mp" + if distribution_method_sp == "withmp" dist_sp = _distribute_sp_with_mp!(input, dist_mp) elseif distribution_method_sp == "greedy" core_loads = _get_core_load!(input, subsystems, dist_mp) From faf33c1cba64251917a509de86dd20579f34a99d Mon Sep 17 00:00:00 2001 From: marynve Date: Fri, 26 Jul 2024 12:55:14 +0200 Subject: [PATCH 15/28] Remove underline --- src/io.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/io.jl b/src/io.jl index 3808bf7..20a295b 100644 --- a/src/io.jl +++ b/src/io.jl @@ -99,7 +99,7 @@ get_horizons(input::DefaultJulESInput) = input.horizons # Define the function to get the mp distribution method with a default -function get_distribution_method_mp(input::DefaultJulESInput, default::String="by_size") +function get_distribution_method_mp(input::DefaultJulESInput, default::String="bysize") settings = get_settings(input) # Retrieve the distribution method value @@ -114,7 +114,7 @@ function get_distribution_method_mp(input::DefaultJulESInput, default::String="b end # Define the function to get the sp distribution method with a default -function get_distribution_method_sp(input::DefaultJulESInput, default::String="with_mp") +function get_distribution_method_sp(input::DefaultJulESInput, default::String="withmp") settings = get_settings(input) # Retrieve the distribution method value From 6785a433a98ce6d79022bb4c3b18378d56dd27e1 Mon Sep 17 00:00:00 2001 From: marynve Date: Mon, 29 Jul 2024 13:52:34 +0200 Subject: [PATCH 16/28] change advanced distribution --- src/generic_io.jl | 41 ++++++++++++++++++++++++----------------- 1 file changed, 24 insertions(+), 17 deletions(-) diff --git a/src/generic_io.jl b/src/generic_io.jl index 4b9ad26..b3a3406 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -121,7 +121,7 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs elseif distribution_method_mp == "sizepairing" dist_mp = _distribute_subsystems_big_small!(subsystems, cores) elseif distribution_method_mp == "advanced" - dist_mp = _distribute_subsystems_advanced(subsystems, cores) + dist_mp = _distribute_subsystems_advanced!(subsystems, cores) dist_sp = _distribute_subscenarios_advanced!(dist_mp, cores, input) return (dist_mp, dist_sp) end @@ -243,22 +243,23 @@ end -#usikker her på om det største mp blir løst dobbelt på de to første kjernene -#koden gjør ivertfall slik at det største mp blir lagt på kjerne 1 og kjerne to, mens resten fordeles etter size på de resterende kjernene -function _distribute_subsystems_advanced(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) + + +#making the largest MP get the two first cores by assigning largest MP to core 1 and "reserving" core two for its SP +function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) dist = Tuple{SubsystemIx, CoreId}[] sorted_subsystems = get_subsystem_ids_by_decending_size(subsystems) #største subsystems først - # Make a copy of the cores array to avoid modifying the original + # Make a copy of the cores array to avoid modifying the original cores_copy = copy(cores) #the first/largest masterproblem (subsystem) gets the two first cores - # Check if there are at least two cores - if length(cores) >= 2 - # Push the first two elements from core to dist + # Check if there are at least two cores + if length(cores) >= 2 + push!(dist, (sorted_subsystems[1], cores[1])) - push!(dist, (sorted_subsystems[1], cores[2])) + # Remove the first subsystem and the first two cores popfirst!(sorted_subsystems) @@ -266,7 +267,7 @@ function _distribute_subsystems_advanced(subsystems::Vector{Tuple{SubsystemIx, A popfirst!(cores_copy) end - #resten av mp fordeles by_size + #the rest of the masterproblems are distributed by_size dist_rest = _distribute_subsystems_by_size!(sorted_subsystems, cores_copy) # Append dist_rest to dist @@ -275,29 +276,33 @@ function _distribute_subsystems_advanced(subsystems::Vector{Tuple{SubsystemIx, A return dist end +# Function to split the scenario problems of the largest MP on the first two cores, and then distribute the rest of SP as before function _distribute_subscenarios_advanced!(dist_mp::Vector{Tuple{SubsystemIx, CoreId}}, cores::Vector{CoreId}, input::AbstractJulESInput) N = get_numscen_stoch(input) dist_sp = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, N * length(dist_mp)) i = 0 - # Split scenarios for the first subsystem across its two cores - (first_sub, first_core1) = dist_mp[1] - (first_sub, first_core2) = dist_mp[2] + # Get the first two cores from the cores input + first_core1 = cores[1] + first_core2 = cores[2] + + # Find the largest MP problem + first_sub = dist_mp[1][1] - #itererer gjennom den første halvdelen av sp + # Iterate through the first half of SP for scen in 1:div(N, 2) i += 1 dist_sp[i] = (scen, first_sub, first_core1) end - #andre halvdel scenarioer får den neste kjernen + # The second half of scenarios get the next core for scen in div(N, 2)+1:N i += 1 dist_sp[i] = (scen, first_sub, first_core2) end # Distribute the rest of the scenarios as before - for j in 3:length(dist_mp) + for j in 2:length(dist_mp) (sub, core) = dist_mp[j] for scen in 1:N i += 1 @@ -305,11 +310,13 @@ function _distribute_subscenarios_advanced!(dist_mp::Vector{Tuple{SubsystemIx, C end end - #fjerner uninizialiez items på slutten + # Remove uninitialized items at the end dist_sp = dist_sp[1:i] return dist_sp end + + #by_size From d7979939f502eb7ede5fd1401dbb758ed6edd9e3 Mon Sep 17 00:00:00 2001 From: marynve Date: Mon, 29 Jul 2024 15:10:13 +0200 Subject: [PATCH 17/28] Commenting generic_io --- src/generic_io.jl | 113 +++++++++++++++++++++------------------------- 1 file changed, 52 insertions(+), 61 deletions(-) diff --git a/src/generic_io.jl b/src/generic_io.jl index b3a3406..6982379 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -71,31 +71,13 @@ function get_core_cp(input::AbstractJulESInput) end # TODO: Is it a better default to minimize total object count on each core? (Can lead to one big subsystem on one core and several subsystems on others). More complicated. -""" -Will try to distribute small and large subsystems evenly on cores. - -E.g. if cores = [1, 2, 3] and subsystems = [3, 6, 1, 4, 5, 2] -where the list of subsystems is sorted from biggest subsystem to smallest -where size is defined as number of objects in the subsystem. - -Then, distribution on cores should be: -- Core 1: Index 1 and 6 (that is, subsystem 3 and 2) (i.e. biggest and smallest) -- Core 2: Index 2 and 5 (that is, subsystem 6 and 5) (i.e. next biggest and next smallest) -- Core 3: Index 3 and 4 (that is, subsystem 1 and 4) (i.e. next next biggest and next next smallest) - -This way, a core that get a relatively big system in one pass, -will get a relatively small system in the next pass. -This should ensure to balance load better than e.g. distributing -subsystems on cores by random choice. -Scenario problems (sp) will be put on the same core as master problems (mp). -""" function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) cores = get_cores(input) #Distributing the master problems/subsystems - subsystems_desc = get_subsystem_ids_by_decending_size(subsystems) + distribution_method_mp = get_distribution_method_mp(input) default = "bysize" @@ -108,12 +90,13 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs distribution_method_mp = default end + if distribution_method_mp == "randdumb" - dist_mp = _distribute_subsystems_randdumb!(subsystems_desc, cores) + dist_mp = _distribute_subsystems_randdumb!(subsystems, cores) elseif distribution_method_mp == "random" - dist_mp = _distribute_subsystems_random!(subsystems_desc, cores) + dist_mp = _distribute_subsystems_random!(subsystems, cores) elseif distribution_method_mp == "bysize" - dist_mp = _distribute_subsystems_by_size!(subsystems_desc, cores) + dist_mp = _distribute_subsystems_by_size!(subsystems, cores) elseif distribution_method_mp == "greedy" dist_mp = _distribute_subsystems_elements_greedy!(subsystems, cores) elseif distribution_method_mp == "storage" @@ -123,6 +106,7 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs elseif distribution_method_mp == "advanced" dist_mp = _distribute_subsystems_advanced!(subsystems, cores) dist_sp = _distribute_subscenarios_advanced!(dist_mp, cores, input) + #Returning here to avoid the rest of the code, since dist_mp is already decided return (dist_mp, dist_sp) end @@ -143,7 +127,9 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs if distribution_method_sp == "withmp" dist_sp = _distribute_sp_with_mp!(input, dist_mp) elseif distribution_method_sp == "greedy" + #Using _get_core_load!() to get the core loads core_loads = _get_core_load!(input, subsystems, dist_mp) + #using _distribute_scenarios_greedy!() to find the distribution of scenario problems dist_sp = _distribute_scenarios_greedy!(input, subsystems, dist_mp, core_loads) end @@ -151,7 +137,7 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs return (dist_mp, dist_sp) end -#function to get the distribution of data elements on the different cores after distributing master problems +"""Function to get the distribution of data elements on the different cores after distributing master problems""" function _get_core_load!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, dist_mp::Vector{Tuple{SubsystemIx, CoreId}}) cores = get_cores(input) @@ -186,7 +172,8 @@ function _get_core_load!(input::AbstractJulESInput, subsystems::Vector{Tuple{Sub return core_loads end -#The original way to distribute senario problems. Each sp is on the same core as its master problem +#withmp +"""The original way to distribute senario problems. Each sp is on the same core as its master problem""" function _distribute_sp_with_mp!(input::AbstractJulESInput, dist_mp::Vector{Tuple{SubsystemIx, CoreId}}) N = get_numscen_stoch(input) dist_sp = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, N*length(dist_mp)) @@ -200,7 +187,8 @@ function _distribute_sp_with_mp!(input::AbstractJulESInput, dist_mp::Vector{Tupl return dist_sp end -#Function to distribute the scenarios on the core with least data elements +#greedy +"""Function to distribute the scenarios on the core with least data elements""" function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, dist_mp::Vector{Tuple{SubsystemIx, CoreId}}, core_loads::Dict{CoreId, Int}) elements = get_elements(input) @@ -241,11 +229,8 @@ function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Ve return dist_sp end - - - - -#making the largest MP get the two first cores by assigning largest MP to core 1 and "reserving" core two for its SP +#advanced +"""Making the largest MP get the two first cores by assigning largest MP to core 1 and "reserving" core two for its SP""" function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) dist = Tuple{SubsystemIx, CoreId}[] @@ -276,7 +261,8 @@ function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, return dist end -# Function to split the scenario problems of the largest MP on the first two cores, and then distribute the rest of SP as before +#advanced +"""Function to split the scenario problems of the largest MP on the first two cores, and then distribute the rest of SP as before""" function _distribute_subscenarios_advanced!(dist_mp::Vector{Tuple{SubsystemIx, CoreId}}, cores::Vector{CoreId}, input::AbstractJulESInput) N = get_numscen_stoch(input) dist_sp = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, N * length(dist_mp)) @@ -316,10 +302,8 @@ function _distribute_subscenarios_advanced!(dist_mp::Vector{Tuple{SubsystemIx, C return dist_sp end - - - -#by_size +#sizepairing +"""Function to sort all subsystems from biggest to smallest in a list, distribute smallest and biggest subsystem on the same core, removing them from the list and repeating until all subsystems are distributed on cores""" function _distribute_subsystems_big_small!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) sorted_subsystems = get_subsystem_ids_by_decending_size(subsystems) @@ -352,79 +336,80 @@ function _distribute_subsystems_big_small!(subsystems::Vector{Tuple{SubsystemIx, return dist end - - - - -function _distribute_subsystems_randdumb!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) +#randdumb +""" Function to distribute the subsystems on completely random cores""" +function _distribute_subsystems_randdumb!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) dist = Tuple{SubsystemIx, CoreId}[] - for sub_ix in subsystems + for (ix, s) in subsystems # Randomly select a core core = rand(cores) # Assign the subsystem to the randomly selected core - push!(dist, (sub_ix, core)) + push!(dist, (ix, core)) end return dist end -#Random but on different cores -function _distribute_subsystems_random!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) +#random +"""Function to distribute the subsystems on random cores, but on different cores until all cores have subproblems assigned to them, then again until all cores have 2 subproblems assigned to them, and so on""" +function _distribute_subsystems_random!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) dist = Tuple{SubsystemIx, CoreId}[] corelist = copy(cores) - #print(corelist) - for sub_ix in subsystems + for (ix, s) in subsystems if isempty(corelist) corelist = copy(cores) end - #for i in 1:length(cores) - # Randomly select a core core = rand(corelist) filter!(x -> x != core, corelist) # Remove the selected core from the list print(corelist) # Assign the subsystem to the randomly selected core - push!(dist, (sub_ix, core)) + push!(dist, (ix, core)) end return dist end - -function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores::Vector{CoreId}) +#bysize +""" +Function that distributes the subsystems by size. +""" +function _distribute_subsystems_by_size!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) N = length(cores) + subsystems_desc = get_subsystem_ids_by_decending_size(subsystems) + dist = Tuple{SubsystemIx, CoreId}[] loop_forward = true - while length(subsystems) > 0 - K = length(subsystems) + while length(subsystems_desc) > 0 + K = length(subsystems_desc) M = min(K, N) if loop_forward for i in 1:M - push!(dist, (subsystems[i], cores[i])) + push!(dist, (subsystems_desc[i], cores[i])) end - subsystems = subsystems[(M+1):end] + subsystems_desc = subsystems_desc[(M+1):end] loop_forward = false else for i in 1:M j = K - (i-1) - push!(dist, (subsystems[j], cores[i])) + push!(dist, (subsystems_desc[j], cores[i])) end - subsystems = subsystems[1:(K-M)] + subsystems_desc = subsystems_desc[1:(K-M)] loop_forward = true end end @@ -432,7 +417,8 @@ function _distribute_subsystems_by_size!(subsystems::Vector{SubsystemIx}, cores: return dist end - +#storage +"""Function that first distributes the subsystems with the highest number of storage elements on the cores with the lowest number of dataelements, then the remaining subsystems are distributed on the core with fewest dataelements one by one. """ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) elements = get_elements(input) @@ -448,6 +434,7 @@ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsy for (ix, s) in subsystems + elements_ix_in_subsystem = get_dataelements(s) elements_in_subsystem = elements[elements_ix_in_subsystem] @@ -490,13 +477,15 @@ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsy end - +"""Function to sort subsystems by decending number of dataelements """ function get_subsystem_ids_by_decending_size(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) subsystems = [(length(get_dataelements(s)), ix) for (ix, s) in subsystems] sort!(subsystems, rev=true) return [ix for (n, ix) in subsystems] end +#greedy +""" Function to distribute subsystems greedy by number of dataelements. First sorting the subsystems in decreasing order, then placing them from biggest to smallest on the core with fewst dataelements.""" function _distribute_subsystems_elements_greedy!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) @@ -520,7 +509,7 @@ end -#function to get a tuple(subsystem index, number of data elements) that is sorted from highest to lowest number of data elements in the subsystem +"""function to get a tuple(subsystem index, number of data elements) that is sorted from highest to lowest number of data elements in the subsystem""" function get_subsystem_number_of_elements(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) dataelements_in_each_subsystem = Tuple{SubsystemIx, Int}[] @@ -542,7 +531,7 @@ end """ -Find which subsystems should have evp and stoch problems +Find which subsystems should have evp problems """ function get_subsystems_evp(allsubsystems::Vector{AbstractSubsystem}) subsystems = Tuple{SubsystemIx, AbstractSubsystem}[] @@ -553,6 +542,8 @@ function get_subsystems_evp(allsubsystems::Vector{AbstractSubsystem}) end return subsystems end + +""" Find which subsystems should have stoch problems""" function get_subsystems_stoch(allsubsystems::Vector{AbstractSubsystem}) subsystems = Tuple{SubsystemIx, AbstractSubsystem}[] for (i, subsystem) in enumerate(allsubsystems) From 78f306f4e914aca43cc616c8608422314f95567a Mon Sep 17 00:00:00 2001 From: marynve Date: Tue, 30 Jul 2024 09:13:42 +0200 Subject: [PATCH 18/28] Comments io.jl --- src/io.jl | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/io.jl b/src/io.jl index 20a295b..62ac97d 100644 --- a/src/io.jl +++ b/src/io.jl @@ -96,9 +96,11 @@ get_phaseindelta(input::DefaultJulESInput) = input.phaseindelta get_phaseinsteps(input::DefaultJulESInput) = input.phaseinsteps get_horizons(input::DefaultJulESInput) = input.horizons +""" -# Define the function to get the mp distribution method with a default - +Returns the subsystem distribution method from the config file. If there is no distribution method, the default method "bysize" is returned. +"Bysize" is the orginal method where the subsystems are sorted from biggest to smallest, and then distributed forward and then backward until all subsystems are distributed. +""" function get_distribution_method_mp(input::DefaultJulESInput, default::String="bysize") settings = get_settings(input) @@ -113,7 +115,11 @@ function get_distribution_method_mp(input::DefaultJulESInput, default::String="b end end -# Define the function to get the sp distribution method with a default + +""" +Returns the scenario problem distribution method from the config file. If there is no distribution method, the default method "withmp" is returned. +Withmp is the original method where scenarios are distributed on the same core as the master problem. +""" function get_distribution_method_sp(input::DefaultJulESInput, default::String="withmp") settings = get_settings(input) From 03d24465cc5bbce9f1931a18c8aaf927f7f68cd1 Mon Sep 17 00:00:00 2001 From: marynve Date: Tue, 30 Jul 2024 09:25:08 +0200 Subject: [PATCH 19/28] sync --- .vscode/settings.json | 2 ++ demos/start_julia_v1.9.bat | 1 + start_julia_v1.9.bat | 1 + 3 files changed, 4 insertions(+) create mode 100644 .vscode/settings.json create mode 100644 demos/start_julia_v1.9.bat create mode 100644 start_julia_v1.9.bat diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..7a73a41 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,2 @@ +{ +} \ No newline at end of file diff --git a/demos/start_julia_v1.9.bat b/demos/start_julia_v1.9.bat new file mode 100644 index 0000000..3281f9e --- /dev/null +++ b/demos/start_julia_v1.9.bat @@ -0,0 +1 @@ +"X:\Programmer\Julia\Julia-1.9.2\bin\julia.exe" \ No newline at end of file diff --git a/start_julia_v1.9.bat b/start_julia_v1.9.bat new file mode 100644 index 0000000..3281f9e --- /dev/null +++ b/start_julia_v1.9.bat @@ -0,0 +1 @@ +"X:\Programmer\Julia\Julia-1.9.2\bin\julia.exe" \ No newline at end of file From 5513055fbb51d1e37a7c9412dfea9a9e8051ba3c Mon Sep 17 00:00:00 2001 From: marynve Date: Thu, 1 Aug 2024 14:18:40 +0200 Subject: [PATCH 20/28] 01.08 --- demos/data/config_jules_prognose_demo.yml | 14 ++--- src/generic_io.jl | 62 ++++++++++++++++++----- src/io.jl | 7 ++- src/prob_stoch.jl | 17 ++++++- 4 files changed, 76 insertions(+), 24 deletions(-) diff --git a/demos/data/config_jules_prognose_demo.yml b/demos/data/config_jules_prognose_demo.yml index 736cc0c..fb4a853 100644 --- a/demos/data/config_jules_prognose_demo.yml +++ b/demos/data/config_jules_prognose_demo.yml @@ -4,16 +4,16 @@ main: datayears: [2024] weatheryears: [1991, 1991] - weekstart: 5 + weekstart: 21 # simulationyears: 1 # extrasteps: 0 # see steplength_hours # settings: fast # fast, threehour, sixhour - simulationyears: 0 + simulationyears: 1 extrasteps: 16 # see steplength_hours - settings: fast # fast, threehour + settings: threehour # fast, threehour outputformat: "juliadict" # hdf5 hvis du kjører gjennom JulESIO outputindex: datayear # standard for paralellsimulering @@ -59,8 +59,8 @@ threehour: startstorages: function: startmagdict - distribution_method_mp: sizepairing #random #bysize #greedy - distribution_method_sp: #greedy #withmp + distribution_method_mp: greedy #random #bysize #greedy + distribution_method_sp: greedy #withmp clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true @@ -192,8 +192,8 @@ fast: # 24 hour steps, 7 static scenarios, aggregated hydro, shrinkablehorizon, solver: HighsSimplexMethod() startstorages: function: startmagdict - distribution_method_mp: advanced #storage #random #bysize #greedy #advanced - distribution_method_sp: greedy #withmp + distribution_method_mp: storage #storage #random #bysize #greedy #advanced + distribution_method_sp: withmp #withmp clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: false diff --git a/src/generic_io.jl b/src/generic_io.jl index 6982379..773f33a 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -77,11 +77,10 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs cores = get_cores(input) #Distributing the master problems/subsystems - - distribution_method_mp = get_distribution_method_mp(input) default = "bysize" + valid_methods_mp = ["randdumb", "random", "bysize", "greedy", "storage", "sizepairing", "advanced"] # Check if distribution_method is valid @@ -229,35 +228,72 @@ function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Ve return dist_sp end +# #advanced +# """Making the largest MP get the two first cores by assigning largest MP to core 1 and "reserving" core two for its SP""" +# function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) + +# dist = Tuple{SubsystemIx, CoreId}[] +# sorted_subsystems = get_subsystem_ids_by_decending_size(subsystems) #største subsystems først +# print("sorted_subsystems:") +# print(sorted_subsystems) +# # Make a copy of the cores array to avoid modifying the original +# cores_copy = copy(cores) + +# #the first/largest masterproblem (subsystem) gets the two first cores +# # Check if there are at least two cores +# if length(cores) >= 2 + +# push!(dist, (sorted_subsystems[1], cores[1])) + + +# # Remove the first subsystem and the first two cores +# popfirst!(sorted_subsystems) +# popfirst!(cores_copy) +# popfirst!(cores_copy) +# end + +# #the rest of the masterproblems are distributed by_size +# dist_rest = _distribute_subsystems_by_size!(subsystems, cores_copy) + +# # Append dist_rest to dist +# append!(dist, dist_rest) + +# return dist +# end + #advanced """Making the largest MP get the two first cores by assigning largest MP to core 1 and "reserving" core two for its SP""" function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) - + dist = Tuple{SubsystemIx, CoreId}[] sorted_subsystems = get_subsystem_ids_by_decending_size(subsystems) #største subsystems først - + println("sorted subsystems") + println(sorted_subsystems) + # Make a copy of the cores array to avoid modifying the original cores_copy = copy(cores) - + subsystems_copy = copy(subsystems) + #the first/largest masterproblem (subsystem) gets the two first cores # Check if there are at least two cores if length(cores) >= 2 - + push!(dist, (sorted_subsystems[1], cores[1])) - - + + print(sorted_subsystems[1]) + # Remove the first subsystem and the first two cores - popfirst!(sorted_subsystems) + deleteat!(subsystems_copy, sorted_subsystems[1]) popfirst!(cores_copy) popfirst!(cores_copy) end - + #the rest of the masterproblems are distributed by_size - dist_rest = _distribute_subsystems_by_size!(sorted_subsystems, cores_copy) - + dist_rest = _distribute_subsystems_by_size!(subsystems_copy, cores_copy) + # Append dist_rest to dist append!(dist, dist_rest) - + return dist end diff --git a/src/io.jl b/src/io.jl index 62ac97d..93e89d8 100644 --- a/src/io.jl +++ b/src/io.jl @@ -105,7 +105,9 @@ function get_distribution_method_mp(input::DefaultJulESInput, default::String="b settings = get_settings(input) # Retrieve the distribution method value - method = settings["problems"]["stochastic"]["distribution_method_mp"] + + + method = get(settings["problems"]["stochastic"],"distribution_method_mp", default) # Check if the method is not nothing and not an empty string if !isnothing(method) && !isempty(method) @@ -123,8 +125,9 @@ Withmp is the original method where scenarios are distributed on the same core a function get_distribution_method_sp(input::DefaultJulESInput, default::String="withmp") settings = get_settings(input) + # Retrieve the distribution method value - method = settings["problems"]["stochastic"]["distribution_method_sp"] + method = get(settings["problems"]["stochastic"],"distribution_method_sp", default) # Check if the method is not nothing and not an empty string if !isnothing(method) && !isempty(method) diff --git a/src/prob_stoch.jl b/src/prob_stoch.jl index 472ae64..743c455 100644 --- a/src/prob_stoch.jl +++ b/src/prob_stoch.jl @@ -48,7 +48,8 @@ end function solve_stoch(t, delta, stepnr, skipmed) db = get_local_db() - + + for (subix, core) in db.dist_mp if core == db.core subsystem = db.subsystems[subix] @@ -67,12 +68,18 @@ function solve_stoch(t, delta, stepnr, skipmed) @sync for _core in get_cores(db) @spawnat _core update_sps(t, stepnr, subix) end - + + + solve_benders(stepnr, subix) + + + maintiming[3] = @elapsed final_solve_mp(t, mp.prob) end end end + end function update_sps(t, stepnr, subix) @@ -112,6 +119,7 @@ function solve_benders(stepnr, subix) maintiming = mp.div[MainTiming] count = 0 + max_inner_iterations = 50 cutreuse = true if stepnr == 1 cutreuse = false @@ -121,6 +129,11 @@ function solve_benders(stepnr, subix) reltol = settings["problems"]["stochastic"]["reltol"] # relative tolerance while !((abs((ub-lb)/ub) < reltol) || abs(ub-lb) < 1) + if (count >= max_inner_iterations) + print("max_inner_iterations is met!!!!") + #break + end + println("count $count, ") count == 0 && setwarmstart!(mp.prob, false) maintiming[2] += @elapsed begin From e66becb27cd9405eeec0319a5bd07993e314b170 Mon Sep 17 00:00:00 2001 From: marynve Date: Fri, 2 Aug 2024 12:15:05 +0200 Subject: [PATCH 21/28] remove max_iterations from solve_benders --- src/prob_stoch.jl | 5 ----- 1 file changed, 5 deletions(-) diff --git a/src/prob_stoch.jl b/src/prob_stoch.jl index 743c455..9f2d8b9 100644 --- a/src/prob_stoch.jl +++ b/src/prob_stoch.jl @@ -119,7 +119,6 @@ function solve_benders(stepnr, subix) maintiming = mp.div[MainTiming] count = 0 - max_inner_iterations = 50 cutreuse = true if stepnr == 1 cutreuse = false @@ -129,10 +128,6 @@ function solve_benders(stepnr, subix) reltol = settings["problems"]["stochastic"]["reltol"] # relative tolerance while !((abs((ub-lb)/ub) < reltol) || abs(ub-lb) < 1) - if (count >= max_inner_iterations) - print("max_inner_iterations is met!!!!") - #break - end println("count $count, ") count == 0 && setwarmstart!(mp.prob, false) From 080c5fe7b11523edcdadf501cadf1e781729d6b2 Mon Sep 17 00:00:00 2001 From: Ingrid Wiig Arnesen Date: Fri, 2 Aug 2024 12:17:40 +0200 Subject: [PATCH 22/28] updated advanced --- src/generic_io.jl | 14 ++++++-------- 1 file changed, 6 insertions(+), 8 deletions(-) diff --git a/src/generic_io.jl b/src/generic_io.jl index 6982379..3d432f8 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -112,7 +112,6 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs - #Distributing scenarioproblems sp distribution_method_sp = get_distribution_method_sp(input) default = "withmp" @@ -132,8 +131,6 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs #using _distribute_scenarios_greedy!() to find the distribution of scenario problems dist_sp = _distribute_scenarios_greedy!(input, subsystems, dist_mp, core_loads) end - - return (dist_mp, dist_sp) end @@ -229,15 +226,16 @@ function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Ve return dist_sp end -#advanced +#advanced MP """Making the largest MP get the two first cores by assigning largest MP to core 1 and "reserving" core two for its SP""" function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) dist = Tuple{SubsystemIx, CoreId}[] sorted_subsystems = get_subsystem_ids_by_decending_size(subsystems) #største subsystems først - + # Make a copy of the cores array to avoid modifying the original cores_copy = copy(cores) + subsystems_copy = copy(subsystems) #the first/largest masterproblem (subsystem) gets the two first cores # Check if there are at least two cores @@ -247,13 +245,13 @@ function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, # Remove the first subsystem and the first two cores - popfirst!(sorted_subsystems) + deleteat!(subsystems_copy, sorted_subsystems[1]) popfirst!(cores_copy) popfirst!(cores_copy) end #the rest of the masterproblems are distributed by_size - dist_rest = _distribute_subsystems_by_size!(sorted_subsystems, cores_copy) + dist_rest = _distribute_subsystems_by_size!(subsystems_copy, cores_copy) # Append dist_rest to dist append!(dist, dist_rest) @@ -261,7 +259,7 @@ function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, return dist end -#advanced +#advanced SP """Function to split the scenario problems of the largest MP on the first two cores, and then distribute the rest of SP as before""" function _distribute_subscenarios_advanced!(dist_mp::Vector{Tuple{SubsystemIx, CoreId}}, cores::Vector{CoreId}, input::AbstractJulESInput) N = get_numscen_stoch(input) From 26285874cc3554f78d3c25070cd1f69cf84cdbed Mon Sep 17 00:00:00 2001 From: Ingrid Wiig Arnesen Date: Mon, 5 Aug 2024 12:05:16 +0200 Subject: [PATCH 23/28] removed prints --- src/generic_io.jl | 3 --- src/prob_stoch.jl | 2 -- 2 files changed, 5 deletions(-) diff --git a/src/generic_io.jl b/src/generic_io.jl index 8150335..b2754a5 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -243,8 +243,6 @@ function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, push!(dist, (sorted_subsystems[1], cores[1])) - print(sorted_subsystems[1]) - # Remove the first subsystem and the first two cores deleteat!(subsystems_copy, sorted_subsystems[1]) popfirst!(cores_copy) @@ -370,7 +368,6 @@ function _distribute_subsystems_random!(subsystems::Vector{Tuple{SubsystemIx, Ab end core = rand(corelist) filter!(x -> x != core, corelist) # Remove the selected core from the list - print(corelist) # Assign the subsystem to the randomly selected core push!(dist, (ix, core)) diff --git a/src/prob_stoch.jl b/src/prob_stoch.jl index 9f2d8b9..1da4a9f 100644 --- a/src/prob_stoch.jl +++ b/src/prob_stoch.jl @@ -128,9 +128,7 @@ function solve_benders(stepnr, subix) reltol = settings["problems"]["stochastic"]["reltol"] # relative tolerance while !((abs((ub-lb)/ub) < reltol) || abs(ub-lb) < 1) - println("count $count, ") count == 0 && setwarmstart!(mp.prob, false) - maintiming[2] += @elapsed begin if cutreuse # try to reuse cuts from last time step try From 41508a66dcc49230ce0c5cc78d2541a7d99738dc Mon Sep 17 00:00:00 2001 From: ingridwarnesen Date: Thu, 8 Aug 2024 14:16:32 +0200 Subject: [PATCH 24/28] cleaned, uncommented dist in config, cleared outputs, replaced config_prognose with config_demo_prognose --- demos/Demo prognosis.ipynb | 551 +--------------------- demos/data/config_jules_prognose.yml | 253 +++++----- demos/data/config_jules_prognose_demo.yml | 269 ----------- src/generic_io.jl | 60 +-- src/io.jl | 7 - 5 files changed, 177 insertions(+), 963 deletions(-) delete mode 100644 demos/data/config_jules_prognose_demo.yml diff --git a/demos/Demo prognosis.ipynb b/demos/Demo prognosis.ipynb index 39453fe..577aca3 100644 --- a/demos/Demo prognosis.ipynb +++ b/demos/Demo prognosis.ipynb @@ -18,37 +18,10 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "id": "6d67dd8b", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[36m\u001b[1mProject\u001b[22m\u001b[39m JulES v0.1.0\n", - "\u001b[32m\u001b[1mStatus\u001b[22m\u001b[39m `X:\\Prosjekter\\2022_FoU_markedsmodell_julia\\Brukere\\mary\\JulES\\Project.toml`\n", - " \u001b[90m[336ed68f] \u001b[39mCSV v0.10.14\n", - " \u001b[90m[aaaa29a8] \u001b[39mClustering v0.15.7\n", - " \u001b[90m[a93c6f00] \u001b[39mDataFrames v1.6.1\n", - " \u001b[90m[aaf54ef3] \u001b[39mDistributedArrays v0.6.7\n", - "\u001b[32m⌃\u001b[39m \u001b[90m[31c24e10] \u001b[39mDistributions v0.25.107\n", - " \u001b[90m[7073ff75] \u001b[39mIJulia v1.24.2\n", - " \u001b[90m[682c06a0] \u001b[39mJSON v0.21.4\n", - " \u001b[90m[f0f68f2c] \u001b[39mPlotlyJS v0.18.13\n", - " \u001b[90m[91a5bcdd] \u001b[39mPlots v1.40.4\n", - "\u001b[32m⌃\u001b[39m \u001b[90m[aea7be01] \u001b[39mPrecompileTools v1.2.0\n", - " \u001b[90m[08abe8d2] \u001b[39mPrettyTables v2.3.2\n", - " \u001b[90m[295af30f] \u001b[39mRevise v3.5.14\n", - " \u001b[90m[970f5c25] \u001b[39mTuLiPa v0.1.0 `https://github.com/NVE/TuLiPa.git#redesign_JulES`\n", - "\u001b[32m⌃\u001b[39m \u001b[90m[ddb6d928] \u001b[39mYAML v0.4.9\n", - " \u001b[90m[ade2ca70] \u001b[39mDates\n", - " \u001b[90m[8ba89e20] \u001b[39mDistributed\n", - " \u001b[90m[10745b16] \u001b[39mStatistics v1.9.0\n", - "\u001b[36m\u001b[1mInfo\u001b[22m\u001b[39m Packages marked with \u001b[32m⌃\u001b[39m have new versions available and may be upgradable.\n" - ] - } - ], + "outputs": [], "source": [ "#Pkg.instantiate()\n", "using Pkg; Pkg.status()\n", @@ -61,41 +34,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "ecbf4aa8", "metadata": { "scrolled": false }, - "outputs": [ - { - "data": { - "application/vnd.webio.node+json": { - "children": [], - "instanceArgs": { - "namespace": "html", - "tag": "div" - }, - "nodeType": "DOM", - "props": {}, - "type": "node" - }, - "text/html": [ - "
\n", - "

The WebIO Jupyter extension was not detected. See the\n", - "\n", - " WebIO Jupyter integration documentation\n", - "\n", - "for more information.\n", - "

\n" - ], - "text/plain": [ - "WebIO._IJuliaInit()" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "using DataFrames, Statistics, JSON, Distributed, Clustering, YAML, Distributions, Revise, Plots, PrettyTables, Random\n", "plotlyjs(); # uncomment for interactive plots" @@ -103,24 +47,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "a8a9f2cf", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "2024" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# config = YAML.load_file(joinpath(\"data\", \"config_jules_prognose.yml\")) # config without datasets\n", - "config = YAML.load_file(joinpath(dirname(dirname(pwd())), \"JulESIO\", \"config_jules_prognose_demo.yml\")) # config with NVE datasets\n", + "config = YAML.load_file(joinpath(dirname(dirname(pwd())), \"JulESIO\", \"config_jules_prognose.yml\")) # config with NVE datasets\n", "weatheryear = config[\"main\"][\"weatheryears\"][1]\n", "datayear = config[\"main\"][\"datayears\"][1]" ] @@ -135,18 +68,10 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "3971d0bb", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nprocs() = 10\n" - ] - } - ], + "outputs": [], "source": [ "const numcores = config[\"main\"][\"numcores\"]\n", "\n", @@ -159,7 +84,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "696e5ec2", "metadata": {}, "outputs": [], @@ -170,39 +95,20 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "d2448075", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\u001b[36m\u001b[1m[ \u001b[22m\u001b[39m\u001b[36m\u001b[1mInfo: \u001b[22m\u001b[39mPrecompiling JulES [05c5cb9d-dcc3-436a-b9c7-df36424a75d6]\n" - ] - } - ], + "outputs": [], "source": [ "@everywhere using JulES" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "35482c34", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "getdataset (generic function with 1 method)" - ] - }, - "execution_count": 7, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "function getdataset(config, weatheryear)\n", " iprogtype = get(config[\"main\"], \"iprogtype\", \"direct\")\n", @@ -313,435 +219,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "ca8bc8dd", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Time parameters\n", - " 0.000052 seconds (56 allocations: 2.250 KiB)\n", - "Handle elements\n", - " 0.000833 seconds (14.37 k allocations: 716.344 KiB)\n", - "Add local dbs\n", - " 0.011991 seconds (720 allocations: 33.359 KiB)\n", - "Add local cores\n", - " 0.001156 seconds (655 allocations: 25.734 KiB)\n", - "Add local input\n", - " 2.642034 seconds (368.41 k allocations: 12.495 MiB)\n", - "Add local dummyobjects\n", - " 0.521665 seconds (1.43 M allocations: 120.557 MiB, 21.19% gc time)\n", - "Add local subsystems\n", - "Number of shortterm storagesystems 0\n", - "Number of longterm storagesystems 19\n", - " 0.116675 seconds (1.29 M allocations: 38.739 MiB)\n", - "Add local scenmod\n", - " 0.011731 seconds (645 allocations: 30.266 KiB)\n", - "Add local problem distribution\n", - "[(1, 1), (2, 2), (3, 3), (4, 4)]\n", - "[(1, 1, 1), (2, 1, 2), (3, 1, 3), (4, 1, 4), (1, 2, 1), (2, 2, 2), (3, 2, 3), (4, 2, 4), (1, 3, 1), (2, 3, 2), (3, 3, 3), (4, 3, 4), (1, 4, 1), (2, 4, 2), (3, 4, 3), (4, 4, 4), (1, 5, 1), (2, 5, 2), (3, 5, 3), (4, 5, 4), (1, 6, 1), (2, 6, 2), (3, 6, 3), (4, 6, 4), (1, 7, 1), (2, 7, 2), (3, 7, 3), (4, 7, 4), (1, 8, 1), (2, 8, 2), (3, 8, 3), (4, 8, 4), (1, 9, 1), (2, 9, 2), (3, 9, 3), (4, 9, 4), (1, 10, 1), (2, 10, 2), (3, 10, 3), (4, 10, 4), (1, 11, 1), (2, 11, 2), (3, 11, 3), (4, 11, 4), (1, 12, 1), (2, 12, 2), (3, 12, 3), (4, 12, 4), (1, 13, 1), (2, 13, 2), (3, 13, 3), (4, 13, 4), (1, 14, 1), (2, 14, 2), (3, 14, 3), (4, 14, 4), (1, 15, 1), (2, 15, 2), (3, 15, 3), (4, 15, 4), (1, 16, 1), (2, 16, 2), (3, 16, 3), (4, 16, 4), (1, 17, 1), (2, 17, 2), (3, 17, 3), (4, 17, 4), (1, 18, 1), (2, 18, 2), (3, 18, 3), (4, 18, 4), (1, 19, 1), (2, 19, 2), (3, 19, 3), (4, 19, 4)]\n", - "[(19, 1), (6, 1), (18, 2), (9, 2), (17, 3), (10, 3), (16, 4), (13, 4), (15, 5), (1, 5), (14, 6), (2, 6), (12, 7), (3, 7), (11, 8), (4, 8), (8, 9), (5, 9), (7, 10)]\n", - "[(1, 19, 1), (1, 6, 1), (1, 18, 2), (1, 9, 2), (1, 17, 3), (1, 10, 3), (1, 16, 4), (1, 13, 4), (1, 15, 5), (1, 1, 5), (1, 14, 6), (1, 2, 6), (1, 12, 7), (1, 3, 7), (1, 11, 8), (1, 4, 8), (1, 8, 9), (1, 5, 9), (1, 7, 10), (2, 19, 1), (2, 6, 1), (2, 18, 2), (2, 9, 2), (2, 17, 3), (2, 10, 3), (2, 16, 4), (2, 13, 4), (2, 15, 5), (2, 1, 5), (2, 14, 6), (2, 2, 6), (2, 12, 7), (2, 3, 7), (2, 11, 8), (2, 4, 8), (2, 8, 9), (2, 5, 9), (2, 7, 10), (3, 19, 1), (3, 6, 1), (3, 18, 2), (3, 9, 2), (3, 17, 3), (3, 10, 3), (3, 16, 4), (3, 13, 4), (3, 15, 5), (3, 1, 5), (3, 14, 6), (3, 2, 6), (3, 12, 7), (3, 3, 7), (3, 11, 8), (3, 4, 8), (3, 8, 9), (3, 5, 9), (3, 7, 10), (4, 19, 1), (4, 6, 1), (4, 18, 2), (4, 9, 2), (4, 17, 3), (4, 10, 3), (4, 16, 4), (4, 13, 4), (4, 15, 5), (4, 1, 5), (4, 14, 6), (4, 2, 6), (4, 12, 7), (4, 3, 7), (4, 11, 8), (4, 4, 8), (4, 8, 9), (4, 5, 9), (4, 7, 10)]\n", - " 0.206719 seconds (15.64 k allocations: 538.281 KiB)\n", - "Add local horizons\n", - " 0.013800 seconds (2.54 k allocations: 183.312 KiB)\n", - "Add local problems\n", - " 1.471939 seconds (4.06 M allocations: 303.887 MiB, 6.87% gc time)\n", - "Add local output\n", - " 0.010589 seconds (862 allocations: 125.172 KiB)\n", - "PrognosisTime(DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-29T00:00:00\"), DateTime(\"1991-01-28T00:00:00\"))\n", - "Startstates\n", - " 0.014167 seconds (75.06 k allocations: 4.659 MiB)\n", - "Price prognosis problems\n", - " 0.812310 seconds (1.38 M allocations: 45.189 MiB)\n", - "End value problems\n", - " 0.026359 seconds (37.13 k allocations: 1.292 MiB)\n", - "Subsystem problems\n", - " 0.037614 seconds (39.62 k allocations: 1.540 MiB)\n", - "Clearing problem\n", - " 0.042919 seconds (86.81 k allocations: 2.954 MiB)\n", - "Update output\n", - " 0.040589 seconds (29.99 k allocations: 1.506 MiB)\n", - "PrognosisTime(DateTime(\"2024-01-31T00:00:00\"), DateTime(\"2024-01-31T00:00:00\"), DateTime(\"1991-01-30T00:00:00\"))\n", - "Startstates\n", - " 0.002867 seconds (3.91 k allocations: 217.695 KiB)\n", - "Price prognosis problems\n", - " 0.180159 seconds (246.40 k allocations: 7.047 MiB)\n", - "End value problems\n", - " 0.011978 seconds (1.14 k allocations: 45.250 KiB)\n", - "Subsystem problems\n", - " 0.002743 seconds (1.99 k allocations: 73.969 KiB)\n", - "Clearing problem\n", - " 0.037058 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.037716 seconds (21.97 k allocations: 1017.062 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-02T00:00:00\"), DateTime(\"2024-02-02T00:00:00\"), DateTime(\"1991-02-01T00:00:00\"))\n", - "Startstates\n", - " 0.013215 seconds (3.90 k allocations: 213.023 KiB)\n", - "Price prognosis problems\n", - " 0.183031 seconds (246.40 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.001289 seconds (1.02 k allocations: 34.578 KiB)\n", - "Subsystem problems\n", - " 0.002947 seconds (2.11 k allocations: 86.188 KiB)\n", - "Clearing problem\n", - " 0.037629 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.027826 seconds (23.17 k allocations: 1.059 MiB)\n", - "PrognosisTime(DateTime(\"2024-02-04T00:00:00\"), DateTime(\"2024-02-04T00:00:00\"), DateTime(\"1991-02-03T00:00:00\"))\n", - "Startstates\n", - " 0.013509 seconds (3.91 k allocations: 212.086 KiB)\n", - "Price prognosis problems\n", - " 0.184199 seconds (246.40 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.001719 seconds (1.15 k allocations: 46.234 KiB)\n", - "Subsystem problems\n", - " 0.013302 seconds (1.99 k allocations: 74.125 KiB)\n", - "Clearing problem\n", - " 0.037544 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.027669 seconds (21.97 k allocations: 1018.656 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-06T00:00:00\"), DateTime(\"2024-02-06T00:00:00\"), DateTime(\"1991-02-05T00:00:00\"))\n", - "Startstates\n", - " 0.003069 seconds (3.90 k allocations: 211.992 KiB)\n", - "Price prognosis problems\n", - " 0.185206 seconds (246.52 k allocations: 7.058 MiB)\n", - "End value problems\n", - " 0.001509 seconds (1.03 k allocations: 35.688 KiB)\n", - "Subsystem problems\n", - " 0.013451 seconds (1.99 k allocations: 73.969 KiB)\n", - "Clearing problem\n", - " 0.027630 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.037819 seconds (21.96 k allocations: 993.344 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-08T00:00:00\"), DateTime(\"2024-02-08T00:00:00\"), DateTime(\"1991-02-07T00:00:00\"))\n", - "Startstates\n", - " 0.004068 seconds (3.90 k allocations: 211.898 KiB)\n", - "Price prognosis problems\n", - " 0.175070 seconds (246.39 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.001362 seconds (1.03 k allocations: 35.688 KiB)\n", - "Subsystem problems\n", - " 0.013801 seconds (2.10 k allocations: 84.484 KiB)\n", - "Clearing problem\n", - " 0.027748 seconds (79.19 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.038051 seconds (21.97 k allocations: 993.406 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-10T00:00:00\"), DateTime(\"2024-02-10T00:00:00\"), DateTime(\"1991-02-09T00:00:00\"))\n", - "Startstates\n", - " 0.003079 seconds (3.90 k allocations: 212.758 KiB)\n", - "Price prognosis problems\n", - " 0.174506 seconds (246.39 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.001389 seconds (1.02 k allocations: 35.438 KiB)\n", - "Subsystem problems\n", - " 0.013947 seconds (2.10 k allocations: 84.484 KiB)\n", - "Clearing problem\n", - " 0.037525 seconds (79.19 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.027738 seconds (21.97 k allocations: 1.019 MiB)\n", - "PrognosisTime(DateTime(\"2024-02-12T00:00:00\"), DateTime(\"2024-02-12T00:00:00\"), DateTime(\"1991-02-11T00:00:00\"))\n", - "Startstates\n", - " 0.013268 seconds (3.91 k allocations: 212.086 KiB)\n", - "Price prognosis problems\n", - " 0.174359 seconds (246.40 k allocations: 7.049 MiB)\n", - "End value problems\n", - " 0.012279 seconds (1.14 k allocations: 45.250 KiB)\n", - "Subsystem problems\n", - " 0.014228 seconds (1.99 k allocations: 73.969 KiB)\n", - "Clearing problem\n", - " 0.038473 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.028195 seconds (21.97 k allocations: 993.406 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-14T00:00:00\"), DateTime(\"2024-02-14T00:00:00\"), DateTime(\"1991-02-13T00:00:00\"))\n", - "Startstates\n", - " 0.013216 seconds (3.91 k allocations: 212.148 KiB)\n", - "Price prognosis problems\n", - " 0.543111 seconds (1.08 M allocations: 32.358 MiB)\n", - "End value problems\n", - " 0.009253 seconds (27.68 k allocations: 927.562 KiB)\n", - "Subsystem problems\n", - " 0.041520 seconds (45.23 k allocations: 1.711 MiB)\n", - "Clearing problem\n", - " 0.042216 seconds (88.67 k allocations: 3.340 MiB)\n", - "Update output\n", - " 0.027969 seconds (21.97 k allocations: 992.719 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-16T00:00:00\"), DateTime(\"2024-02-16T00:00:00\"), DateTime(\"1991-02-15T00:00:00\"))\n", - "Startstates\n", - " 0.003132 seconds (3.91 k allocations: 212.055 KiB)\n", - "Price prognosis problems\n", - " 0.179695 seconds (246.40 k allocations: 7.049 MiB)\n", - "End value problems\n", - " 0.001429 seconds (1.02 k allocations: 34.828 KiB)\n", - "Subsystem problems\n", - " 0.002904 seconds (2.11 k allocations: 86.031 KiB)\n", - "Clearing problem\n", - " 0.027500 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.038229 seconds (21.97 k allocations: 993.375 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-18T00:00:00\"), DateTime(\"2024-02-18T00:00:00\"), DateTime(\"1991-02-17T00:00:00\"))\n", - "Startstates\n", - " 0.013236 seconds (3.90 k allocations: 211.961 KiB)\n", - "Price prognosis problems\n", - " 0.180282 seconds (246.40 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.012301 seconds (1.14 k allocations: 45.250 KiB)\n", - "Subsystem problems\n", - " 0.013378 seconds (1.99 k allocations: 73.969 KiB)\n", - "Clearing problem\n", - " 0.027900 seconds (79.18 k allocations: 2.978 MiB)\n", - "Update output\n", - " 0.038815 seconds (21.96 k allocations: 993.344 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-20T00:00:00\"), DateTime(\"2024-02-20T00:00:00\"), DateTime(\"1991-02-19T00:00:00\"))\n", - "Startstates\n", - " 0.013752 seconds (3.91 k allocations: 212.148 KiB)\n", - "Price prognosis problems\n", - " 0.183366 seconds (246.39 k allocations: 7.047 MiB)\n", - "End value problems\n", - " 0.012219 seconds (1.15 k allocations: 46.141 KiB)\n", - "Subsystem problems\n", - " 0.013999 seconds (1.99 k allocations: 73.969 KiB)\n", - "Clearing problem\n", - " 0.038281 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.038132 seconds (21.96 k allocations: 993.344 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-22T00:00:00\"), DateTime(\"2024-02-22T00:00:00\"), DateTime(\"1991-02-21T00:00:00\"))\n", - "Startstates\n", - " 0.013626 seconds (4.03 k allocations: 324.133 KiB)\n", - "Price prognosis problems\n", - " 0.172365 seconds (246.39 k allocations: 7.046 MiB)\n", - "End value problems\n", - " 0.012259 seconds (1.03 k allocations: 35.781 KiB)\n", - "Subsystem problems\n", - " 0.004775 seconds (7.45 k allocations: 447.391 KiB)\n", - "Clearing problem\n", - " 0.038787 seconds (79.31 k allocations: 2.991 MiB)\n", - "Update output\n", - " 0.029311 seconds (21.97 k allocations: 993.406 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-24T00:00:00\"), DateTime(\"2024-02-24T00:00:00\"), DateTime(\"1991-02-23T00:00:00\"))\n", - "Startstates\n", - " 0.013358 seconds (3.92 k allocations: 212.211 KiB)\n", - "Price prognosis problems\n", - " 0.175818 seconds (246.40 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.012411 seconds (1.15 k allocations: 46.109 KiB)\n", - "Subsystem problems\n", - " 0.002765 seconds (1.98 k allocations: 73.844 KiB)\n", - "Clearing problem\n", - " 0.028617 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.038745 seconds (21.96 k allocations: 993.344 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-26T00:00:00\"), DateTime(\"2024-02-26T00:00:00\"), DateTime(\"1991-02-25T00:00:00\"))\n", - "Startstates\n", - " 0.013417 seconds (3.91 k allocations: 212.914 KiB)\n", - "Price prognosis problems\n", - " 0.181561 seconds (246.40 k allocations: 7.048 MiB)\n", - "End value problems\n", - " 0.012065 seconds (1.15 k allocations: 46.203 KiB)\n", - "Subsystem problems\n", - " 0.003130 seconds (1.99 k allocations: 73.969 KiB)\n", - "Clearing problem\n", - " 0.026837 seconds (79.19 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.038092 seconds (21.97 k allocations: 993.406 KiB)\n", - "PrognosisTime(DateTime(\"2024-02-28T00:00:00\"), DateTime(\"2024-02-28T00:00:00\"), DateTime(\"1991-02-27T00:00:00\"))\n", - "Startstates\n", - " 0.013331 seconds (3.91 k allocations: 212.023 KiB)\n", - "Price prognosis problems\n", - " 0.172581 seconds (246.40 k allocations: 7.049 MiB)\n", - "End value problems\n", - " 0.011974 seconds (1.15 k allocations: 45.375 KiB)\n", - "Subsystem problems\n", - " 0.002989 seconds (1.99 k allocations: 73.969 KiB)\n", - "Clearing problem\n", - " 0.037813 seconds (79.18 k allocations: 2.979 MiB)\n", - "Update output\n", - " 0.028977 seconds (21.96 k allocations: 993.281 KiB)\n", - "\n", - "The simulation took: 0.09 minutes\n", - "Time usage per simulation step: 0.35 seconds\n", - "\n" - ] - }, - { - "data": { - "text/html": [ - "
7×5 DataFrame
Rowmodelupdatesolveothertotal
StringFloat64Float64Float64Float64
1long0.06009220.06137190.0001486750.121613
2med0.07642610.04462620.000244650.121297
3short0.02239610.06109560.002065020.0855567
4evp0.0005761420.001164880.0006906030.00243163
5mp6.78289e-50.0003867840.0009304580.00138507
6sp0.0008134180.001404620.004742060.00696009
7clearing0.007833460.01606170.002969880.0268651
" - ], - "text/latex": [ - "\\begin{tabular}{r|ccccc}\n", - "\t& model & update & solve & other & total\\\\\n", - "\t\\hline\n", - "\t& String & Float64 & Float64 & Float64 & Float64\\\\\n", - "\t\\hline\n", - "\t1 & long & 0.0600922 & 0.0613719 & 0.000148675 & 0.121613 \\\\\n", - "\t2 & med & 0.0764261 & 0.0446262 & 0.00024465 & 0.121297 \\\\\n", - "\t3 & short & 0.0223961 & 0.0610956 & 0.00206502 & 0.0855567 \\\\\n", - "\t4 & evp & 0.000576142 & 0.00116488 & 0.000690603 & 0.00243163 \\\\\n", - "\t5 & mp & 6.78289e-5 & 0.000386784 & 0.000930458 & 0.00138507 \\\\\n", - "\t6 & sp & 0.000813418 & 0.00140462 & 0.00474206 & 0.00696009 \\\\\n", - "\t7 & clearing & 0.00783346 & 0.0160617 & 0.00296988 & 0.0268651 \\\\\n", - "\\end{tabular}\n" - ], - "text/plain": [ - "\u001b[1m7×5 DataFrame\u001b[0m\n", - "\u001b[1m Row \u001b[0m│\u001b[1m model \u001b[0m\u001b[1m update \u001b[0m\u001b[1m solve \u001b[0m\u001b[1m other \u001b[0m\u001b[1m total \u001b[0m\n", - " │\u001b[90m String \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64 \u001b[0m\n", - "─────┼─────────────────────────────────────────────────────────────\n", - " 1 │ long 0.0600922 0.0613719 0.000148675 0.121613\n", - " 2 │ med 0.0764261 0.0446262 0.00024465 0.121297\n", - " 3 │ short 0.0223961 0.0610956 0.00206502 0.0855567\n", - " 4 │ evp 0.000576142 0.00116488 0.000690603 0.00243163\n", - " 5 │ mp 6.78289e-5 0.000386784 0.000930458 0.00138507\n", - " 6 │ sp 0.000813418 0.00140462 0.00474206 0.00696009\n", - " 7 │ clearing 0.00783346 0.0160617 0.00296988 0.0268651" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
10×15 DataFrame
Rowcoretotevp_totmp_totsp_totevp_uevp_sevp_omp_ump_smp_finmp_osp_usp_ssp_o
AnyFloat64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?Float64?
15.0missingmissing0.00252460.0108905missingmissingmissing0.00012360.000656258.1e-60.001736650.001537150.00160910.00774425
26.0missingmissing0.002662050.0123995missingmissingmissing0.00012490.00070147.15e-60.00182860.00156790.002449350.0083822
37.0missingmissing0.00281640.0150379missingmissingmissing0.00013610.000893859.6e-60.001776850.00157560.00284010.0106221
48.0missingmissing0.0031670.0149395missingmissingmissing0.000130350.00074251.07e-50.002283450.001572950.003124550.0102421
59.0missingmissing0.003071350.0155729missingmissingmissing0.00014480.00071771.075e-50.00219810.001572750.002690.0113101
610.0missingmissing0.002068150.0082357missingmissingmissing8.465e-50.00034665.6e-60.00163130.00080510.00079770.0066329
71.00.03210010.01624260.00146490.01439260.00290670.00559150.000968050.000137050.00084671.53e-50.000465850.001804250.002758350.00983
82.00.02836460.01030.002938350.01512610.00281050.00559540.0002367690.00014260.00092888.85e-60.00185810.00179040.003823150.0095126
93.00.02582260.0099170.00292420.01298150.002660850.005526650.0002161880.00013990.00072639.1e-60.00204890.00163180.0031060.00824365
104.00.02508630.009741250.002679350.01266570.002568650.00541920.0002191750.00012480.00078881.045e-50.00175530.001597050.00348940.00757925
" - ], - "text/latex": [ - "\\begin{tabular}{r|ccccccccc}\n", - "\t& core & tot & evp\\_tot & mp\\_tot & sp\\_tot & evp\\_u & evp\\_s & evp\\_o & \\\\\n", - "\t\\hline\n", - "\t& Any & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & \\\\\n", - "\t\\hline\n", - "\t1 & 5.0 & \\emph{missing} & \\emph{missing} & 0.0025246 & 0.0108905 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t2 & 6.0 & \\emph{missing} & \\emph{missing} & 0.00266205 & 0.0123995 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t3 & 7.0 & \\emph{missing} & \\emph{missing} & 0.0028164 & 0.0150379 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t4 & 8.0 & \\emph{missing} & \\emph{missing} & 0.003167 & 0.0149395 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t5 & 9.0 & \\emph{missing} & \\emph{missing} & 0.00307135 & 0.0155729 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t6 & 10.0 & \\emph{missing} & \\emph{missing} & 0.00206815 & 0.0082357 & \\emph{missing} & \\emph{missing} & \\emph{missing} & $\\dots$ \\\\\n", - "\t7 & 1.0 & 0.0321001 & 0.0162426 & 0.0014649 & 0.0143926 & 0.0029067 & 0.0055915 & 0.00096805 & $\\dots$ \\\\\n", - "\t8 & 2.0 & 0.0283646 & 0.0103 & 0.00293835 & 0.0151261 & 0.0028105 & 0.0055954 & 0.000236769 & $\\dots$ \\\\\n", - "\t9 & 3.0 & 0.0258226 & 0.009917 & 0.0029242 & 0.0129815 & 0.00266085 & 0.00552665 & 0.000216188 & $\\dots$ \\\\\n", - "\t10 & 4.0 & 0.0250863 & 0.00974125 & 0.00267935 & 0.0126657 & 0.00256865 & 0.0054192 & 0.000219175 & $\\dots$ \\\\\n", - "\\end{tabular}\n" - ], - "text/plain": [ - "\u001b[1m10×15 DataFrame\u001b[0m\n", - "\u001b[1m Row \u001b[0m│\u001b[1m core \u001b[0m\u001b[1m tot \u001b[0m\u001b[1m evp_tot \u001b[0m\u001b[1m mp_tot \u001b[0m\u001b[1m sp_tot \u001b[0m\u001b[1m evp_u \u001b[0m ⋯\n", - " │\u001b[90m Any \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64\u001b[0m ⋯\n", - "─────┼──────────────────────────────────────────────────────────────────────────\n", - " 1 │ 5.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0025246 0.0108905 \u001b[90m missing\u001b[0m ⋯\n", - " 2 │ 6.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00266205 0.0123995 \u001b[90m missing\u001b[0m\n", - " 3 │ 7.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.0028164 0.0150379 \u001b[90m missing\u001b[0m\n", - " 4 │ 8.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.003167 0.0149395 \u001b[90m missing\u001b[0m\n", - " 5 │ 9.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00307135 0.0155729 \u001b[90m missing\u001b[0m ⋯\n", - " 6 │ 10.0 \u001b[90m missing \u001b[0m\u001b[90m missing \u001b[0m 0.00206815 0.0082357 \u001b[90m missing\u001b[0m\n", - " 7 │ 1.0 0.0321001 0.0162426 0.0014649 0.0143926 0\n", - " 8 │ 2.0 0.0283646 0.0103 0.00293835 0.0151261 0\n", - " 9 │ 3.0 0.0258226 0.009917 0.0029242 0.0129815 0 ⋯\n", - " 10 │ 4.0 0.0250863 0.00974125 0.00267935 0.0126657 0\n", - "\u001b[36m 10 columns omitted\u001b[0m" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "
19×15 DataFrame
Rowsubixtotevp_totmp_totsp_totevp_uevp_sevp_omp_ump_smp_finmp_osp_usp_ssp_o
AnyFloat64Float64?Float64?Float64?Float64?Float64?Float64?AnyAnyAnyAnyFloat64?Float64?Float64?
18.00.01406840.00241710.002225950.00942530.0005580.001450955.10188e-57.995e-50.000418256.7e-60.001721050.000799450.001845750.0067801
218.00.01368750.00223320.001482450.00997190.00055520.00135794.00125e-58.015e-50.00039644.35e-60.001001550.000923950.001692950.007355
31.00.01313880.007937950.0009790.00422180.00084330.000948750.0007682384.96e-50.0002924.05e-60.000633350.00075430.000792850.00267465
411.00.01286640.0021740.00227290.00841950.000545950.001293754.17875e-58.125e-50.00040526.6e-60.001779850.0008160.00158810.0060154
57.00.01204010.001736250.002068150.00823570.000565150.00085213.9875e-58.465e-50.00034665.6e-60.00163130.00080510.00079770.0066329
617.00.01190280.002382950.00139580.0081240.00056960.001416054.96625e-57.37e-50.000399855.9e-60.000916350.000831750.00164850.00564375
712.00.0118030.0016070.001807950.008388050.000561750.000701854.2925e-58.52e-50.000334954.95e-60.001382850.00080540.000776250.0068064
814.00.01179460.00229440.00175670.00774350.00056790.001429653.71063e-57.835e-50.000395053.65e-60.001279650.000799250.001604250.00534
916.00.01131240.00219240.001628350.00749170.000539450.0013623.63687e-56.805e-50.000453056.45e-60.00110080.000808450.00170010.00498315
1019.00.010350.00161090.000557750.00818140.0005550.00075113.81e-57.415e-50.000298658.75e-60.00017620.00091330.000773850.00649425
113.00.01007680.00241850.001008450.00664980.00054620.00145435.225e-55.09e-50.00055894.65e-60.0003940.00077020.002063850.00381575
124.00.01006020.0026460.00089410.006520050.00056530.00145257.8525e-54.91e-50.00033734.1e-60.00050360.000756950.001536450.00422665
1315.00.009915450.001701150.00154560.00666870.00056160.000721455.22625e-57.4e-50.000364254.05e-60.00110330.000782850.000816250.0050696
146.00.009346150.00222780.000907150.00621120.000564150.00128924.68062e-56.29e-50.000548056.55e-60.000289650.000890950.00198450.00333575
159.00.00897610.002365950.00145590.005154250.00056080.001365.56437e-56.245e-50.00053244.5e-60.000856550.000866450.00213020.0021576
165.00.008728850.00173590.00084540.006147550.000586050.000738155.14625e-56.485e-50.000299454.05e-60.000477050.00077330.000844250.00453
1710.00.008632850.0022470.00152840.004857450.00055910.001323654.55312e-56.62e-50.000326453.2e-60.001132550.000800050.00145750.0025999
1813.00.008571550.002346550.0010510.0051740.000538650.001414054.92313e-55.675e-50.000335754.0e-60.00065450.00078860.00178930.0025961
192.00.00748720.00192590.000905350.004655950.000603550.000815356.3375e-54.655e-50.000306353.5e-60.000548950.000768650.00084510.0030422
" - ], - "text/latex": [ - "\\begin{tabular}{r|ccccccccc}\n", - "\t& subix & tot & evp\\_tot & mp\\_tot & sp\\_tot & evp\\_u & evp\\_s & evp\\_o & \\\\\n", - "\t\\hline\n", - "\t& Any & Float64 & Float64? & Float64? & Float64? & Float64? & Float64? & Float64? & \\\\\n", - "\t\\hline\n", - "\t1 & 8.0 & 0.0140684 & 0.0024171 & 0.00222595 & 0.0094253 & 0.000558 & 0.00145095 & 5.10188e-5 & $\\dots$ \\\\\n", - "\t2 & 18.0 & 0.0136875 & 0.0022332 & 0.00148245 & 0.0099719 & 0.0005552 & 0.0013579 & 4.00125e-5 & $\\dots$ \\\\\n", - "\t3 & 1.0 & 0.0131388 & 0.00793795 & 0.000979 & 0.0042218 & 0.0008433 & 0.00094875 & 0.000768238 & $\\dots$ \\\\\n", - "\t4 & 11.0 & 0.0128664 & 0.002174 & 0.0022729 & 0.0084195 & 0.00054595 & 0.00129375 & 4.17875e-5 & $\\dots$ \\\\\n", - "\t5 & 7.0 & 0.0120401 & 0.00173625 & 0.00206815 & 0.0082357 & 0.00056515 & 0.0008521 & 3.9875e-5 & $\\dots$ \\\\\n", - "\t6 & 17.0 & 0.0119028 & 0.00238295 & 0.0013958 & 0.008124 & 0.0005696 & 0.00141605 & 4.96625e-5 & $\\dots$ \\\\\n", - "\t7 & 12.0 & 0.011803 & 0.001607 & 0.00180795 & 0.00838805 & 0.00056175 & 0.00070185 & 4.2925e-5 & $\\dots$ \\\\\n", - "\t8 & 14.0 & 0.0117946 & 0.0022944 & 0.0017567 & 0.0077435 & 0.0005679 & 0.00142965 & 3.71063e-5 & $\\dots$ \\\\\n", - "\t9 & 16.0 & 0.0113124 & 0.0021924 & 0.00162835 & 0.0074917 & 0.00053945 & 0.001362 & 3.63687e-5 & $\\dots$ \\\\\n", - "\t10 & 19.0 & 0.01035 & 0.0016109 & 0.00055775 & 0.0081814 & 0.000555 & 0.0007511 & 3.81e-5 & $\\dots$ \\\\\n", - "\t11 & 3.0 & 0.0100768 & 0.0024185 & 0.00100845 & 0.0066498 & 0.0005462 & 0.0014543 & 5.225e-5 & $\\dots$ \\\\\n", - "\t12 & 4.0 & 0.0100602 & 0.002646 & 0.0008941 & 0.00652005 & 0.0005653 & 0.0014525 & 7.8525e-5 & $\\dots$ \\\\\n", - "\t13 & 15.0 & 0.00991545 & 0.00170115 & 0.0015456 & 0.0066687 & 0.0005616 & 0.00072145 & 5.22625e-5 & $\\dots$ \\\\\n", - "\t14 & 6.0 & 0.00934615 & 0.0022278 & 0.00090715 & 0.0062112 & 0.00056415 & 0.0012892 & 4.68062e-5 & $\\dots$ \\\\\n", - "\t15 & 9.0 & 0.0089761 & 0.00236595 & 0.0014559 & 0.00515425 & 0.0005608 & 0.00136 & 5.56437e-5 & $\\dots$ \\\\\n", - "\t16 & 5.0 & 0.00872885 & 0.0017359 & 0.0008454 & 0.00614755 & 0.00058605 & 0.00073815 & 5.14625e-5 & $\\dots$ \\\\\n", - "\t17 & 10.0 & 0.00863285 & 0.002247 & 0.0015284 & 0.00485745 & 0.0005591 & 0.00132365 & 4.55312e-5 & $\\dots$ \\\\\n", - "\t18 & 13.0 & 0.00857155 & 0.00234655 & 0.001051 & 0.005174 & 0.00053865 & 0.00141405 & 4.92313e-5 & $\\dots$ \\\\\n", - "\t19 & 2.0 & 0.0074872 & 0.0019259 & 0.00090535 & 0.00465595 & 0.00060355 & 0.00081535 & 6.3375e-5 & $\\dots$ \\\\\n", - "\\end{tabular}\n" - ], - "text/plain": [ - "\u001b[1m19×15 DataFrame\u001b[0m\n", - "\u001b[1m Row \u001b[0m│\u001b[1m subix \u001b[0m\u001b[1m tot \u001b[0m\u001b[1m evp_tot \u001b[0m\u001b[1m mp_tot \u001b[0m\u001b[1m sp_tot \u001b[0m\u001b[1m evp_u \u001b[0m\u001b[1m evp_\u001b[0m ⋯\n", - " │\u001b[90m Any \u001b[0m\u001b[90m Float64 \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Float64? \u001b[0m\u001b[90m Floa\u001b[0m ⋯\n", - "─────┼──────────────────────────────────────────────────────────────────────────\n", - " 1 │ 8.0 0.0140684 0.0024171 0.00222595 0.0094253 0.000558 0.00 ⋯\n", - " 2 │ 18.0 0.0136875 0.0022332 0.00148245 0.0099719 0.0005552 0.00\n", - " 3 │ 1.0 0.0131388 0.00793795 0.000979 0.0042218 0.0008433 0.00\n", - " 4 │ 11.0 0.0128664 0.002174 0.0022729 0.0084195 0.00054595 0.00\n", - " 5 │ 7.0 0.0120401 0.00173625 0.00206815 0.0082357 0.00056515 0.00 ⋯\n", - " 6 │ 17.0 0.0119028 0.00238295 0.0013958 0.008124 0.0005696 0.00\n", - " 7 │ 12.0 0.011803 0.001607 0.00180795 0.00838805 0.00056175 0.00\n", - " 8 │ 14.0 0.0117946 0.0022944 0.0017567 0.0077435 0.0005679 0.00\n", - " 9 │ 16.0 0.0113124 0.0021924 0.00162835 0.0074917 0.00053945 0.00 ⋯\n", - " 10 │ 19.0 0.01035 0.0016109 0.00055775 0.0081814 0.000555 0.00\n", - " 11 │ 3.0 0.0100768 0.0024185 0.00100845 0.0066498 0.0005462 0.00\n", - " 12 │ 4.0 0.0100602 0.002646 0.0008941 0.00652005 0.0005653 0.00\n", - " 13 │ 15.0 0.00991545 0.00170115 0.0015456 0.0066687 0.0005616 0.00 ⋯\n", - " 14 │ 6.0 0.00934615 0.0022278 0.00090715 0.0062112 0.00056415 0.00\n", - " 15 │ 9.0 0.0089761 0.00236595 0.0014559 0.00515425 0.0005608 0.00\n", - " 16 │ 5.0 0.00872885 0.0017359 0.0008454 0.00614755 0.00058605 0.00\n", - " 17 │ 10.0 0.00863285 0.002247 0.0015284 0.00485745 0.0005591 0.00 ⋯\n", - " 18 │ 13.0 0.00857155 0.00234655 0.001051 0.005174 0.00053865 0.00\n", - " 19 │ 2.0 0.0074872 0.0019259 0.00090535 0.00465595 0.00060355 0.00\n", - "\u001b[36m 9 columns omitted\u001b[0m" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/plain": [ - "Dict{Any, Any} with 23 entries:\n", - " \"demandbalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", - " \"endvaluetimes\" => Dict{Any, Any}((1, 12)=>[0.0001766 0.0002924 0.000578…\n", - " \"resindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", - " \"areanames\" => [\"SORLAND\"]\n", - " \"priceindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-2…\n", - " \"batmatrix\" => Matrix{Float64}(undef, 128, 0)\n", - " \"stateindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", - " \"statematrix\" => [547.673 4078.56 … 0.174767 0.0; 547.673 4078.56 … 0.…\n", - " \"statenames\" => [\"Reservoir_FINNMARK_hydro_reservoir_max\", \"Reservoir…\n", - " \"resnames\" => [\"Reservoir_SORLAND_hydro_reservoir\"]\n", - " \"demandvalues\" => [1.3 0.0 … 0.0831064 1.40595; 1.3 0.0 … 0.0476586 1.9…\n", - " \"batindex\" => [DateTime(\"2024-01-29T00:00:00\"), DateTime(\"2024-01-3…\n", - " \"resmatrix\" => [14.4024; 14.3551; … ; 13.769; 13.753;;]\n", - " \"supplybalancenames\" => SubString{String}[\"SORLAND\", \"SORLAND\", \"SORLAND\", \"S…\n", - " \"supplynames\" => [\"PlantResponse_SORLAND_VALHALL\", \"Plant_SORLAND_hydr…\n", - " \"demandnames\" => [\"Transm_SORLAND->UK\", \"SlackVar_PowerBalance_SORLAND…\n", - " \"sptimes\" => Dict{Any, Any}((1, 12)=>[0.0002057 0.0003672 0.000905…\n", - " \"clearingtimes\" => [0.0073302 0.0181178 0.0310275; 0.0070494 0.0158453 0…\n", - " \"supplyvalues\" => [0.0 3.74366 … 0.0 0.254503; 0.0 6.29271 … 0.00267863…\n", - " \"batnames\" => String[]\n", - " \"prognosistimes\" => [0.0812614 0.0967173 0.178134; 0.0 0.0 0.0; … ; 0.0 0…\n", - " \"pricematrix\" => [0.256997; 0.256997; … ; 0.256799; 0.256799;;]\n", - " \"mptimes\" => Dict{Any, Any}(5=>[5.61e-5 0.0003233 3.4e-6 0.0004319…" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "\n", "dataset = getdataset(config, weatheryear)\n", diff --git a/demos/data/config_jules_prognose.yml b/demos/data/config_jules_prognose.yml index 5c19028..246afc0 100644 --- a/demos/data/config_jules_prognose.yml +++ b/demos/data/config_jules_prognose.yml @@ -1,92 +1,112 @@ -# TODO: This is not up to date - main: inputpath: "data" - numcores: 1 # kjerner per scenario + numcores: 10 #8 #6 #5 # kjerner per scenario datayears: [2024] - weatheryears: [1991, 2000] - weekstart: 5 - simulationyears: 1 - extrasteps: 0 # see steplength_hours + weatheryears: [1991, 1991] + weekstart: 21 + # simulationyears: 1 + # extrasteps: 0 # see steplength_hours - settings: fast # fast, threehour, sixhour + # settings: fast # fast, threehour, sixhour - # simulationyears: 0 - # extrasteps: 16 # see steplength_hours + simulationyears: 0 + extrasteps: 16 # see steplength_hours - # settings: threehour # fast, threehour, sixhour + settings: threehour # fast, threehour outputformat: "juliadict" # hdf5 hvis du kjører gjennom JulESIO outputindex: datayear # standard for paralellsimulering - + ############################################################# threehour: time: - scenarioyearstart: 1991 - scenarioyearstop: 2021 + weatheryearstart: 1991 + weatheryearstop: 2021 probtime: normaltime: PrognosisTime phaseintime: PhaseinPrognosisTime - phaseindelta_days: 120 - phaseinsteps: 5 + phaseindelta_days: 7 + phaseinsteps: 7 skipmax: 4 # how many steps should the watervalues be reused / at what interval should new watervalues be calculated - problems: + problems: prognosis: aggsupplyn: 4 residualarealist: [] shorttermstoragecutoff_hours: 10 long: - prob: HiGHS_Prob() solver: HighsSimplexMethod() med: - prob: HiGHS_Prob() solver: HighsSimplexMethod() short: - prob: HiGHS_Prob() solver: HighsSimplexMethod(warmstart=false) startstorages: function: aggstartmagdict + endvalue: + solver: HighsSimplexMethod() + startstorages: + function: startmagdict stochastic: maxcuts: 13 lb: -100000.0 reltol: 0.0001 master: - prob: HiGHS_Prob() solver: HighsSimplexMethod() subs: solver: HighsSimplexMethod() startstorages: function: startmagdict - distribution_method: random #randdumb #storage #random #by_size #greedy + + # distribution_method_mp: bysize #random #bysize #greedy #randdumb #storage #sizepairing #advanced + # distribution_method_sp: withmp #withmp #greedy clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true statedependentpump: true headlosscost: true scenariogeneration: - endvalue: + stochastic: function: InflowClusteringMethod numscen: 7 scendelta_days: 365 parts: 4 + # function: SumInflowQuantileMethod + # numscen: 7 + # scendelta_days: 365 + # maxquantile: 0.95 + # usedensity: true + # a: 0.5 + # b: -4 + # c: 10 + # a: 1 + # b: 0 + # c: 5 + # a: 0 + # b: 0 + # c: 1 subsystems: function: twostorageduration # dataset, twostorageduration shorttermstoragecutoff_hours: 10 shortstochduration_hours: 168 - longstochduration_days: 406 # 420 - 14 # we reuse prices for two weeks, so have to be two weeks shorter than price prognosis problem - longevduration_days: 840 + longstochduration_days: 91 + longevduration_days: 721 + + horizons: - commodities: ["hydro", "power"] + commodities: ["Hydro", "Power"] + shrinkable: + startafter_days: 91 # clear + short + med + shrinkatleast_days: 360 # (longperiod - clear)*9 long: - horizonduration_weeks: 200 - hydro: + termduration_weeks: 198 # 42*33 = 198 weeks (211 total) + shrinkable: true + Hydro: function: SequentialHorizon periodduration_days: 42 - power: + Power: function: AdaptiveHorizon - macro: hydro + macro: Hydro rhsdata: function: DynamicExogenPriceAHData balance: PowerBalance_TYSKLAND @@ -94,13 +114,13 @@ threehour: clusters: 4 unitduration_hours: 6 med: - termduration_days: 413 - hydro: + termduration_days: 84 # 7*12 = 42*2 = 12 weeks (13 total) + Hydro: function: SequentialHorizon periodduration_days: 7 - power: + Power: function: AdaptiveHorizon - macro: hydro + macro: Hydro rhsdata: function: DynamicExogenPriceAHData balance: PowerBalance_TYSKLAND @@ -108,132 +128,141 @@ threehour: clusters: 4 unitduration_hours: 4 short: - termduration_hours: 120 - hydro: + termduration_hours: 120 # 5 days (7 total) + Hydro: function: SequentialHorizon periodduration_hours: 24 - power: + Power: function: SequentialHorizon periodduration_hours: 3 clearing: - termduration_hours: 48 - hydro: + termduration_hours: 48 # 2 days + Hydro: function: SequentialHorizon periodduration_hours: 6 - power: + Power: function: SequentialHorizon periodduration_hours: 3 results: mainresults: ["SORLAND"] times: true - storagevalues: true + storagevalues: false + memory: false + + ############################################################# -fast: +fast: # 24 hour steps, 7 static scenarios, aggregated hydro, shrinkablehorizon, no phasein, 1 year long, 18 week med, 2 day short time: - scenarioyearstart: 1991 - scenarioyearstop: 2021 + weatheryearstart: 1991 + weatheryearstop: 2021 probtime: normaltime: PrognosisTime phaseintime: PrognosisTime - phaseindelta_days: 120 - phaseinsteps: 5 + phaseindelta_days: 7 + phaseinsteps: 7 - steplength_hours: 24 skipmax: 8 # how many steps should the watervalues be reused / at what interval should new watervalues be calculated - scenariogeneration: - simulation: - function: InflowClusteringMethod - numscen: 7 - scendelta_days: 1095 - parts: 4 - prognosis: - function: InflowClusteringMethod - numscen: 7 - scendelta_days: 365 - parts: 4 - stochastic: - function: InflowClusteringMethod - numscen: 7 - scendelta_days: 365 - parts: 4 problems: onlyagghydro: true - shorttermstoragecutoff_hours: 10 prognosis: - shrinkable: both_nophasein # both, both_ignorephasein, no - TODO: long, med aggsupplyn: 4 residualarealist: [] + shorttermstoragecutoff_hours: 10 long: - prob: HiGHS_Prob() solver: HighsSimplexMethod() med: - prob: HiGHS_Prob() solver: HighsSimplexMethod() short: - prob: HiGHS_Prob() solver: HighsSimplexMethod(warmstart=false) startstorages: function: aggstartmagdict + endvalue: + solver: HighsSimplexMethod() + startstorages: + function: startmagdict stochastic: maxcuts: 13 lb: -100000.0 reltol: 0.0001 master: - prob: HiGHS_Prob() solver: HighsSimplexMethod() subs: solver: HighsSimplexMethod() startstorages: function: startmagdict - distribution_method: #randdumb #storage #random #by_size #greedy #size-pairing + # distribution_method_mp: bysize #random #bysize #greedy #randdumb #storage #sizepairing #advanced + # distribution_method_sp: withmp #withmp #greedy clearing: solver: HighsSimplexMethod(warmstart=false) - statedependentprod: true - statedependentpump: true - headlosscost: true + statedependentprod: false + statedependentpump: false + headlosscost: false + scenariogeneration: + simulation: + function: InflowClusteringMethod + numscen: 4 #5 #7 + scendelta_days: 1095 + parts: 4 + subsystems: + function: twostorageduration # dataset, twostorageduration + shorttermstoragecutoff_hours: 10 + shortstochduration_hours: 168 + longstochduration_days: 91 + longevduration_days: 343 + horizons: - long: # only support sequential hydro and adaptive power - horizonduration_weeks: 52 # 5*52 - hydroperiodduration_days: 42 # 6*7 - rhsdata: - function: DynamicExogenPriceAHData - balance: PowerBalance_TYSKLAND - rhsmethod: KMeansAHMethod() - clusters: 4 - unitduration_hours: 12 - med: # only support sequential hydro and adaptive power - horizonduration_days: 126 # 3*6*7 - hydroperiodduration_days: 7 - rhsdata: - function: DynamicExogenPriceAHData - balance: PowerBalance_TYSKLAND - rhsmethod: KMeansAHMethod() - clusters: 4 - unitduration_hours: 6 - short: # only support sequential hydro and power - horizonduration_hours: 48 - hydroperiodduration_hours: 24 - powerparts: 4 - stochastic: - med: - horizonduration_days: 112 # 126 - 14 we reuse prices for two weeks, so have to be two weeks shorter than price prognosis problem: TODO rather calculate - master: - power: - periodduration_hours: 24 - hydro: - periodduration_hours: 24 - subs: - power: - periodduration_hours: 168 - hydro: - periodduration_hours: 168 + commodities: ["Hydro", "Power"] + shrinkable: + startafter_days: 91 # clear + short + med + shrinkatleast_days: 160 # (longperiod - clear)*4 + long: + termduration_weeks: 54 # 9*42 = 54 weeks (67 total) + shrinkable: true + Hydro: + function: SequentialHorizon + periodduration_days: 42 + Power: + function: AdaptiveHorizon + macro: Hydro + rhsdata: + function: DynamicExogenPriceAHData + balance: PowerBalance_TYSKLAND + rhsmethod: KMeansAHMethod() + clusters: 4 + unitduration_hours: 12 + med: + termduration_days: 84 # 7*12 = 42*2 = 12 weeks (13 total) + Hydro: + function: SequentialHorizon + periodduration_days: 7 + Power: + function: AdaptiveHorizon + macro: Hydro + rhsdata: + function: DynamicExogenPriceAHData + balance: PowerBalance_TYSKLAND + rhsmethod: KMeansAHMethod() + clusters: 4 + unitduration_hours: 6 + short: + termduration_hours: 120 # 5 days (7 total) + Hydro: + function: SequentialHorizon + periodduration_hours: 24 + Power: + function: SequentialHorizon + periodduration_hours: 6 clearing: - power: - periodduration_hours: 6 # should be the same as prognosis and stochastic short - hydro: + termduration_hours: 48 # 2 days + Hydro: + function: SequentialHorizon periodduration_hours: 24 + Power: + function: SequentialHorizon + periodduration_hours: 6 results: mainresults: ["SORLAND"] times: true - storagevalues: true \ No newline at end of file + storagevalues: false + memory: false \ No newline at end of file diff --git a/demos/data/config_jules_prognose_demo.yml b/demos/data/config_jules_prognose_demo.yml deleted file mode 100644 index fb4a853..0000000 --- a/demos/data/config_jules_prognose_demo.yml +++ /dev/null @@ -1,269 +0,0 @@ -main: - inputpath: "\\\\e-srv10\\X\\Prosjekter\\2022_FoU_markedsmodell_julia\\prognosemodell\\prognoser" - numcores: 10 #8 #6 #5 # kjerner per scenario - - datayears: [2024] - weatheryears: [1991, 1991] - weekstart: 21 - # simulationyears: 1 - # extrasteps: 0 # see steplength_hours - - # settings: fast # fast, threehour, sixhour - - simulationyears: 1 - extrasteps: 16 # see steplength_hours - - settings: threehour # fast, threehour - - outputformat: "juliadict" # hdf5 hvis du kjører gjennom JulESIO - outputindex: datayear # standard for paralellsimulering - - -############################################################# -threehour: - time: - weatheryearstart: 1991 - weatheryearstop: 2021 - probtime: - normaltime: PrognosisTime - phaseintime: PhaseinPrognosisTime - phaseindelta_days: 7 - phaseinsteps: 7 - - skipmax: 4 # how many steps should the watervalues be reused / at what interval should new watervalues be calculated - problems: - prognosis: - aggsupplyn: 4 - residualarealist: [] - shorttermstoragecutoff_hours: 10 - long: - solver: HighsSimplexMethod() - med: - solver: HighsSimplexMethod() - short: - solver: HighsSimplexMethod(warmstart=false) - startstorages: - function: aggstartmagdict - endvalue: - solver: HighsSimplexMethod() - startstorages: - function: startmagdict - stochastic: - maxcuts: 13 - lb: -100000.0 - reltol: 0.0001 - master: - solver: HighsSimplexMethod() - subs: - solver: HighsSimplexMethod() - startstorages: - function: startmagdict - - distribution_method_mp: greedy #random #bysize #greedy - distribution_method_sp: greedy #withmp - clearing: - solver: HighsSimplexMethod(warmstart=false) - statedependentprod: true - statedependentpump: true - headlosscost: true - scenariogeneration: - stochastic: - function: InflowClusteringMethod - numscen: 7 - scendelta_days: 365 - parts: 4 - # function: SumInflowQuantileMethod - # numscen: 7 - # scendelta_days: 365 - # maxquantile: 0.95 - # usedensity: true - # a: 0.5 - # b: -4 - # c: 10 - # a: 1 - # b: 0 - # c: 5 - # a: 0 - # b: 0 - # c: 1 - subsystems: - function: twostorageduration # dataset, twostorageduration - shorttermstoragecutoff_hours: 10 - shortstochduration_hours: 168 - longstochduration_days: 91 - longevduration_days: 721 - - - horizons: - commodities: ["Hydro", "Power"] - shrinkable: - startafter_days: 91 # clear + short + med - shrinkatleast_days: 360 # (longperiod - clear)*9 - long: - termduration_weeks: 198 # 42*33 = 198 weeks (211 total) - shrinkable: true - Hydro: - function: SequentialHorizon - periodduration_days: 42 - Power: - function: AdaptiveHorizon - macro: Hydro - rhsdata: - function: DynamicExogenPriceAHData - balance: PowerBalance_TYSKLAND - rhsmethod: KMeansAHMethod() - clusters: 4 - unitduration_hours: 6 - med: - termduration_days: 84 # 7*12 = 42*2 = 12 weeks (13 total) - Hydro: - function: SequentialHorizon - periodduration_days: 7 - Power: - function: AdaptiveHorizon - macro: Hydro - rhsdata: - function: DynamicExogenPriceAHData - balance: PowerBalance_TYSKLAND - rhsmethod: KMeansAHMethod() - clusters: 4 - unitduration_hours: 4 - short: - termduration_hours: 120 # 5 days (7 total) - Hydro: - function: SequentialHorizon - periodduration_hours: 24 - Power: - function: SequentialHorizon - periodduration_hours: 3 - clearing: - termduration_hours: 48 # 2 days - Hydro: - function: SequentialHorizon - periodduration_hours: 6 - Power: - function: SequentialHorizon - periodduration_hours: 3 - results: - mainresults: ["SORLAND"] - times: true - storagevalues: true - memory: false - - - -############################################################# -fast: # 24 hour steps, 7 static scenarios, aggregated hydro, shrinkablehorizon, no phasein, 1 year long, 18 week med, 2 day short - time: - weatheryearstart: 1991 - weatheryearstop: 2021 - probtime: - normaltime: PrognosisTime - phaseintime: PrognosisTime - phaseindelta_days: 7 - phaseinsteps: 7 - - skipmax: 8 # how many steps should the watervalues be reused / at what interval should new watervalues be calculated - problems: - onlyagghydro: true - prognosis: - aggsupplyn: 4 - residualarealist: [] - shorttermstoragecutoff_hours: 10 - long: - solver: HighsSimplexMethod() - med: - solver: HighsSimplexMethod() - short: - solver: HighsSimplexMethod(warmstart=false) - startstorages: - function: aggstartmagdict - endvalue: - solver: HighsSimplexMethod() - startstorages: - function: startmagdict - stochastic: - maxcuts: 13 - lb: -100000.0 - reltol: 0.0001 - master: - solver: HighsSimplexMethod() - subs: - solver: HighsSimplexMethod() - startstorages: - function: startmagdict - distribution_method_mp: storage #storage #random #bysize #greedy #advanced - distribution_method_sp: withmp #withmp - clearing: - solver: HighsSimplexMethod(warmstart=false) - statedependentprod: false - statedependentpump: false - headlosscost: false - scenariogeneration: - simulation: - function: InflowClusteringMethod - numscen: 4 #5 #7 - scendelta_days: 1095 - parts: 4 - subsystems: - function: twostorageduration # dataset, twostorageduration - shorttermstoragecutoff_hours: 10 - shortstochduration_hours: 168 - longstochduration_days: 91 - longevduration_days: 343 - - horizons: - commodities: ["Hydro", "Power"] - shrinkable: - startafter_days: 91 # clear + short + med - shrinkatleast_days: 160 # (longperiod - clear)*4 - long: - termduration_weeks: 54 # 9*42 = 54 weeks (67 total) - shrinkable: true - Hydro: - function: SequentialHorizon - periodduration_days: 42 - Power: - function: AdaptiveHorizon - macro: Hydro - rhsdata: - function: DynamicExogenPriceAHData - balance: PowerBalance_TYSKLAND - rhsmethod: KMeansAHMethod() - clusters: 4 - unitduration_hours: 12 - med: - termduration_days: 84 # 7*12 = 42*2 = 12 weeks (13 total) - Hydro: - function: SequentialHorizon - periodduration_days: 7 - Power: - function: AdaptiveHorizon - macro: Hydro - rhsdata: - function: DynamicExogenPriceAHData - balance: PowerBalance_TYSKLAND - rhsmethod: KMeansAHMethod() - clusters: 4 - unitduration_hours: 6 - short: - termduration_hours: 120 # 5 days (7 total) - Hydro: - function: SequentialHorizon - periodduration_hours: 24 - Power: - function: SequentialHorizon - periodduration_hours: 6 - clearing: - termduration_hours: 48 # 2 days - Hydro: - function: SequentialHorizon - periodduration_hours: 24 - Power: - function: SequentialHorizon - periodduration_hours: 6 - results: - mainresults: ["SORLAND"] - times: true - storagevalues: true - memory: false \ No newline at end of file diff --git a/src/generic_io.jl b/src/generic_io.jl index c7f8d0f..eeb6310 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -87,6 +87,26 @@ end # TODO: Is it a better default to minimize total object count on each core? (Can lead to one big subsystem on one core and several subsystems on others). More complicated. +""" +Will try to distribute small and large subsystems evenly on cores. + +E.g. if cores = [1, 2, 3] and subsystems = [3, 6, 1, 4, 5, 2] +where the list of subsystems is sorted from biggest subsystem to smallest +where size is defined as number of objects in the subsystem. + +Then, distribution on cores should be: +- Core 1: Index 1 and 6 (that is, subsystem 3 and 2) (i.e. biggest and smallest) +- Core 2: Index 2 and 5 (that is, subsystem 6 and 5) (i.e. next biggest and next smallest) +- Core 3: Index 3 and 4 (that is, subsystem 1 and 4) (i.e. next next biggest and next next smallest) + +This way, a core that get a relatively big system in one pass, +will get a relatively small system in the next pass. +This should ensure to balance load better than e.g. distributing +subsystems on cores by random choice. + +Scenario problems (sp) will be put on the same core as master problems (mp). +""" + function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) cores = get_cores(input) @@ -158,7 +178,6 @@ function _get_core_load!(input::AbstractJulESInput, subsystems::Vector{Tuple{Sub core_loads[core] = 0 end - # Create a dictionary to map SubsystemIx to AbstractSubsystem subsystem_dict = Dict{SubsystemIx, AbstractSubsystem}() for (ix, s) in subsystems @@ -177,8 +196,6 @@ function _get_core_load!(input::AbstractJulESInput, subsystems::Vector{Tuple{Sub else println("Warning: Core $core not found in core_loads dictionary. Skipping...") end - - end return core_loads end @@ -235,8 +252,6 @@ function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Ve end assign_scenarios!(subsystem_elements, core_loads, dist_sp) - - return dist_sp end @@ -263,7 +278,6 @@ function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, popfirst!(cores_copy) popfirst!(cores_copy) end - #the rest of the masterproblems are distributed by_size dist_rest = _distribute_subsystems_by_size!(subsystems_copy, cores_copy) @@ -344,17 +358,13 @@ function _distribute_subsystems_big_small!(subsystems::Vector{Tuple{SubsystemIx, deleteat!(sorted_subsystems, length(sorted_subsystems)) end end - return dist end #randdumb """ Function to distribute the subsystems on completely random cores""" function _distribute_subsystems_randdumb!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) - - dist = Tuple{SubsystemIx, CoreId}[] - for (ix, s) in subsystems # Randomly select a core core = rand(cores) @@ -363,20 +373,14 @@ function _distribute_subsystems_randdumb!(subsystems::Vector{Tuple{SubsystemIx, # Assign the subsystem to the randomly selected core push!(dist, (ix, core)) end - return dist end #random """Function to distribute the subsystems on random cores, but on different cores until all cores have subproblems assigned to them, then again until all cores have 2 subproblems assigned to them, and so on""" function _distribute_subsystems_random!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) - - dist = Tuple{SubsystemIx, CoreId}[] - corelist = copy(cores) - - for (ix, s) in subsystems if isempty(corelist) corelist = copy(cores) @@ -385,9 +389,7 @@ function _distribute_subsystems_random!(subsystems::Vector{Tuple{SubsystemIx, Ab filter!(x -> x != core, corelist) # Remove the selected core from the list # Assign the subsystem to the randomly selected core push!(dist, (ix, core)) - end - return dist end @@ -397,20 +399,15 @@ Function that distributes the subsystems by size. """ function _distribute_subsystems_by_size!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) N = length(cores) - subsystems_desc = get_subsystem_ids_by_decending_size(subsystems) - dist = Tuple{SubsystemIx, CoreId}[] loop_forward = true while length(subsystems_desc) > 0 K = length(subsystems_desc) M = min(K, N) - if loop_forward for i in 1:M - - push!(dist, (subsystems_desc[i], cores[i])) end subsystems_desc = subsystems_desc[(M+1):end] @@ -424,7 +421,6 @@ function _distribute_subsystems_by_size!(subsystems::Vector{Tuple{SubsystemIx, A loop_forward = true end end - return dist end @@ -432,11 +428,8 @@ end """Function that first distributes the subsystems with the highest number of storage elements on the cores with the lowest number of dataelements, then the remaining subsystems are distributed on the core with fewest dataelements one by one. """ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) elements = get_elements(input) - dist = Tuple{SubsystemIx, CoreId}[] - num_cores = length(cores) - has_storage = Tuple{SubsystemIx, AbstractSubsystem, Int}[] not_storage = Tuple{SubsystemIx, AbstractSubsystem, Int}[] @@ -444,11 +437,8 @@ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsy core_loads = fill(0, num_cores) for (ix, s) in subsystems - - elements_ix_in_subsystem = get_dataelements(s) elements_in_subsystem = elements[elements_ix_in_subsystem] - storage = false num_storage = 0 @@ -483,7 +473,6 @@ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsy assign_subsystems!(has_storage, core_loads, dist) assign_subsystems!(not_storage, core_loads, dist) - return dist end @@ -498,10 +487,7 @@ end #greedy """ Function to distribute subsystems greedy by number of dataelements. First sorting the subsystems in decreasing order, then placing them from biggest to smallest on the core with fewst dataelements.""" function _distribute_subsystems_elements_greedy!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) - - num_cores = length(cores) - dist = Tuple{SubsystemIx, CoreId}[] # Initialize an array to hold the load (number of data elements) for each core core_loads = fill(0, num_cores) @@ -522,21 +508,15 @@ end """function to get a tuple(subsystem index, number of data elements) that is sorted from highest to lowest number of data elements in the subsystem""" function get_subsystem_number_of_elements(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) - dataelements_in_each_subsystem = Tuple{SubsystemIx, Int}[] - for (ix, s) in subsystems - data_elements_in_sub= get_dataelements(s) number_data_elements = length(data_elements_in_sub) - # Create a tuple (data_element_index, number_data_elements) data_tuple = (ix, number_data_elements) - # Add the tuple to the dataelements array push!(dataelements_in_each_subsystem, data_tuple) end - return dataelements_in_each_subsystem end diff --git a/src/io.jl b/src/io.jl index bbea5a7..7f38df3 100644 --- a/src/io.jl +++ b/src/io.jl @@ -110,12 +110,8 @@ Returns the subsystem distribution method from the config file. If there is no d """ function get_distribution_method_mp(input::DefaultJulESInput, default::String="bysize") settings = get_settings(input) - # Retrieve the distribution method value - - method = get(settings["problems"]["stochastic"],"distribution_method_mp", default) - # Check if the method is not nothing and not an empty string if !isnothing(method) && !isempty(method) return method @@ -131,7 +127,6 @@ Withmp is the original method where scenarios are distributed on the same core a """ function get_distribution_method_sp(input::DefaultJulESInput, default::String="withmp") settings = get_settings(input) - # Retrieve the distribution method value method = get(settings["problems"]["stochastic"],"distribution_method_sp", default) @@ -168,7 +163,6 @@ end function get_ifm_weights(input::DefaultJulESInput) w = input.dataset["ifm_weights"] - # remove stations from w that does not exist # and update weights accordingly names = get_ifm_names(input) @@ -217,7 +211,6 @@ function get_datascenarios(datayear::Int64, weatheryear::Int64, weekstart::Int64 weatheroffset = weatherscenariotime - weathersimtime datascenarios[scen] = WeatherScenario(weatheroffset, 1/datanumscen, scen) end - return (simtime, NoScenarioModellingMethod(datascenarios)) end From cc3f2e1ec3fc010b7d9dcc9a2d9e600004a7dbef Mon Sep 17 00:00:00 2001 From: ingridwarnesen Date: Thu, 8 Aug 2024 14:49:16 +0200 Subject: [PATCH 25/28] commented on bugs with greedy_greedy --- demos/data/config_jules_prognose.yml | 4 ++-- src/generic_io.jl | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/demos/data/config_jules_prognose.yml b/demos/data/config_jules_prognose.yml index 246afc0..d9e5314 100644 --- a/demos/data/config_jules_prognose.yml +++ b/demos/data/config_jules_prognose.yml @@ -59,7 +59,7 @@ threehour: function: startmagdict # distribution_method_mp: bysize #random #bysize #greedy #randdumb #storage #sizepairing #advanced - # distribution_method_sp: withmp #withmp #greedy + # distribution_method_sp: withmp #withmp clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: true @@ -192,7 +192,7 @@ fast: # 24 hour steps, 7 static scenarios, aggregated hydro, shrinkablehorizon, startstorages: function: startmagdict # distribution_method_mp: bysize #random #bysize #greedy #randdumb #storage #sizepairing #advanced - # distribution_method_sp: withmp #withmp #greedy + # distribution_method_sp: withmp #withmp clearing: solver: HighsSimplexMethod(warmstart=false) statedependentprod: false diff --git a/src/generic_io.jl b/src/generic_io.jl index eeb6310..ce8430d 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -114,7 +114,6 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs distribution_method_mp = get_distribution_method_mp(input) default = "bysize" - valid_methods_mp = ["randdumb", "random", "bysize", "greedy", "storage", "sizepairing", "advanced"] @@ -216,6 +215,7 @@ function _distribute_sp_with_mp!(input::AbstractJulESInput, dist_mp::Vector{Tupl end #greedy +#TODO: bugs, Benders does not converge with this method for distribution of scenarioproblems """Function to distribute the scenarios on the core with least data elements""" function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, dist_mp::Vector{Tuple{SubsystemIx, CoreId}}, core_loads::Dict{CoreId, Int}) elements = get_elements(input) From 6f4b96a0cdb4f85c951c3deb444af31f6676c567 Mon Sep 17 00:00:00 2001 From: ingridwarnesen Date: Thu, 8 Aug 2024 15:37:33 +0200 Subject: [PATCH 26/28] added an end --- src/io.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/io.jl b/src/io.jl index 7f38df3..c0c5c3e 100644 --- a/src/io.jl +++ b/src/io.jl @@ -1199,7 +1199,7 @@ function get_output_timing_local(data, steplength, skipmax) display(df_core) display(df_subix) - + end # # display number of elements of each type per subsystem # unique_types = ["subix", "name_first_element", "name_second_element", "total_count"] # # # loop gjennom get_elements(db.input) og legg til push!(unique_type, ) From 5740ac3bba62c221dd60ab22832d23bcd3537455 Mon Sep 17 00:00:00 2001 From: culi122 <40186418+cjuli1@users.noreply.github.com> Date: Fri, 9 Aug 2024 13:40:12 +0200 Subject: [PATCH 27/28] small change demo --- demos/Demo prognosis.ipynb | 1 - 1 file changed, 1 deletion(-) diff --git a/demos/Demo prognosis.ipynb b/demos/Demo prognosis.ipynb index 577aca3..e39546f 100644 --- a/demos/Demo prognosis.ipynb +++ b/demos/Demo prognosis.ipynb @@ -23,7 +23,6 @@ "metadata": {}, "outputs": [], "source": [ - "#Pkg.instantiate()\n", "using Pkg; Pkg.status()\n", "# Pkg.add(\"Revise\"); Pkg.add(\"Plots\"); Pkg.add(\"PlotlyJS\"); Pkg.add(\"PrettyTables\")\n", "# Pkg.update(\"TuLiPa\") # uncomment to update TuLiPa to latest version\n", From 5e8a47b4b27697789d5c68ac106698019ab7f5a9 Mon Sep 17 00:00:00 2001 From: culi122 <40186418+cjuli1@users.noreply.github.com> Date: Fri, 9 Aug 2024 13:49:28 +0200 Subject: [PATCH 28/28] make generic_io more compact --- src/generic_io.jl | 45 ++------------------------------------------- 1 file changed, 2 insertions(+), 43 deletions(-) diff --git a/src/generic_io.jl b/src/generic_io.jl index ce8430d..a5dba70 100644 --- a/src/generic_io.jl +++ b/src/generic_io.jl @@ -20,22 +20,17 @@ end """ How price prognosis problems (ppp) are distributed on cores initially """ - - - function get_dist_ppp(input::AbstractJulESInput) cores = get_cores(input) N = length(cores) S = get_numscen_sim(input) dist = Vector{Tuple{ScenarioIx, CoreId}}(undef, S) - for s in 1:S j = (s - 1) % N + 1 dist[s] = (s, cores[j]) end - return dist end @@ -44,16 +39,11 @@ How end value problems (evp) are distributed on cores initially """ function get_dist_evp(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) cores = get_cores(input) - N = length(cores) #number of cores S = get_numscen_sim(input) #number of scenarios Y = length(subsystems) - - - out = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, S*Y) - if N >= S*Y k = 0 for (subix, sub) in subsystems @@ -67,7 +57,6 @@ function get_dist_evp(input::AbstractJulESInput, subsystems::Vector{Tuple{Subsys end # TODO: Do better when S < N < S*Y - k = 0 for (subix, sub) in subsystems for scenix in 1:S @@ -85,8 +74,6 @@ function get_core_cp(input::AbstractJulESInput) return first(get_cores(input)) end -# TODO: Is it a better default to minimize total object count on each core? (Can lead to one big subsystem on one core and several subsystems on others). More complicated. - """ Will try to distribute small and large subsystems evenly on cores. @@ -108,22 +95,18 @@ Scenario problems (sp) will be put on the same core as master problems (mp). """ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) - cores = get_cores(input) #Distributing the master problems/subsystems distribution_method_mp = get_distribution_method_mp(input) - default = "bysize" - + default = "bysize" valid_methods_mp = ["randdumb", "random", "bysize", "greedy", "storage", "sizepairing", "advanced"] - # Check if distribution_method is valid if !(distribution_method_mp in valid_methods_mp) println("distribution method $distribution_method_mp is not valid. Using $default") distribution_method_mp = default end - if distribution_method_mp == "randdumb" dist_mp = _distribute_subsystems_randdumb!(subsystems, cores) elseif distribution_method_mp == "random" @@ -143,8 +126,6 @@ function get_dist_stoch(input::AbstractJulESInput, subsystems::Vector{Tuple{Subs return (dist_mp, dist_sp) end - - #Distributing scenarioproblems sp distribution_method_sp = get_distribution_method_sp(input) default = "withmp" @@ -183,7 +164,6 @@ function _get_core_load!(input::AbstractJulESInput, subsystems::Vector{Tuple{Sub subsystem_dict[ix] = s end - for (sub_ix, core) in dist_mp s = subsystem_dict[sub_ix] num_elements = length(get_dataelements(s)) @@ -199,8 +179,7 @@ function _get_core_load!(input::AbstractJulESInput, subsystems::Vector{Tuple{Sub return core_loads end -#withmp -"""The original way to distribute senario problems. Each sp is on the same core as its master problem""" +"""The original way to distribute scenario problems. Each sp is on the same core as its master problem""" function _distribute_sp_with_mp!(input::AbstractJulESInput, dist_mp::Vector{Tuple{SubsystemIx, CoreId}}) N = get_numscen_stoch(input) dist_sp = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, N*length(dist_mp)) @@ -214,19 +193,15 @@ function _distribute_sp_with_mp!(input::AbstractJulESInput, dist_mp::Vector{Tupl return dist_sp end -#greedy #TODO: bugs, Benders does not converge with this method for distribution of scenarioproblems """Function to distribute the scenarios on the core with least data elements""" function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, dist_mp::Vector{Tuple{SubsystemIx, CoreId}}, core_loads::Dict{CoreId, Int}) elements = get_elements(input) - N = get_numscen_stoch(input) - dist_sp = Vector{Tuple{ScenarioIx, SubsystemIx, CoreId}}(undef, N*length(dist_mp)) #vektor med tupler med subsystem id, subsystem og antall dataelementer subsystem_elements = Tuple{SubsystemIx, Int}[] - for (ix, s) in subsystems push!(subsystem_elements, (ix, length(get_dataelements(s)))) end @@ -241,11 +216,9 @@ function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Ve for scen in 1:N # Find the core with the minimum load - min_load_core = findmin(core_loads)[2] dist_sp[i] = (scen, ix, min_load_core) core_loads[min_load_core] += elements - i += 1 end end @@ -255,8 +228,6 @@ function _distribute_scenarios_greedy!(input::AbstractJulESInput, subsystems::Ve return dist_sp end - -#advanced MP """Making the largest MP get the two first cores by assigning largest MP to core 1 and "reserving" core two for its SP""" function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) @@ -287,7 +258,6 @@ function _distribute_subsystems_advanced!(subsystems::Vector{Tuple{SubsystemIx, return dist end -#advanced SP """Function to split the scenario problems of the largest MP on the first two cores, and then distribute the rest of SP as before""" function _distribute_subscenarios_advanced!(dist_mp::Vector{Tuple{SubsystemIx, CoreId}}, cores::Vector{CoreId}, input::AbstractJulESInput) N = get_numscen_stoch(input) @@ -328,7 +298,6 @@ function _distribute_subscenarios_advanced!(dist_mp::Vector{Tuple{SubsystemIx, C return dist_sp end -#sizepairing """Function to sort all subsystems from biggest to smallest in a list, distribute smallest and biggest subsystem on the same core, removing them from the list and repeating until all subsystems are distributed on cores""" function _distribute_subsystems_big_small!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) sorted_subsystems = get_subsystem_ids_by_decending_size(subsystems) @@ -348,7 +317,6 @@ function _distribute_subsystems_big_small!(subsystems::Vector{Tuple{SubsystemIx, # Assign the smallest subsystem to the current core push!(dist, (sorted_subsystems[1], cores[i])) deleteat!(sorted_subsystems, 1) - if length(sorted_subsystems) == 0 break end @@ -361,7 +329,6 @@ function _distribute_subsystems_big_small!(subsystems::Vector{Tuple{SubsystemIx, return dist end -#randdumb """ Function to distribute the subsystems on completely random cores""" function _distribute_subsystems_randdumb!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) dist = Tuple{SubsystemIx, CoreId}[] @@ -369,14 +336,12 @@ function _distribute_subsystems_randdumb!(subsystems::Vector{Tuple{SubsystemIx, # Randomly select a core core = rand(cores) - # Assign the subsystem to the randomly selected core push!(dist, (ix, core)) end return dist end -#random """Function to distribute the subsystems on random cores, but on different cores until all cores have subproblems assigned to them, then again until all cores have 2 subproblems assigned to them, and so on""" function _distribute_subsystems_random!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) dist = Tuple{SubsystemIx, CoreId}[] @@ -393,7 +358,6 @@ function _distribute_subsystems_random!(subsystems::Vector{Tuple{SubsystemIx, Ab return dist end -#bysize """ Function that distributes the subsystems by size. """ @@ -424,7 +388,6 @@ function _distribute_subsystems_by_size!(subsystems::Vector{Tuple{SubsystemIx, A return dist end -#storage """Function that first distributes the subsystems with the highest number of storage elements on the cores with the lowest number of dataelements, then the remaining subsystems are distributed on the core with fewest dataelements one by one. """ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) elements = get_elements(input) @@ -476,7 +439,6 @@ function _distribute_subsystems_storage_greedy!(input::AbstractJulESInput, subsy return dist end - """Function to sort subsystems by decending number of dataelements """ function get_subsystem_ids_by_decending_size(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) subsystems = [(length(get_dataelements(s)), ix) for (ix, s) in subsystems] @@ -484,7 +446,6 @@ function get_subsystem_ids_by_decending_size(subsystems::Vector{Tuple{SubsystemI return [ix for (n, ix) in subsystems] end -#greedy """ Function to distribute subsystems greedy by number of dataelements. First sorting the subsystems in decreasing order, then placing them from biggest to smallest on the core with fewst dataelements.""" function _distribute_subsystems_elements_greedy!(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}, cores::Vector{CoreId}) num_cores = length(cores) @@ -504,8 +465,6 @@ function _distribute_subsystems_elements_greedy!(subsystems::Vector{Tuple{Subsys return dist end - - """function to get a tuple(subsystem index, number of data elements) that is sorted from highest to lowest number of data elements in the subsystem""" function get_subsystem_number_of_elements(subsystems::Vector{Tuple{SubsystemIx, AbstractSubsystem}}) dataelements_in_each_subsystem = Tuple{SubsystemIx, Int}[]