First version for an intersection feature for DownsetBasisSelectors

src/basisselectors.jl

@@ -128,7 +128,7 @@ maxorder(Bsel::SimpleSparseBasis, args...) =
 """
 `AbstractSparseBasis`: Super-type for sparse basis selection as sub-levelsets of
 the levelset function `level` and corresponding (possibly order-dependent)
-levels provided in the dictionary `maxdegs::Dict{Any, Float64}`. In the default
+levels provided in the dictionary `maxlevels::Dict{Any, Float64}`. In the default
 implementation the levelset function and the degree function are identical.
 
 Basis functions are selected in two steps. First, "admissible" basis 
@@ -183,15 +183,15 @@ function SparseBasis(;  maxorder::Integer = nothing,
                         p = 1, 
                         weight = Dict(:l => 1.0, :n => 1.0), 
                         default_maxdeg = nothing, 
-                        maxdegs = nothing ) 
-   if (default_maxdeg != nothing) && (maxdegs == nothing )
+                        maxlevels = nothing ) 
+   if (default_maxdeg != nothing) && (maxlevels == nothing )
       return SparseBasis(maxorder, weight, 
                          Dict{Any, Float64}("default" => default_maxdeg), 
                          p)
-   elseif (default_maxdeg == nothing) && (maxdegs != nothing)
-      SparseBasis(maxorder, weight, maxdegs, p)
+   elseif (default_maxdeg == nothing) && (maxlevels != nothing)
+      SparseBasis(maxorder, weight, maxlevels, p)
    else
-      error("""Either both or neither optional arguments `maxdegs` and 
+      error("""Either both or neither optional arguments `maxlevels` and 
                `default_maxdeg` were provided. To avoid ambiguity ensure that 
                exactly one of these arguments is provided.""")
    end
@@ -282,10 +282,87 @@ cat_weighted_degree(bb::Prodb, Bsel::CategorySparseBasis, basis::OneParticleBasi
       )
 
 
-# --------------------------- 
+      # --------------------------- 
 # Some useful filters 
 
 struct NoConstant 
 end
 
 (::NoConstant)(bb) = (length(bb) > 0)
+
+
+"""
+`EvenL`: selects all basis functions where the sum `L = sum_i l_i` of the degrees `l_i` of the spherical harmonics is even.   
+"""
+struct EvenL
+      isym::Symbol
+      categories
+end
+
+function (f::ACE.EvenL)(bb) 
+      if isempty(bb)
+            return true
+      else
+            suml(s) = sum( [getl(O3(), b) for b in bb if getproperty(b, f.isym) == s])
+            return all(iseven(suml(s)) for s in f.categories)
+      end
+end
+
+
+
+"""
+`DownsetIntersection`: Basis selector whose set of admissible specifications is the intersection 
+of the sets of admissible specifications of the sparse basis selectors contained in the lists `DBsels` and `ABsels`.
+"""
+struct DownsetIntersection <: DownsetBasisSelector
+   DBsels::Vector{DownsetBasisSelector}
+   ABsels::Vector{AbstractBasisSelector}
+   maxorder::Int
+end
+
+maxlevel(Bsel::DownsetIntersection, basis::OneParticleBasis) = 1.0 
+
+maxlevel(bb::Prodb, Bsel::DownsetIntersection, basis::OneParticleBasis) = 1.0
+
+
+maxorder(Bsel::DownsetIntersection) = Bsel.maxorder
+
+const MAXORDER = 10000
+function Base.intersect(Bsel1::DownsetIntersection,Bsel2::DownsetBasisSelector)
+      return DownsetIntersection(vcat(Bsel1.DBsels,[Bsel2]), Bsel1.ABsels, minimum([maxorder(Bsel1),maxorder(Bsel2)]))
+end
+
+function Base.intersect(Bsel1::DownsetIntersection,Bsel2::AbstractBasisSelector)
+      return DownsetIntersection(Bsel1.DBsels, vcat(Bsel1.ABsels,[Bsel2]), minimum([maxorder(Bsel1),maxorder(Bsel2)]))
+end
+
+function Base.intersect(Bsel1::DownsetBasisSelector, Bsel2::AbstractBasisSelector) 
+      Bsel = DownsetIntersection(Vector{DownsetBasisSelector}([]), Vector{AbstractBasisSelector}([]), MAXORDER)
+      return intersect(intersect(Bsel, Bsel1), Bsel2)
+end
+
+function Base.intersect(Bsel1::DownsetBasisSelector, Bsel2::DownsetBasisSelector) 
+      Bsel = DownsetIntersection(Vector{DownsetBasisSelector}([]), Vector{AbstractBasisSelector}([]), MAXORDER)
+      return intersect(intersect(Bsel, Bsel1), Bsel2)
+end
+
+Base.intersect(Bsel1::AbstractBasisSelector, Bsel2::DownsetBasisSelector)  = intersect(Bsel2,Bsel1)
+Base.intersect(Bsel1::AbstractBasisSelector, Bsel2::DownsetIntersection) = intersect(Bsel2,Bsel1)
+
+function Base.intersect(Bsel1::DownsetIntersection, Bsel2::DownsetIntersection)
+      Bsel = deepcopy(Bsel1)
+      for b in Bsel2
+            Bsel = intersect(Bsel, b)
+      end
+      return Bsel
+end
+
+function level(bb, Bsel::DownsetIntersection, basis::OneParticleBasis) 
+   return maximum([ level(bb, bsel, basis)/maxlevel(bsel,basis) for bsel in Bsel.DBsels])
+   #return maximum([ level(bb, bsel, basis)/maxlevel(length(bb),bsel,basis) for bsel in Bsel.DBsels])
+end
+
+function filter(bb, Bsel::DownsetIntersection, basis::OneParticleBasis) 
+   return all([filter(bb, bsel, basis) for bsel in Bsel.DBsels]) && all([filter(bb, bsel, basis) for bsel in Bsel.ABsels])
+end
+

src/bonds.jl

@@ -42,7 +42,7 @@ cutoff_env(env::CylindricalBondEnvelope) = sqrt(env.rcut^2 + (env.r0cut + env.zc
 cutoff_radialbasis(env::CylindricalBondEnvelope) = sqrt(env.rcut^2 + (env.zcut + env.floppy * env.λ * env.r0cut)^2)
 
 struct EllipsoidBondEnvelope{T} <: BondEnvelope{T}
-   r0cut::T
+   r0cut::T # bond-length cutoff
    rcut::T
    zcut::T  # must satisfy zcut >= r0cut/2
    p0::Int

src/cov_coeffs_dict.jl

@@ -0,0 +1,29 @@
+crmatrices=Dict(
+(l=1, m=-1, mu=-1, i=1) => SVector{3,ComplexF64}(0.1666666666666667+0.0im, 0.0+0.1666666666666667im, 0.0+0.0im),
+(l=1, m=-1, mu=0, i=1) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=-1, mu=1, i=1) => SVector{3,ComplexF64}(-0.1666666666666667+0.0im, 0.0+-0.1666666666666667im, 0.0+0.0im),
+(l=1, m=0, mu=-1, i=1) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, -0.2357022603955158+0.0im),
+(l=1, m=0, mu=0, i=1) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=0, mu=1, i=1) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.2357022603955158+0.0im),
+(l=1, m=1, mu=-1, i=1) => SVector{3,ComplexF64}(-0.1666666666666667+0.0im, 0.0+0.1666666666666667im, 0.0+0.0im),
+(l=1, m=1, mu=0, i=1) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=1, mu=1, i=1) => SVector{3,ComplexF64}(0.1666666666666667+0.0im, 0.0+-0.1666666666666667im, 0.0+0.0im),
+(l=1, m=-1, mu=-1, i=2) => SVector{3,ComplexF64}(0.0+-0.1666666666666667im, 0.1666666666666667+0.0im, 0.0+0.0im),
+(l=1, m=-1, mu=0, i=2) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=-1, mu=1, i=2) => SVector{3,ComplexF64}(0.0+-0.1666666666666667im, 0.1666666666666667+0.0im, 0.0+0.0im),
+(l=1, m=0, mu=-1, i=2) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.2357022603955158im),
+(l=1, m=0, mu=0, i=2) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=0, mu=1, i=2) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.2357022603955158im),
+(l=1, m=1, mu=-1, i=2) => SVector{3,ComplexF64}(0.0+0.1666666666666667im, 0.1666666666666667+0.0im, 0.0+0.0im),
+(l=1, m=1, mu=0, i=2) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=1, mu=1, i=2) => SVector{3,ComplexF64}(0.0+0.1666666666666667im, 0.1666666666666667+0.0im, 0.0+0.0im),
+(l=1, m=-1, mu=-1, i=3) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=-1, mu=0, i=3) => SVector{3,ComplexF64}(-0.2357022603955158+0.0im, 0.0+-0.2357022603955158im, 0.0+0.0im),
+(l=1, m=-1, mu=1, i=3) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=0, mu=-1, i=3) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=0, mu=0, i=3) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.3333333333333333+0.0im),
+(l=1, m=0, mu=1, i=3) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=1, mu=-1, i=3) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im),
+(l=1, m=1, mu=0, i=3) => SVector{3,ComplexF64}(0.2357022603955158+0.0im, 0.0+-0.2357022603955158im, 0.0+0.0im),
+(l=1, m=1, mu=1, i=3) => SVector{3,ComplexF64}(0.0+0.0im, 0.0+0.0im, 0.0+0.0im)
+)