Extend data access API

LibTrixi.jl/src/LibTrixi.jl

@@ -1,9 +1,9 @@
 module LibTrixi
 
 using OrdinaryDiffEq: OrdinaryDiffEq, step!, check_error, DiscreteCallback
-using Trixi: Trixi, summary_callback, mesh_equations_solver_cache, nelements,
-             nelementsglobal, nvariables, nnodes, wrap_array, eachelement, cons2prim,
-             get_node_vars, eachnode
+using Trixi: Trixi, summary_callback, mesh_equations_solver_cache, ndims, nelements,
+             nelementsglobal, ndofs, ndofsglobal, nvariables, nnodes, wrap_array,
+             eachelement, cons2prim, get_node_vars, eachnode
 using MPI: MPI, run_init_hooks, set_default_error_handler_return
 using Pkg
 
@@ -28,15 +28,27 @@ export trixi_ndims,
 export trixi_nelements,
        trixi_nelements_cfptr,
        trixi_nelements_jl
-export trixi_nelements_global,
-       trixi_nelements_global_cfptr,
-       trixi_nelements_global_jl
+export trixi_nelementsglobal,
+       trixi_nelementsglobal_cfptr,
+       trixi_nelementsglobal_jl
+export trixi_ndofs,
+       trixi_ndofs_cfptr,
+       trixi_ndofs_jl
+export trixi_ndofsglobal,
+       trixi_ndofsglobal_cfptr,
+       trixi_ndofsglobal_jl
+export trixi_ndofselement,
+       trixi_ndofselement_cfptr,
+       trixi_ndofselement_jl
 export trixi_nvariables,
        trixi_nvariables_cfptr,
        trixi_nvariables_jl
-export trixi_load_cell_averages,
-       trixi_load_cell_averages_cfptr,
-       trixi_load_cell_averages_jl
+export trixi_load_primitive_vars,
+       trixi_load_primitive_vars_cfptr,
+       trixi_load_primitive_vars_jl
+export trixi_load_element_averaged_primitive_vars,
+       trixi_load_element_averaged_primitive_vars_cfptr,
+       trixi_load_element_averaged_primitive_vars_jl
 export trixi_version_library,
        trixi_version_library_cfptr,
        trixi_version_library_jl

LibTrixi.jl/src/api_c.jl

@@ -285,7 +285,7 @@ trixi_ndims_cfptr() = @cfunction(trixi_ndims, Cint, (Cint,))
 """
     trixi_nelements(simstate_handle::Cint)::Cint
 
-Return number of local elements (cells).
+Return number of local elements.
 """
 function trixi_nelements end
 
@@ -298,18 +298,63 @@ trixi_nelements_cfptr() = @cfunction(trixi_nelements, Cint, (Cint,))
 
 
 """
-    trixi_nelements_global(simstate_handle::Cint)::Cint
+    trixi_nelementsglobal(simstate_handle::Cint)::Cint
 
-Return number of global elements (cells).
+Return global number of elements.
 """
-function trixi_nelements_global end
+function trixi_nelementsglobal end
 
-Base.@ccallable function trixi_nelements_global(simstate_handle::Cint)::Cint
+Base.@ccallable function trixi_nelementsglobal(simstate_handle::Cint)::Cint
     simstate = load_simstate(simstate_handle)
-    return trixi_nelements_global_jl(simstate)
+    return trixi_nelementsglobal_jl(simstate)
 end
 
-trixi_nelements_global_cfptr() = @cfunction(trixi_nelements_global, Cint, (Cint,))
+trixi_nelementsglobal_cfptr() = @cfunction(trixi_nelementsglobal, Cint, (Cint,))
+
+
+"""
+    trixi_ndofs(simstate_handle::Cint)::Cint
+
+Return number of degrees of freedom (all quadrature points on all elements of current rank).
+"""
+function trixi_ndofs end
+
+Base.@ccallable function trixi_ndofs(simstate_handle::Cint)::Cint
+    simstate = load_simstate(simstate_handle)
+    return trixi_ndofs_jl(simstate)
+end
+
+trixi_ndofs_cfptr() = @cfunction(trixi_ndofs, Cint, (Cint,))
+
+
+"""
+    trixi_ndofsglobal(simstate_handle::Cint)::Cint
+
+Return global number of degrees of freedom (all quadrature points on all elements).
+"""
+function trixi_ndofsglobal end
+
+Base.@ccallable function trixi_ndofsglobal(simstate_handle::Cint)::Cint
+    simstate = load_simstate(simstate_handle)
+    return trixi_ndofsglobal_jl(simstate)
+end
+
+trixi_ndofsglobal_cfptr() = @cfunction(trixi_ndofsglobal, Cint, (Cint,))
+
+
+"""
+    trixi_ndofselement(simstate_handle::Cint)::Cint
+
+Return number of degrees of freedom per element.
+"""
+function trixi_ndofselement end
+
+Base.@ccallable function trixi_ndofselement(simstate_handle::Cint)::Cint
+    simstate = load_simstate(simstate_handle)
+    return trixi_ndofselement_jl(simstate)
+end
+
+trixi_ndofselement_cfptr() = @cfunction(trixi_ndofselement, Cint, (Cint,))
 
 
 """
@@ -328,32 +373,62 @@ trixi_nvariables_cfptr() = @cfunction(trixi_nvariables, Cint, (Cint,))
 
 
 """
-    trixi_load_cell_averages(data::Ptr{Cdouble}, simstate_handle::Cint)::Cvoid
+    trixi_load_primitive_vars(simstate_handle::Cint, variable_id::Cint,
+                              data::Ptr{Cdouble})::Cvoid
+
+Load primitive variable.
+
+The values for the primitive variable at position `variable_id` at every degree of freedom
+for are stored in the given array `data`.
+
+The given array has to be of correct size (ndofs) and memory has to be allocated beforehand.
+"""
+function trixi_load_primitive_vars end
+
+Base.@ccallable function trixi_load_primitive_vars(simstate_handle::Cint, variable_id::Cint,
+                                                   data::Ptr{Cdouble})::Cvoid
+    simstate = load_simstate(simstate_handle)
+
+    # convert C to Julia array
+    size = trixi_ndofs_jl(simstate)
+    data_jl = unsafe_wrap(Array, data, size)
+
+    trixi_load_primitive_vars_jl(simstate, variable_id, data_jl)
+    return nothing
+end
+
+trixi_load_primitive_vars_cfptr() =
+    @cfunction(trixi_load_primitive_vars, Cvoid, (Cint, Cint, Ptr{Cdouble}))
+
+
+"""
+    trixi_load_element_averaged_primitive_vars(simstate_handle::Cint, variable_id::Cint,
+                                            data::Ptr{Cdouble})::Cvoid
 
-Return cell averaged solution state.
+Load element averages for primitive variable.
 
-Cell averaged values for each cell and each primitive variable are stored in a contiguous
-array, where cell values for the first variable appear first and values for the other
-variables subsequently (structure-of-arrays layout).
+Element averaged values for the primitive variable at position `variable_id` for each
+element are stored in the given array `data`.
 
-The given array has to be of correct size and memory has to be allocated beforehand.
+The given array has to be of correct size (nelements) and memory has to be allocated
+beforehand.
 """
-function trixi_load_cell_averages end
+function trixi_load_element_averaged_primitive_vars end
 
-Base.@ccallable function trixi_load_cell_averages(data::Ptr{Cdouble},
-                                                  simstate_handle::Cint)::Cvoid
+Base.@ccallable function trixi_load_element_averaged_primitive_vars(simstate_handle::Cint,
+    variable_id::Cint, data::Ptr{Cdouble})::Cvoid
     simstate = load_simstate(simstate_handle)
 
     # convert C to Julia array
-    size = trixi_nvariables_jl(simstate) * trixi_nelements_jl(simstate)
+    size = trixi_nelements_jl(simstate)
     data_jl = unsafe_wrap(Array, data, size)
 
-    trixi_load_cell_averages_jl(data_jl, simstate)
+    trixi_load_element_averaged_primitive_vars_jl(simstate, variable_id, data_jl)
     return nothing
 end
 
-trixi_load_cell_averages_cfptr() =
-    @cfunction(trixi_load_cell_averages, Cvoid, (Ptr{Cdouble}, Cint,))
+trixi_load_element_averaged_primitive_vars_cfptr() =
+    @cfunction(trixi_load_element_averaged_primitive_vars, Cvoid, (Cint, Cint, Ptr{Cdouble}))
 
 
 """

LibTrixi.jl/src/api_jl.jl

@@ -76,22 +76,63 @@ function trixi_nelements_jl(simstate)
 end
 
 
-function trixi_nelements_global_jl(simstate)
+function trixi_nelementsglobal_jl(simstate)
     _, _, solver, cache = mesh_equations_solver_cache(simstate.semi)
     return nelementsglobal(solver, cache)
 end
 
 
+function trixi_ndofs_jl(simstate)
+    mesh, _, solver, cache = mesh_equations_solver_cache(simstate.semi)
+    return ndofs(mesh, solver, cache)
+end
+
+
+function trixi_ndofsglobal_jl(simstate)
+    mesh, _, solver, cache = mesh_equations_solver_cache(simstate.semi)
+    return ndofsglobal(mesh, solver, cache)
+end
+
+
+function trixi_ndofselement_jl(simstate)
+    mesh, _, solver, _ = mesh_equations_solver_cache(simstate.semi)
+    return nnodes(solver)^ndims(mesh)
+end
+
+
 function trixi_nvariables_jl(simstate)
     _, equations, _, _ = mesh_equations_solver_cache(simstate.semi)
     return nvariables(equations)
 end
 
 
-function trixi_load_cell_averages_jl(data, simstate)
+function trixi_load_primitive_vars_jl(simstate, variable_id, data)
+    mesh, equations, solver, cache = mesh_equations_solver_cache(simstate.semi)
+    n_nodes_per_dim = nnodes(solver)
+    n_dims = ndims(mesh)
+    n_nodes = n_nodes_per_dim^n_dims
+
+    u_ode = simstate.integrator.u
+    u = wrap_array(u_ode, mesh, equations, solver, cache)
+
+    # all permutations of nodes indices for arbitrary dimension
+    node_cis = CartesianIndices(ntuple(i -> n_nodes_per_dim, n_dims))
+    node_lis = LinearIndices(node_cis)
+
+    for element in eachelement(solver, cache)
+        for node_ci in node_cis
+            node_vars = get_node_vars(u, equations, solver, node_ci, element)
+            node_index = (element-1) * n_nodes + node_lis[node_ci]
+            data[node_index] = cons2prim(node_vars, equations)[variable_id]
+        end
+    end
+
+    return nothing
+end
+
+
+function trixi_load_element_averaged_primitive_vars_jl(simstate, variable_id, data)
     mesh, equations, solver, cache = mesh_equations_solver_cache(simstate.semi)
-    n_elements = nelements(solver, cache)
-    n_variables = nvariables(equations)
     n_nodes = nnodes(solver)
     n_dims = ndims(mesh)
 
@@ -101,15 +142,13 @@ function trixi_load_cell_averages_jl(data, simstate)
     # all permutations of nodes indices for arbitrary dimension
     node_cis = CartesianIndices(ntuple(i -> n_nodes, n_dims))
 
-    # temporary storage for mean value on current element for all variables
-    u_mean = get_node_vars(u, equations, solver, node_cis[1], 1)
-
     for element in eachelement(solver, cache)
 
         # compute mean value using nodal dg values and quadrature
-        u_mean = zero(u_mean)
+        u_mean = zero(eltype(u))
         for node_ci in node_cis
-            u_node_prim = cons2prim(get_node_vars(u, equations, solver, node_ci, element), equations)
+            u_node_prim = cons2prim(get_node_vars(u, equations, solver, node_ci, element),
+                                    equations)[variable_id]
             weight = 1.
             for node_index in Tuple(node_ci)
                 weight *= solver.basis.weights[node_index]
@@ -120,11 +159,8 @@ function trixi_load_cell_averages_jl(data, simstate)
         # normalize to unit element
         u_mean = u_mean / 2^n_dims
 
-        # copy to provided array
-        # all element values for first variable, then for second, ...
-        for ivar = 0:n_variables-1
-            data[element + ivar * n_elements] = u_mean[ivar+1]
-        end
+        # write to provided array
+        data[element] = u_mean
     end
 
     return nothing

LibTrixi.jl/test/test_interface.jl

@@ -77,20 +77,40 @@ end
     nelements_jl = trixi_nelements_jl(simstate_jl)
     @test nelements_c == nelements_jl
 
-    nelements_global_c = trixi_nelements_global(handle)
-    nelements_global_jl = trixi_nelements_global_jl(simstate_jl)
-    @test nelements_global_c == nelements_global_jl
+    nelementsglobal_c = trixi_nelementsglobal(handle)
+    nelementsglobal_jl = trixi_nelementsglobal_jl(simstate_jl)
+    @test nelementsglobal_c == nelementsglobal_jl
+
+    # compare number of dofs
+    ndofs_c = trixi_ndofs(handle)
+    ndofs_jl = trixi_ndofs_jl(simstate_jl)
+    @test ndofs_c == ndofs_jl
+
+    ndofsglobal_c = trixi_ndofsglobal(handle)
+    ndofsglobal_jl = trixi_ndofsglobal_jl(simstate_jl)
+    @test ndofsglobal_c == ndofsglobal_jl
+
+    ndofselement_c = trixi_ndofselement(handle)
+    ndofselement_jl = trixi_ndofselement_jl(simstate_jl)
+    @test ndofselement_c == ndofselement_jl
 
     # compare number of variables
     nvariables_c = trixi_nvariables(handle)
     nvariables_jl = trixi_nvariables_jl(simstate_jl)
     @test nvariables_c == nvariables_jl
 
-    # compare cell averaged values
-    data_c = zeros(nvariables_c * nelements_c)
-    trixi_load_cell_averages(pointer(data_c), handle)
-    data_jl = zeros(nvariables_jl * nelements_jl)
-    trixi_load_cell_averages_jl(data_jl, simstate_jl)
+    # compare element averaged values
+    data_c = zeros(nelements_c)
+    trixi_load_element_averaged_primitive_vars(handle, Int32(1), pointer(data_c))
+    data_jl = zeros(nelements_jl)
+    trixi_load_element_averaged_primitive_vars_jl(simstate_jl, 1, data_jl)
+    @test data_c == data_jl
+
+    # compare primitive variable values on all dofs
+    data_c = zeros(ndofs_c)
+    trixi_load_primitive_vars(handle, Int32(1), pointer(data_c))
+    data_jl = zeros(ndofs_jl)
+    trixi_load_primitive_vars_jl(simstate_jl, 1, data_jl)
     @test data_c == data_jl
 end
 

examples/trixi_controller_data.c

@@ -46,16 +46,16 @@ int main ( int argc, char *argv[] ) {
             printf("\n*** Trixi controller ***   nelements %d\n", nelements);
 
             // Allocate memory
-            data = realloc( data, sizeof(double) * nelements * nvariables );
+            data = realloc( data, sizeof(double) * nelements );
 
-            // Get averaged cell values for each variable
-            trixi_load_cell_averages(data, handle);
+            // Get element averaged values for first variable
+            trixi_load_element_averaged_primitive_vars(handle, 1, data);
         }
     }
 
     // Print first variable
     for (int i = 0; i < nelements; ++i) {
-        printf("u[cell %3d] = %f\n", i, data[i]);
+        printf("u[element %3d] = %f\n", i, data[i]);
     }
 
     // Finalize Trixi simulation

examples/trixi_controller_data.f90

@@ -63,16 +63,16 @@ program trixi_controller_data_f
 
       ! allocate memory
       if ( associated(data) ) deallocate(data)
-      allocate( data(nelements*nvariables) )
+      allocate( data(nelements) )
 
-      ! get averaged cell values for each variable
-      call trixi_load_cell_averages(data, handle)
+      ! get element averaged values for first variable
+      call trixi_load_element_averaged_primitive_vars(handle, 1, data)
     end if
   end do
 
   ! print first variable
   do i = 1,nelements
-    print "('u[cell  ', i4, '] = ', e14.8)", i, data(i)
+    print "('u[element  ', i4, '] = ', e14.8)", i, data(i)
   end do
 
   ! Finalize Trixi simulation