From 397b41c2ecbf1463762f86911ea7f9afc7226de3 Mon Sep 17 00:00:00 2001 From: "David A. Dahlbom" <34151623+ddahlbom@users.noreply.github.com> Date: Wed, 16 Oct 2024 18:51:54 -0400 Subject: [PATCH] Entangled units updates (#324) * Fixes for external fields and more tests * Additional function aliasing * Plumbing for setting entangled unit states from dipoles --- src/EntangledUnits/EntangledReshaping.jl | 14 ++ src/EntangledUnits/EntangledSpinWaveTheory.jl | 47 ++++++ src/EntangledUnits/EntangledUnits.jl | 12 ++ src/EntangledUnits/TypesAndAliasing.jl | 70 ++++++-- test/test_entangled_units.jl | 149 ++++++++---------- 5 files changed, 199 insertions(+), 93 deletions(-) diff --git a/src/EntangledUnits/EntangledReshaping.jl b/src/EntangledUnits/EntangledReshaping.jl index d4337f6da..bc2591891 100644 --- a/src/EntangledUnits/EntangledReshaping.jl +++ b/src/EntangledUnits/EntangledReshaping.jl @@ -85,5 +85,19 @@ function repeat_periodically(esys, counts) dipole_operators_origin = all_dipole_observables(sys_origin_new; apply_g=false) (; observables, source_idcs) = observables_to_product_space(dipole_operators_origin, sys_origin_new, contraction_info) + return EntangledSystem(sys_new, sys_origin_new, contraction_info, observables, source_idcs) +end + +function resize_supercell(esys::EntangledSystem, dims::NTuple{3,Int}) + (; sys, sys_origin, contraction_info) = esys + + # Resize both entangled and original system periodically + sys_new = reshape_supercell(sys, diagm(Vec3(dims))) + sys_origin_new = reshape_supercell(sys_origin, diagm(Vec3(dims))) + + # Construct dipole operator field for reshaped EntangledSystem + dipole_operators_origin = all_dipole_observables(sys_origin_new; apply_g=false) + (; observables, source_idcs) = observables_to_product_space(dipole_operators_origin, sys_origin_new, contraction_info) + return EntangledSystem(sys_new, sys_origin_new, contraction_info, observables, source_idcs) end \ No newline at end of file diff --git a/src/EntangledUnits/EntangledSpinWaveTheory.jl b/src/EntangledUnits/EntangledSpinWaveTheory.jl index 636e5a097..78c1cb8e9 100644 --- a/src/EntangledUnits/EntangledSpinWaveTheory.jl +++ b/src/EntangledUnits/EntangledSpinWaveTheory.jl @@ -255,6 +255,53 @@ function excitations!(T, tmp, swt::EntangledSpinWaveTheory, q) end end +# No changes +function excitations(swt::EntangledSpinWaveTheory, q) + L = nbands(swt) + T = zeros(ComplexF64, 2L, 2L) + H = zeros(ComplexF64, 2L, 2L) + energies = excitations!(T, copy(H), swt, q) + return (energies, T) +end + +# No changes +function dispersion(swt::EntangledSpinWaveTheory, qpts) + L = nbands(swt) + qpts = convert(AbstractQPoints, qpts) + disp = zeros(L, length(qpts.qs)) + for (iq, q) in enumerate(qpts.qs) + view(disp, :, iq) .= view(excitations(swt, q)[1], 1:L) + end + return reshape(disp, L, size(qpts.qs)...) +end + +# No changes +function energy_per_site_lswt_correction(swt::EntangledSpinWaveTheory; opts...) + any(in(keys(opts)), (:rtol, :atol, :maxevals)) || error("Must specify one of `rtol`, `atol`, or `maxevals` to control momentum-space integration.") + + (; sys) = swt + Natoms = natoms(sys.crystal) + L = nbands(swt) + H = zeros(ComplexF64, 2L, 2L) + V = zeros(ComplexF64, 2L, 2L) + + # The uniform correction to the classical energy (trace of the (1,1)-block + # of the spin-wave Hamiltonian) + dynamical_matrix!(H, swt, zero(Vec3)) + δE₁ = -real(tr(view(H, 1:L, 1:L))) / Natoms + + # Integrate zero-point energy over the first Brillouin zone 𝐪 ∈ [0, 1]³ for + # magnetic cell in reshaped RLU + δE₂ = hcubature((0,0,0), (1,1,1); opts...) do q_reshaped + dynamical_matrix!(H, swt, q_reshaped) + ωs = bogoliubov!(V, H) + return sum(view(ωs, 1:L)) / 2Natoms + end + + # Error bars in δE₂[2] are discarded + return δE₁ + δE₂[1] +end + # Only change is no Ewald function swt_hamiltonian_SUN!(H::Matrix{ComplexF64}, swt::EntangledSpinWaveTheory, q_reshaped::Vec3) (; sys) = swt diff --git a/src/EntangledUnits/EntangledUnits.jl b/src/EntangledUnits/EntangledUnits.jl index 0ebf76b12..e1515edba 100644 --- a/src/EntangledUnits/EntangledUnits.jl +++ b/src/EntangledUnits/EntangledUnits.jl @@ -244,6 +244,10 @@ function entangle_system(sys::System{M}, units) where M # Construct contracted crystal contracted_crystal, contraction_info = contract_crystal(sys.crystal, units) + # Make sure we have a uniform external field + @assert allequal(@view sys.extfield[:,:,:,:]) "`EntangledSystems` requires a uniform applied field." + B = sys.extfield[1,1,1,1] + # Determine Ns for local Hilbert spaces (all must be equal). (TODO: Determine if alternative behavior preferable in mixed case.) Ns_unit = Ns_in_units(sys, contraction_info) Ns_contracted = map(Ns -> prod(Ns), Ns_unit) @@ -254,6 +258,9 @@ function entangle_system(sys::System{M}, units) where M spin_infos = [i => Moment(s=(N-1)/2, g=1.0) for (i, N) in enumerate(Ns_contracted)] # TODO: Decisions about g-factor sys_entangled = System(contracted_crystal, spin_infos, :SUN; dims) + # Transfer rng from origin system to entangled system + copy!(sys_entangled.rng, sys.rng) + # TODO: Extend to inhomogenous systems # For each contracted site, scan original interactions and reconstruct as necessary. new_pair_data = Tuple{Bond, Matrix{ComplexF64}}[] @@ -267,9 +274,14 @@ function entangle_system(sys::System{M}, units) where M # Pair interactions that become within-unit interactions original_interactions = sys.interactions_union[relevant_sites] for (site, interaction) in zip(relevant_sites, original_interactions) + # Onsite anisotropy portion onsite_original = interaction.onsite unit_index = contraction_info.forward[site][2] unit_operator += local_op_to_product_space(onsite_original, unit_index, Ns) + + # Zeeman portion + S = [local_op_to_product_space(S, unit_index, Ns) for S in spin_matrices((Ns[unit_index]-1)/2)] + unit_operator += Hermitian((sys.gs[1, 1, 1, site] * B)' * S) end # Sort all PairCouplings in couplings that will be within a unit and couplings that will be between units diff --git a/src/EntangledUnits/TypesAndAliasing.jl b/src/EntangledUnits/TypesAndAliasing.jl index 9108fd0d7..b051ecb39 100644 --- a/src/EntangledUnits/TypesAndAliasing.jl +++ b/src/EntangledUnits/TypesAndAliasing.jl @@ -26,6 +26,10 @@ struct CrystalContractionInfo inverse :: Vector{Vector{InverseData}} # List ordered according to contracted crystal sites. Each element is itself a list containing original crystal site indices and corresponding offset information end +function Base.copy(cci::CrystalContractionInfo) + return CrystalContractionInfo(copy(cci.forward), copy(cci.inverse)) +end + ################################################################################ # System @@ -65,25 +69,23 @@ function EntangledSystem(sys::System{N}, units) where {N} for atom in axes(sys.coherents, 4) @assert allequal(@view sys.gs[:,:,:,atom]) "`EntangledSystem` require g-factors be uniform across unit cells" end - @assert allequal(@view sys.extfield[:,:,:,:]) "`EntangledSystems` requires a uniform applied field." # Generate pair of contracted and uncontracted systems (; sys_entangled, contraction_info) = entangle_system(sys, units) sys_origin = clone_system(sys) - # Generate observable field. This observable field has as many entres as the - # uncontracted system but contains operators in the local product spaces of - # the contracted system. `source_idcs` provides the unit index (of the + # Generate observable field. This observable field has as many entries as + # the uncontracted system but contains operators in the local product spaces + # of the contracted system. `source_idcs` provides the unit index (of the # contracted system) in terms of the atom index (of the uncontracted # system). dipole_operators_origin = all_dipole_observables(sys_origin; apply_g=false) - (; observables, source_idcs) = observables_to_product_space(dipole_operators_origin, sys_origin, contraction_info) + (; observables, source_idcs) = observables_to_product_space(dipole_operators_origin, sys_origin, contraction_info) esys = EntangledSystem(sys_entangled, sys_origin, contraction_info, observables, source_idcs) # Coordinate sys_entangled and sys_origin set_expected_dipoles_of_entangled_system!(esys) - set_field!(esys, sys.extfield[1,1,1,1]) # Note external field checked to be uniform return esys end @@ -97,7 +99,7 @@ end # Aliasing ################################################################################ function Base.show(io::IO, esys::EntangledSystem) - print(io, "EntangledSystem($(mode_to_str(esys.sys)), $(lattice_to_str(esys.sys_origin)), $(energy_to_str(esys.sys)))") + print(io, "EntangledSystem($(mode_to_str(esys.sys)), $(supercell_to_str(esys.sys_origin.dims, esys.sys_origin.crystal)), $(energy_to_str(esys.sys)))") end function Base.show(io::IO, ::MIME"text/plain", esys::EntangledSystem) @@ -116,6 +118,16 @@ eachunit(esys::EntangledSystem) = eachsite(esys.sys) energy(esys::EntangledSystem) = energy(esys.sys) energy_per_site(esys::EntangledSystem) = energy(esys.sys) / length(eachsite(esys.sys_origin)) +function clone_system(esys::EntangledSystem) + sys = clone_system(esys.sys) + sys_origin = clone_system(esys.sys_origin) + contraction_info = copy(esys.contraction_info) + dipole_operators = copy(esys.dipole_operators) + source_idcs = copy(esys.source_idcs) + + return EntangledSystem(sys, sys_origin, contraction_info, dipole_operators, source_idcs) +end + function set_field!(esys::EntangledSystem, B) (; sys, sys_origin, dipole_operators, source_idcs) = esys B_old = sys_origin.extfield[1,1,1,1] @@ -127,16 +139,54 @@ function set_field!(esys::EntangledSystem, B) unit = source_idcs[1, 1, 1, atom] S = dipole_operators[:, 1, 1, 1, atom] ΔB = sys_origin.gs[1, 1, 1, atom]' * (B - B_old) - sys.interactions_union[unit].onsite -= Hermitian(ΔB' * S) + sys.interactions_union[unit].onsite += Hermitian(ΔB' * S) end end +# TODO: Actually, we could give a well-defined meaning to this procedure. Implement this. function set_field_at!(::EntangledSystem, _, _) - error("`EntangledSystem`s do not support inhomogenous external fields. Use `set_field!(sys, B).") + error("`EntangledSystem`s do not support inhomogenous external fields. Use `set_field!(sys, B) to set a uniform field.") end -set_dipole!(esys::EntangledSystem, dipole, site; kwargs...) = error("Setting dipoles of an EntangledSystem not well defined.") +function set_dipole!(::EntangledSystem, dipole, site) + error("`set_dipole!` operation for `EntangledSystem` not well defined. Consider using `set_coherent!` to set the state of each entangled unit.") +end + +# Find the unique coherent state corresponding to a set of fully-polarized +# dipoles on each site inside a specified entangled unit. +function coherent_state_from_dipoles(esys::EntangledSystem, dipoles, unit) + (; sys_origin, contraction_info) = esys + + # Find the atom indices (of original system) that lie in the specified unit + # (of contracted system). + atoms = [id.site for id in contraction_info.inverse[unit]] + + # Test that the number of specified dipoles is equal to the number of atoms + # inside the entangled unit. + @assert length(dipoles) == length(atoms) "Invalid number of dipoles for specified unit." + + # Retrieve the dimensions of the local Hilbert spaces corresponding to those + # atoms. + Ns = Ns_in_units(sys_origin, contraction_info)[unit] + + # Generate a list of coherent states corresponding to given dipoles _in each + # local Hilbert space_. + coherents = [] + for (dipole, N) in zip(dipoles, Ns) + # Get the spin matrices in the appropriate representation for the site. + S = spin_matrices((N-1)/2) + + # Find a local coherent state representation of the dipole + coherent = eigvecs(S' * dipole)[:,N] # Retrieve highest-weight eigenvector + push!(coherents, coherent) + end + + # Return the tensor product of each of these local coherent states to get + # the coherent state for the entangled unit. + return kron(coherents...) +end + # Sets the coherent state of a specified unit. The `site` refers to the # contracted lattice (i.e., to a "unit"). The function then updates all dipoles diff --git a/test/test_entangled_units.jl b/test/test_entangled_units.jl index 0116b679d..6b8837c96 100644 --- a/test/test_entangled_units.jl +++ b/test/test_entangled_units.jl @@ -22,7 +22,8 @@ end # TODO: Add test with magnetic unit cell larger than a single unit (i.e. not q=0 # ordering). -@testitem "Test Dimer Interactions" begin +@testitem "Dimer Tests" begin + import LinearAlgebra: norm J = 1.0 J′ = 0.1 latvecs = [ @@ -33,7 +34,7 @@ end positions = [[0, 0, 0], [0.0, 0.5, 0.0]] crystal = Crystal(latvecs, positions, 1; types = ["A", "B"]) - sys = System(crystal, [1 => Moment(s=1/2, g=2), 2 => Moment(s=1/2, g=2)], :SUN) + sys = System(crystal, [1 => Moment(s=1/2, g=2), 2 => Moment(s=1/2, g=2)], :SUN; seed=1) set_exchange!(sys, J, Bond(1, 2, [0, 0, 0])) set_exchange!(sys, J′, Bond(1, 1, [1, 0, 0])) set_exchange!(sys, J′, Bond(2, 2, [1, 0, 0])) # Needed because we broke the symmetry equivalence of the two sites @@ -51,9 +52,35 @@ end # Test external field works as expected set_field!(esys, [0, 0, 1]) onsite_operator = esys.sys.interactions_union[1].onsite - field_offset = -2*(Sl[3] + Su[3]) # 2 for g-factor + field_offset = 2*(Sl[3] + Su[3]) # 2 for g-factor @test onsite_operator ≈ onsite_ref + field_offset + # Test apparatus for setting coherent states from dipoles specification + dipoles = [[0, 1/2, 0], [0, -1/2, 0]] # Dipoles specifying a dimer state + cs = Sunny.coherent_state_from_dipoles(esys, dipoles, 1) + set_coherent!(esys, cs, CartesianIndex(1,1,1,1)) + @test esys.sys_origin.dipoles[1,1,1,1][2] ≈ 1/2 + @test esys.sys_origin.dipoles[1,1,1,2][2] ≈ -1/2 + + # Test external field works in action + set_field!(esys, [0, 0, 10]) + randomize_spins!(esys) + minimize_energy!(esys) + esys.sys_origin.dipoles[1][3] ≈ -1/2 + esys.sys_origin.dipoles[2][3] ≈ -1/2 + + set_field!(esys, [0, 0, -10]) + randomize_spins!(esys) + minimize_energy!(esys) + esys.sys_origin.dipoles[1][3] ≈ 1/2 + esys.sys_origin.dipoles[2][3] ≈ 1/2 + + set_field!(esys, [0, 0, 0]) + randomize_spins!(esys) + minimize_energy!(esys; g_tol=1e-14) + norm(esys.sys_origin.dipoles[1]) < 1e-14 + norm(esys.sys_origin.dipoles[2]) < 1e-14 + # Test inter-bond exchange pc = Sunny.as_general_pair_coupling(interactions.pair[1], esys.sys) Sl1, Sl2 = to_product_space(Sl, Sl) @@ -64,86 +91,42 @@ end end bond_ref = J′*((Sl2' * Sl1) .+ (Su2' * Su1)) @test bond_operator ≈ bond_ref + + + # Test dispersion against analytical formula for antisymmetric channel. + qpts = q_space_path(crystal, [[0, 1, 0], [1, 1, 0]], 5) + qs = qpts.qs + + ω_ref(q, J, J′) = J*sqrt(1 + 2(J′/J) * cos(2π*q)) + ωs_analytical = ω_ref.([q[1] for q in qs], J, J′) + + set_field!(esys, [0, 0, 0]) + for unit in Sunny.eachunit(esys) + set_coherent!(esys, [0, 1/√2, -1/√2, 0], unit) + end + swt = SpinWaveTheory(esys; measure=Sunny.empty_measurespec(sys), regularization=0.0) + disp = dispersion(swt, qpts) + ωs_numerical = disp[1,:] + + @test all(both -> isapprox(both[1], both[2]; atol=1e-12), zip(ωs_analytical, ωs_numerical)) + + + # Test classical dynamics and perform golden test. + esys = repeat_periodically(esys, (8, 1, 1)) + energies = range(0, 2, 10) + dt = 0.1 + measure = ssf_trace(esys) + sc = SampledCorrelations(esys; dt, energies, measure) + integrator = Langevin(dt ; damping=0.4, kT=0.05) + + for _ in 1:100 + step!(esys, integrator) + end + add_sample!(sc, esys) + res = intensities(sc, qpts; energies, kT=0.05) + intensities_ref = [-0.0009151914880177183 -0.002340042772876626 -0.0037316702420023395 -0.002340042772876612 -0.0009151914880177183; 0.02116154679963919 0.05967703767242055 0.009161242329689078 0.03233210977077469 0.02116154679963919; -0.04206086791537969 -0.2227189243447692 -0.12040711429107293 -0.025389877189384635 -0.04206086791537969; 0.3962131659090294 2.7150236439903197 4.3968225602687 0.5625477581811109 0.3962131659090294; 8.48497330044607 17.689468342820923 14.169270995083266 3.1979660472637534 8.48497330044607; 17.1145045637742 21.877166922282075 10.751399167760733 3.8125499846147113 17.1145045637742; 8.490961712258231 5.100854031990811 0.6862255516496436 0.8503635473494539 8.490961712258231; -0.3334143274663385 -0.966097718147396 -0.1252420669485946 -0.2868227954981837 -0.3334143274663385; 0.07518063142323421 0.2337350060517672 0.13638239262286792 0.012717547170902647 0.07518063142323421; -0.09925761646769077 -0.29077390054022495 -0.03237049466881591 -0.290773900540224 -0.09925761646769077] + @test isapprox(res.data, intensities_ref) end -# @testitem "Ba3Mn2O8 Dispersion and Intensities" begin -# function J_of_Q(_, J1, J2, J3, J4, q) -# h, k, l = q -# ω1(h, k, l) = cos((2π/3)*(-h + k + l)) + cos((2π/3)*(-h - 2k + l)) + cos((2π/3)*(2h + k + l)) -# ω2(h, k, l) = cos(2π*k) + cos(2π*(h + k)) + cos(2π*h) -# ω4(h, k, l) = cos((2π/3)*(2h - 2k + l)) + cos((2π/3)*(2h + 4k + l)) + cos((2π/3)*(-4h - 2k + l)) -# -J1*ω1(h, k, l) + 2(J2 - J3)*ω2(h, k, l) - J4*ω4(h, k, l) -# end -# -# function disp0(q) -# J0, J1, J2, J3, J4, D = 1.642, 0.118, 0.256, 0.142, 0.037, -0.032 -# Δ0 = J0 + 2D/3 -# sqrt(Δ0^2 + (8/3)*Δ0*J_of_Q(J0, J1, J2, J3, J4, q) ) -# end -# -# function dispm(q) -# J0, J1, J2, J3, J4, D = 1.642, 0.118, 0.256, 0.142, 0.037, -0.032 -# Δm = J0 - D/3 -# sqrt(Δm^2 + (8/3)*Δm*J_of_Q(J0, J1, J2, J3, J4, q) ) -# end -# -# function Mn_crystal() -# latvecs = [5.710728 -2.855364 0.0; 0.0 4.945635522103099 0.0; 0.0 0.0 21.44383] -# positions = [[1/3, 2/3, 0.07374666666666664], [1/3, 2/3, 0.25958666666666663], [0.0, 0.0, 0.40708], [0.0, 0.0, 0.59292], [2/3, 1/3, 0.7404133333333334], [2/3, 1/3, 0.9262533333333333]] -# symprec = 0.01 -# return Crystal(latvecs, positions; symprec) -# end -# -# function Ba3Mn2O8(; dims=(1, 1, 1), g=1.0, D = -0.032, J0 = 1.642, J1 = 0.118, J2 = 0.256, J3 = 0.142, J4 = 0.037) -# sys = System(Mn_crystal(), dims, [SpinInfo(1; S=1, g)], :SUN) -# S = spin_matrices(1) -# S1, S2 = to_product_space(S, S) -# set_pair_coupling!(sys, J0 * (S1' * S2), Bond(1, 2, [0, 0, 0])) -# set_pair_coupling!(sys, J1 * (S1' * S2), Bond(3, 2, [0, 0, 0])) -# set_pair_coupling!(sys, J2 * (S1' * S2), Bond(1, 1, [1, 0, 0])) -# set_pair_coupling!(sys, J3 * (S1' * S2), Bond(1, 2, [1, 0, 0])) -# set_pair_coupling!(sys, J4 * (S1' * S2), Bond(3, 2, [1, 0, 0])) -# set_onsite_coupling!(sys, D*S[3]^2, 1) -# return sys -# end -# -# # Set up system and reshape into primitive cell -# crystal = Mn_crystal() -# sys = Ba3Mn2O8() -# shape = [-1 -1 2/3; 0 -1 1/3; 0 0 1/3] -# sys_reshaped = reshape_supercell(sys, shape) -# -# # Make entangled system and spin wave theory -# sys_entangled = EntangledSystem(sys_reshaped, [(1, 2)]) -# set_coherent!(sys_entangled.sys, Sunny.CVec{9}(0.0, 0.0, √3/3, 0.0, -√3/3, 0.0, √3/3, 0, 0), (1, 1, 1, 1)) -# swt = EntangledSpinWaveTheory(sys_entangled) -# -# # Calculation dispersion and intensities -# FWHM = 0.295 -# -# points = [ -# [0.175, 0.175, 1.5], -# [0.85, 0.85, 1.5], -# [0.85, 0.85, 3], -# [0.0, 0.0, 3], -# [0.0, 0.0, 8], -# ] -# qpts = q_space_path(crystal, points, 20) -# energies = range(0.0, 4.0, 10) -# -# is = intensities(swt, qpts; energies; kernel=gaussian(; fwhm=FWHM)) -# is_bands = intensities_bands(swt, qpts) -# -# d0_ref = disp0.(path) -# d0 = disp[:,8] -# band_err1 = √sum((d0_ref .- d0) .^ 2) -# @test band_err1 < 1e-7 -# -# dm_ref = dispm.(path) -# dm = disp[:,6] -# band_err2 = √sum((dm_ref .- dm) .^ 2) -# @test band_err2 < 1e-7 -# -# is_ref = [1.5318559039289553e-54 5.4757218095775535e-33 7.357403275541178e-17 3.9795517317276186e-6 0.9020338263369125 0.8314157146337926 2.911058313640675e-6 3.665251511398035e-17 1.6108014399323818e-33 1.2770658651600437e-42; 6.344775971921163e-16 1.8297903880834307e-5 2.186860140613253 1.125414819762803 2.372670614798904e-6 1.8884749639385228e-17 5.364594261005178e-34 5.293626361366888e-56 1.5507874038885882e-56 1.5731739245245433e-42; 1.916445283080627e-22 1.5112603523543528e-9 0.046321847672565045 5.889951708200119 0.0031331962838944093 6.5822336276008166e-12 5.1035843246680587e-26 1.398942793394379e-45 1.4068300720405523e-55 1.0612068475874395e-41; 1.0342024392072121e-16 6.295383373660083e-6 1.5314917741949632 1.5884648898847082 6.9292015386003456e-6 1.1783549059185498e-16 7.29390986501124e-33 1.5826736515812515e-54 7.205550912747091e-56 5.5831854222249985e-42; 7.816369005435853e-65 4.958135881093393e-41 1.1004603393444979e-22 8.837745291621732e-10 0.02729382866823639 3.4792844815914976 0.001870907449751048 4.029919472431617e-12 3.236721779435184e-26 1.258781799195952e-42; 4.1286086857912686e-32 4.109912848294968e-16 1.53865152859326e-5 2.312737091532787 1.4474386749428667 3.6605144080508623e-6 3.5053122616269065e-17 1.205982396647456e-33 1.888239550856115e-55 3.384617657031145e-42; 1.0956905921250642e-15 3.09807215254437e-5 3.6242252907637944 1.8260559377579642 3.77624592541727e-6 2.953182889984101e-17 8.250224084439066e-34 8.009410306835117e-56 4.543889223635611e-56 5.863106256174803e-42; 2.4641979663556544e-21 9.259498870544819e-9 0.1405047201368198 8.991804007003132 0.0023532144516871254 2.345225668006157e-12 8.408440394132043e-27 1.0520889028677954e-46 1.508356309761414e-55 1.1755786936605455e-41; 5.9006127773674436e-21 1.6083917235355553e-8 0.18138815381567364 8.612130243663842 0.0016307094799296721 1.1473990136958224e-12 2.86349056374958e-27 2.4776173823909797e-47 1.4600597514018359e-56 1.2635254358709617e-42; 3.534719908717514e-16 1.5534826875777495e-5 2.933172504328625 2.2501936681347714 6.4727258857098395e-6 6.621955526402235e-17 2.3498631523198714e-33 2.862774376331706e-55 9.224249931423226e-57 1.3867670560912468e-42; 2.9056707554206643e-34 1.1389749648037732e-17 1.8359864206642449e-6 1.1476609410649823 2.6195576292904894 2.104174627891465e-5 5.842573811256141e-16 5.564262837339542e-32 1.8126351339556568e-53 9.514020434069003e-43; 4.95669586498486e-51 4.090111065132001e-30 1.1512703563038524e-14 0.00011053986637697482 3.620428209362293 0.40448305917267885 1.541487919718299e-7 2.0039150465080363e-19 8.886236730407736e-37 8.03538987497683e-43; 1.6256804884099134e-104 1.626131554260588e-73 5.548499522448917e-48 6.457952119615799e-28 2.563973194366388e-13 0.0003472414267885618 1.6041647745239174 0.025279344649153018 1.358882914693268e-9 2.491710931378807e-22; 1.4445317508683965e-67 1.425287573157436e-43 4.79708370999404e-25 5.507461722013346e-12 0.00021568754619639152 0.02881363456352638 1.3130171839110966e-5 2.0409960671735094e-14 1.0822144233620588e-28 1.799465203023977e-45; 9.225789423317937e-80 5.21566646643929e-53 1.0058089054657094e-31 6.616381427047744e-16 1.4846530782284771e-5 1.1363937177899095 0.29670991367977784 2.64261978483415e-7 8.028542283600199e-19 8.320283660276395e-36; 1.0913958451883772e-93 2.04937342166082e-64 1.312681289078253e-40 2.868117121788508e-22 2.1376365239065535e-9 0.05434633134660532 4.713092846351799 0.0013942515956084163 1.4069403885772203e-12 4.8429461011708685e-27] -# @test isapprox(is, is_ref; atol=1e-12) +# @testitem "Ba3Mn2O8 Dispersion and Golden Test" begin # end \ No newline at end of file