Cleanups

Author: kshyatt

src/tensors/abstractblocktensor/conversion.jl

@@ -1,36 +1,51 @@
 # Conversion
 # ----------
-function Base.convert(::Type{TensorMap}, t::AbstractBlockTensorMap)
-    S = spacetype(t)
-    N₁, N₂ = numout(t), numin(t)
-    cod = ProductSpace{S, N₁}(oplus.(codomain(t).spaces))
-    dom = ProductSpace{S, N₂}(oplus.(domain(t).spaces))
-    tdst = similar(t, cod ← dom)
-
-    issparse(t) && zerovector!(tdst)
 
+function _copy_subblocks!(tdst, tsrc)
+    S = spacetype(tsrc)
+    N₁, N₂ = numout(tsrc), numin(tsrc)
     for ((f₁, f₂), arr) in subblocks(tdst)
         blockax = ntuple(N₁ + N₂) do i
             return if i <= N₁
-                blockedrange(map(Base.Fix2(dim, f₁.uncoupled[i]), space(t, i)))
+                blockedrange(map(Base.Fix2(dim, f₁.uncoupled[i]), space(tsrc, i)))
             else
-                blockedrange(map(Base.Fix2(dim, f₂.uncoupled[i - N₁]), space(t, i)'))
+                blockedrange(map(Base.Fix2(dim, f₂.uncoupled[i - N₁]), space(tsrc, i)'))
             end
         end
 
-        for (k, v) in nonzero_pairs(t)
+        for (k, v) in nonzero_pairs(tsrc)
             indices = getindex.(blockax, Block.(Tuple(k)))
             arr_slice = arr[indices...]
             # need to check for empty since fusion tree pair might not be present
             isempty(arr_slice) || copy!(arr_slice, v[f₁, f₂])
         end
     end
+    return tdst
+end
+
+function Base.convert(::Type{TensorMap}, t::AbstractBlockTensorMap)
+    S = spacetype(t)
+    N₁, N₂ = numout(t), numin(t)
+    cod = ProductSpace{S, N₁}(oplus.(codomain(t).spaces))
+    dom = ProductSpace{S, N₂}(oplus.(domain(t).spaces))
+    tdst = similar(t, cod ← dom)
+
+    issparse(t) && zerovector!(tdst)
+    _copy_subblocks!(tdst, t)
+    return tdst
+end
+
+function Base.convert(::Type{TT}, t::AbstractBlockTensorMap) where {TT <: TensorMap}
+    S = spacetype(t)
+    N₁, N₂ = numout(t), numin(t)
+    cod = ProductSpace{S, N₁}(oplus.(codomain(t).spaces))
+    dom = ProductSpace{S, N₂}(oplus.(domain(t).spaces))
+    tdst = TK.TensorMapWithStorage{scalartype(TT), storagetype(TT)}(undef, cod ← dom)
+    issparse(t) && zerovector!(tdst)
 
+    _copy_subblocks!(tdst, t)
     return tdst
 end
-# use subtype of TensorMap here to support CuTensorMap
-# ROCTensorMap, etc.
-Base.convert(::Type{<:TensorMap}, t::AbstractBlockTensorMap) = convert(TensorMap, t)
 
 function Base.convert(::Type{TT}, t::AbstractTensorMap) where {TT <: AbstractBlockTensorMap}
     t isa TT && return t

src/tensors/blocktensor.jl

@@ -26,10 +26,6 @@ struct BlockTensorMap{TT <: AbstractTensorMap, E, S, N₁, N₂, N} <:
     end
 end
 
-# seems necessary to dispatch correctly onto the storage type of TT
-# AbstractBlockTensorMap doesn't have this TT field
-TensorKit.storagetype(::Type{<:BlockTensorMap{TT}}) where {TT <: AbstractTensorMap} = storagetype(TT)
-
 function BlockTensorMap{TT, E, S, N₁, N₂, N}(
         ::UndefInitializer, space::TensorMapSumSpace{S, N₁, N₂}
     ) where {TT, E, S, N₁, N₂, N}

src/tensors/sparseblocktensor.jl

@@ -63,10 +63,6 @@ function sparseblocktensormaptype(
     return SparseBlockTensorMap{TT}
 end
 
-# seems necessary to dispatch correctly onto the storage type of TT
-# AbstractBlockTensorMap doesn't have this TT field
-TensorKit.storagetype(::Type{<:SparseBlockTensorMap{TT}}) where {TT <: AbstractTensorMap} = storagetype(TT)
-
 # Constructors
 # ------------
 function SparseBlockTensorMap{TT}(