Merge pull request #606 from gridap/misc_renamings

fverdugo · web-flow · commit 56e3f0cbec34 · 2021-06-02T20:32:59.000+02:00
Misc renamings
diff --git a/NEWS.md b/NEWS.md
@@ -17,6 +17,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - The default quadrature rule for tets has changed. Since PR [#578](https://github.com/gridap/Gridap.jl/pull/578).
 - Refactoring in `SparseMatrixAssembler` to make it more extensible and efficient. Since PR [#568](https://github.com/gridap/Gridap.jl/pull/568).
 - Renamed `get_free_values` -> `get_free_dof_values`. Since PR [#567](https://github.com/gridap/Gridap.jl/pull/567).
+- Renamed `get_dirichlet_values` -> `get_dirichlet_dof_values`. Since PR [#606](https://github.com/gridap/Gridap.jl/pull/606).
+- Renamed `object` -> `value` the variable in `ConstantField`. Since PR [#606](https://github.com/gridap/Gridap.jl/pull/606).
 - Miscellaneous changes in the FE assembly to allow the solution of mixed dimensional problems. Since PR [#567](https://github.com/gridap/Gridap.jl/pull/567).
 - Renamed `get_cell_shapefuns` by `get_fe_basis`. Since PR [#579](https://github.com/gridap/Gridap.jl/pull/579).
 - Renamed `get_cell_shapefuns_trial` by `get_trial_fe_basis`. Since PR [#579](https://github.com/gridap/Gridap.jl/pull/579).
diff --git a/src/Exports.jl b/src/Exports.jl
@@ -140,7 +140,7 @@ using Gridap.CellData: ∫; export ∫
 @publish FESpaces AffineFEOperator
 @publish FESpaces LinearFESolver
 @publish FESpaces get_free_dof_values
-@publish FESpaces get_dirichlet_values
+@publish FESpaces get_dirichlet_dof_values
 @publish FESpaces num_dirichlet_dofs
 @publish FESpaces num_free_dofs
 @publish FESpaces num_dirichlet_tags
diff --git a/src/FESpaces/DivConformingFESpaces.jl b/src/FESpaces/DivConformingFESpaces.jl
@@ -41,7 +41,7 @@ function get_cell_shapefuns(model::DiscreteModel,
     lazy_map(_transform_rt_shapefuns,
              cell_reffe,
              get_cell_map(Triangulation(model)),
-             lazy_map(Broadcasting(ConstantField), sign_flip))
+             lazy_map(Broadcasting(constant_field), sign_flip))
 end
 
 struct SignFlipMap{T} <: Map
diff --git a/src/FESpaces/FESpaces.jl b/src/FESpaces/FESpaces.jl
@@ -97,7 +97,7 @@ export gather_dirichlet_values!
 export gather_free_values
 export gather_free_values!
 export test_single_field_fe_space
-export get_dirichlet_values
+export get_dirichlet_dof_values
 export interpolate
 export interpolate!
 export interpolate_everywhere
diff --git a/src/FESpaces/FESpacesWithLinearConstraints.jl b/src/FESpaces/FESpacesWithLinearConstraints.jl
@@ -332,8 +332,8 @@ function _setup_ddof_to_tag!(
   end
 end
 
-function get_dirichlet_values(f::FESpaceWithLinearConstraints)
-  ddof_to_tag = get_dirichlet_values(f.space)
+function get_dirichlet_dof_values(f::FESpaceWithLinearConstraints)
+  ddof_to_tag = get_dirichlet_dof_values(f.space)
   dmdof_to_tag = zeros(eltype(ddof_to_tag),num_dirichlet_dofs(f))
   _setup_ddof_to_tag!(
     dmdof_to_tag,
diff --git a/src/FESpaces/SingleFieldFESpaces.jl b/src/FESpaces/SingleFieldFESpaces.jl
@@ -176,7 +176,7 @@ end
 
 """
 """
-function get_dirichlet_values(f::SingleFieldFESpace)
+function get_dirichlet_dof_values(f::SingleFieldFESpace)
   zero_dirichlet_values(f)
 end
 
@@ -269,7 +269,7 @@ end
       fs::SingleFieldFESpace, free_values::AbstractVector, dirichlet_values::AbstractVector)
 
 The resulting FEFunction will be in the space if and only if `dirichlet_values`
-are the ones provided by `get_dirichlet_values(fs)`
+are the ones provided by `get_dirichlet_dof_values(fs)`
 """
 function FEFunction(
   fs::SingleFieldFESpace, free_values::AbstractVector, dirichlet_values::AbstractVector)
@@ -279,7 +279,7 @@ function FEFunction(
 end
 
 function FEFunction(fe::SingleFieldFESpace, free_values)
-  diri_values = get_dirichlet_values(fe)
+  diri_values = get_dirichlet_dof_values(fe)
   FEFunction(fe,free_values,diri_values)
 end
 
diff --git a/src/FESpaces/TrialFESpaces.jl b/src/FESpaces/TrialFESpaces.jl
@@ -35,7 +35,7 @@ end
 """
 """
 function TrialFESpace!(space::TrialFESpace,objects)
-  dir_values = get_dirichlet_values(space)
+  dir_values = get_dirichlet_dof_values(space)
   dir_values_scratch = zero_dirichlet_values(space)
   dir_values = compute_dirichlet_values_for_tags!(dir_values,dir_values_scratch,space,objects)
   space
@@ -69,7 +69,7 @@ end
 
 # Genuine functions
 
-get_dirichlet_values(f::TrialFESpace) = f.dirichlet_values
+get_dirichlet_dof_values(f::TrialFESpace) = f.dirichlet_values
 
 # Delegated functions
 
diff --git a/src/FESpaces/ZeroMeanFESpaces.jl b/src/FESpaces/ZeroMeanFESpaces.jl
@@ -72,7 +72,7 @@ get_cell_isconstrained(f::ZeroMeanFESpace) = get_cell_isconstrained(f.space)
 
 get_cell_constraints(f::ZeroMeanFESpace) = get_cell_constraints(f.space)
 
-get_dirichlet_values(f::ZeroMeanFESpace) = get_dirichlet_values(f.space)
+get_dirichlet_dof_values(f::ZeroMeanFESpace) = get_dirichlet_dof_values(f.space)
 
 get_fe_basis(f::ZeroMeanFESpace) = get_fe_basis(f.space)
 
diff --git a/src/Fields/FieldsInterfaces.jl b/src/Fields/FieldsInterfaces.jl
@@ -235,20 +235,20 @@ end
 # I think it is conceptually better to have ConstantField as struct otherwise we break the invariant
 # "for any object wrapped in a GenericField we can assume that it implements the Field interface"
 struct ConstantField{T<:Number} <: Field
-  object::T
+  value::T
 end
 
 @inline constant_field(a) = ConstantField(a)
 
 Base.zero(::Type{ConstantField{T}}) where T = ConstantField(zero(T))
 
 @inline function evaluate!(c,f::ConstantField,x::Point)
-  f.object
+  f.value
 end
 
 function return_cache(f::ConstantField,x::AbstractArray{<:Point})
   nx = size(x)
-  c = fill(f.object,nx)
+  c = fill(f.value,nx)
   CachedArray(c)
 end
 
@@ -258,19 +258,19 @@ function evaluate!(c,f::ConstantField,x::AbstractArray{<:Point})
   # in the same array and we try to reuse cache between them.
   #if size(c) != nx
     setsize!(c,nx)
-    fill!(c.array,f.object)
+    fill!(c.array,f.value)
   #end
   c.array
 end
 
 @inline function return_cache(f::FieldGradient{N,<:ConstantField},x::Point) where N
-  gradient(f.object.object,Val(N))(x)
+  gradient(f.object.value,Val(N))(x)
 end
 
 @inline evaluate!(c,f::FieldGradient{N,<:ConstantField},x::Point) where N = c
 
 @inline function return_cache(f::FieldGradient{N,<:ConstantField},x::AbstractArray{<:Point}) where N
-  CachedArray(gradient(f.object.object,Val(N)).(x))
+  CachedArray(gradient(f.object.value,Val(N)).(x))
 end
 
 function evaluate!(c,f::FieldGradient{N,<:ConstantField},x::AbstractArray{<:Point}) where N
diff --git a/test/FESpacesTests/DirichletFESpacesTests.jl b/test/FESpacesTests/DirichletFESpacesTests.jl
@@ -41,7 +41,7 @@ op_ff = AffineFEOperator(a,l,Uf,Vf)
 op_fd = AffineFEOperator(a,l,Ud,Vf)
 op_df = AffineFEOperator(a,l,Uf,Vd)
 
-xd = get_dirichlet_values(Uf)
+xd = get_dirichlet_dof_values(Uf)
 
 @test maximum(abs.(get_vector(op_ff) + get_matrix(op_fd)*xd)) < 1.0e-10
 
diff --git a/test/FESpacesTests/TrialFESpacesTests.jl b/test/FESpacesTests/TrialFESpacesTests.jl
@@ -33,17 +33,17 @@ matdata = ([],[],[])
 vecdata = ([],[])
 test_single_field_fe_space(U,matvecdata,matdata,vecdata)
 
-@test get_dirichlet_values(U) == [4.0, 3.0, 3.0, 3.0, 3.0, 3.0]
+@test get_dirichlet_dof_values(U) == [4.0, 3.0, 3.0, 3.0, 3.0, 3.0]
 TrialFESpace!(U,[1,2])
-@test get_dirichlet_values(U) == [1.0, 2.0, 2.0, 2.0, 2.0, 2.0]
+@test get_dirichlet_dof_values(U) == [1.0, 2.0, 2.0, 2.0, 2.0, 2.0]
 
 U0 = HomogeneousTrialFESpace(V)
-@test get_dirichlet_values(U0) == zeros(6)
+@test get_dirichlet_dof_values(U0) == zeros(6)
 
 U0 = HomogeneousTrialFESpace!(v,V)
-@test v === get_dirichlet_values(U0)
+@test v === get_dirichlet_dof_values(U0)
 @test v == zeros(6)
-@test get_dirichlet_values(U0) == zeros(6)
+@test get_dirichlet_dof_values(U0) == zeros(6)
 
 u(x) = x[1]
 U = TrialFESpace(V,u)
@@ -66,7 +66,7 @@ cell_dofs = get_cell_dof_ids(U,cellidsS)
 @test isa(cell_dofs[1],ArrayBlock)
 
 U0 = HomogeneousTrialFESpace(U)
-@test get_dirichlet_values(U0) == zeros(6)
+@test get_dirichlet_dof_values(U0) == zeros(6)
 
 #trian = get_triangulation(model)
 #
