RealBSparseOperator -> BSparseOperator

Author: vitartas

app/quoll.jl

@@ -62,9 +62,9 @@ for idir in my_idirs
     operators = load_operators(input_dir, operatorkinds, params.input.format)
 
     # TODO: in the future could allow for <other canonical formats/shortcut conversions>
-    @info "Converting operators into RealBSparseOperator format"
+    @info "Converting operators into BSparseOperator format"
 
-    operators = convert_operators(operators, RealBSparseOperator)
+    operators = convert_operators(operators, BSparseOperator)
 
     if Quoll.Parser.requires_kpoint_grid(params)
         @info "Initialising k-point grid"

src/Quoll.jl

@@ -54,7 +54,7 @@ export write_operator, write_operators
 export find_operatorkinds
 include("operators/interface.jl")
 
-export RealBSparseOperator
+export BSparseOperator
 include("operators/canonical/abstract.jl")
 include("operators/canonical/bsparse.jl")
 

src/conversions/deeph/deeph.jl

@@ -1,4 +1,4 @@
-function DeepHOperator(in_operator::RealBSparseOperator; radii = nothing, hermitian = false, float = Float64)
+function DeepHOperator(in_operator::BSparseOperator; radii = nothing, hermitian = false, float = Float64)
 
     in_metadata = get_metadata(in_operator)
     in_atoms = get_atoms(in_operator)
@@ -18,21 +18,21 @@ function DeepHOperator(in_operator::RealBSparseOperator; radii = nothing, hermit
     return DeepHOperator(in_kind, out_data, out_metadata)
 end
 
-function convert_operator_data(out_metadata::DeepHMetadata, in_operator::RealBSparseOperator; float = Float64)
+function convert_operator_data(out_metadata::DeepHMetadata, in_operator::BSparseOperator; float = Float64)
     return convert_operator_data(
         get_sparsity(out_metadata),
         get_basisset(out_metadata),
         get_keydata(in_operator),
         get_atoms(in_operator),
         get_sparsity(in_operator),
         DeepHOperator,
-        RealBSparseOperator,
+        BSparseOperator,
         float,
     )
 end
 
 function convert_operator_data(out_sparsity, out_basisset, in_keydata, in_atoms, in_sparsity,
-    out_type::Type{DeepHOperator}, in_type::Type{RealBSparseOperator}, ::Type{T} = Float64) where T
+    out_type::Type{DeepHOperator}, in_type::Type{BSparseOperator}, ::Type{T} = Float64) where T
 
     herm_nonherm_conv = in_sparsity.hermitian && !out_sparsity.hermitian
     species2nbasis = get_species2nbasis(out_basisset)

src/conversions/fhiaims/fhiaims_csc.jl

@@ -1,5 +1,5 @@
 
-function RealBSparseOperator(in_operator::FHIaimsCSCOperator; radii = nothing, hermitian = true, float = Float64)
+function BSparseOperator(in_operator::FHIaimsCSCOperator; radii = nothing, hermitian = true, float = Float64)
 
     in_metadata = get_metadata(in_operator)
     in_atoms = get_atoms(in_operator)
@@ -14,7 +14,7 @@ function RealBSparseOperator(in_operator::FHIaimsCSCOperator; radii = nothing, h
     out_metadata = RealBSparseMetadata(in_atoms, out_sparsity, in_basisset, in_spins)
 
     # Initialize out_operator with zeros
-    out_operator = RealBSparseOperator(in_kind, out_metadata; float = float)
+    out_operator = BSparseOperator(in_kind, out_metadata; float = float)
 
     # Populate out_operator with values from the in_operator
     populate!(out_operator, in_operator)
@@ -23,25 +23,25 @@ function RealBSparseOperator(in_operator::FHIaimsCSCOperator; radii = nothing, h
 end
 
 # Probably shouldn't be used directly because this assumes appropriately converted metadata
-function populate!(out_operator::RealBSparseOperator, in_operator::FHIaimsCSCOperator)
+function populate!(out_operator::BSparseOperator, in_operator::FHIaimsCSCOperator)
     return populate!(
         get_keydata(out_operator),
         get_sparsity(out_operator),
         get_basisset(out_operator),
         get_data(in_operator),
         get_sparsity(in_operator),
-        RealBSparseOperator,
+        BSparseOperator,
         FHIaimsCSCOperator,
     )
 end
 
 # Loop over the CSC sparsity and occupy appropriate values based on block sparsity
 function populate!(out_keydata, out_sparsity, out_basisset, in_data, in_sparsity,
-    out_type::Type{RealBSparseOperator}, in_type::Type{FHIaimsCSCOperator})
+    out_type::Type{BSparseOperator}, in_type::Type{FHIaimsCSCOperator})
 
     # TODO: We could perform hermitian to hermitian populate! and afterwards perform
-    # RealBSparseOperator hermitian -> RealBSparseOperator non-hermitian conversion.
-    # However, one would have to modify RealBSparseOperator(::FHIaimsCSCOperator)
+    # BSparseOperator hermitian -> BSparseOperator non-hermitian conversion.
+    # However, one would have to modify BSparseOperator(::FHIaimsCSCOperator)
     # by computing non-hermitian sparsity and metadata after populate! and initiating
     # the conversion.
     herm_to_nonherm = in_sparsity.hermitian && !out_sparsity.hermitian

src/operators/canonical/bsparse.jl

@@ -2,11 +2,11 @@ using StructArrays
 
 # TODO: add additional field with spin metadata? This is related to considerations of
 # the ability to add arbitrary element metadata to `keydata`, how could this be extendable?
-# Would any additional metadata in `keydata` elements would have to be added to RealBSparseMetadata as a field?
+# Would any additional metadata in `keydata` elements would have to be added to BSparseMetadata as a field?
 # This can be achieved by creating a function which would take relevant information such as basisf and spin from
 # RealBSparseMetadata but would also allow to add custom metadata (no need for an extra struct)
 # It would also be nice to be able to change metadata on `keydata` once RealBSparseOperator has been
-# defined already (however this wouldn't be possible without creating a new instance because RealBSparseOperator
+# defined already (however this wouldn't be possible without creating a new instance because BSparseOperator
 # is parametric with respect to KT, but that's possible without copies)
 
 struct RealBSparseMetadata{A<:AbstractSystem, S<:RealBlockSparsity, B<:BasisSetMetadata, P<:Union{SpinsMetadata, Nothing}} <: AbstractBSparseMetadata{A, S, B, P}
@@ -16,23 +16,30 @@ struct RealBSparseMetadata{A<:AbstractSystem, S<:RealBlockSparsity, B<:BasisSetM
     spins::P
 end
 
+struct RecipBSparseMetadata{A<:AbstractSystem, S<:RecipBlockSparsity, B<:BasisSetMetadata, P<:Union{SpinsMetadata, Nothing}} <: AbstractBSparseMetadata{A, S, B, P}
+    atoms::A
+    sparsity::S
+    basisset::B
+    spins::P
+    kpoint::SVector{3, Float64}
+end
+
 # I will usually work with the case where metadata in keydata are named tuples
 # i.e. KT == Tuple{Vector{@NamedTuple{basisf::BasisMetadata{E}, spin::SpinMetadata}}, ...}
 # TODO: Consider changing <:SpeciesPairAnyDict{<:AbstractArray{T}}
-struct RealBSparseOperator{O<:OperatorKind, T<:Real, D<:SpeciesPairAnyDict{<:AbstractArray{T}}, M<:AbstractBSparseMetadata, KD<:AtomPairAnyDict} <: AbstractBSparseOperator{O, T, D, M, KD}
+struct BSparseOperator{O<:OperatorKind, T<:Number, D<:SpeciesPairAnyDict{<:AbstractArray{T}}, M<:AbstractBSparseMetadata, KD<:AtomPairAnyDict} <: AbstractBSparseOperator{O, T, D, M, KD}
     kind::O
     data::D
     metadata::M
     keydata::KD
 end
 
-get_float(operator::RealBSparseOperator) = typeof(operator).parameters[2]
-get_keydata(operator::RealBSparseOperator) = operator.keydata
+get_keydata(operator::BSparseOperator) = operator.keydata
 
 # Constructor to initialize the operator with zero values
 # TODO: possibly split into smaller functions? Also this function could accept
 # additional metadata to go into keydata
-function RealBSparseOperator(kind::OperatorKind, metadata::RealBSparseMetadata; float::Type{T} = Float64) where T
+function BSparseOperator(kind::OperatorKind, metadata::AbstractBSparseMetadata; float::Type{T} = Float64) where T
 
     z1z2_ij2interval = get_z1z2_ij2interval(metadata)
     basisset = get_basisset(metadata)
@@ -97,11 +104,11 @@ function RealBSparseOperator(kind::OperatorKind, metadata::RealBSparseMetadata;
     end
     keydata = Dictionary{NTuple{2, Int}, typeof(first(keydata_values))}(ij_contiguous, keydata_values)
 
-    return RealBSparseOperator(kind, data, metadata, keydata)
+    return BSparseOperator(kind, data, metadata, keydata)
 end
 
-get_z1z2_ij2interval(operator::RealBSparseOperator) = get_z1z2_ij2interval(get_atoms(operator), get_sparsity(operator))
-get_z1z2_ij2interval(metadata::RealBSparseMetadata) = get_z1z2_ij2interval(get_atoms(metadata), get_sparsity(metadata))
+get_z1z2_ij2interval(operator::BSparseOperator) = get_z1z2_ij2interval(get_atoms(operator), get_sparsity(operator))
+get_z1z2_ij2interval(metadata::AbstractBSparseMetadata) = get_z1z2_ij2interval(get_atoms(metadata), get_sparsity(metadata))
 
 function get_z1z2_ij2interval(atoms::AbstractSystem, sparsity::RealBlockSparsity)
     unique_species = unique(species(atoms, :))
@@ -132,10 +139,10 @@ function get_z1z2_ij2interval(atoms::AbstractSystem, sparsity::RealBlockSparsity
     return Base.ImmutableDict(pairs(z1z2_ij2interval)...)
 end
 
-get_z1z2_ij2offset(operator::RealBSparseOperator) = get_z1z2_ij2offset(get_atoms(operator), get_sparsity(operator))
-get_z1z2_ij2offset(metadata::RealBSparseMetadata) = get_z1z2_ij2offset(get_atoms(metadata), get_sparsity(metadata))
+get_z1z2_ij2offset(operator::BSparseOperator) = get_z1z2_ij2offset(get_atoms(operator), get_sparsity(operator))
+get_z1z2_ij2offset(metadata::AbstractBSparseMetadata) = get_z1z2_ij2offset(get_atoms(metadata), get_sparsity(metadata))
 
-function get_z1z2_ij2offset(atoms::AbstractSystem, sparsity::RealBlockSparsity)
+function get_z1z2_ij2offset(atoms::AbstractSystem, sparsity::AbstractBlockSparsity)
     # Converting from Base.ImmutableDict to Dictionary
     z1z2_ij2interval = dictionary(get_z1z2_ij2interval(atoms, sparsity))
     return get_z1z2_ij2offset(z1z2_ij2interval)

src/sparsity.jl

@@ -1,6 +1,9 @@
 abstract type AbstractSparsity end
 
-struct RealCSCSparsity <: AbstractSparsity
+abstract type AbstractCSCSparsity <: AbstractSparsity end
+abstract type AbstractBlockSparsity <: AbstractSparsity end
+
+struct RealCSCSparsity <: AbstractCSCSparsity
     rowval::Vector{Int}
     colcellptr::Array{Int, 3}
     images::Vector{SVector{3, Int}}
@@ -9,12 +12,17 @@ end
 
 # In reciprocal space we could only have unique (i, j) pairs from `ij2images`
 # Assuming 'U' hermicity
-struct RealBlockSparsity <: AbstractSparsity
+struct RealBlockSparsity <: AbstractBlockSparsity
     ij2images::Dictionary{NTuple{2, Int}, Vector{SVector{3, Int}}}
     images::Vector{SVector{3, Int}}
     hermitian::Bool
 end
 
+struct RecipBlockSparsity <: AbstractBlockSparsity
+    ij::Vector{NTuple{2, Int}}
+    hermitian::Bool
+end
+
 ### FROM NEIGHBOURLIST ###
 
 # assumes fractional coordinates of all atoms are [0.0, 1.0)
@@ -155,9 +163,9 @@ end
 # If converting from type 1 to nonhermitian sparsity then we will have new keys in ij2images.
 # Does that affect how we convert other properties during operator -> operator conversion?
 # This matters only for conversions where image order and (i, j) order matters in other operator
-# fields, e.g. 3rd axis in keydata in RealBSparseOperator contains some order of images
+# fields, e.g. 3rd axis in keydata in BSparseOperator contains some order of images
 # and by changing the sparsity the order would not be the same anymore.
-# This would make RealBSparseOperator -> RealBSparseOperator conversion a bit tricky
+# This would make BSparseOperator -> BSparseOperator conversion a bit tricky
 # but it's not something that would have to be done normally.
 function convert_to_nonhermitian(sparsity::RealBlockSparsity)
     !sparsity.hermitian && return sparsity