Physical fes

docs/src/ReferenceFEs.md

@@ -162,10 +162,10 @@ get_face_own_nodes_permutations(reffe::NodalReferenceFE,d::Integer)
 get_face_nodes(reffe::NodalReferenceFE,d::Integer)
 ```
 
-### GenericNodalRefFE
+### GenericNodalCartesianRefFE
 
 ```@docs
-GenericNodalRefFE
+GenericNodalCartesianRefFE
 ```
 
 ### Lagrangian reference elements

docs/src/TensorValues.md

@@ -34,6 +34,6 @@ n_components
 inner
 outer
 meas
-symmetic_part
+symmetric_part
 ```
 

src/Arrays/Apply.jl

@@ -118,7 +118,7 @@ end
 """
     apply_all(f::Tuple,a::AbstractArray...) -> Tuple
 
-Numerically equivalent to 
+Numerically equivalent to
 
     tuple( ( apply(fi, a...) for fi in f)... )
 
@@ -370,4 +370,3 @@ Base.IndexStyle(::Type{<:ArrayWithCounter{T,N,A}}) where {T,A,N} = IndexStyle(A)
 function reset_counter!(a::ArrayWithCounter)
   a.counter[:] .= 0
 end
-

src/Arrays/Tables.jl

@@ -6,7 +6,7 @@
       ptrs::Vector{P}
     end
 
-Type representing a list of lists (i.e., a table) in 
+Type representing a list of lists (i.e., a table) in
 compressed format.
 """
 struct Table{T,P} <: AbstractVector{Vector{T}}
@@ -337,7 +337,7 @@ end
 """
     collect1d(a)
 
-Equivalent to 
+Equivalent to
 
     [a[i] for in 1:length(a)]
 """
@@ -442,5 +442,3 @@ function from_dict(::Type{Table{T,P}}, dict::Dict{Symbol,Any}) where {T,P}
   ptrs::Vector{P} = dict[:ptrs]
   Table(data,ptrs)
 end
-
-

src/FESpaces/CLagrangianFESpaces.jl

@@ -9,7 +9,7 @@
     end
 """
 struct CLagrangianFESpace{S} <: SingleFieldFESpace
-  space::UnsconstrainedFESpace
+  space::UnconstrainedFESpace
   grid::Grid
   dof_to_node::Vector{Int}
   dof_to_comp::Vector{Int8}
@@ -19,7 +19,7 @@ struct CLagrangianFESpace{S} <: SingleFieldFESpace
       CLagrangianFESpace(::Type{T},grid::Grid) where T
   """
   function CLagrangianFESpace(::Type{T},grid::Grid) where T
-    space, dof_to_node, dof_to_comp, node_and_comp_to_dof = _generate_clargangian_fespace(T,grid)
+    space, dof_to_node, dof_to_comp, node_and_comp_to_dof = _generate_clagrangian_fespace(T,grid)
     S = eltype(node_and_comp_to_dof)
     new{S}(space,grid,dof_to_node,dof_to_comp,node_and_comp_to_dof)
   end
@@ -81,7 +81,7 @@ end
 
 # Helpers
 
-function _generate_clargangian_fespace(T,grid)
+function _generate_clagrangian_fespace(T,grid)
 
     grid_reffes = get_reffes(grid)
     function fun(reffe)
@@ -114,7 +114,7 @@ function _generate_clargangian_fespace(T,grid)
     dirichlet_cells = Int[]
     ntags = 0
 
-    space = UnsconstrainedFESpace(
+    space = UnconstrainedFESpace(
       nfree,
       ndirichlet,
       cell_dofs,
@@ -235,4 +235,3 @@ function _fill_cell_dofs_clagrangian_fespace!(
   end
 
 end
-

src/FESpaces/CellBases.jl

@@ -41,10 +41,20 @@ end
 
 # Define how the metadata is preserved
 
+function change_ref_style(cf::CellBasis)
+  ref_sty = RefStyle(cf)
+  bool = !get_val_parameter(ref_sty)
+  new_sty = Val{bool}()
+  trial_style = TrialStyle(cf)
+  ar = get_array(cf)
+  cm = get_cell_map(cf)
+  GenericCellBasis(trial_style,ar,cm,new_sty)
+end
+
 function similar_object(cf::CellBasis,array::AbstractArray)
   cm = get_cell_map(cf)
   trial_style = TrialStyle(cf)
-  GenericCellBasis(trial_style,array,cm)
+  GenericCellBasis(trial_style,array,cm,RefStyle(cf))
 end
 
 function similar_object(a::CellBasis,b::CellField,v::AbstractArray)
@@ -73,7 +83,8 @@ end
 
 function _similar_cell_basis_test_trial(v,a,b)
   cm = get_cell_map(a)
-  GenericCellMatrixField(v,cm)
+  @assert is_in_ref_space(a) == is_in_ref_space(b)
+  GenericCellMatrixField(v,cm,RefStyle(a))
 end
 
 # Operations
@@ -114,13 +125,13 @@ end
 
 function operate(op,cf1::CellBasis,object)
   cm = get_cell_map(cf1)
-  cf2 = convert_to_cell_field(object,cm)
+  cf2 = convert_to_cell_field(object,cm,RefStyle(cf1))
   operate(op,cf1,cf2)
 end
 
 function operate(op,object,cf2::CellBasis)
   cm = get_cell_map(cf2)
-  cf1 = convert_to_cell_field(object,cm)
+  cf1 = convert_to_cell_field(object,cm,RefStyle(cf2))
   operate(op,cf1,cf2)
 end
 
@@ -191,17 +202,16 @@ end
 
 """
 """
-struct GenericCellBasis{T} <: CellBasis
+struct GenericCellBasis{T,R} <: CellBasis
   trial_style::Val{T}
   array
   cell_map
+  ref_trait::Val{R}
 end
 
-"""
-"""
-function GenericCellBasis(array::AbstractArray,cell_map::AbstractArray)
-  trial_style = Val{false}()
-  GenericCellBasis(trial_style,array,cell_map)
+function GenericCellBasis(trial_style::Val{T},array::AbstractArray,cell_map::AbstractArray) where T
+  ref_trait = Val{true}()
+  GenericCellBasis(trial_style,array,cell_map,ref_trait)
 end
 
 get_array(a::GenericCellBasis) = a.array
@@ -212,7 +222,9 @@ function TrialStyle(::Type{<:GenericCellBasis{T}}) where T
   Val{T}()
 end
 
-# CellMatrixField
+function RefStyle(::Type{<:GenericCellBasis{T,R}}) where {T,R}
+  Val{R}()
+end
 
 """
 """
@@ -226,9 +238,18 @@ end
 
 # Define how the metadata is preserved
 
+function change_ref_style(cf::CellMatrixField)
+  ref_sty = RefStyle(cf)
+  bool = !get_val_parameter(ref_sty)
+  new_sty = Val{bool}()
+  ar = get_array(cf)
+  cm = get_cell_map(cf)
+  GenericCellMatrixField(ar,cm,new_sty)
+end
+
 function similar_object(cf::CellMatrixField,a::AbstractArray)
   cm = get_cell_map(cf)
-  GenericCellMatrixField(a,cm)
+  GenericCellMatrixField(a,cm,RefStyle(cf))
 end
 
 function similar_object(a::CellMatrixField,b::CellField,v::AbstractArray)
@@ -274,33 +295,38 @@ end
 
 function operate(op,a::CellMatrixField,b)
   cm = get_cell_map(a)
-  _b = convert_to_cell_field(b,cm)
+  _b = convert_to_cell_field(b,cm,RefStyle(a))
   operate(op,a,_b)
 end
 
 function operate(op,a,b::CellMatrixField)
   cm = get_cell_map(b)
-  _a = convert_to_cell_field(a,cm)
+  _a = convert_to_cell_field(a,cm,RefStyle(b))
   operate(op,_a,b)
 end
 
+
 # Concrete CellMatrixField
 
 """
 """
-struct GenericCellMatrixField{A,B} <: CellMatrixField
+struct GenericCellMatrixField{A,B,R} <: CellMatrixField
   array::A
   cell_map::B
+  ref_style::Val{R}
 end
 
+RefStyle(::Type{GenericCellMatrixField{A,B,R}}) where {A,B,R} = Val{R}()
+
 get_array(a::GenericCellMatrixField) = a.array
 
 get_cell_map(a::GenericCellMatrixField) = a.cell_map
 
 # Restrictions
 
 function restrict(cf::CellBasis,trian::Triangulation)
-  a = get_array(cf)
+  _cf = to_ref_space(cf)
+  a = get_array(_cf)
   r = restrict(a,trian)
   trial_style = TrialStyle(cf)
   _restrict_cell_basis(trial_style,r,trian)
@@ -398,13 +424,13 @@ end
 
 function operate(op,cf1::SkeletonCellBasis,object)
   cm = get_cell_map(cf1)
-  cf2 = convert_to_cell_field(object,cm)
+  cf2 = convert_to_cell_field(object,cm,RefStyle(cf1.left))
   operate(op,cf1,cf2)
 end
 
 function operate(op,object,cf2::SkeletonCellBasis)
   cm = get_cell_map(cf2)
-  cf1 = convert_to_cell_field(object,cm)
+  cf1 = convert_to_cell_field(object,cm,RefStyle(cf2.left))
   operate(op,cf1,cf2)
 end
 
@@ -450,13 +476,13 @@ end
 
 function operate(op,cf1::ReducedSkeletonCellBasis,object)
   cm = get_cell_map(cf1)
-  cf2 = convert_to_cell_field(object,cm)
+  cf2 = convert_to_cell_field(object,cm,RefStyle(cf1.left))
   operate(op,cf1,cf2)
 end
 
 function operate(op,object,cf2::ReducedSkeletonCellBasis)
   cm = get_cell_map(cf2)
-  cf1 = convert_to_cell_field(object,cm)
+  cf1 = convert_to_cell_field(object,cm,RefStyle(cf2.left))
   operate(op,cf1,cf2)
 end
 
@@ -533,13 +559,13 @@ end
 
 function operate(op,object,cf2::SkeletonCellMatrixField)
   cm = get_cell_map(cf2)
-  cf1 = convert_to_cell_field(object,cm)
+  cf1 = convert_to_cell_field(object,cm,RefStyle(cf2.ll))
   operate(op,cf1,cf2)
 end
 
 function operate(op,cf1::SkeletonCellMatrixField,object)
   cm = get_cell_map(cf1)
-  cf2 = convert_to_cell_field(object,cm)
+  cf2 = convert_to_cell_field(object,cm,RefStyle(cf1.ll))
   operate(op,cf1,cf2)
 end
 
@@ -645,4 +671,3 @@ end
   add_to_array!(vecd,vec)
   (mat, vecd)
 end
-

src/FESpaces/CellDofBases.jl

@@ -0,0 +1,55 @@
+"""
+   abstract type CellDofBasis end
+
+Abstract type that represents a cell array of `Dof`. The main motivation for
+its definition is to provide a trait that informs whether the `Dof` entries are
+defined for functions in the reference or physical space
+"""
+abstract type CellDofBasis end
+
+RefStyle(::Type{<:CellDofBasis}) = @abstractmethod
+get_array(::CellDofBasis) = @abstractmethod
+
+function test_cell_dof_basis(cf::CellDofBasis,f::CellFieldLike)
+  ar = get_array(cf)
+  @test isa(ar,AbstractArray)
+  a = evaluate(cf,f)
+  _ = collect(a)
+  rs = RefStyle(cf)
+  @test isa(get_val_parameter(rs),Bool)
+end
+
+"""
+    evaluate(dof_array::CellDofBasis,field_array::AbstractArray)
+
+Evaluates the `CellDofBasis` for the `Field` objects
+at the array `field` element by element.
+
+The result is numerically equivalent to
+
+    map(evaluate_dof, dof_array.array, field_array)
+
+but it is described with a more memory-friendly lazy type.
+"""
+function evaluate(cell_dofs::CellDofBasis,cell_field::CellFieldLike)
+ _evaluate_cell_dofs(cell_dofs,cell_field,RefStyle(cell_dofs))
+end
+
+function  _evaluate_cell_dofs(cell_dofs,cell_field,ref_trait::Val{true})
+  evaluate_dof_array(get_array(cell_dofs),get_array(to_ref_space(cell_field)))
+end
+
+function  _evaluate_cell_dofs(cell_dofs,cell_field,ref_trait::Val{false})
+  evaluate_dof_array(get_array(cell_dofs),get_array(to_physical_space(cell_field)))
+end
+
+"""
+"""
+struct GenericCellDofBasis{R} <: CellDofBasis
+   ref_trait::Val{R}
+   array::AbstractArray{<:Dof}
+end
+
+RefStyle(::Type{<:GenericCellDofBasis{R}}) where R = Val{R}()
+
+get_array(a::GenericCellDofBasis) = a.array