removed duplicate nodevalues!

Author: chmerdon

src/interpolations.jl

@@ -260,52 +260,31 @@ end
 """
 ````
 function nodevalues!(
-	target::AbstractArray{<:Real,2},
-	source::AbstractArray{T,1},
-	FE::FESpace{Tv,Ti,FEType,AT},
-	operator::Type{<:AbstractFunctionOperator} = Identity;
-	kwargs...)
-````
-
-calls the nodevalues_subset! function with all nodes of the dofgrid, see nodevalues_subset!(target, source, FE, operator; nodes = 1:num_nodes(FE.dofgrid), kwargs...)
-"""
-function nodevalues!(
-        target::AbstractArray{T, 2},
-        source::AbstractArray{T, 1},
-        FE::FESpace{Tv, Ti, FEType, AT},
-        operator::Type{<:AbstractFunctionOperator} = Identity;
-        kwargs...
-    ) where {T, Tv, Ti, FEType, AT}
-
-    nodevalues_subset!(target, source, FE, operator; nodes = 1:num_nodes(FE.dofgrid), kwargs...)
-
-    return nothing
-end
-
-"""
-````
-piecewise_nodevalues!(
-        target::AbstractArray{T, 2},
-        source::AbstractArray{T, 1},
-        FE::FESpace{Tv, Ti, FEType, AT},
+        target::AbstractArray{<:Real,2},
+        source::AbstractArray{T,1},
+        FE::FESpace{Tv,Ti,FEType,AT},
         operator::Type{<:AbstractFunctionOperator} = Identity;
         abs::Bool = false,
         factor = 1,
-        regions::Array{Int, 1} = [0],
+        regions::Array{Int,1} = [0],
         target_offset::Int = 0,
         source_offset::Int = 0,
         zero_target::Bool = true,
         continuous::Bool = false
     )
 ````
 
-Evaluate a finite element function (given by the coefficient vector `source` and FE space `FE`) at all nodes, but store the results in a piecewise (cellwise) fashion, i.e., for each cell, the values at its local nodes are written into `target`. The result is organized so that each column of `target` corresponds to a cell, and each row corresponds to the values at the cell's nodes.
+Evaluate a finite element function (given by the coefficient vector `source` and FE space `FE`) at all nodes of the grid, applying an optional function operator, and write the results into `target`.
+
+By default, the function is evaluated at every node in the mesh. If `continuous` is `false`, the value at each node is averaged over all neighboring cells (suitable for discontinuous quantities). If `continuous` is `true`, the value is taken from a single cell per node (suitable for continuous quantities). The result can optionally be scaled, offset, or restricted to specific regions.
 
 # Arguments
-- `target`: Output array to store the evaluated values (size: result dimension × number of nodes per cell, number of cells).
+- `target`: Output array to store the evaluated values (size: result dimension × number of nodes).
 - `source`: Coefficient vector for the FE function.
 - `FE`: The finite element space.
-- `operator`: Function operator to apply (default: `Identity`).
+- `operator`: Function operator to apply at each node (default: `Identity`).
+
+# Keyword Arguments
 - `abs`: If `true`, store the Euclidean norm of the result at each node (default: `false`).
 - `factor`: Scaling factor applied to the result (default: `1`).
 - `regions`: List of region indices to restrict evaluation (default: all regions).
@@ -316,8 +295,11 @@ Evaluate a finite element function (given by the coefficient vector `source` and
 
 # Notes
 - The result dimension is determined by the FE space, the operator, and the `abs` argument.
+- The function modifies `target` in-place.
+- For vector-valued or higher-dimensional results, the first dimension of `target` corresponds to the result dimension.
+
 """
-function piecewise_nodevalues!(
+function nodevalues!(
         target::AbstractArray{T, 2},
         source::AbstractArray{T, 1},
         FE::FESpace{Tv, Ti, FEType, AT},
@@ -327,7 +309,8 @@ function piecewise_nodevalues!(
         regions::Array{Int, 1} = [0],
         target_offset::Int = 0,
         source_offset::Int = 0,
-        zero_target::Bool = true
+        zero_target::Bool = true,
+        continuous::Bool = false
     ) where {T, Tv, Ti, FEType, AT}
 
     xgrid = FE.dofgrid
@@ -354,11 +337,14 @@ function piecewise_nodevalues!(
         fill!(target, 0)
     end
 
+    nnodes::Int = num_sources(xgrid[Coordinates])
+    nneighbours::Array{Int, 1} = zeros(Int, nnodes)
+    flag4node::Array{Bool, 1} = zeros(Bool, nnodes)
+
     function barrier(EG, qf, BE)
         node::Int = 0
         dof::Ti = 0
         weights::Array{T, 1} = qf.w
-        nweights = length(weights)
         basisvals = BE.cvals
         ndofs = size(basisvals, 2)
         cvals_resultdim::Int = size(basisvals, 1)
@@ -378,32 +364,29 @@ function piecewise_nodevalues!(
                     for i in eachindex(weights) # vertices
                         node = xItemNodes[i, item]
                         fill!(localT, 0)
-
-                        for dof_i in 1:ndofs
-                            dof = xItemDofs[dof_i, item]
-                            eval_febe!(temp, BE, dof_i, i)
-                            for k in 1:cvals_resultdim
-                                localT[k] += source[source_offset + dof] * temp[k]
-                                #target[k+target_offset,node] += temp[k] * source[source_offset + dof]
-                            end
-                        end
-                        localT .*= factor
-                        if abs
-                            for k in 1:cvals_resultdim
-                                target[target_offset + i, item] += localT[k]^2
+                        if continuous == false || flag4node[node] == false
+                            nneighbours[node] += 1
+                            flag4node[node] = true
+                            for dof_i in 1:ndofs
+                                dof = xItemDofs[dof_i, item]
+                                eval_febe!(temp, BE, dof_i, i)
+                                for k in 1:cvals_resultdim
+                                    localT[k] += source[source_offset + dof] * temp[k]
+                                    #target[k+target_offset,node] += temp[k] * source[source_offset + dof]
+                                end
                             end
-                        else
-                            for k in 1:cvals_resultdim
-                                target[target_offset + i + (k - 1) * nweights, item] += localT[k]
+                            localT .*= factor
+                            if abs
+                                for k in 1:cvals_resultdim
+                                    target[1 + target_offset, node] += localT[k]^2
+                                end
+                            else
+                                for k in 1:cvals_resultdim
+                                    target[k + target_offset, node] += localT[k]
+                                end
                             end
                         end
                     end
-
-                    if abs
-                        for i in 1:nweights
-                            target[i + target_offset, item] = sqrt(target[i + target_offset, item])
-                        end
-                    end
                     break # region for loop
                 end # if in region
             end # region for loop
@@ -417,38 +400,48 @@ function piecewise_nodevalues!(
         barrier(EG[j], qf, BE)
     end
 
+
+    if continuous == false
+        for n in 1:nnodes, k in 1:target_resultdim
+            if nneighbours[n] > 0
+                target[k + target_offset, n] /= nneighbours[n]
+            end
+        end
+    end
+
+    if abs
+        for n in 1:nnodes
+            target[1 + target_offset, n] = sqrt(target[1 + target_offset, n])
+        end
+    end
+
     return nothing
 end
 
-
 """
 ````
-function nodevalues!(
-        target::AbstractArray{<:Real,2},
-        source::AbstractArray{T,1},
-        FE::FESpace{Tv,Ti,FEType,AT},
+piecewise_nodevalues!(
+        target::AbstractArray{T, 2},
+        source::AbstractArray{T, 1},
+        FE::FESpace{Tv, Ti, FEType, AT},
         operator::Type{<:AbstractFunctionOperator} = Identity;
         abs::Bool = false,
         factor = 1,
-        regions::Array{Int,1} = [0],
+        regions::Array{Int, 1} = [0],
         target_offset::Int = 0,
         source_offset::Int = 0,
         zero_target::Bool = true,
         continuous::Bool = false
     )
 ````
 
-Evaluate a finite element function (given by the coefficient vector `source` and FE space `FE`) at all nodes of the grid, applying an optional function operator, and write the results into `target`.
-
-By default, the function is evaluated at every node in the mesh. If `continuous` is `false`, the value at each node is averaged over all neighboring cells (suitable for discontinuous quantities). If `continuous` is `true`, the value is taken from a single cell per node (suitable for continuous quantities). The result can optionally be scaled, offset, or restricted to specific regions.
+Evaluate a finite element function (given by the coefficient vector `source` and FE space `FE`) at all nodes, but store the results in a piecewise (cellwise) fashion, i.e., for each cell, the values at its local nodes are written into `target`. The result is organized so that each column of `target` corresponds to a cell, and each row corresponds to the values at the cell's nodes.
 
 # Arguments
-- `target`: Output array to store the evaluated values (size: result dimension × number of nodes).
+- `target`: Output array to store the evaluated values (size: result dimension × number of nodes per cell, number of cells).
 - `source`: Coefficient vector for the FE function.
 - `FE`: The finite element space.
-- `operator`: Function operator to apply at each node (default: `Identity`).
-
-# Keyword Arguments
+- `operator`: Function operator to apply (default: `Identity`).
 - `abs`: If `true`, store the Euclidean norm of the result at each node (default: `false`).
 - `factor`: Scaling factor applied to the result (default: `1`).
 - `regions`: List of region indices to restrict evaluation (default: all regions).
@@ -459,11 +452,8 @@ By default, the function is evaluated at every node in the mesh. If `continuous`
 
 # Notes
 - The result dimension is determined by the FE space, the operator, and the `abs` argument.
-- The function modifies `target` in-place.
-- For vector-valued or higher-dimensional results, the first dimension of `target` corresponds to the result dimension.
-
 """
-function nodevalues!(
+function piecewise_nodevalues!(
         target::AbstractArray{T, 2},
         source::AbstractArray{T, 1},
         FE::FESpace{Tv, Ti, FEType, AT},
@@ -473,8 +463,7 @@ function nodevalues!(
         regions::Array{Int, 1} = [0],
         target_offset::Int = 0,
         source_offset::Int = 0,
-        zero_target::Bool = true,
-        continuous::Bool = false
+        zero_target::Bool = true
     ) where {T, Tv, Ti, FEType, AT}
 
     xgrid = FE.dofgrid
@@ -501,14 +490,11 @@ function nodevalues!(
         fill!(target, 0)
     end
 
-    nnodes::Int = num_sources(xgrid[Coordinates])
-    nneighbours::Array{Int, 1} = zeros(Int, nnodes)
-    flag4node::Array{Bool, 1} = zeros(Bool, nnodes)
-
     function barrier(EG, qf, BE)
         node::Int = 0
         dof::Ti = 0
         weights::Array{T, 1} = qf.w
+        nweights = length(weights)
         basisvals = BE.cvals
         ndofs = size(basisvals, 2)
         cvals_resultdim::Int = size(basisvals, 1)
@@ -528,27 +514,30 @@ function nodevalues!(
                     for i in eachindex(weights) # vertices
                         node = xItemNodes[i, item]
                         fill!(localT, 0)
-                        if continuous == false || flag4node[node] == false
-                            nneighbours[node] += 1
-                            flag4node[node] = true
-                            for dof_i in 1:ndofs
-                                dof = xItemDofs[dof_i, item]
-                                eval_febe!(temp, BE, dof_i, i)
-                                for k in 1:cvals_resultdim
-                                    localT[k] += source[source_offset + dof] * temp[k]
-                                    #target[k+target_offset,node] += temp[k] * source[source_offset + dof]
-                                end
+
+                        for dof_i in 1:ndofs
+                            dof = xItemDofs[dof_i, item]
+                            eval_febe!(temp, BE, dof_i, i)
+                            for k in 1:cvals_resultdim
+                                localT[k] += source[source_offset + dof] * temp[k]
+                                #target[k+target_offset,node] += temp[k] * source[source_offset + dof]
                             end
-                            localT .*= factor
-                            if abs
-                                for k in 1:cvals_resultdim
-                                    target[1 + target_offset, node] += localT[k]^2
-                                end
-                            else
-                                for k in 1:cvals_resultdim
-                                    target[k + target_offset, node] += localT[k]
-                                end
+                        end
+                        localT .*= factor
+                        if abs
+                            for k in 1:cvals_resultdim
+                                target[target_offset + i, item] += localT[k]^2
                             end
+                        else
+                            for k in 1:cvals_resultdim
+                                target[target_offset + i + (k - 1) * nweights, item] += localT[k]
+                            end
+                        end
+                    end
+
+                    if abs
+                        for i in 1:nweights
+                            target[i + target_offset, item] = sqrt(target[i + target_offset, item])
                         end
                     end
                     break # region for loop
@@ -564,21 +553,6 @@ function nodevalues!(
         barrier(EG[j], qf, BE)
     end
 
-
-    if continuous == false
-        for n in 1:nnodes, k in 1:target_resultdim
-            if nneighbours[n] > 0
-                target[k + target_offset, n] /= nneighbours[n]
-            end
-        end
-    end
-
-    if abs
-        for n in 1:nnodes
-            target[1 + target_offset, n] = sqrt(target[1 + target_offset, n])
-        end
-    end
-
     return nothing
 end