changed multilayerBC and compose

Author: xtalax

src/derivative_operators/.logo

@@ -0,0 +1,35 @@
+[?25l[?7l██████████████████  ████████
+██████████████████  ████████
+██████████████████  ████████
+██████████████████  ████████
+████████            ████████
+████████  ████████  ████████
+████████  ████████  ████████
+████████  ████████  ████████
+████████  ████████  ████████
+████████  ████████  ████████
+████████  ████████  ████████
+████████  ████████  ████████
+████████  ████████  ████████
+████████  ████████  ████████
+zander@Arcadia 
+-------------- 
+OS: Manjaro Linux x86_64 
+Host: N56VM 1.0 
+Kernel: 4.19.66-1-MANJARO 
+Uptime: 5 days, 23 hours, 35 mins 
+Packages: 1133 (pacman) 
+Shell: zsh 5.7.1 
+Resolution: 1920x1080 
+WM: i3 
+Theme: Adapta-Nokto-Eta-Maia [GTK2], solarized-dark-gtk [GTK3] 
+Icons: Papirus-Adapta-Nokto-Maia [GTK2/3] 
+Terminal: guake 
+CPU: Intel i7-3610QM (8) @ 3.300GHz 
+GPU: Intel 3rd Gen Core processor Graphics Controller 
+GPU: NVIDIA GeForce GT 620M/630M/635M/640M LE 
+Memory: 2199MiB / 7861MiB 
+
+                        
+
+

src/derivative_operators/multi_dim_bc_operators.jl

@@ -54,6 +54,44 @@ struct ComposedMultiDimBC{T, B<:AtomicBC{T}, N,M} <: MultiDimensionalBC{T, N}
     BCs::Vector{Array{B, M}}
 end
 
+struct PartiallyComposedMultiDimBC{T,B<:MultiDimDirectionalBC,N,L} <:MultiDimensionalBC{T,N}
+    BCs::Vector{B}
+end
+
+function Base.:+(Q1::MultiDimDirectionalBC{T,B1,D1,N,M}, Q2::MultiDimDirectionalBC{T,B2,D2,N,M}) where {T,B1, B2,D1,D2,N,M}
+    @assert D1 != D2 "BCs should all extend along a unique axis"
+    return PartiallyComposedMultiDimBC{T,Union{typeof(Q1),typeof(Q2)}, N,2}(Array[Q1,Q2])	
+end
+
+function Base.:+(Q1::MultiDimDirectionalBC{T,B1,D1,2,1}, Q2:: MultiDimDirectionalBC{T,B2,D2,2,1}) where {T,B1,B2,D1,D2}
+    return compose(Q1,Q2)
+end
+
+function Base.:+(Q::PartiallyComposedMultiDimBC{T,B,N,L}, Q1::MultiDimDirectionalBC) where {T,B,N,M,L}
+    new_BCs = vcat(Q.BCs,Q1)
+    if L+1 == N
+        return compose(new_BCs...)
+    elseif !(getaxis(Q1) in getaxis.(Q.BCs))
+	return PartiallyComposedMultiDimBC{T,eltype(new_BCs), N,L-1}(new_BCs)
+    else
+	throw("BCs should all extend along a unique axis")
+    end
+end
+
+Base.:+(Q1::MultiDimDirectionalBC, Q::PartiallyComposedMultiDimBC) = +(Q,Q1)
+
+function Base.:+(Q1::PartiallyComposedMultiDimBC{T,B1,N,L1} Q2::PartiallyComposedMultiDimBC{T,B2,N,L2) where {T,B1,B2,N,L1,L2}
+    new_BCs = vcat(Q1.BCs, Q2.BCs)
+    if L1 + L2 < N
+	@assert length(setdiff(1:N, getaxis.(new_BCs))) == (N-L1-L2) "BCs should all extend along a unique axis"
+	return PartiallyComposedMultiDimBC{T,Union{B1,B2}, N, L1+ L2}(new_BCs)
+    elseif L1+L2 == N
+        return compose(new_BCs...)
+    else
+        throw("Too many supplied BCs for the number of dimensions")
+    end
+end
+
 """
 A multiple dimensional BC, supporting arbitrary BCs at each boundary point.
 To construct an arbitrary BC, pass an Array of BCs with dimension `N-1`, if `N` is the dimensionality of your domain `u`
@@ -82,15 +120,16 @@ For Neumann0BC, please use
     Qx, Qy, Qz... = Neumann0BC(T::Type, (dx::Vector, dy::Vector, dz::Vector ...), approximation_order, size(u))
 where T is the element type of the domain to be extended
 """
-MultiDimBC(BC::Array{B,N}, dim::Integer) where {N, B<:AtomicBC} = MultiDimDirectionalBC{gettype(BC[1]), B, dim, N+1, N}(BC)
+struct MultiDimBC{N} end
+MultiDimBC{dim}(BC::Array{B,N}) where {N, B<:AtomicBC, dim} = MultiDimDirectionalBC{gettype(BC[1]), B, dim, N+1, N}(BC)
 #s should be size of the domain
-MultiDimBC(BC::B, s, dim::Integer) where  {B<:AtomicBC} = MultiDimDirectionalBC{gettype(BC), B, dim, length(s), length(s)-1}(fill(BC, s[setdiff(1:length(s), dim)]))
+MultiDimBC{dim}(BC::B, s) where  {B<:AtomicBC, dim} = MultiDimDirectionalBC{gettype(BC), B, dim, length(s), length(s)-1}(fill(BC, s[setdiff(1:length(s), dim)]))
 
 #Extra constructor to make a set of BC operators that extend an atomic BC Operator to the whole domain
 #Only valid in the uniform grid case!
 MultiDimBC(BC::B, s) where {B<:AtomicBC} = Tuple([MultiDimDirectionalBC{gettype(BC), B, dim, length(s), length(s)-1}(fill(BC, s[setdiff(1:length(s), dim)])) for dim in 1:length(s)])
 
-# Additional constructors for cases when the BC is the same for all boundarties
+# Additional constructors for cases when the BC is the same for all boundarties 
 
 PeriodicBC{T}(s) where T = MultiDimBC(PeriodicBC{T}(), s)
 
@@ -158,3 +197,6 @@ function Base.:*(Q::ComposedMultiDimBC{T, B, N, K}, u::AbstractArray{T, N}) wher
     out = slice_rmul.(Q.BCs, fill(u, N), 1:N)
     return ComposedBoundaryPaddedArray{T, N, K, typeof(u), typeof(out[1][1])}([A[1] for A in out], [A[2] for A in out], u)
 end
+
+function Base.:*(Q::PartiallyComposedMultiDimBC, u::AbstractArray{T,N} where {T,N}
+    return Tuple([MultiDimDirectionalBC

test/MultiDimBC_test.jl

@@ -16,8 +16,8 @@ BCx = vcat(fill(q1, div(m,2)), fill(q2, m-div(m,2)))  #The size of BCx has to be
 BCy = vcat(fill(q1, div(n,2)), fill(q2, n-div(n,2)))
 
 
-Qx = MultiDimBC(BCx, 1)
-Qy = MultiDimBC(BCy, 2)
+Qx = MultiDimBC{1}(BCx)
+Qy = MultiDimBC{2}(BCy)
 
 Ax = Qx*A
 Ay = Qy*A
@@ -51,10 +51,12 @@ BCx = vcat(fill(q1, (div(m,2), o)), fill(q2, (m-div(m,2), o)))  #The size of BCx
 BCy = vcat(fill(q1, (div(n,2), o)), fill(q2, (n-div(n,2), o)))
 BCz = fill(Dirichlet0BC(Float64), (n,m))
 
-Qx = MultiDimBC(BCx, 1)
-Qy = MultiDimBC(BCy, 2)
-Qz = MultiDimBC(Dirichlet0BC(Float64), size(A), 3) #Test the other constructor
-
+Qx = MultiDimBC{1}(BCx)
+Qy = MultiDimBC{2}(BCy, 2)
+Qz = MultiDimBC{3}(Dirichlet0BC(Float64), size(A)) #Test the other constructor
+@test (Qx+Qy+Qz) == compose(Qx,Qy,Qz) #test addition combinations
+Qtmp = Qx + Qz
+@test Qz+Qx+Qy == Qy+Qtmp
 Ax = Qx*A
 Ay = Qy*A
 Az = Qz*A