preserve spaces in tensorspace Conversion (#308)

* preserve spaces in tensorspace Conversion

* spaces in mul for kronprodop

Author: jishnub

src/Operators/general/algebra.jl

@@ -334,8 +334,9 @@ end
         op = op2 : domainspace(op1) → rangespace(op2)
         return [op], bandwidths(op)
     else
-        op1_dsp = op1:rangespace(op2)
-        return [op1_dsp, op2], bandwidthssum((op1_dsp, op2))
+        op2_dsp = op2:dsp
+        op1_dsp = op1:rangespace(op2_dsp)
+        return [op1_dsp, op2_dsp], bandwidthssum((op1_dsp, op2_dsp))
     end
 end
 
@@ -549,14 +550,15 @@ collateops(op, As::Operator...) = collateops(op, Val(anyplustimes(op, As...)), A
 collateops(op, ::Val{true}, As...) = mapreduce(x -> _extractops(x, op), vcat, As)
 collateops(op, ::Val{false}, As...) = As
 
-function *(A::Operator,B::Operator)
+*(A::Operator,B::Operator) = A_mul_B(A, B)
+function A_mul_B(A::Operator, B::Operator; dspB = domainspace(B), rspA = rangespace(A))
     if isconstop(A)
-        promoterangespace(strictconvert(Number,A)*B,rangespace(A))
+        promoterangespace(strictconvert(Number,A)*B, rspA)
     elseif isconstop(B)
-        promotedomainspace(strictconvert(Number,B)*A,domainspace(B))
+        promotedomainspace(strictconvert(Number,B)*A, dspB)
     else
         promotetimes(collateops(*, A, B),
-            domainspace(B), _timessize((A,B)), false)
+            dspB, _timessize((A,B)), false)
     end
 end
 

src/PDE/KroneckerOperator.jl

@@ -208,8 +208,15 @@ function getindex(KO::KroneckerOperator,k::Integer)
 end
 
 
-*(A::KroneckerOperator,B::KroneckerOperator) =
-    KroneckerOperator(A.ops[1]*B.ops[1],A.ops[2]*B.ops[2])
+function *(A::KroneckerOperator, B::KroneckerOperator)
+    dspB = domainspace(B)
+    rspA = rangespace(A)
+    A1, A2 = A.ops
+    B1, B2 = B.ops
+    AB1 = A_mul_B(A1, B1; dspB = factor(dspB,1), rspA = factor(rspA,1))
+    AB2 = A_mul_B(A2, B2; dspB = factor(dspB,2), rspA = factor(rspA,2))
+    KroneckerOperator(AB1, AB2, dspB, rspA)
+end
 
 
 
@@ -390,10 +397,12 @@ ConcreteConversion(a::BivariateSpace,b::BivariateSpace) =
     ConcreteConversion{typeof(a),typeof(b),
                         promote_type(prectype(a),prectype(b))}(a,b)
 
-Conversion(a::TensorSpace,b::TensorSpace) = ConversionWrapper(promote_type(prectype(a),prectype(b)),
-                KroneckerOperator(Conversion(a.spaces[1],b.spaces[1]),Conversion(a.spaces[2],b.spaces[2])))
-
-
+function Conversion(a::TensorSpace2D,b::TensorSpace2D)
+    C1 = Conversion(a.spaces[1],b.spaces[1])
+    C2 = Conversion(a.spaces[2],b.spaces[2])
+    K = KroneckerOperator(C1, C2, a, b)
+    ConversionWrapper(promote_type(prectype(a),prectype(b)), K)
+end
 
 function Multiplication(f::Fun{<:TensorSpace}, S::TensorSpace)
     lr = LowRankFun(f)