Mercurial > repos > public > sbplib_julia

comparison src/SbpOperators/boundaryops/boundary_operator.jl @ 1047:d12ab8120d29 feature/first_derivative

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge default
author Jonatan Werpers <jonatan@werpers.com>
date Wed, 23 Mar 2022 12:43:03 +0100
parents 1ba8a398af9c
children 52f07c77299d 3bb94ce74697 fc57804c9bf4
comparison
equal deleted inserted replaced
1046:e00eb000346e 1047:d12ab8120d29
4 Creates a boundary operator on a `Dim`-dimensional grid for the 4 Creates a boundary operator on a `Dim`-dimensional grid for the
5 specified `boundary`. The action of the operator is determined by `closure_stencil`. 5 specified `boundary`. The action of the operator is determined by `closure_stencil`.
6 6
7 When `Dim=1`, the corresponding `BoundaryOperator` tensor mapping is returned. 7 When `Dim=1`, the corresponding `BoundaryOperator` tensor mapping is returned.
8 When `Dim>1`, the `BoundaryOperator` `op` is inflated by the outer product 8 When `Dim>1`, the `BoundaryOperator` `op` is inflated by the outer product
9 of `IdentityMappings` in orthogonal coordinate directions, e.g for `Dim=3`, 9 of `IdentityTensors` in orthogonal coordinate directions, e.g for `Dim=3`,
10 the boundary restriction operator in the y-direction direction is `Ix⊗op⊗Iz`. 10 the boundary restriction operator in the y-direction direction is `Ix⊗op⊗Iz`.
11 """ 11 """
12 function boundary_operator(grid::EquidistantGrid, closure_stencil, boundary::CartesianBoundary) 12 function boundary_operator(grid::EquidistantGrid, closure_stencil, boundary::CartesianBoundary)
13 #TODO:Check that dim(boundary) <= Dim? 13 #TODO:Check that dim(boundary) <= Dim?
14 14
15 # Create 1D boundary operator 15 # Create 1D boundary operator
16 r = region(boundary) 16 r = region(boundary)
17 d = dim(boundary) 17 d = dim(boundary)
18 op = BoundaryOperator(restrict(grid, d), closure_stencil, r) 18 op = BoundaryOperator(restrict(grid, d), closure_stencil, r)
19 19
20 # Create 1D IdentityMappings for each coordinate direction 20 # Create 1D IdentityTensors for each coordinate direction
21 one_d_grids = restrict.(Ref(grid), Tuple(1:dimension(grid))) 21 one_d_grids = restrict.(Ref(grid), Tuple(1:dimension(grid)))
22 Is = IdentityMapping{eltype(grid)}.(size.(one_d_grids)) 22 Is = IdentityTensor{eltype(grid)}.(size.(one_d_grids))
23 23
24 # Formulate the correct outer product sequence of the identity mappings and 24 # Formulate the correct outer product sequence of the identity mappings and
25 # the boundary operator 25 # the boundary operator
26 parts = Base.setindex(Is, op, d) 26 parts = Base.setindex(Is, op, d)
27 return foldl(⊗, parts) 27 return foldl(⊗, parts)
28 end 28 end
29 29
30 """ 30 """
31 BoundaryOperator{T,R,N} <: TensorMapping{T,0,1} 31 BoundaryOperator{T,R,N} <: LazyTensor{T,0,1}
32 32
33 Implements the boundary operator `op` for 1D as a `TensorMapping` 33 Implements the boundary operator `op` for 1D as a `LazyTensor`
34 34
35 `op` is the restriction of a grid function to the boundary using some closure `Stencil{T,N}`. 35 `op` is the restriction of a grid function to the boundary using some closure `Stencil{T,N}`.
36 The boundary to restrict to is determined by `R`. 36 The boundary to restrict to is determined by `R`.
37 `op'` is the prolongation of a zero dimensional array to the whole grid using the same closure stencil. 37 `op'` is the prolongation of a zero dimensional array to the whole grid using the same closure stencil.
38 """ 38 """
39 struct BoundaryOperator{T,R<:Region,N} <: TensorMapping{T,0,1} 39 struct BoundaryOperator{T,R<:Region,N} <: LazyTensor{T,0,1}
40 stencil::Stencil{T,N} 40 stencil::Stencil{T,N}
41 size::Int 41 size::Int
42 end 42 end
43 43
44 BoundaryOperator{R}(stencil::Stencil{T,N}, size::Int) where {T,R,N} = BoundaryOperator{T,R,N}(stencil, size) 44 BoundaryOperator{R}(stencil::Stencil{T,N}, size::Int) where {T,R,N} = BoundaryOperator{T,R,N}(stencil, size)
60 closure_size(::BoundaryOperator{T,R,N}) where {T,R,N} = N 60 closure_size(::BoundaryOperator{T,R,N}) where {T,R,N} = N
61 61
62 LazyTensors.range_size(op::BoundaryOperator) = () 62 LazyTensors.range_size(op::BoundaryOperator) = ()
63 LazyTensors.domain_size(op::BoundaryOperator) = (op.size,) 63 LazyTensors.domain_size(op::BoundaryOperator) = (op.size,)
64 64
65 function LazyTensors.apply(op::BoundaryOperator{T,Lower}, v::AbstractVector{T}) where T 65 function LazyTensors.apply(op::BoundaryOperator{<:Any,Lower}, v::AbstractVector)
66 apply_stencil(op.stencil,v,1) 66 apply_stencil(op.stencil,v,1)
67 end 67 end
68 68
69 function LazyTensors.apply(op::BoundaryOperator{T,Upper}, v::AbstractVector{T}) where T 69 function LazyTensors.apply(op::BoundaryOperator{<:Any,Upper}, v::AbstractVector)
70 apply_stencil_backwards(op.stencil,v,op.size) 70 apply_stencil_backwards(op.stencil,v,op.size)
71 end 71 end
72 72
73 function LazyTensors.apply_transpose(op::BoundaryOperator{T,Lower}, v::AbstractArray{T,0}, i::Index{Lower}) where T 73 function LazyTensors.apply_transpose(op::BoundaryOperator{<:Any,Lower}, v::AbstractArray{<:Any,0}, i::Index{Lower})
74 return op.stencil[Int(i)-1]*v[] 74 return op.stencil[Int(i)-1]*v[]
75 end 75 end
76 76
77 function LazyTensors.apply_transpose(op::BoundaryOperator{T,Upper}, v::AbstractArray{T,0}, i::Index{Upper}) where T 77 function LazyTensors.apply_transpose(op::BoundaryOperator{<:Any,Upper}, v::AbstractArray{<:Any,0}, i::Index{Upper})
78 return op.stencil[op.size[1] - Int(i)]*v[] 78 return op.stencil[op.size[1] - Int(i)]*v[]
79 end 79 end
80 80
81 # Catch all combinations of Lower, Upper and Interior not caught by the two previous methods. 81 # Catch all combinations of Lower, Upper and Interior not caught by the two previous methods.
82 function LazyTensors.apply_transpose(op::BoundaryOperator{T}, v::AbstractArray{T,0}, i::Index) where T 82 function LazyTensors.apply_transpose(op::BoundaryOperator, v::AbstractArray{<:Any,0}, i::Index)
83 return zero(T) 83 return zero(eltype(v))
84 end 84 end
85 85
86 function LazyTensors.apply_transpose(op::BoundaryOperator{T}, v::AbstractArray{T,0}, i) where T 86 function LazyTensors.apply_transpose(op::BoundaryOperator, v::AbstractArray{<:Any,0}, i)
87 r = getregion(i, closure_size(op), op.size) 87 r = getregion(i, closure_size(op), op.size)
88 apply_transpose(op, v, Index(i,r)) 88 apply_transpose(op, v, Index(i,r))
89 end 89 end