Mercurial > repos > public > sbplib_julia

comparison DiffOps/src/laplace.jl @ 281:1eefaefdd0c7 boundary_conditions

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Add missing type parametrization
author Vidar Stiernström <vidar.stiernstrom@it.uu.se>
date Thu, 09 Jan 2020 10:53:03 +0100
parents fe9e8737ddfa
children ce6a2f3f732a
comparison
equal deleted inserted replaced
280:fe9e8737ddfa 281:1eefaefdd0c7
46 op::D2{T,N,M,K} 46 op::D2{T,N,M,K}
47 grid::EquidistantGrid{Dim,T} 47 grid::EquidistantGrid{Dim,T}
48 end 48 end
49 export Quadrature 49 export Quadrature
50 50
51 LazyTensors.range_size(H::Quadrature{2}, domain_size::NTuple{2,Integer}) where T = size(H.grid) 51 LazyTensors.domain_size(H::Quadrature{Dim}, range_size::NTuple{Dim,Integer}) where Dim = size(H.grid)
52 LazyTensors.domain_size(H::Quadrature{2}, range_size::NTuple{2,Integer}) where T = size(H.grid) 52
53 53 @inline function LazyTensors.apply(H::Quadrature{2,T}, v::AbstractArray{T,2}, I::NTuple{2,Index}) where T
54 @inline function LazyTensors.apply(H::Quadrature{2}, v::AbstractArray{T,2}, I::NTuple{2, Index}) where T
55 N = size(H.grid) 54 N = size(H.grid)
56 # Quadrature in x direction 55 # Quadrature in x direction
57 @inbounds q = apply_quadrature(H.op, spacing(H.grid)[1], v[I] , I[1], N[1]) 56 @inbounds q = apply_quadrature(H.op, spacing(H.grid)[1], v[I] , I[1], N[1])
58 # Quadrature in y-direction 57 # Quadrature in y-direction
59 @inbounds q = apply_quadrature(H.op, spacing(H.grid)[2], q, I[2], N[2]) 58 @inbounds q = apply_quadrature(H.op, spacing(H.grid)[2], q, I[2], N[2])
60 return q 59 return q
61 end 60 end
62 61
63 LazyTensors.apply_transpose(H::Quadrature{2}, v::AbstractArray{T,2}, I::NTuple{2, Index}) where T = LazyTensors.apply(H,v,I) 62 LazyTensors.apply_transpose(H::Quadrature{2,T}, v::AbstractArray{T,2}, I::NTuple{2,Index}) where T = LazyTensors.apply(H,v,I)
64 63
65 64
66 """ 65 """
67 InverseQuadrature{Dim,T<:Real,N,M,K} <: TensorMapping{T,Dim,Dim} 66 InverseQuadrature{Dim,T<:Real,N,M,K} <: TensorMapping{T,Dim,Dim}
68 67
72 op::D2{T,N,M,K} 71 op::D2{T,N,M,K}
73 grid::EquidistantGrid{Dim,T} 72 grid::EquidistantGrid{Dim,T}
74 end 73 end
75 export InverseQuadrature 74 export InverseQuadrature
76 75
77 LazyTensors.range_size(H_inv::InverseQuadrature{2}, domain_size::NTuple{2,Integer}) where T = size(H_inv.grid) 76 LazyTensors.domain_size(H_inv::InverseQuadrature{Dim}, range_size::NTuple{Dim,Integer}) where Dim = size(H_inv.grid)
78 LazyTensors.domain_size(H_inv::InverseQuadrature{2}, range_size::NTuple{2,Integer}) where T = size(H_inv.grid) 77
79 78 @inline function LazyTensors.apply(H_inv::InverseQuadrature{2,T}, v::AbstractArray{T,2}, I::NTuple{2,Index}) where T
80 @inline function LazyTensors.apply(H_inv::InverseQuadrature{2}, v::AbstractArray{T,2}, I::NTuple{2, Index}) where T
81 N = size(H_inv.grid) 79 N = size(H_inv.grid)
82 # Inverse quadrature in x direction 80 # Inverse quadrature in x direction
83 @inbounds q_inv = apply_inverse_quadrature(H_inv.op, inverse_spacing(H_inv.grid)[1], v[I] , I[1], N[1]) 81 @inbounds q_inv = apply_inverse_quadrature(H_inv.op, inverse_spacing(H_inv.grid)[1], v[I] , I[1], N[1])
84 # Inverse quadrature in y-direction 82 # Inverse quadrature in y-direction
85 @inbounds q_inv = apply_inverse_quadrature(H_inv.op, inverse_spacing(H_inv.grid)[2], q_inv, I[2], N[2]) 83 @inbounds q_inv = apply_inverse_quadrature(H_inv.op, inverse_spacing(H_inv.grid)[2], q_inv, I[2], N[2])
86 return q_inv 84 return q_inv
87 end 85 end
88 86
89 LazyTensors.apply_transpose(H_inv::InverseQuadrature{2}, v::AbstractArray{T,2}, I::NTuple{2, Index}) where T = LazyTensors.apply(H_inv,v,I) 87 LazyTensors.apply_transpose(H_inv::InverseQuadrature{2,T}, v::AbstractArray{T,2}, I::NTuple{2,Index}) where T = LazyTensors.apply(H_inv,v,I)
90 88
91 """ 89 """
92 BoundaryValue{T,N,M,K} <: TensorMapping{T,2,1} 90 BoundaryValue{T,N,M,K} <: TensorMapping{T,2,1}
93 91
94 Implements the boundary operator `e` as a TensorMapping 92 Implements the boundary operator `e` as a TensorMapping
104 # Can we give special treatment to TensorMappings that go to a higher dim? 102 # Can we give special treatment to TensorMappings that go to a higher dim?
105 LazyTensors.range_size(e::BoundaryValue{T}, domain_size::NTuple{1,Integer}) where T = size(e.grid) 103 LazyTensors.range_size(e::BoundaryValue{T}, domain_size::NTuple{1,Integer}) where T = size(e.grid)
106 LazyTensors.domain_size(e::BoundaryValue{T}, range_size::NTuple{2,Integer}) where T = (range_size[3-dim(e.bId)],) 104 LazyTensors.domain_size(e::BoundaryValue{T}, range_size::NTuple{2,Integer}) where T = (range_size[3-dim(e.bId)],)
107 105
108 # TODO: Make this independent of dimension 106 # TODO: Make this independent of dimension
109 function LazyTensors.apply(e::BoundaryValue{T}, v::AbstractArray{T}, I::NTuple{2, Index}) where T 107 function LazyTensors.apply(e::BoundaryValue{T}, v::AbstractArray{T}, I::NTuple{2,Index}) where T
110 i = I[dim(e.bId)] 108 i = I[dim(e.bId)]
111 j = I[3-dim(e.bId)] 109 j = I[3-dim(e.bId)]
112 N_i = size(e.grid)[dim(e.bId)] 110 N_i = size(e.grid)[dim(e.bId)]
113 return apply_boundary_value(e.op, v[j], i, N_i, region(e.bId)) 111 return apply_boundary_value(e.op, v[j], i, N_i, region(e.bId))
114 end 112 end
115 113
116 function LazyTensors.apply_transpose(e::BoundaryValue{T}, v::AbstractArray{T}, I::NTuple{1, Index}) where T 114 function LazyTensors.apply_transpose(e::BoundaryValue{T}, v::AbstractArray{T}, I::NTuple{1,Index}) where T
117 u = selectdim(v,3-dim(e.bId),Int(I[1])) 115 u = selectdim(v,3-dim(e.bId),Int(I[1]))
118 return apply_boundary_value_transpose(e.op, u, region(e.bId)) 116 return apply_boundary_value_transpose(e.op, u, region(e.bId))
119 end 117 end
120 118
121 """ 119 """
130 end 128 end
131 export NormalDerivative 129 export NormalDerivative
132 130
133 # TODO: This is obviouly strange. Is domain_size just discarded? Is there a way to avoid storing grid in BoundaryValue? 131 # TODO: This is obviouly strange. Is domain_size just discarded? Is there a way to avoid storing grid in BoundaryValue?
134 # Can we give special treatment to TensorMappings that go to a higher dim? 132 # Can we give special treatment to TensorMappings that go to a higher dim?
135 LazyTensors.range_size(e::NormalDerivative{T}, domain_size::NTuple{1,Integer}) where T = size(e.grid) 133 LazyTensors.range_size(e::NormalDerivative, domain_size::NTuple{1,Integer}) = size(e.grid)
136 LazyTensors.domain_size(e::NormalDerivative{T}, range_size::NTuple{2,Integer}) where T = (range_size[3-dim(e.bId)],) 134 LazyTensors.domain_size(e::NormalDerivative, range_size::NTuple{2,Integer}) = (range_size[3-dim(e.bId)],)
137 135
138 # TODO: Not type stable D:< 136 # TODO: Not type stable D:<
139 # TODO: Make this independent of dimension 137 # TODO: Make this independent of dimension
140 function LazyTensors.apply(d::NormalDerivative{T}, v::AbstractArray{T}, I::NTuple{2, Index}) where T 138 function LazyTensors.apply(d::NormalDerivative{T}, v::AbstractArray{T}, I::NTuple{2,Index}) where T
141 i = I[dim(d.bId)] 139 i = I[dim(d.bId)]
142 j = I[3-dim(d.bId)] 140 j = I[3-dim(d.bId)]
143 N_i = size(d.grid)[dim(d.bId)] 141 N_i = size(d.grid)[dim(d.bId)]
144 h_inv = inverse_spacing(d.grid)[dim(d.bId)] 142 h_inv = inverse_spacing(d.grid)[dim(d.bId)]
145 return apply_normal_derivative(d.op, h_inv, v[j], i, N_i, region(d.bId)) 143 return apply_normal_derivative(d.op, h_inv, v[j], i, N_i, region(d.bId))
146 end 144 end
147 145
148 function LazyTensors.apply_transpose(d::NormalDerivative{T}, v::AbstractArray{T}, I::NTuple{1, Index}) where T 146 function LazyTensors.apply_transpose(d::NormalDerivative{T}, v::AbstractArray{T}, I::NTuple{1,Index}) where T
149 u = selectdim(v,3-dim(d.bId),Int(I[1])) 147 u = selectdim(v,3-dim(d.bId),Int(I[1]))
150 return apply_normal_derivative_transpose(d.op, inverse_spacing(d.grid)[dim(d.bId)], u, region(d.bId)) 148 return apply_normal_derivative_transpose(d.op, inverse_spacing(d.grid)[dim(d.bId)], u, region(d.bId))
151 end 149 end
152 150
153 """ 151 """
162 end 160 end
163 export BoundaryQuadrature 161 export BoundaryQuadrature
164 162
165 # TODO: Make this independent of dimension 163 # TODO: Make this independent of dimension
166 # TODO: Dispatch directly on Index{R}? 164 # TODO: Dispatch directly on Index{R}?
167 function LazyTensors.apply(q::BoundaryQuadrature{T}, v::AbstractArray{T,1}, I::NTuple{1, Index}) where T 165 function LazyTensors.apply(q::BoundaryQuadrature{T}, v::AbstractArray{T,1}, I::NTuple{1,Index}) where T
168 h = spacing(q.grid)[3-dim(q.bId)] 166 h = spacing(q.grid)[3-dim(q.bId)]
169 N = size(v) 167 N = size(v)
170 return apply_quadrature(q.op, h, v[I[1]], I[1], N[1]) 168 return apply_quadrature(q.op, h, v[I[1]], I[1], N[1])
171 end 169 end
172 170
173 LazyTensors.apply_transpose(q::BoundaryQuadrature{T}, v::AbstractArray{T,1}, I::NTuple{1, Index}) where T = LazyTensors.apply(q,v,I) 171 LazyTensors.apply_transpose(q::BoundaryQuadrature{T}, v::AbstractArray{T,1}, I::NTuple{1,Index}) where T = LazyTensors.apply(q,v,I)
174 172
175 173
176 174
177 175
178 struct Neumann{Bid<:BoundaryIdentifier} <: BoundaryCondition end 176 struct Neumann{Bid<:BoundaryIdentifier} <: BoundaryCondition end