Merge pull request #81 from ProjectTorreyPines/updates

New updates to projection and plotting recipes

## Plotting:

2D heatmap plot of properties updated
* Added option of provigin value_field
* Added option of providing clims for colorbar
* Added equal aspect ration for the heatmap

## Projection:

* `project_prop_on_subset!` now has two methods.
*  `space` is a keyword argument now and optional as `get_space` can be used to get `space` object from `subset` objects.
*  Projection can be done for all time instances saved in different `ggd` by using the second method.

**Note**: This changes the call sign of `project_prop_on_subset!` and thus can break previous code using this function.

Author: anchal-physics

Project.toml

@@ -1,7 +1,7 @@
 name = "IMASggd"
 uuid = "b7b5e640-9b39-4803-84eb-376048795def"
 authors = ["Anchal Gupta <guptaa@fusion.gat.com>"]
-version = "3.1.1"
+version = "3.2.0"
 
 [deps]
 ArgParse = "c7e460c6-2fb9-53a9-8c5b-16f535851c63"

docs/src/index.md

@@ -58,6 +58,7 @@ can be imported for further use.
 IMASggd.all__grid_ggd
 IMASggd.all__space
 IMASggd.all__grid_subset
+IMASggd.all__ggd
 IMASggd.all__grid_subset_prop
 ```
 

src/recipes.jl

@@ -128,17 +128,28 @@ is the heatmap and b is the colorbar.
     yaxis --> "Z / m"
     layout := @layout [a{0.95w} b]
     if subset.element[1].object[1].dimension == 3
+        if :value_field in keys(plotattributes)
+            value_field = plotattributes[:value_field]
+        else
+            value_field = :values
+        end
+        prop_values = getfield(prop, value_field)
         if :seriescolor in keys(plotattributes)
             color_scheme = plotattributes[:seriescolor]
         else
             color_scheme = :inferno
         end
-        color_grad = getproperty(ColorSchemes, color_scheme)
-        val_min = minimum(prop.values)
-        val_max = maximum(prop.values)
-        function get_color(prop_value)
-            return color_grad[(log10(prop_value/val_min)/log10(val_max/val_min))]
+        if :clims in keys(plotattributes)
+            val_min, val_max = plotattributes[:clims]
+        else
+            val_min = minimum(prop_values)
+            val_max = maximum(prop_values)
         end
+        color_grad = getproperty(ColorSchemes, color_scheme)
+        colors = [
+            color_grad[(log10(pv/val_min)/log10(val_max/val_min))] for
+            pv ∈ prop_values
+        ]
 
         if :colorbar_title in keys(plotattributes)
             prop_name = plotattributes[:colorbar_title]
@@ -163,13 +174,14 @@ is the heatmap and b is the colorbar.
 
         # Actual plot is plotted as different cell shapes filled with color values
         # based on property value
-        for (ele, prop_value) ∈ zip(subset.element, prop.values)
+        for (ele, color) ∈ zip(subset.element, colors)
             cell = cells[ele.object[1].index]
             @series begin
                 subplot := 1
                 seriestype := :shape
-                linecolor := get_color(prop_value)
-                fillcolor := get_color(prop_value)
+                linecolor := color
+                fillcolor := color
+                aspect_ratio := :equal
                 label := ""
                 [Tuple(nodes[cell.nodes[ii]].geometry) for ii ∈ [1, 2, 4, 3]]
             end

src/subset_tools.jl

@@ -202,11 +202,11 @@ end
 
 """
     subset_do(
-    set_operator,
-    itrs::Vararg{all__grid_subset};
-    use_nodes=false,
 
-)::all__grid_subset
+        set_operator,
+        itrs::Vararg{all__grid_subset};
+        use_nodes=false,
+    )::all__grid_subset
 
 Function to perform any set operation (intersect, union, setdiff etc.) on
 subset.element to generate a list of elements to go to subset object. If use_nodes is
@@ -271,91 +271,108 @@ end
 
 """
     project_prop_on_subset!(
-        prop_arr::AbstractVector{<:all__grid_subset_prop}),
-        from_subset::all__grid_subset),
-        to_subset::all__grid_subset),
-        space::all__space,
+        prop_arr::IMASdd.IDSvector{<:all__grid_subset_prop},
+        from_subset::all__grid_subset,
+        to_subset::all__grid_subset;
+        space::all__space=get_space(from_subset),
         value_field::Symbol=:values,
-        TPS_mats::Union{
-            Nothing,
-            Tuple{Matrix{U}, Matrix{U}, Matrix{U}, Vector{Tuple{U, U}}},
-        }=nothing,
+
+        TPS_mats::Tuple{Matrix{U}, Matrix{U}, Matrix{U}, Vector{Tuple{U, U}}}=get_TPS_mats(
+            space,
+            from_subset,
+        ),
+
     ) where {U <: Real}
 
 This function can be used to add another instance on a property vector representing the
 value in a new subset that can be taken as a projection from an existing larger subset.
 
 Input Arguments:
 
-  - prop: A property like electrons.density that is a vector of objects with fields
+  - `prop`: A property like electrons.density that is a vector of objects with fields
     coefficients, grid_index, grid_subset_index, and values. The different instances
     in the vector correspond to different grid_subset for which the property is
     provided.
-  - from_subset: grid_subset object which is already represented in the property instance.
+  - `from_subset`: grid_subset object which is already represented in the property instance.
     grid subset with index 5 is populated in electrons.density already if the
     values for all cells are present.
-  - to_subset: grid_subset which is either a smaller part of from_subset (core, sol, idr,
+  - `to_subset`: grid_subset which is either a smaller part of from_subset (core, sol, idr,
     odr) but has same dimensions as from_subset
     OR
     is smaller in dimension that goes through the from_subset (core_boundary,
     separatix etc.)
-  - space: (optional) space object in grid_ggd is required only when from_subset is
-    higher dimensional than to_subset.
+  - `space`: (optional) space object in grid_ggd corresponding to the subsets
+  - `value_field`: If the values field is called something else, that can be provided here.
 
 Returns:
 NOTE: This function ends in ! which means it updates prop argument in place. But for
 the additional utility, this function also returns a tuple
-(to_subset_centers, to_prop_values) when from_subset dimension is greater than
-to_subset dimension
-OR
-(to_subset_ele_obj_inds, to_prop_values) when from_subset dimension is same as
-to_subset dimension)
-
-Descriptions:
-to_subset_centers: center of cells or center of edges of the to_subset where property
-values are defined and stored
-to_subset_ele_obj_inds: Indices of the elements of to_subset where property values are
-defined and stored
-to_prop_values: The projected values of the properties added to prop object in a new
-instance
+
+(`to_subset_centers`, `to_prop_values`)
+
+  - `to_subset_centers`: center of cells or center of edges of the to_subset where
+    property values are defined and stored
+  - `to_prop_values`: The projected values of the properties added to prop object in a
+    new instance
 """
 function project_prop_on_subset!(
     prop_arr::IMASdd.IDSvector{<:all__grid_subset_prop},
     from_subset::all__grid_subset,
-    to_subset::all__grid_subset,
-    space::all__space,
+    to_subset::all__grid_subset;
+    space::all__space=get_space(from_subset),
     value_field::Symbol=:values,
-    TPS_mats::Union{
-        Nothing,
-        Tuple{Matrix{U}, Matrix{U}, Matrix{U}, Vector{Tuple{U, U}}},
-    }=nothing,
+    TPS_mats::Tuple{Matrix{U}, Matrix{U}, Matrix{U}, Vector{Tuple{U, U}}}=get_TPS_mats(
+        space,
+        from_subset,
+    ),
 ) where {U <: Real}
-    if from_subset.element[1].object[1].dimension ==
-       to_subset.element[1].object[1].dimension
-        return project_prop_on_subset!(prop_arr, from_subset, to_subset, value_field)
-    elseif from_subset.element[1].object[1].dimension >
-           to_subset.element[1].object[1].dimension
-        if length(prop_arr) < 1
-            error(
-                "The property $(strip(repr(prop_arr))) is empty; ",
-                "there are no data available for any subset.",
-            )
-        end
-        from_prop =
-            get_prop_with_grid_subset_index(prop_arr, from_subset.identifier.index)
-        if isnothing(from_prop)
+    if length(prop_arr) < 1
+        error(
+            "The property $(strip(repr(prop_arr))) is empty; ",
+            "there are no data available for any subset.",
+        )
+    end
+    from_prop = get_prop_with_grid_subset_index(prop_arr, from_subset.identifier.index)
+    if isnothing(from_prop)
+        error(
+            "from_subset ($(from_subset.identifier.index)) not represented in the ",
+            "property yet",
+        )
+    end
+    to_subset_centers = get_subset_centers(space, to_subset)
+    from_dim = from_subset.element[1].object[1].dimension
+    to_dim = to_subset.element[1].object[1].dimension
+    resize!(prop_arr, length(prop_arr) + 1)
+    to_prop = prop_arr[end]
+    to_prop.grid_index = from_prop.grid_index
+    to_prop.grid_subset_index = to_subset.identifier.index
+    to_prop_values = getfield(to_prop, value_field)
+    from_prop_values = getfield(from_prop, value_field)
+    if from_dim == to_dim
+        from_subset_ele_obj_inds = [ele.object[1].index for ele ∈ from_subset.element]
+        to_subset_ele_obj_inds = [ele.object[1].index for ele ∈ to_subset.element]
+        if to_subset_ele_obj_inds ⊆ from_subset_ele_obj_inds
+            from_ele_inds = []
+            for to_ele_obj_ind ∈ to_subset_ele_obj_inds
+                for (from_ele_ind, from_ele_obj_ind) ∈
+                    enumerate(from_subset_ele_obj_inds)
+                    if from_ele_obj_ind == to_ele_obj_ind
+                        append!(from_ele_inds, from_ele_ind)
+                    end
+                end
+            end
+            filtered_values =
+                [from_prop_values[from_ele_ind] for from_ele_ind ∈ from_ele_inds]
+            resize!(to_prop_values, length(filtered_values))
+            setproperty!(to_prop, value_field, filtered_values)
+            return to_subset_centers, filtered_values
+        else
             error(
-                "from_subset ($(from_subset.identifier.index)) not represented in the ",
-                "property yet",
+                "to_subset ($(to_subset.identifier.index)) does not lie entirely inside ",
+                "from_subset ($(from_subset.identifier.index)). Projection not possible.",
             )
         end
-        to_subset_centers = get_subset_centers(space, to_subset)
-        resize!(prop_arr, length(prop_arr) + 1)
-        to_prop = prop_arr[end]
-        to_prop.grid_index = from_prop.grid_index
-        to_prop.grid_subset_index = to_subset.identifier.index
-        to_prop_values = getfield(to_prop, value_field)
-        from_prop_values = getfield(from_prop, value_field)
+    elseif from_dim > to_dim
         resize!(to_prop_values, length(to_subset.element))
         if isnothing(TPS_mats)
             prop_interp = interp(prop_arr, space, from_subset)
@@ -375,74 +392,83 @@ end
 
 """
     project_prop_on_subset!(
-        prop_arr::AbstractVector{<:all__grid_subset_prop}),
-        from_subset::all__grid_subset),
-        to_subset::all__grid_subset),
+        ggds::IMASdd.IDSvector{<:all__ggd},
+        prop_path::String,
+        from_subset::all__grid_subset,
+        to_subset::all__grid_subset;
+        space::all__space=get_space(from_subset),
         value_field::Symbol=:values,
-    )
+        TPS_mats::Tuple{Matrix{U}, Matrix{U}, Matrix{U}, Vector{Tuple{U, U}}}=get_TPS_mats(
+            space,
+            from_subset,
+        ),
+    ) where {U <: Real}
 
-If the dimensions of from_subset and to_subset are the same, this function can be used
-to add another instance on a property vector representing the value in to_subset without
-any interpolation or use of space object. The function returns a tuple of indices of
-elements of to_subset and the values of the property in to_subset.
+This function projects properties from `from_subset` to `to_subset` for each of the
+`ggds` element. Here property is given as a relative path from `ggd` object. For
+example, for electron density in `edge_profiles`, one would provide `edge_profiles.ggd`
+as the `ggds` argument and "electrons.density" as the `prop_path` argument. Note that
+`prop_path` can be parsed even if it includes array in it. For example, in
+`edge_profiles.ggd`, `prop_path` of "ion.state[7].density" would correspond to the
+index 7 in `state` array of `ion` while a `prop_path` of "ion.state[:].density" would
+do the projection for all the states of the `ion`. This function call returns a combined
+list of return tuples for all projections performed.
 """
 function project_prop_on_subset!(
-    prop_arr::IMASdd.IDSvector{<:all__grid_subset_prop},
+    ggds::IMASdd.IDSvector{<:all__ggd},
+    prop_path::String,
     from_subset::all__grid_subset,
-    to_subset::all__grid_subset,
+    to_subset::all__grid_subset;
+    space::all__space=get_space(from_subset),
     value_field::Symbol=:values,
-)
-    from_prop = get_prop_with_grid_subset_index(prop_arr, from_subset.identifier.index)
-    if length(prop_arr) < 1
-        error(
-            "The property $(strip(repr(prop_arr))) is empty; ",
-            "there are no data available for any subset.",
-        )
+    TPS_mats::Tuple{Matrix{U}, Matrix{U}, Matrix{U}, Vector{Tuple{U, U}}}=get_TPS_mats(
+        space,
+        from_subset,
+    ),
+) where {U <: Real}
+    prop_arrays = Array{IMASdd.IDSvector{<:all__grid_subset_prop}}[]
+    for ggd ∈ ggds
+        append!(prop_arrays, _prop_arrays_from_path(prop_path::String, ggd))
     end
-    if isnothing(from_prop)
-        error(
-            "from_subset ($(from_subset.identifier.index)) not represented in the property yet",
+    to_return = []
+    for prop_arr ∈ prop_arrays
+        append!(
+            to_return,
+            project_prop_on_subset!(
+                prop_arr,
+                from_subset,
+                to_subset;
+                space,
+                value_field,
+                TPS_mats,
+            ),
         )
     end
-    if from_subset.element[1].object[1].dimension ==
-       to_subset.element[1].object[1].dimension
-        resize!(prop_arr, length(prop_arr) + 1)
-        to_prop = prop_arr[end]
-        to_prop.grid_index = from_prop.grid_index
-        to_prop.grid_subset_index = to_subset.identifier.index
-        to_prop_values = getfield(to_prop, value_field)
-        from_prop_values = getfield(from_prop, value_field)
-        from_subset_ele_obj_inds = [ele.object[1].index for ele ∈ from_subset.element]
-        to_subset_ele_obj_inds = [ele.object[1].index for ele ∈ to_subset.element]
-        if to_subset_ele_obj_inds ⊆ from_subset_ele_obj_inds
-            from_ele_inds = []
-            for to_ele_obj_ind ∈ to_subset_ele_obj_inds
-                for (from_ele_ind, from_ele_obj_ind) ∈
-                    enumerate(from_subset_ele_obj_inds)
-                    if from_ele_obj_ind == to_ele_obj_ind
-                        append!(from_ele_inds, from_ele_ind)
-                    end
+    return to_return
+end
+
+function _prop_arrays_from_path(prop_path::String, parent)
+    prop_arrays = Array{IMASdd.IDSvector{<:all__grid_subset_prop}}[]
+    if occursin(".", prop_path)
+        pf = split(prop_path, ".")[1]
+        rem_path = prop_path[(findfirst('.', prop_path)+1):end]
+        if occursin("[", pf)
+            new_parent = getfield(parent, Symbol(pf[1:(findfirst('[', pf)-1)]))
+            ind_str = pf[(findfirst('[', pf)+1):(findfirst(']', pf)-1)]
+            if ind_str == ":"
+                for np ∈ new_parent
+                    append!(prop_arrays, _prop_arrays_from_path(rem_path, np))
                 end
+            else
+                ind = parse(Int, ind_str)
+                append!(prop_arrays, _prop_arrays_from_path(rem_path, new_parent[ind]))
             end
-            filtered_values =
-                [from_prop_values[from_ele_ind] for from_ele_ind ∈ from_ele_inds]
-            resize!(to_prop_values, length(filtered_values))
-            to_prop_values = filtered_values
-            return to_subset_ele_obj_inds, to_prop_values
         else
-            error(
-                "to_subset ($(to_subset.identifier.index)) does not lie entirely inside ",
-                "from_subset ($(from_subset.identifier.index)). Projection not possible.",
-            )
+            new_parent = getfield(parent, Symbol(pf))
+            append!(prop_arrays, _prop_arrays_from_path(rem_path, new_parent))
         end
-    else
-        error(
-            "Dimensions of from_subset ($(from_subset.identifier.index)) and to_subset ",
-            "($(to_subset.identifier.index)) do not match. Provide keyword ",
-            "argument space if you want to project to a smaller dimension as space ",
-            "information is required for that. Use\n",
-            "project_prop_on_subset!(prop, from_subset, to_subset; space=space)")
     end
+    return prop_arrays
 end
 
 """