From d25d2f1c33910ee056cc243db487fc0e33f2e482 Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Fri, 7 Jan 2022 14:46:57 +0100 Subject: [PATCH 01/13] Added HomogeneousTrialFESpace --- src/FESpaces.jl | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/FESpaces.jl b/src/FESpaces.jl index 8a16333c..b858e1a6 100644 --- a/src/FESpaces.jl +++ b/src/FESpaces.jl @@ -318,6 +318,13 @@ function FESpaces.TrialFESpace(fun,f::DistributedSingleFieldFESpace) DistributedSingleFieldFESpace(spaces,f.gids,f.vector_type) end +function FESpaces.HomogeneousTrialFESpace(f::DistributedSingleFieldFESpace) + spaces = map_parts(f.spaces) do s + HomogeneousTrialFESpace(s) + end + DistributedSingleFieldFESpace(spaces,f.gids,f.vector_type) +end + function generate_gids( model::DistributedDiscreteModel, spaces::AbstractPData{<:SingleFieldFESpace}) From e225d8f6731586d233c50cc86cb7168a6ed012af Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Fri, 7 Jan 2022 22:54:09 +0100 Subject: [PATCH 02/13] added TrialFESpace! function --- src/FESpaces.jl | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/FESpaces.jl b/src/FESpaces.jl index b858e1a6..4f479f3c 100644 --- a/src/FESpaces.jl +++ b/src/FESpaces.jl @@ -318,6 +318,13 @@ function FESpaces.TrialFESpace(fun,f::DistributedSingleFieldFESpace) DistributedSingleFieldFESpace(spaces,f.gids,f.vector_type) end +function FESpaces.TrialFESpace!(f::DistributedSingleFieldFESpace,fun) + spaces = map_parts(f.spaces) do s + TrialFESpace!(s,fun) + end + DistributedSingleFieldFESpace(spaces,f.gids,f.vector_type) +end + function FESpaces.HomogeneousTrialFESpace(f::DistributedSingleFieldFESpace) spaces = map_parts(f.spaces) do s HomogeneousTrialFESpace(s) From a4e104543a9bb9fa975887e0cdc855d5c1201968 Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Mon, 17 Jan 2022 13:34:41 +0100 Subject: [PATCH 03/13] Specialization of setindex! for distributed PVTKFiles --- src/Visualization.jl | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/src/Visualization.jl b/src/Visualization.jl index 81ec99fb..b5a96b0e 100644 --- a/src/Visualization.jl +++ b/src/Visualization.jl @@ -152,3 +152,14 @@ function Visualization.create_vtk_file( celldata=c,nodaldata=n) end end + +function Base.setindex!( + pvd::WriteVTK.CollectionFile, + datafiles::AbstractPData{<:WriteVTK.PVTKFile}, + time::Real) + map_parts(datafiles) do datafile + if datafile.pvtkargs.ismain + collection_add_timestep(pvd, datafile, time) + end + end +end From 6df96db6a73e955f180b6265500ea101f6e2ffae Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Mon, 17 Jan 2022 20:54:16 +0100 Subject: [PATCH 04/13] Reverted changes in Visualization --- src/Visualization.jl | 11 ----------- 1 file changed, 11 deletions(-) diff --git a/src/Visualization.jl b/src/Visualization.jl index b5a96b0e..81ec99fb 100644 --- a/src/Visualization.jl +++ b/src/Visualization.jl @@ -152,14 +152,3 @@ function Visualization.create_vtk_file( celldata=c,nodaldata=n) end end - -function Base.setindex!( - pvd::WriteVTK.CollectionFile, - datafiles::AbstractPData{<:WriteVTK.PVTKFile}, - time::Real) - map_parts(datafiles) do datafile - if datafile.pvtkargs.ismain - collection_add_timestep(pvd, datafile, time) - end - end -end From 01fbe278dbcd41333b7f415442c1d972fea6c630 Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Wed, 19 Jan 2022 09:16:38 +0100 Subject: [PATCH 05/13] Added interpolate_everywhere and interpolate_dirichlet --- src/FESpaces.jl | 72 +++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 72 insertions(+) diff --git a/src/FESpaces.jl b/src/FESpaces.jl index 4f479f3c..f5d97903 100644 --- a/src/FESpaces.jl +++ b/src/FESpaces.jl @@ -11,6 +11,10 @@ function FESpaces.get_free_dof_ids(fs::DistributedFESpace) @abstractmethod end +function get_dirichlet_dof_ids(f::DistributedFESpace) + @abstractmethod +end + function FESpaces.FEFunction(f::DistributedFESpace,::AbstractVector) @abstractmethod end @@ -33,8 +37,16 @@ function FESpaces.zero_free_values(f::DistributedFESpace) fill!(vec,zero(eltype(vec))) end +function FESpaces.zero_dirichlet_values(f::DistributedFESpace) + V = get_vector_type(f) + vec = allocate_vector(V,num_dirichlet_dofs(f)) + fill!(vec,zero(eltype(vec))) +end + FESpaces.num_free_dofs(f::DistributedFESpace) = length(get_free_dof_ids(f)) +FESpaces.num_dirichlet_dofs(f::DistributedFESpace) = length(get_dirichlet_dof_ids(f)) + function Base.zero(f::DistributedFESpace) free_values = zero_free_values(f) isconsistent = true @@ -247,6 +259,10 @@ function FESpaces.get_free_dof_values(uh::DistributedSingleFieldFEFunction) uh.metadata.free_values end +function FESpaces.get_dirichlet_dof_values(U::DistributedSingleFieldFESpace) + map_parts(get_dirichlet_dof_values,U.spaces) +end + # Single field related struct DistributedSingleFieldFESpace{A,B,C} <: DistributedFESpace @@ -281,6 +297,15 @@ function FESpaces.FEFunction( DistributedCellField(fields,metadata) end +function FESpaces.FEFunction( + f::DistributedSingleFieldFESpace,free_values::AbstractVector, + dirichlet_values::AbstractPData{<:AbstractVector},isconsistent=false) + local_vals = consistent_local_views(free_values,f.gids,isconsistent) + fields = map_parts(FEFunction,f.spaces,local_vals,dirichlet_values) + metadata = DistributedFEFunctionData(free_values) + DistributedCellField(fields,metadata) +end + function FESpaces.EvaluationFunction( f::DistributedSingleFieldFESpace,free_values::AbstractVector,isconsistent=false) local_vals = consistent_local_views(free_values,f.gids,isconsistent) @@ -289,6 +314,15 @@ function FESpaces.EvaluationFunction( DistributedCellField(fields,metadata) end +function FESpaces.EvaluationFunction( + f::DistributedSingleFieldFESpace,free_values::AbstractVector, + dirichlet_values::AbstractPData{<:AbstractVector},isconsistent=false) + local_vals = consistent_local_views(free_values,f.gids,isconsistent) + fields = map_parts(EvaluationFunction,f.spaces,local_vals,dirichlet_values) + metadata = DistributedFEFunctionData(free_values) + DistributedCellField(fields,metadata) +end + function FESpaces.get_fe_basis(f::DistributedSingleFieldFESpace) fields = map_parts(get_fe_basis,f.spaces) DistributedCellField(fields) @@ -353,6 +387,44 @@ function FESpaces.interpolate!( FEFunction(f,free_values) end +function FESpaces.interpolate_dirichlet(u, f::DistributedSingleFieldFESpace) + free_values = zero_free_values(f) + dirichlet_values = get_dirichlet_dof_values(f) + map_parts(f.spaces,local_views(free_values),dirichlet_values) do V,fvec,dvec + interpolate_dirichlet!(u,fvec,dvec,V) + end + FEFunction(f,free_values,dirichlet_values) +end + +function FESpaces.interpolate_dirichlet!( + u, free_values::AbstractVector, + dirichlet_values::AbstractPData{<:AbstractVector}, + f::DistributedSingleFieldFESpace) + map_parts(f.spaces,local_views(free_values),dirichlet_values) do V,fvec,dvec + interpolate_dirichlet!(u,fvec,dvec,V) + end + FEFunction(f,free_values,dirichlet_values) +end + +function FESpaces.interpolate_everywhere(u, f::DistributedSingleFieldFESpace) + free_values = zero_free_values(f) + dirichlet_values = get_dirichlet_dof_values(f) + map_parts(f.spaces,local_views(free_values),dirichlet_values) do V,fvec,dvec + interpolate_everywhere!(u,fvec,dvec,V) + end + FEFunction(f,free_values,dirichlet_values) +end + +function FESpaces.interpolate_everywhere!( + u, free_values::AbstractVector, + dirichlet_values::AbstractPData{<:AbstractVector}, + f::DistributedSingleFieldFESpace) + map_parts(f.spaces,local_views(free_values),dirichlet_values) do V,fvec,dvec + interpolate_everywhere!(u,fvec,dvec,V) + end + FEFunction(f,free_values,dirichlet_values) +end + # Factories function FESpaces.FESpace(model::DistributedDiscreteModel,reffe;kwargs...) From d074880e02512be1bfbc289ed56f3f08764553a3 Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Wed, 19 Jan 2022 09:16:47 +0100 Subject: [PATCH 06/13] Adding tests --- test/FESpacesTests.jl | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/test/FESpacesTests.jl b/test/FESpacesTests.jl index cb5f96b0..ce787dc2 100644 --- a/test/FESpacesTests.jl +++ b/test/FESpacesTests.jl @@ -34,9 +34,15 @@ function main(parts,das) uh = interpolate(u,U) eh = u - uh + uh_dir = interpolate_dirichlet(u,U) + uh_everywhere = interpolate_everywhere(u,U) + eh2 = u - uh_everywhere + dΩ = Measure(Ω,3) cont = ∫( abs2(eh) )dΩ + cont2 = ∫( abs2(eh2) )dΩ @test sqrt(sum(cont)) < 1.0e-9 + @test sqrt(sum(cont2)) < 1.0e-9 # Assembly Ωass = Triangulation(das,model) From 002a86899ff8c6c8991b3c09f8a7aef66296dec7 Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Fri, 21 Jan 2022 17:06:36 +0100 Subject: [PATCH 07/13] interpolate_everywhere/dirichlet for multifields --- src/MultiField.jl | 74 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 72 insertions(+), 2 deletions(-) diff --git a/src/MultiField.jl b/src/MultiField.jl index 93cd8537..fb1a2305 100644 --- a/src/MultiField.jl +++ b/src/MultiField.jl @@ -117,6 +117,78 @@ function FESpaces.interpolate!(objects,free_values::AbstractVector,fe::Distribut DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) end +function FESpaces.interpolate_everywhere(objects,fe::DistributedMultiFieldFESpace) + free_values = zero_free_values(fe) + local_vals = consistent_local_views(free_values,fe.gids,true) + part_fe_fun = map_parts(local_vals,local_views(fe)) do x,f + interpolate!(objects,x,f) + end + field_fe_fun = DistributedSingleFieldFEFunction[] + for i in 1:num_fields(fe) + free_values_i = restrict_to_field(fe,free_values,i) + fe_space_i = fe.field_fe_space[i] + dirichlet_values_i = zero_dirichlet_values(fe_space_i) + fe_fun_i = interpolate_everywhere!(objects[i], free_values_i,dirichlet_values_i,fe_space_i) + push!(field_fe_fun,fe_fun_i) + end + DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) +end + +function FESpaces.interpolate_everywhere!( + objects,free_values::AbstractVector, + dirichlet_values::Vector{AbstractPData{<:AbstractVector}}, + fe::DistributedMultiFieldFESpace) + local_vals = consistent_local_views(free_values,fe.gids,true) + part_fe_fun = map_parts(local_vals,local_views(fe)) do x,f + interpolate!(objects,x,f) + end + field_fe_fun = DistributedSingleFieldFEFunction[] + for i in 1:num_fields(fe) + free_values_i = restrict_to_field(fe,free_values,i) + dirichlet_values_i = dirichlet_values[i] + fe_space_i = fe.field_fe_space[i] + fe_fun_i = interpolate_everywhere!(objects[i], free_values_i,dirichlet_values_i,fe_space_i) + push!(field_fe_fun,fe_fun_i) + end + DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) +end + +function FESpaces.interpolate_dirichlet(objects,fe::DistributedMultiFieldFESpace) + free_values = zero_free_values(fe) + local_vals = consistent_local_views(free_values,fe.gids,true) + part_fe_fun = map_parts(local_vals,local_views(fe)) do x,f + interpolate!(objects,x,f) + end + field_fe_fun = DistributedSingleFieldFEFunction[] + for i in 1:num_fields(fe) + free_values_i = restrict_to_field(fe,free_values,i) + fe_space_i = fe.field_fe_space[i] + dirichlet_values_i = zero_dirichlet_values(fe_space_i) + fe_fun_i = interpolate_everywhere!(objects[i], free_values_i,dirichlet_values_i,fe_space_i) + push!(field_fe_fun,fe_fun_i) + end + DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) +end + +function FESpaces.interpolate_dirichlet!( + objects,free_values::AbstractVector, + dirichlet_values::Vector{AbstractPData{<:AbstractVector}}, + fe::DistributedMultiFieldFESpace) + local_vals = consistent_local_views(free_values,fe.gids,true) + part_fe_fun = map_parts(local_vals,local_views(fe)) do x,f + interpolate!(objects,x,f) + end + field_fe_fun = DistributedSingleFieldFEFunction[] + for i in 1:num_fields(fe) + free_values_i = restrict_to_field(fe,free_values,i) + dirichlet_values_i = dirichlet_values[i] + fe_space_i = fe.field_fe_space[i] + fe_fun_i = interpolate_everywhere!(objects[i], free_values_i,dirichlet_values_i,fe_space_i) + push!(field_fe_fun,fe_fun_i) + end + DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) +end + struct DistributedMultiFieldFEBasis{A,B} <: GridapType field_fe_basis::A part_fe_basis::B @@ -313,5 +385,3 @@ function propagate_to_ghost_multifield!( end end end - - From 9a3a8b845fa0d7e4638448162dff68588aad9a2f Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Fri, 21 Jan 2022 22:20:20 +0100 Subject: [PATCH 08/13] interpolate of DistributedCellFields --- src/FESpaces.jl | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/src/FESpaces.jl b/src/FESpaces.jl index f5d97903..ab16709d 100644 --- a/src/FESpaces.jl +++ b/src/FESpaces.jl @@ -259,10 +259,6 @@ function FESpaces.get_free_dof_values(uh::DistributedSingleFieldFEFunction) uh.metadata.free_values end -function FESpaces.get_dirichlet_dof_values(U::DistributedSingleFieldFESpace) - map_parts(get_dirichlet_dof_values,U.spaces) -end - # Single field related struct DistributedSingleFieldFESpace{A,B,C} <: DistributedFESpace @@ -289,6 +285,10 @@ function FESpaces.get_free_dof_ids(fs::DistributedSingleFieldFESpace) fs.gids end +function FESpaces.get_dirichlet_dof_values(U::DistributedSingleFieldFESpace) + map_parts(get_dirichlet_dof_values,U.spaces) +end + function FESpaces.FEFunction( f::DistributedSingleFieldFESpace,free_values::AbstractVector,isconsistent=false) local_vals = consistent_local_views(free_values,f.gids,isconsistent) @@ -387,6 +387,14 @@ function FESpaces.interpolate!( FEFunction(f,free_values) end +function FESpaces.interpolate!( + u::DistributedCellField,free_values::AbstractVector,f::DistributedSingleFieldFESpace) + map_parts(local_views(u),f.spaces,local_views(free_values)) do ui,V,vec + interpolate!(ui,vec,V) + end + FEFunction(f,free_values) +end + function FESpaces.interpolate_dirichlet(u, f::DistributedSingleFieldFESpace) free_values = zero_free_values(f) dirichlet_values = get_dirichlet_dof_values(f) @@ -425,6 +433,16 @@ function FESpaces.interpolate_everywhere!( FEFunction(f,free_values,dirichlet_values) end +function FESpaces.interpolate_everywhere!( + u::DistributedCellField, free_values::AbstractVector, + dirichlet_values::AbstractPData{<:AbstractVector}, + f::DistributedSingleFieldFESpace) + map_parts(local_views(u),f.spaces,local_views(free_values),dirichlet_values) do ui,V,fvec,dvec + interpolate_everywhere!(ui,fvec,dvec,V) + end + FEFunction(f,free_values,dirichlet_values) +end + # Factories function FESpaces.FESpace(model::DistributedDiscreteModel,reffe;kwargs...) From e6ca9fafa2b5c7c67354fa6f5f7b4ac76aa97375 Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Fri, 21 Jan 2022 22:20:41 +0100 Subject: [PATCH 09/13] interpolate_everywhere of MultiFields --- src/MultiField.jl | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/src/MultiField.jl b/src/MultiField.jl index 1fe46fda..cff12b6e 100644 --- a/src/MultiField.jl +++ b/src/MultiField.jl @@ -25,6 +25,8 @@ Base.iterate(m::DistributedMultiFieldFEFunction) = iterate(m.field_fe_fun) Base.iterate(m::DistributedMultiFieldFEFunction,state) = iterate(m.field_fe_fun,state) Base.getindex(m::DistributedMultiFieldFEFunction,field_id::Integer) = m.field_fe_fun[field_id] +local_views(a::Vector{<:DistributedCellField}) = [ai.fields for ai in a] + struct DistributedMultiFieldFESpace{A,B,C,D} <: DistributedFESpace field_fe_space::A part_fe_space::B @@ -154,6 +156,25 @@ function FESpaces.interpolate_everywhere!( DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) end +function FESpaces.interpolate_everywhere( + objects::Vector{<:DistributedCellField},fe::DistributedMultiFieldFESpace) + local_objects = local_views(objects) + local_spaces = local_views(fe) + part_fe_fun = map_parts(local_spaces,local_objects...) do f,o... + interpolate_everywhere(o,f) + end + free_values = zero_free_values(fe) + field_fe_fun = DistributedSingleFieldFEFunction[] + for i in 1:num_fields(fe) + free_values_i = restrict_to_field(fe,free_values,i) + fe_space_i = fe.field_fe_space[i] + dirichlet_values_i = get_dirichlet_dof_values(fe_space_i) + fe_fun_i = interpolate_everywhere!(objects[i], free_values_i,dirichlet_values_i,fe_space_i) + push!(field_fe_fun,fe_fun_i) + end + DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) +end + function FESpaces.interpolate_dirichlet(objects,fe::DistributedMultiFieldFESpace) free_values = zero_free_values(fe) local_vals = consistent_local_views(free_values,fe.gids,true) From b91b01f799c725faa636dce50b8151622000fafa Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Fri, 21 Jan 2022 22:22:06 +0100 Subject: [PATCH 10/13] removed interpolate_dirichlet for MultiField --- src/MultiField.jl | 35 ----------------------------------- 1 file changed, 35 deletions(-) diff --git a/src/MultiField.jl b/src/MultiField.jl index cff12b6e..90e6f281 100644 --- a/src/MultiField.jl +++ b/src/MultiField.jl @@ -175,41 +175,6 @@ function FESpaces.interpolate_everywhere( DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) end -function FESpaces.interpolate_dirichlet(objects,fe::DistributedMultiFieldFESpace) - free_values = zero_free_values(fe) - local_vals = consistent_local_views(free_values,fe.gids,true) - part_fe_fun = map_parts(local_vals,local_views(fe)) do x,f - interpolate!(objects,x,f) - end - field_fe_fun = DistributedSingleFieldFEFunction[] - for i in 1:num_fields(fe) - free_values_i = restrict_to_field(fe,free_values,i) - fe_space_i = fe.field_fe_space[i] - dirichlet_values_i = zero_dirichlet_values(fe_space_i) - fe_fun_i = interpolate_everywhere!(objects[i], free_values_i,dirichlet_values_i,fe_space_i) - push!(field_fe_fun,fe_fun_i) - end - DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) -end - -function FESpaces.interpolate_dirichlet!( - objects,free_values::AbstractVector, - dirichlet_values::Vector{AbstractPData{<:AbstractVector}}, - fe::DistributedMultiFieldFESpace) - local_vals = consistent_local_views(free_values,fe.gids,true) - part_fe_fun = map_parts(local_vals,local_views(fe)) do x,f - interpolate!(objects,x,f) - end - field_fe_fun = DistributedSingleFieldFEFunction[] - for i in 1:num_fields(fe) - free_values_i = restrict_to_field(fe,free_values,i) - dirichlet_values_i = dirichlet_values[i] - fe_space_i = fe.field_fe_space[i] - fe_fun_i = interpolate_everywhere!(objects[i], free_values_i,dirichlet_values_i,fe_space_i) - push!(field_fe_fun,fe_fun_i) - end - DistributedMultiFieldFEFunction(field_fe_fun,part_fe_fun,free_values) -end struct DistributedMultiFieldFEBasis{A,B} <: GridapType field_fe_basis::A From 7030e01a8373acb07da0d5d62a286a79984e0e51 Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Sat, 12 Feb 2022 21:40:17 +0100 Subject: [PATCH 11/13] Fixes for PR #74 --- src/FESpaces.jl | 39 +++++++++++++++++++++++++++------------ test/FESpacesTests.jl | 11 +++++++++++ 2 files changed, 38 insertions(+), 12 deletions(-) diff --git a/src/FESpaces.jl b/src/FESpaces.jl index 442611b2..d5a96a95 100644 --- a/src/FESpaces.jl +++ b/src/FESpaces.jl @@ -11,7 +11,7 @@ function FESpaces.get_free_dof_ids(fs::DistributedFESpace) @abstractmethod end -function get_dirichlet_dof_ids(f::DistributedFESpace) +function FESpaces.get_dirichlet_dof_ids(f::DistributedFESpace) @abstractmethod end @@ -295,34 +295,39 @@ end function FESpaces.FEFunction( f::DistributedSingleFieldFESpace,free_values::AbstractVector,isconsistent=false) - local_vals = consistent_local_views(free_values,f.gids,isconsistent) - fields = map_parts(FEFunction,f.spaces,local_vals) - metadata = DistributedFEFunctionData(free_values) - DistributedCellField(fields,metadata) + _EvaluationFunction(FEFunction,f,free_values,isconsistent) end function FESpaces.FEFunction( f::DistributedSingleFieldFESpace,free_values::AbstractVector, dirichlet_values::AbstractPData{<:AbstractVector},isconsistent=false) - local_vals = consistent_local_views(free_values,f.gids,isconsistent) - fields = map_parts(FEFunction,f.spaces,local_vals,dirichlet_values) - metadata = DistributedFEFunctionData(free_values) - DistributedCellField(fields,metadata) + _EvaluationFunction(FEFunction,f,free_values,dirichlet_values,isconsistent) end function FESpaces.EvaluationFunction( + f::DistributedSingleFieldFESpace,free_values::AbstractVector,isconsistent=false) + _EvaluationFunction(EvaluationFunction,f,free_values,isconsistent) +end + +function FESpaces.EvaluationFunction( + f::DistributedSingleFieldFESpace,free_values::AbstractVector, + dirichlet_values::AbstractPData{<:AbstractVector},isconsistent=false) + _EvaluationFunction(EvaluationFunction,f,free_values,dirichlet_values,isconsistent) +end + +function _EvaluationFunction(func, f::DistributedSingleFieldFESpace,free_values::AbstractVector,isconsistent=false) local_vals = consistent_local_views(free_values,f.gids,isconsistent) - fields = map_parts(EvaluationFunction,f.spaces,local_vals) + fields = map_parts(func,f.spaces,local_vals) metadata = DistributedFEFunctionData(free_values) DistributedCellField(fields,metadata) end -function FESpaces.EvaluationFunction( +function _EvaluationFunction(func, f::DistributedSingleFieldFESpace,free_values::AbstractVector, dirichlet_values::AbstractPData{<:AbstractVector},isconsistent=false) local_vals = consistent_local_views(free_values,f.gids,isconsistent) - fields = map_parts(EvaluationFunction,f.spaces,local_vals,dirichlet_values) + fields = map_parts(func,f.spaces,local_vals,dirichlet_values) metadata = DistributedFEFunctionData(free_values) DistributedCellField(fields,metadata) end @@ -437,6 +442,16 @@ function FESpaces.interpolate_everywhere!( FEFunction(f,free_values,dirichlet_values) end +function FESpaces.interpolate_everywhere(u::DistributedCellField, + f::DistributedSingleFieldFESpace) + free_values = zero_free_values(f) + dirichlet_values = get_dirichlet_dof_values(f) + map_parts(local_views(u),f.spaces,local_views(free_values),dirichlet_values) do ui,V,fvec,dvec + interpolate_everywhere!(ui,fvec,dvec,V) + end + FEFunction(f,free_values,dirichlet_values) +end + function FESpaces.interpolate_everywhere!( u::DistributedCellField, free_values::AbstractVector, dirichlet_values::AbstractPData{<:AbstractVector}, diff --git a/test/FESpacesTests.jl b/test/FESpacesTests.jl index ce787dc2..5bfe48be 100644 --- a/test/FESpacesTests.jl +++ b/test/FESpacesTests.jl @@ -35,14 +35,25 @@ function main(parts,das) eh = u - uh uh_dir = interpolate_dirichlet(u,U) + free_values = zero_free_values(U) + dirichlet_values = get_dirichlet_dof_values(U) + uh_dir2 = interpolate_dirichlet!(u,free_values,dirichlet_values,U) + uh_everywhere = interpolate_everywhere(u,U) + uh_everywhere_ = interpolate_everywhere!(u,free_values,dirichlet_values,U) eh2 = u - uh_everywhere + uh_everywhere2 = interpolate_everywhere(uh_everywhere,U) + uh_everywhere2_ = interpolate_everywhere!(uh_everywhere,free_values,dirichlet_values,U) + eh3 = u - uh_everywhere2 + dΩ = Measure(Ω,3) cont = ∫( abs2(eh) )dΩ cont2 = ∫( abs2(eh2) )dΩ + cont3 = ∫( abs2(eh3) )dΩ @test sqrt(sum(cont)) < 1.0e-9 @test sqrt(sum(cont2)) < 1.0e-9 + @test sqrt(sum(cont3)) < 1.0e-9 # Assembly Ωass = Triangulation(das,model) From 4737441f9be613b84b1ca10bfc110e38a6219256 Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Sun, 13 Feb 2022 10:26:08 +0100 Subject: [PATCH 12/13] update NEWS.md and .gitignore --- .gitignore | 1 + NEWS.md | 1 + 2 files changed, 2 insertions(+) diff --git a/.gitignore b/.gitignore index 6527b61c..079af296 100644 --- a/.gitignore +++ b/.gitignore @@ -8,3 +8,4 @@ /docs/site/ /tmp/ *.vtu +*.pvtu diff --git a/NEWS.md b/NEWS.md index 7bc1be68..1b3a5ef9 100644 --- a/NEWS.md +++ b/NEWS.md @@ -8,6 +8,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 ### Added - Skeleton documentation and some content. Since PR [#77](https://github.com/gridap/GridapDistributed.jl/pull/77) + - Added `interpolate_everywhere` and `interpolate_dirichlet` functions. Since PR [#74](https://github.com/gridap/GridapDistributed.jl/pull/74) ## [0.2.4] - 2021-12-09 From fa9873ea6a8b6bebe8a481016138297fc0687dfc Mon Sep 17 00:00:00 2001 From: Oriol Colomes Date: Mon, 14 Feb 2022 20:33:14 +0100 Subject: [PATCH 13/13] Removed zero_dirichlet_values and associated functions --- src/FESpaces.jl | 32 ++------------------------------ 1 file changed, 2 insertions(+), 30 deletions(-) diff --git a/src/FESpaces.jl b/src/FESpaces.jl index d5a96a95..ec165f59 100644 --- a/src/FESpaces.jl +++ b/src/FESpaces.jl @@ -11,10 +11,6 @@ function FESpaces.get_free_dof_ids(fs::DistributedFESpace) @abstractmethod end -function FESpaces.get_dirichlet_dof_ids(f::DistributedFESpace) - @abstractmethod -end - function FESpaces.FEFunction(f::DistributedFESpace,::AbstractVector) @abstractmethod end @@ -37,16 +33,8 @@ function FESpaces.zero_free_values(f::DistributedFESpace) fill!(vec,zero(eltype(vec))) end -function FESpaces.zero_dirichlet_values(f::DistributedFESpace) - V = get_vector_type(f) - vec = allocate_vector(V,num_dirichlet_dofs(f)) - fill!(vec,zero(eltype(vec))) -end - FESpaces.num_free_dofs(f::DistributedFESpace) = length(get_free_dof_ids(f)) -FESpaces.num_dirichlet_dofs(f::DistributedFESpace) = length(get_dirichlet_dof_ids(f)) - function Base.zero(f::DistributedFESpace) free_values = zero_free_values(f) isconsistent = true @@ -407,10 +395,7 @@ end function FESpaces.interpolate_dirichlet(u, f::DistributedSingleFieldFESpace) free_values = zero_free_values(f) dirichlet_values = get_dirichlet_dof_values(f) - map_parts(f.spaces,local_views(free_values),dirichlet_values) do V,fvec,dvec - interpolate_dirichlet!(u,fvec,dvec,V) - end - FEFunction(f,free_values,dirichlet_values) + interpolate_dirichlet!(u,free_values,dirichlet_values,f) end function FESpaces.interpolate_dirichlet!( @@ -426,10 +411,7 @@ end function FESpaces.interpolate_everywhere(u, f::DistributedSingleFieldFESpace) free_values = zero_free_values(f) dirichlet_values = get_dirichlet_dof_values(f) - map_parts(f.spaces,local_views(free_values),dirichlet_values) do V,fvec,dvec - interpolate_everywhere!(u,fvec,dvec,V) - end - FEFunction(f,free_values,dirichlet_values) + interpolate_everywhere!(u,free_values,dirichlet_values,f) end function FESpaces.interpolate_everywhere!( @@ -442,16 +424,6 @@ function FESpaces.interpolate_everywhere!( FEFunction(f,free_values,dirichlet_values) end -function FESpaces.interpolate_everywhere(u::DistributedCellField, - f::DistributedSingleFieldFESpace) - free_values = zero_free_values(f) - dirichlet_values = get_dirichlet_dof_values(f) - map_parts(local_views(u),f.spaces,local_views(free_values),dirichlet_values) do ui,V,fvec,dvec - interpolate_everywhere!(ui,fvec,dvec,V) - end - FEFunction(f,free_values,dirichlet_values) -end - function FESpaces.interpolate_everywhere!( u::DistributedCellField, free_values::AbstractVector, dirichlet_values::AbstractPData{<:AbstractVector},