Add functions to spatially visualise individual and aggregate criteria for location selection

docs/src/usage/analysis.md

@@ -186,6 +186,35 @@ save("ranks_plot.png", rank_fig)
 
 ![Rank frequency plots for multiple ranks](/ADRIA.jl/dev/assets/imgs/ranks_plot.png?raw=true "Rank frequency plot 3 ranks")
 
+## Intervention location selection - plot criteria maps
+
+```julia
+
+dom = ADRIA.load_domain("path to domain", "45")
+scens = ADRIA.sample_guided(dom, 8)
+
+mcda_funcs = ADRIA.decision.mcda_methods()
+
+scens = ADRIA.sample_guided(dom, 2^5)
+rs = ADRIA.run_scenarios(dom, scens, "45")
+
+# Remove any risk filtering
+scens[1, ["deployed_coral_risk_tol"]] .= [1.0]
+
+# Create decision matrices for first scenario, get aggregate score using the
+# first MCDA method
+decision_dict = ADRIA.decision.decision_matrices(rs, scens[1, :], mcda_funcs[1])
+
+# Plot maps of seeding criteria and aggreagte selection score
+fig_criteria = hs = ADRIA.viz.map(
+    rs, decision_dict[:seed_matrix], decision_dict[:seed_scores]
+)
+save("criteria_maps.png", fig_criteria)
+```
+
+![Spatial maps of location selection criteria](/ADRIA.jl/dev/assets/imgs/criteria_spatial_plots.png?raw=true "Spatial maps of location selection criteria")
+
+
 ### PAWN sensitivity (heatmap overview)
 
 The PAWN sensitivity analysis method is a moment-independent approach to Global Sensitivity

ext/AvizExt/viz/location_selection.jl

@@ -20,6 +20,8 @@ Plot a spatial map of location selection frequencies.
 - `opts` : Aviz options
     - `colorbar_label`, label for colorbar. Defaults to "Relative Cover".
     - `color_map`, preferred colormap for plotting heatmaps.
+    - `colorbar_limits` : Upper and lower limits displayed on colorbar,
+    (default is (0.0, maximum(data)))
 - `axis_opts` : Additional options to pass to adjust Axis attributes
   See: https://docs.makie.org/v0.19/api/index.html#Axis
 - `fig_opts` : Additional options to pass to adjust Figure creation
@@ -29,7 +31,7 @@ Plot a spatial map of location selection frequencies.
 Figure
 """
 function ADRIA.viz.ranks_to_frequencies!(
-    g::Union{GridLayout,GridPosition},
+    g::Union{GridLayout, GridPosition},
     rs::ResultSet,
     frequencies::NamedDimsArray,
     rank_ids::Vector{Int64};
@@ -86,7 +88,7 @@ function ADRIA.viz.ranks_to_frequencies!(
     return g
 end
 function ADRIA.viz.ranks_to_frequencies!(
-    g::Union{GridLayout,GridPosition},
+    g::Union{GridLayout, GridPosition},
     rs::ResultSet,
     frequencies::NamedDimsArray,
     rank_id::Int64;
@@ -110,10 +112,9 @@ end
 function ADRIA.viz.ranks_to_frequencies(
     rs::ResultSet,
     frequencies::NamedDimsArray,
-    rank_ids::Union{Int64,Vector{Int64}};
+    rank_ids::Union{Int64, Vector{Int64}};
     opts::Dict=Dict(),
     fig_opts::Dict=Dict(), axis_opts::Dict=Dict())
-
     f = Figure(; fig_opts...)
     g = f[1, 1] = GridLayout()
     ADRIA.viz.ranks_to_frequencies!(
@@ -141,7 +142,7 @@ Retrieve set of colormaps for plotting overlayed colormaps.
 Maps for each key in rank_groups to a unique colormap.
 """
 function _default_colormap(
-    rank_groups::Dict{Symbol,BitVector}, alpha_vals::Dict{Symbol,Float64}
+    rank_groups::Dict{Symbol, BitVector}, alpha_vals::Dict{Symbol, Float64}
 )
     rank_colors = colors(rank_groups, alpha_vals)
     rank_ids = keys(rank_groups)

ext/AvizExt/viz/scenarios.jl

@@ -56,13 +56,13 @@ function ADRIA.viz.scenarios(
     )
 end
 function ADRIA.viz.scenarios!(
-    g::Union{GridLayout,GridPosition},
+    g::Union{GridLayout, GridPosition},
     rs::ResultSet,
     outcomes::NamedDimsArray;
     opts::Dict=Dict(:by_RCP => false),
     axis_opts::Dict=Dict(),
     series_opts::Dict=Dict(),
-)::Union{GridLayout,GridPosition}
+)::Union{GridLayout, GridPosition}
     opts[:histogram] = get(opts, :histogram, false)
 
     return ADRIA.viz.scenarios!(
@@ -91,13 +91,13 @@ function ADRIA.viz.scenarios(
     return f
 end
 function ADRIA.viz.scenarios!(
-    g::Union{GridLayout,GridPosition},
+    g::Union{GridLayout, GridPosition},
     scenarios::DataFrame,
     outcomes::NamedDimsArray;
     opts::Dict=Dict(),
     axis_opts::Dict=Dict(),
     series_opts::Dict=Dict(),
-)::Union{GridLayout,GridPosition}
+)::Union{GridLayout, GridPosition}
     # Ensure last year is always shown in x-axis
     xtick_vals = get(axis_opts, :xticks, _time_labels(timesteps(outcomes)))
     xtick_rot = get(axis_opts, :xticklabelrotation, 2 / π)
@@ -121,14 +121,14 @@ function ADRIA.viz.scenarios!(
     )
 end
 function ADRIA.viz.scenarios!(
-    g::Union{GridLayout,GridPosition},
+    g::Union{GridLayout, GridPosition},
     ax::Axis,
     outcomes::NamedDimsArray,
-    scen_groups::Dict{Symbol,BitVector};
+    scen_groups::Dict{Symbol, BitVector};
     opts::Dict=Dict(),
     axis_opts::Dict=Dict(),
     series_opts::Dict=Dict(),
-)::Union{GridLayout,GridPosition}
+)::Union{GridLayout, GridPosition}
     if get(opts, :summarize, true)
         scenarios_confint!(ax, outcomes, scen_groups)
     else
@@ -149,7 +149,7 @@ function ADRIA.viz.scenarios!(
 end
 
 function _confints(
-    outcomes::NamedDimsArray, scen_groups::Dict{Symbol,BitVector}
+    outcomes::NamedDimsArray, scen_groups::Dict{Symbol, BitVector}
 )::Array{Float64}
     groups::Vector{Symbol} = _sort_keys(scen_groups, outcomes)
     n_timesteps::Int64 = size(outcomes, 1)
@@ -171,10 +171,9 @@ function scenarios_confint!(
     ax::Axis,
     confints::AbstractArray,
     ordered_groups::Vector{Symbol},
-    _colors::Dict{Symbol,Union{Symbol,RGBA{Float32}}};
-    x_vals::Union{Vector{Int64},Vector{Float64}}=collect(1:size(confints, 1)),
+    _colors::Dict{Symbol, Union{Symbol, RGBA{Float32}}};
+    x_vals::Union{Vector{Int64}, Vector{Float64}}=collect(1:size(confints, 1)),
 )::Nothing
-
     for idx in eachindex(ordered_groups)
         band_color = (_colors[ordered_groups[idx]], 0.4)
         y_lower, y_upper = confints[:, idx, 1], confints[:, idx, 3]
@@ -187,9 +186,9 @@ function scenarios_confint!(
     return nothing
 end
 function scenarios_confint!(
-    ax::Axis, outcomes::NamedDimsArray, scen_groups::Dict{Symbol,BitVector}
+    ax::Axis, outcomes::NamedDimsArray, scen_groups::Dict{Symbol, BitVector}
 )::Nothing
-    _colors::Dict{Symbol,Union{Symbol,RGBA{Float32}}} = colors(scen_groups)
+    _colors::Dict{Symbol, Union{Symbol, RGBA{Float32}}} = colors(scen_groups)
     ordered_groups = _sort_keys(scen_groups, outcomes)
     confints = _confints(outcomes, scen_groups)
     return scenarios_confint!(
@@ -204,13 +203,13 @@ end
 function scenarios_series!(
     ax::Axis,
     outcomes::NamedDimsArray,
-    scen_groups::Dict{Symbol,BitVector};
+    scen_groups::Dict{Symbol, BitVector};
     series_opts::Dict=Dict(),
-    x_vals::Union{Vector{Int64},Vector{Float64}}=collect(1:size(outcomes, 1)),
+    x_vals::Union{Vector{Int64}, Vector{Float64}}=collect(1:size(outcomes, 1)),
     sort_by=:size,
 )::Nothing
-    _colors::Dict{Symbol,Union{Symbol,RGBA{Float32}}} = colors(scen_groups)
-    _alphas::Dict{Symbol,Float64} = alphas(scen_groups)
+    _colors::Dict{Symbol, Union{Symbol, RGBA{Float32}}} = colors(scen_groups)
+    _alphas::Dict{Symbol, Float64} = alphas(scen_groups)
 
     for group in _sort_keys(scen_groups, outcomes; by=sort_by)
         color = (_colors[group], _alphas[group])
@@ -222,9 +221,9 @@ function scenarios_series!(
 end
 
 function scenarios_hist(
-    g::Union{GridLayout,GridPosition},
+    g::Union{GridLayout, GridPosition},
     outcomes::NamedDimsArray,
-    scen_groups::Dict{<:Any,BitVector},
+    scen_groups::Dict{<:Any, BitVector},
 )::Nothing
     scen_dist = dropdims(mean(outcomes; dims=:timesteps); dims=:timesteps)
     ax_hist = Axis(g[1, 2]; width=100)
@@ -248,9 +247,9 @@ function scenarios_hist(
 end
 
 function _render_legend(
-    g::Union{GridLayout,GridPosition},
-    scen_groups::Dict{<:Any,BitVector},
-    legend_position::Tuple{Int64,Int64},
+    g::Union{GridLayout, GridPosition},
+    scen_groups::Dict{<:Any, BitVector},
+    legend_position::Tuple{Int64, Int64},
 )::Nothing
     group_names::Vector{Symbol} = sort(collect(keys(scen_groups)))
     _colors = colors(scen_groups)
@@ -274,7 +273,7 @@ Sort types by variance in reverse order.
     - :counterfactual
 """
 function _sort_keys(
-    scenario_types::Dict{Symbol,BitVector},
+    scenario_types::Dict{Symbol, BitVector},
     outcomes::AbstractArray;
     by=:variance,
 )::Vector{Symbol}

ext/AvizExt/viz/spatial.jl

@@ -20,6 +20,8 @@ Create a spatial choropleth figure.
 - `centroids` : Vector{Tuple}, of lon and lats
 - `show_colorbar` : Whether to show a colorbar (true) or not (false)
 - `colorbar_label` : Label to use for color bar
+- `colorbar_limits` : Upper and lower limits displayed on colorbar,
+    (default is (0.0, maximum(data)))
 - `color_map` : Type of colormap to use,
     See: https://docs.makie.org/stable/documentation/colors/#colormaps
 - `legend_params` : Legend parameters
@@ -34,6 +36,7 @@ function create_map!(
     centroids::Vector,
     show_colorbar::Bool=true,
     colorbar_label::String="",
+    colorbar_limits::Tuple{Float64, Float64}=(0.0, maximum(data)),
     color_map::Union{Symbol, Vector{Symbol}, RGBA{Float32}, Vector{RGBA{Float32}}}=:grayC,
     legend_params::Union{Tuple, Nothing}=nothing,
     axis_opts::Dict=Dict(),
@@ -58,28 +61,23 @@ function create_map!(
 
     spatial.yticklabelpad = 50
     spatial.ytickalign = 10
-    max_val = @lift(maximum($data))
-
-    # Plot geodata polygons using data as internal color
-    color_range = (0.0, max_val[])
 
     poly!(
         spatial,
         geodata;
         color=data,
         colormap=color_map,
-        colorrange=color_range,
         strokecolor=(:black, 0.05),
         strokewidth=1.0,
     )
 
     if show_colorbar
         Colorbar(
             f[1, 2];
-            colorrange=color_range,
             colormap=color_map,
             label=colorbar_label,
             height=Relative(0.65),
+            limits=colorbar_limits,
         )
     end
 
@@ -126,17 +124,32 @@ function create_map!(
 end
 
 """
-    ADRIA.viz.map(rs::Union{Domain,ResultSet}; opts=Dict(by_RCP => false), fig_opts=Dict(), axis_opts=Dict(), series_opts=Dict())
-    ADRIA.viz.map(rs::ResultSet, y::NamedDimsArray; opts=Dict(by_RCP => false), fig_opts=Dict(), axis_opts=Dict(), series_opts=Dict())
-    ADRIA.viz.map!(f::Union{GridLayout,GridPosition}, rs::ADRIA.ResultSet, y::NamedDimsArray; opts=Dict(by_RCP => false), axis_opts=Dict(), series_opts=Dict())
+    ADRIA.viz.map(rs::Union{Domain,ResultSet}; opts=Dict(by_RCP => false), fig_opts=Dict(), 
+        axis_opts=Dict(), series_opts=Dict())
+    ADRIA.viz.map(rs::ResultSet, y::NamedDimsArray; opts=Dict(by_RCP => false), fig_opts=Dict(), 
+        axis_opts=Dict(), series_opts=Dict())
+    ADRIA.viz.map(rs::ResultSet, S::NamedDimsArray, scores::Vector{Float64};
+        criteria::Vector{Symbol} = S.criteria, opts::Dict = Dict(), axis_opts::Dict = Dict(),
+        fig_opts::Dict = Dict())
+    ADRIA.viz.map!(f::Union{GridLayout,GridPosition}, rs::ADRIA.ResultSet, y::NamedDimsArray; 
+        opts=Dict(by_RCP => false), axis_opts=Dict(), series_opts=Dict())
+    ADRIA.viz.map!(g::Union{GridLayout,GridPosition},rs::ResultSet, S::NamedDimsArray, 
+        scores::Vector{Float64}; criteria::Vector{Symbol} = S.criteria, opts::Dict = Dict(), 
+        axis_opts::Dict = Dict(), fig_opts::Dict = Dict())
 
 Plot spatial choropleth of outcomes.
 
 # Arguments
 - `rs` : ResultSet
 - `y` : results of scenario metric
+- `S` : A normalised decision matrix calculated using decison.decision_matrices
+- `scores` : Aggregated criteria scores.
+- `criteria` : Names of criteria to be plotted, if not specified all criteria in 
+    S will be plotted.
 - `opts` : Aviz options
     - `colorbar_label`, label for colorbar. Defaults to "Relative Cover"
+    -`colorbar_limits`, min and max values to be shown on the colorbar. 
+        Defaults to (0.0,maximum(y)).
     - `color_map`, preferred colormap for plotting heatmaps
 - `axis_opts` : Additional options to pass to adjust Axis attributes
   See: https://docs.makie.org/v0.19/api/index.html#Axis
@@ -196,7 +209,7 @@ function ADRIA.viz.map!(
     legend_params = get(opts, :legend_params, nothing)
     show_colorbar = get(opts, :show_colorbar, true)
     color_map = get(opts, :color_map, :grayC)
-
+    colorbar_limits = get(opts, :colorbar_limits, (0.0, maximum(y)))
     return create_map!(
         g,
         geodata,
@@ -205,11 +218,82 @@ function ADRIA.viz.map!(
         ADRIA.centroids(rs),
         show_colorbar,
         c_label,
+        colorbar_limits,
         color_map,
         legend_params,
         axis_opts,
     )
 end
+function ADRIA.viz.map(
+    rs::ResultSet,
+    S::NamedDimsArray,
+    scores::Vector{Float64};
+    criteria::Vector{Symbol}=S.criteria,
+    opts::Dict=Dict(),
+    axis_opts::Dict=Dict(),
+    fig_opts::Dict=Dict(),
+)
+    f = Figure(; fig_opts...)
+    g = f[1, 1] = GridLayout()
+    ADRIA.viz.map!(
+        g, rs, S, scores; criteria=criteria, opts=opts, axis_opts=axis_opts
+    )
+    return f
+end
+function ADRIA.viz.map!(
+    g::Union{GridLayout, GridPosition},
+    rs::ResultSet,
+    S::NamedDimsArray,
+    scores::Vector{Float64};
+    criteria::Vector{Symbol}=S.criteria,
+    opts::Dict=Dict(),
+    axis_opts::Dict=Dict(),
+)
+    if length(rs.site_data.site_id) != size(S, 1)
+        error("Only unfiltered decision matrices can be plotted.")
+    end
+
+    opts[:color_map] = get(opts, :color_map, :viridis)
+    opts[:colorbar_limits] = get(opts, :colorbar_limits, (0.0, 1.0))
+
+    m_spec = model_spec(rs)
+    criteria_names::Vector{String} = m_spec[
+        dropdims(
+            any(
+                reshape(criteria, 1, length(criteria)) .== m_spec[:, "fieldname"]; dims=2
+            );
+            dims=2,
+        ), "name"]
+    n_criteria::Int64 = length(criteria)
+    n_rows, n_cols = _calc_gridsize(n_criteria + 1)
+    step::Int64 = 1
+
+    for row in 1:n_rows, col in 1:n_cols
+        if step > length(criteria_names)
+            ADRIA.viz.map!(
+                g[row, col],
+                rs,
+                vec(scores);
+                opts=opts,
+                axis_opts=Dict(:title => "Aggregate criteria score"; axis_opts...),
+            )
+            break
+        end
+        axis_opts_temp = Dict(:title => criteria_names[step]; axis_opts...)
+        ADRIA.viz.map!(
+            g[row, col],
+            rs,
+            vec(S(criteria[step]));
+            opts=opts,
+            axis_opts=axis_opts_temp,
+        )
+
+        step += 1
+    end
+
+    # Clear empty figures
+    return trim!(g)
+end
 
 """
     make_geojson_copy(ds::Union{ResultSet,Domain})::String