Mercurial > repos > public > sbplib_julia

changeset 542:011ca1639153 refactor/tensor_index_coupling

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Remove Index{Unknown} and replace with general Any implementations
author Jonatan Werpers <jonatan@werpers.com>
date Fri, 27 Nov 2020 11:27:37 +0100
parents 62d96e2cd165
children 1a53eb83ed24
files TODO.md src/RegionIndices/RegionIndices.jl src/SbpOperators/constantstenciloperator.jl src/SbpOperators/laplace/laplace.jl src/SbpOperators/laplace/secondderivative.jl src/SbpOperators/quadrature/diagonal_inner_product.jl src/SbpOperators/quadrature/inverse_diagonal_inner_product.jl src/SbpOperators/quadrature/inverse_quadrature.jl src/SbpOperators/quadrature/quadrature.jl
diffstat 9 files changed, 49 insertions(+), 48 deletions(-) [+]
line wrap: on
line diff
--- a/TODO.md	Thu Nov 26 21:35:34 2020 +0100
+++ b/TODO.md	Fri Nov 27 11:27:37 2020 +0100
@@ -14,6 +14,7 @@
  - [ ] Use `@inferred` in a lot of tests.
  - [ ] Make sure we are setting tolerances in tests in a consistent way
  - [ ] Add check for correct domain sizes to lazy tensor operations using SizeMismatch
+ - [ ] Write down some coding guideline or checklist for code convetions. For example i,j,... för indecies and I for multi-index
 
 ## Repo
  - [ ] Add Vidar to the authors list
--- a/src/RegionIndices/RegionIndices.jl	Thu Nov 26 21:35:34 2020 +0100
+++ b/src/RegionIndices/RegionIndices.jl	Fri Nov 27 11:27:37 2020 +0100
@@ -4,9 +4,8 @@
 struct Interior <: Region end
 struct Lower    <: Region end
 struct Upper    <: Region end
-struct Unknown  <: Region end
 
-export Region, Interior, Lower, Upper, Unknown
+export Region, Interior, Lower, Upper
 
 struct Index{R<:Region, T<:Integer}
     i::T
--- a/src/SbpOperators/constantstenciloperator.jl	Thu Nov 26 21:35:34 2020 +0100
+++ b/src/SbpOperators/constantstenciloperator.jl	Fri Nov 27 11:27:37 2020 +0100
@@ -14,7 +14,7 @@
     return @inbounds h_inv*h_inv*Int(op.parity)*apply_stencil_backwards(op.closureStencils[N-Int(i)+1], v, Int(i))
 end
 
-@inline function apply_2nd_derivative(op::ConstantStencilOperator, h_inv::Real, v::AbstractVector, index::Index{Unknown})
+@inline function apply_2nd_derivative(op::ConstantStencilOperator, h_inv::Real, v::AbstractVector, i)
     N = length(v)
     r = getregion(Int(index), closuresize(op), N)
     i = Index(Int(index), r)
@@ -26,9 +26,9 @@
 apply_quadrature(op::ConstantStencilOperator, h::Real, v::T, i::Index{Upper}, N::Integer) where T = v*h*op.quadratureClosure[N-Int(i)+1]
 apply_quadrature(op::ConstantStencilOperator, h::Real, v::T, i::Index{Interior}, N::Integer) where T = v*h
 
-function apply_quadrature(op::ConstantStencilOperator, h::Real, v::T, index::Index{Unknown}, N::Integer) where T
-    r = getregion(Int(index), closuresize(op), N)
-    i = Index(Int(index), r)
+function apply_quadrature(op::ConstantStencilOperator, h::Real, v::T, i, N::Integer) where T
+    r = getregion(i, closuresize(op), N)
+    i = Index(i, r)
     return apply_quadrature(op, h, v, i, N)
 end
 export apply_quadrature
@@ -38,9 +38,9 @@
 apply_inverse_quadrature(op::ConstantStencilOperator, h_inv::Real, v::T, i::Index{Upper}, N::Integer) where T = h_inv*v/op.quadratureClosure[N-Int(i)+1]
 apply_inverse_quadrature(op::ConstantStencilOperator, h_inv::Real, v::T, i::Index{Interior}, N::Integer) where T = v*h_inv
 
-function apply_inverse_quadrature(op::ConstantStencilOperator, h_inv::Real, v::T, index::Index{Unknown}, N::Integer) where T
-    r = getregion(Int(index), closuresize(op), N)
-    i = Index(Int(index), r)
+function apply_inverse_quadrature(op::ConstantStencilOperator, h_inv::Real, v::T, i, N::Integer) where T
+    r = getregion(i, closuresize(op), N)
+    i = Index(i, r)
     return apply_inverse_quadrature(op, h_inv, v, i, N)
 end
 
--- a/src/SbpOperators/laplace/laplace.jl	Thu Nov 26 21:35:34 2020 +0100
+++ b/src/SbpOperators/laplace/laplace.jl	Fri Nov 27 11:27:37 2020 +0100
@@ -23,24 +23,24 @@
 LazyTensors.range_size(L::Laplace) = getindex.(range_size.(L.D2),1)
 LazyTensors.domain_size(L::Laplace) = getindex.(domain_size.(L.D2),1)
 
-function LazyTensors.apply(L::Laplace{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Index,Dim}) where {T,Dim}
+function LazyTensors.apply(L::Laplace{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Any,Dim}) where {T,Dim}
     error("not implemented")
 end
 
 # u = L*v
-function LazyTensors.apply(L::Laplace{1,T}, v::AbstractVector{T}, I::Index) where T
-    @inbounds u = LazyTensors.apply(L.D2[1],v,I)
+function LazyTensors.apply(L::Laplace{1,T}, v::AbstractVector{T}, i) where T
+    @inbounds u = LazyTensors.apply(L.D2[1],v,i)
     return u
 end
 
-function LazyTensors.apply(L::Laplace{2,T}, v::AbstractArray{T,2}, I::Index, J::Index) where T
+function LazyTensors.apply(L::Laplace{2,T}, v::AbstractArray{T,2}, i, j) where T
     # 2nd x-derivative
-    @inbounds vx = view(v, :, Int(J))
-    @inbounds uᵢ = LazyTensors.apply(L.D2[1], vx , I)
+    @inbounds vx = view(v, :, Int(j))
+    @inbounds uᵢ = LazyTensors.apply(L.D2[1], vx , i)
 
     # 2nd y-derivative
-    @inbounds vy = view(v, Int(I), :)
-    @inbounds uᵢ += LazyTensors.apply(L.D2[2], vy , J)
+    @inbounds vy = view(v, Int(i), :)
+    @inbounds uᵢ += LazyTensors.apply(L.D2[2], vy , j)
 
     return uᵢ
 end
--- a/src/SbpOperators/laplace/secondderivative.jl	Thu Nov 26 21:35:34 2020 +0100
+++ b/src/SbpOperators/laplace/secondderivative.jl	Fri Nov 27 11:27:37 2020 +0100
@@ -38,10 +38,10 @@
     return @inbounds D2.h_inv*D2.h_inv*apply_stencil_backwards(D2.closureStencils[N-Int(I)+1], v, Int(I))
 end
 
-function LazyTensors.apply(D2::SecondDerivative{T}, v::AbstractVector{T}, index::Index{Unknown}) where T
+function LazyTensors.apply(D2::SecondDerivative{T}, v::AbstractVector{T}, i) where T
     N = length(v)  # TODO: Use domain_size here instead?
-    r = getregion(Int(index), closuresize(D2), N)
-    I = Index(Int(index), r)
+    r = getregion(i, closuresize(D2), N)
+    I = Index(i, r)
     return LazyTensors.apply(D2, v, I)
 end
 
--- a/src/SbpOperators/quadrature/diagonal_inner_product.jl	Thu Nov 26 21:35:34 2020 +0100
+++ b/src/SbpOperators/quadrature/diagonal_inner_product.jl	Fri Nov 27 11:27:37 2020 +0100
@@ -17,6 +17,7 @@
 LazyTensors.range_size(H::DiagonalInnerProduct) = H.size
 LazyTensors.domain_size(H::DiagonalInnerProduct) = H.size
 
+# Behövs den här?
 function LazyTensors.apply(H::DiagonalInnerProduct{T}, v::AbstractVector{T}, I::Index) where T
     return @inbounds apply(H, v, I)
 end
@@ -34,13 +35,13 @@
     return @inbounds H.h*v[Int(I)]
 end
 
-function LazyTensors.apply(H::DiagonalInnerProduct{T},  v::AbstractVector{T}, index::Index{Unknown}) where T
+function LazyTensors.apply(H::DiagonalInnerProduct{T},  v::AbstractVector{T}, i) where T
     N = length(v);
-    r = getregion(Int(index), closuresize(H), N)
-    i = Index(Int(index), r)
-    return LazyTensors.apply(H, v, i)
+    r = getregion(i, closuresize(H), N)
+    I = Index(i, r)
+    return LazyTensors.apply(H, v, I)
 end
 
-LazyTensors.apply_transpose(H::DiagonalInnerProduct{T}, v::AbstractVector{T}, I::Index) where T = LazyTensors.apply(H,v,I)
+LazyTensors.apply_transpose(H::DiagonalInnerProduct{T}, v::AbstractVector{T}, i) where T = LazyTensors.apply(H,v,i)
 
 closuresize(H::DiagonalInnerProduct{T,M}) where {T,M} = M
--- a/src/SbpOperators/quadrature/inverse_diagonal_inner_product.jl	Thu Nov 26 21:35:34 2020 +0100
+++ b/src/SbpOperators/quadrature/inverse_diagonal_inner_product.jl	Fri Nov 27 11:27:37 2020 +0100
@@ -31,14 +31,14 @@
     return @inbounds Hi.h_inv*v[Int(I)]
 end
 
-function LazyTensors.apply(Hi::InverseDiagonalInnerProduct,  v::AbstractVector{T}, index::Index{Unknown}) where T
+function LazyTensors.apply(Hi::InverseDiagonalInnerProduct{T},  v::AbstractVector{T}, i) where T
     N = length(v);
-    r = getregion(Int(index), closuresize(Hi), N)
-    i = Index(Int(index), r)
-    return LazyTensors.apply(Hi, v, i)
+    r = getregion(i, closuresize(Hi), N)
+    I = Index(i, r)
+    return LazyTensors.apply(Hi, v, I)
 end
 
-LazyTensors.apply_transpose(Hi::InverseDiagonalInnerProduct{T}, v::AbstractVector{T}, I::Index) where T = LazyTensors.apply(Hi,v,I)
+LazyTensors.apply_transpose(Hi::InverseDiagonalInnerProduct{T}, v::AbstractVector{T}, i) where T = LazyTensors.apply(Hi,v,i)
 
 
 closuresize(Hi::InverseDiagonalInnerProduct{T,M}) where {T,M} =  M
--- a/src/SbpOperators/quadrature/inverse_quadrature.jl	Thu Nov 26 21:35:34 2020 +0100
+++ b/src/SbpOperators/quadrature/inverse_quadrature.jl	Fri Nov 27 11:27:37 2020 +0100
@@ -25,23 +25,23 @@
 
 LazyTensors.domain_size(Qi::InverseQuadrature{Dim}, range_size::NTuple{Dim,Integer}) where Dim = range_size
 
-function LazyTensors.apply(Qi::InverseQuadrature{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Index,Dim}) where {T,Dim}
+function LazyTensors.apply(Qi::InverseQuadrature{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Any,Dim}) where {T,Dim}
     error("not implemented")
 end
 
-@inline function LazyTensors.apply(Qi::InverseQuadrature{1,T}, v::AbstractVector{T}, I::Index) where T
-    @inbounds q = apply(Qi.Hi[1], v , I)
+@inline function LazyTensors.apply(Qi::InverseQuadrature{1,T}, v::AbstractVector{T}, i) where T
+    @inbounds q = apply(Qi.Hi[1], v , i)
     return q
 end
 
-@inline function LazyTensors.apply(Qi::InverseQuadrature{2,T}, v::AbstractArray{T,2}, I::Index, J::Index) where T
+@inline function LazyTensors.apply(Qi::InverseQuadrature{2,T}, v::AbstractArray{T,2}, i,j) where T
     # InverseQuadrature in x direction
-    @inbounds vx = view(v, :, Int(J))
-    @inbounds qx_inv = apply(Qi.Hi[1], vx , I)
+    @inbounds vx = view(v, :, Int(j))
+    @inbounds qx_inv = apply(Qi.Hi[1], vx , i)
     # InverseQuadrature in y-direction
-    @inbounds vy = view(v, Int(I), :)
-    @inbounds qy_inv = apply(Qi.Hi[2], vy, J)
+    @inbounds vy = view(v, Int(i), :)
+    @inbounds qy_inv = apply(Qi.Hi[2], vy, j)
     return qx_inv*qy_inv
 end
 
-LazyTensors.apply_transpose(Qi::InverseQuadrature{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Index,Dim}) where {Dim,T} = LazyTensors.apply(Qi,v,I...)
+LazyTensors.apply_transpose(Qi::InverseQuadrature{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Any,Dim}) where {Dim,T} = LazyTensors.apply(Qi,v,I...)
--- a/src/SbpOperators/quadrature/quadrature.jl	Thu Nov 26 21:35:34 2020 +0100
+++ b/src/SbpOperators/quadrature/quadrature.jl	Fri Nov 27 11:27:37 2020 +0100
@@ -22,23 +22,23 @@
 LazyTensors.range_size(H::Quadrature) = getindex.(range_size.(H.H),1)
 LazyTensors.domain_size(H::Quadrature) = getindex.(domain_size.(H.H),1)
 
-function LazyTensors.apply(Q::Quadrature{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Index,Dim}) where {T,Dim}
+function LazyTensors.apply(Q::Quadrature{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Any,Dim}) where {T,Dim}
     error("not implemented")
 end
 
-function LazyTensors.apply(Q::Quadrature{1,T}, v::AbstractVector{T}, I::Index) where T
-    @inbounds q = apply(Q.H[1], v , I)
+function LazyTensors.apply(Q::Quadrature{1,T}, v::AbstractVector{T}, i) where T
+    @inbounds q = apply(Q.H[1], v , i)
     return q
 end
 
-function LazyTensors.apply(Q::Quadrature{2,T}, v::AbstractArray{T,2}, I::Index, J::Index) where T
+function LazyTensors.apply(Q::Quadrature{2,T}, v::AbstractArray{T,2}, i, j) where T
     # Quadrature in x direction
-    @inbounds vx = view(v, :, Int(J))
-    @inbounds qx = apply(Q.H[1], vx , I)
+    @inbounds vx = view(v, :, Int(j))
+    @inbounds qx = apply(Q.H[1], vx , i)
     # Quadrature in y-direction
-    @inbounds vy = view(v, Int(I), :)
-    @inbounds qy = apply(Q.H[2], vy, J)
+    @inbounds vy = view(v, Int(i), :)
+    @inbounds qy = apply(Q.H[2], vy, j)
     return qx*qy
 end
 
-LazyTensors.apply_transpose(Q::Quadrature{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Index,Dim}) where {Dim,T} = LazyTensors.apply(Q,v,I...)
+LazyTensors.apply_transpose(Q::Quadrature{Dim,T}, v::AbstractArray{T,Dim}, I::Vararg{Any,Dim}) where {Dim,T} = LazyTensors.apply(Q,v,I...)