use crate::discrete::{DiscreteSF, Resonance};
use crate::segment::Segment;
use crate::singularity::{AsymptTerm, Singularity};
use crate::util::fermi;
use crate::{ContinuousSF, SpectralFunction};
use special::Elliptic;
use std::f64::consts::{PI, SQRT_2};
use std::sync::Arc;
fn mirrored_in_order<const N: usize>(
singularities: &[Singularity; N],
omega: f64,
) -> [Singularity; N] {
let mut out = singularities.each_ref().map(|s| s.mirrored(omega));
out.reverse();
out
}
pub fn discrete(levels: &[f64], weights: &[f64]) -> SpectralFunction {
SpectralFunction::from_discrete_continuous(
levels
.iter()
.zip(weights)
.map(|(&eps, &weight)| Resonance { eps, weight })
.collect(),
vec![],
)
}
#[derive(Clone)]
struct FlatDOS {
eps: f64,
d: f64,
delta: f64,
inv_edge_width: f64,
prefactor: f64,
}
impl FlatDOS {
fn new(eps: f64, d: f64, delta: f64) -> FlatDOS {
assert!(d > 0.0, "bandwidth must be positive");
assert!(delta >= 0.0, "edge width must be non-negative");
let inv_edge_width = d / delta;
FlatDOS {
eps,
d,
delta,
inv_edge_width,
prefactor: if delta == 0.0 {
1.0 / (2.0 * d)
} else {
let x = inv_edge_width.tanh();
x / (d * (1.0 + x))
},
}
}
}
impl ContinuousSF for FlatDOS {
fn support(&self) -> Segment {
if self.delta == 0.0 {
Segment::new(self.eps - self.d, self.eps + self.d)
} else {
Segment::new(f64::NEG_INFINITY, f64::INFINITY)
}
}
fn regular(&self, omega: f64) -> f64 {
if self.delta == 0.0 {
self.prefactor
} else {
let x = (omega - self.eps) / self.d;
self.prefactor
* fermi(self.inv_edge_width * (x - 1.0))
* fermi(-self.inv_edge_width * (x + 1.0))
}
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(FlatDOS {
eps: self.eps + by,
..self.clone()
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(FlatDOS {
eps: omega - self.eps,
..self.clone()
})
}
}
pub fn flat(eps: f64, d: f64, delta: f64) -> SpectralFunction {
SpectralFunction::from_continuous(FlatDOS::new(eps, d, delta))
}
#[derive(Clone)]
struct GaussianDOS {
eps: f64,
sigma: f64,
prefactor: f64,
}
impl GaussianDOS {
fn new(eps: f64, sigma: f64) -> GaussianDOS {
assert!(sigma > 0.0, "width must be positive");
GaussianDOS {
eps,
sigma,
prefactor: 1.0 / (sigma * (2.0 * PI).sqrt()),
}
}
}
impl ContinuousSF for GaussianDOS {
fn support(&self) -> Segment {
Segment::new(f64::NEG_INFINITY, f64::INFINITY)
}
fn regular(&self, omega: f64) -> f64 {
let x = (omega - self.eps) / self.sigma;
self.prefactor * (-0.5 * x.powi(2)).exp()
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(GaussianDOS {
eps: self.eps + by,
..self.clone()
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(GaussianDOS {
eps: omega - self.eps,
..self.clone()
})
}
}
pub fn gaussian(eps: f64, sigma: f64) -> SpectralFunction {
SpectralFunction::from_continuous(GaussianDOS::new(eps, sigma))
}
#[derive(Clone)]
struct SemicircleDOS {
eps: f64,
radius: f64,
edges: [Singularity; 2],
prefactor: f64,
}
impl SemicircleDOS {
fn new(eps: f64, radius: f64) -> SemicircleDOS {
assert!(radius > 0.0, "radius must be positive");
let prefactor = 2.0 / (PI * radius);
let c = prefactor * SQRT_2;
SemicircleDOS {
eps,
radius,
edges: [
Singularity::new(eps - radius, radius, vec![AsymptTerm::power(0.5, c)]),
Singularity::new(eps + radius, radius, vec![AsymptTerm::power(0.5, c)]),
],
prefactor,
}
}
}
impl ContinuousSF for SemicircleDOS {
fn support(&self) -> Segment {
Segment::new(self.edges[0].position(), self.edges[1].position())
}
fn regular(&self, omega: f64) -> f64 {
if omega == self.edges[0].position() {
-self.edges[1].value(omega)
} else if omega == self.edges[1].position() {
-self.edges[0].value(omega)
} else {
let x = (omega - self.eps) / self.radius;
self.prefactor * (1.0 - x * x).sqrt()
- self.edges[0].value(omega)
- self.edges[1].value(omega)
}
}
fn singularities(&self) -> &[Singularity] {
&self.edges
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(SemicircleDOS {
eps: self.eps + by,
edges: self.edges.each_ref().map(|s| s.shifted(by)),
..self.clone()
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(SemicircleDOS {
eps: omega - self.eps,
edges: mirrored_in_order(&self.edges, omega),
..self.clone()
})
}
}
pub fn semicircle(eps: f64, r: f64) -> SpectralFunction {
SpectralFunction::from_continuous(SemicircleDOS::new(eps, r))
}
struct PowerLawDOS {
edges: Segment,
law: Singularity,
singular: bool,
}
impl PowerLawDOS {
fn new(eps: f64, r: f64, w: f64) -> PowerLawDOS {
assert!(r > -1.0, "asymptotics exponent must satisfy r > -1");
assert!(w > 0.0, "bandwidth must be positive");
PowerLawDOS {
edges: Segment::new(eps, eps + w),
law: Singularity::new(eps, w, vec![AsymptTerm::power(r, (r + 1.0) / w)]),
singular: r < AsymptTerm::MAX_EXPONENT,
}
}
}
impl ContinuousSF for PowerLawDOS {
fn support(&self) -> Segment {
self.edges
}
fn regular(&self, omega: f64) -> f64 {
if self.singular {
0.0
} else {
self.law.value(omega)
}
}
fn singularities(&self) -> &[Singularity] {
if self.singular {
std::slice::from_ref(&self.law)
} else {
&[]
}
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(PowerLawDOS {
edges: self.edges.shifted(by),
law: self.law.shifted(by),
singular: self.singular,
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(PowerLawDOS {
edges: self.edges.mirrored(omega),
law: self.law.mirrored(omega),
singular: self.singular,
})
}
}
pub fn powerlaw(eps: f64, r: f64, w: f64) -> SpectralFunction {
SpectralFunction::from_continuous(PowerLawDOS::new(eps, r, w))
}
struct PseudogapDOS {
edges: Segment,
law: Singularity,
marker: Option<Singularity>,
}
impl PseudogapDOS {
fn new(eps: f64, r: f64, d: f64) -> PseudogapDOS {
assert!(r > 0.0, "asymptotics exponent must be positive");
assert!(d > 0.0, "bandwidth must be positive");
let marker = if r < AsymptTerm::MAX_EXPONENT {
None
} else {
Some(Singularity::new(eps, d, vec![]))
};
PseudogapDOS {
edges: Segment::new(eps - d, eps + d),
law: Singularity::new(eps, d, vec![AsymptTerm::power(r, (r + 1.0) / (2.0 * d))]),
marker,
}
}
}
impl ContinuousSF for PseudogapDOS {
fn support(&self) -> Segment {
self.edges
}
fn regular(&self, omega: f64) -> f64 {
if self.marker.is_some() {
self.law.value(omega)
} else {
0.0
}
}
fn singularities(&self) -> &[Singularity] {
match &self.marker {
Some(marker) => std::slice::from_ref(marker),
None => std::slice::from_ref(&self.law),
}
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(PseudogapDOS {
edges: self.edges.shifted(by),
law: self.law.shifted(by),
marker: self.marker.as_ref().map(|s| s.shifted(by)),
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(PseudogapDOS {
edges: self.edges.mirrored(omega),
law: self.law.mirrored(omega),
marker: self.marker.as_ref().map(|s| s.mirrored(omega)),
})
}
}
pub fn pseudogap(eps: f64, r: f64, d: f64) -> SpectralFunction {
SpectralFunction::from_continuous(PseudogapDOS::new(eps, r, d))
}
#[derive(Clone)]
struct ChainDOS {
eps: f64,
t: f64,
edges: [Singularity; 2],
prefactor: f64,
}
impl ChainDOS {
fn new(eps: f64, t: f64) -> ChainDOS {
assert!(t > 0.0, "hopping constant must be positive");
let prefactor = 1.0 / (2.0 * PI * t);
let terms = || {
vec![
AsymptTerm::power(-0.5, prefactor),
AsymptTerm::power(0.5, prefactor / 8.0),
]
};
ChainDOS {
eps,
t,
edges: [
Singularity::new(eps - 2.0 * t, t, terms()),
Singularity::new(eps + 2.0 * t, t, terms()),
],
prefactor,
}
}
}
impl ContinuousSF for ChainDOS {
fn support(&self) -> Segment {
Segment::new(self.edges[0].position(), self.edges[1].position())
}
fn regular(&self, omega: f64) -> f64 {
if omega == self.edges[0].position() {
-self.edges[1].value(omega)
} else if omega == self.edges[1].position() {
-self.edges[0].value(omega)
} else {
let x = (omega - self.eps) / (2.0 * self.t);
self.prefactor / (1.0 - x * x).sqrt()
- self.edges[0].value(omega)
- self.edges[1].value(omega)
}
}
fn singularities(&self) -> &[Singularity] {
&self.edges
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(ChainDOS {
eps: self.eps + by,
edges: self.edges.each_ref().map(|s| s.shifted(by)),
..self.clone()
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(ChainDOS {
eps: omega - self.eps,
edges: mirrored_in_order(&self.edges, omega),
..self.clone()
})
}
}
pub fn chain(eps: f64, t: f64) -> SpectralFunction {
SpectralFunction::from_continuous(ChainDOS::new(eps, t))
}
#[derive(Clone)]
struct BetheDOS {
eps: f64,
edges: [Singularity; 2],
num_scale: f64,
denom_scale: f64,
prefactor: f64,
}
impl BetheDOS {
fn new(z: u32, eps: f64, t: f64) -> BetheDOS {
assert!(z >= 3, "coordination number z must be at least 3");
assert!(t > 0.0, "hopping constant must be positive");
let z = f64::from(z);
let sz1 = (z - 1.0).sqrt();
let num_scale = 2.0 * sz1 * t;
let denom_scale = z * t;
let prefactor = sz1 / (PI * denom_scale);
let edge_denom = (1.0 - 2.0 / z).powi(2);
let c = prefactor / edge_denom * SQRT_2;
BetheDOS {
eps,
edges: [
Singularity::new(eps - num_scale, num_scale, vec![AsymptTerm::power(0.5, c)]),
Singularity::new(eps + num_scale, num_scale, vec![AsymptTerm::power(0.5, c)]),
],
num_scale,
denom_scale,
prefactor,
}
}
}
impl ContinuousSF for BetheDOS {
fn support(&self) -> Segment {
Segment::new(self.edges[0].position(), self.edges[1].position())
}
fn regular(&self, omega: f64) -> f64 {
if omega == self.edges[0].position() {
-self.edges[1].value(omega)
} else if omega == self.edges[1].position() {
-self.edges[0].value(omega)
} else {
let domega = omega - self.eps;
let x = domega / self.num_scale;
let y = domega / self.denom_scale;
self.prefactor * (1.0 - x * x).sqrt() / (1.0 - y * y)
- self.edges[0].value(omega)
- self.edges[1].value(omega)
}
}
fn singularities(&self) -> &[Singularity] {
&self.edges
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(BetheDOS {
eps: self.eps + by,
edges: self.edges.each_ref().map(|s| s.shifted(by)),
..self.clone()
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(BetheDOS {
eps: omega - self.eps,
edges: mirrored_in_order(&self.edges, omega),
..self.clone()
})
}
}
pub fn bethe(z: u32, eps: f64, t: f64) -> SpectralFunction {
assert!(z >= 2, "coordination number z must be at least 2");
match z {
2 => chain(eps, t),
_ => SpectralFunction::from_continuous(BetheDOS::new(z, eps, t)),
}
}
#[derive(Clone)]
struct SquareDOS {
eps: f64,
t: f64,
edges: Segment,
singularity: [Singularity; 1],
prefactor: f64,
}
impl SquareDOS {
const SERIES_THRESHOLD: f64 = 1e-3;
fn new(eps: f64, t: f64) -> SquareDOS {
assert!(t > 0.0, "hopping constant must be positive");
let prefactor = 1.0 / (2.0 * PI.powi(2) * t);
SquareDOS {
eps,
t,
edges: Segment::new(eps - 4.0 * t, eps + 4.0 * t),
singularity: [Singularity::new(
eps,
16.0 * t,
vec![AsymptTerm::log(prefactor)],
)],
prefactor,
}
}
}
impl ContinuousSF for SquareDOS {
fn support(&self) -> Segment {
self.edges
}
fn regular(&self, omega: f64) -> f64 {
let ax = ((omega - self.eps) / (4.0 * self.t)).abs();
if ax == 0.0 {
0.0
} else if ax < Self::SERIES_THRESHOLD {
self.prefactor * 0.25 * ax.powi(2) * ((4.0 / ax).ln() - 1.0)
} else {
self.prefactor * (1.0 - ax * ax).elliptic_k() - self.singularity[0].value(omega)
}
}
fn singularities(&self) -> &[Singularity] {
&self.singularity
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(SquareDOS {
eps: self.eps + by,
edges: self.edges.shifted(by),
singularity: self.singularity.each_ref().map(|s| s.shifted(by)),
..self.clone()
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(SquareDOS {
eps: omega - self.eps,
edges: self.edges.mirrored(omega),
singularity: mirrored_in_order(&self.singularity, omega),
..self.clone()
})
}
}
pub fn square(eps: f64, t: f64) -> SpectralFunction {
SpectralFunction::from_continuous(SquareDOS::new(eps, t))
}
#[derive(Clone)]
struct TriangularDOS {
eps: f64,
t: f64,
edges: Segment,
singularity: [Singularity; 1],
prefactor: f64,
}
impl TriangularDOS {
const SERIES_THRESHOLD: f64 = 1e-3;
fn new(eps: f64, t: f64) -> TriangularDOS {
assert!(t != 0.0, "hopping constant must be non-zero");
let omega_min = eps + (-6.0 * t).min(3.0 * t);
let omega_max = eps + (-6.0 * t).max(3.0 * t);
let prefactor = 1.0 / (PI.powi(2) * t.abs());
TriangularDOS {
eps,
t,
edges: Segment::new(omega_min, omega_max),
singularity: [Singularity::new(
eps + 2.0 * t,
8.0 * t.abs(),
vec![AsymptTerm::log(prefactor * 0.75)],
)],
prefactor,
}
}
}
impl ContinuousSF for TriangularDOS {
fn support(&self) -> Segment {
self.edges
}
fn regular(&self, omega: f64) -> f64 {
let ax = ((omega - self.singularity[0].position()) / (8.0 * self.t)).abs();
if ax == 0.0 {
0.0
} else if ax < Self::SERIES_THRESHOLD {
let d = (omega - self.singularity[0].position()) / self.t;
let l = -ax.ln();
self.prefactor
* d
* ((3.0 / 16.0) * l - 9.0 / 32.0
+ d * ((15.0 / 128.0) * l - 99.0 / 512.0
+ d * ((21.0 / 256.0) * l - 75.0 / 512.0)))
} else {
let x = (omega - self.eps) / self.t;
let s = (3.0 - x).sqrt();
let a = 3.0 + 2.0 * s - (x / 2.0).powi(2);
let b = 4.0 * s;
let (z0, z1) = if x >= 2.0 { (a, b) } else { (b, a) };
self.prefactor * (((z1 / z0).elliptic_k() / z0.sqrt()) + 0.75 * ax.ln())
}
}
fn singularities(&self) -> &[Singularity] {
&self.singularity
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(TriangularDOS {
eps: self.eps + by,
edges: self.edges.shifted(by),
singularity: self.singularity.each_ref().map(|s| s.shifted(by)),
..self.clone()
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(TriangularDOS {
eps: omega - self.eps,
t: -self.t,
edges: self.edges.mirrored(omega),
singularity: mirrored_in_order(&self.singularity, omega),
..self.clone()
})
}
}
pub fn triangular(eps: f64, t: f64) -> SpectralFunction {
SpectralFunction::from_continuous(TriangularDOS::new(eps, t))
}
#[derive(Clone)]
struct HoneycombDOS {
eps: f64,
t: f64,
edges: Segment,
singularities: [Singularity; 3],
prefactor: f64,
}
impl HoneycombDOS {
const SERIES_THRESHOLD: f64 = 1e-3;
fn new(eps: f64, t: f64) -> HoneycombDOS {
assert!(t > 0.0, "hopping constant must be positive");
let prefactor = 1.0 / (PI.powi(2) * t);
let log_terms = || vec![AsymptTerm::log(prefactor * 0.75)];
let dirac = prefactor * PI / 3.0f64.sqrt();
HoneycombDOS {
eps,
t,
edges: Segment::new(eps - 3.0 * t, eps + 3.0 * t),
singularities: [
Singularity::new(eps - t, 4.0 * t, log_terms()),
Singularity::new(eps, t, vec![AsymptTerm::power(1.0, dirac)]),
Singularity::new(eps + t, 4.0 * t, log_terms()),
],
prefactor,
}
}
}
impl ContinuousSF for HoneycombDOS {
fn support(&self) -> Segment {
self.edges
}
fn regular(&self, omega: f64) -> f64 {
let ax = ((omega - self.eps) / self.t).abs();
let d = (1.0 - ax) * (1.0 + ax);
let y = 0.125 * d.abs();
let logs_subtracted = if y == 0.0 {
-self.prefactor * 0.75 * std::f64::consts::LN_2
} else if y < Self::SERIES_THRESHOLD {
let l = -y.ln();
let s = d
* ((3.0 / 16.0) * l - 9.0 / 32.0
+ d * ((15.0 / 128.0) * l - 99.0 / 512.0
+ d * ((21.0 / 256.0) * l - 75.0 / 512.0)));
self.prefactor * (ax * s - 0.75 * (l * d / (1.0 + ax) + std::f64::consts::LN_2))
} else {
let a = 3.0 + 2.0 * ax - 0.25 * (3.0 - ax.powi(2)).powi(2);
let b = 4.0 * ax;
let (z0, z1) = if ax <= 1.0 { (a, b) } else { (b, a) };
self.prefactor * (ax * ((z1 / z0).elliptic_k() / z0.sqrt()) + 0.75 * (0.5 * y).ln())
};
logs_subtracted - self.singularities[1].value(omega)
}
fn singularities(&self) -> &[Singularity] {
&self.singularities
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(HoneycombDOS {
eps: self.eps + by,
edges: self.edges.shifted(by),
singularities: self.singularities.each_ref().map(|s| s.shifted(by)),
..self.clone()
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(HoneycombDOS {
eps: omega - self.eps,
edges: self.edges.mirrored(omega),
singularities: mirrored_in_order(&self.singularities, omega),
..self.clone()
})
}
}
pub fn honeycomb(eps: f64, t: f64) -> SpectralFunction {
SpectralFunction::from_continuous(HoneycombDOS::new(eps, t))
}
pub fn kagome(eps: f64, t: f64) -> SpectralFunction {
assert!(t != 0.0, "hopping constant must be non-zero");
SpectralFunction::from_discrete_continuous(
DiscreteSF::one_resonance(eps - 2.0 * t, 1.0 / 3.0),
vec![(Arc::new(HoneycombDOS::new(eps + t, t.abs())), 2.0 / 3.0)],
)
}
#[derive(Clone)]
struct LiebDOS {
eps: f64,
t: f64,
edges: Segment,
singularities: [Singularity; 3],
prefactor: f64,
}
impl LiebDOS {
const SERIES_THRESHOLD: f64 = 1e-3;
fn new(eps: f64, t: f64) -> LiebDOS {
assert!(t > 0.0, "hopping constant must be positive");
let prefactor = 1.0 / (PI.powi(2) * t);
let half_width = 2.0 * SQRT_2 * t;
let log_terms = || vec![AsymptTerm::log(prefactor)];
let touching = prefactor * PI / 2.0;
LiebDOS {
eps,
t,
edges: Segment::new(eps - half_width, eps + half_width),
singularities: [
Singularity::new(eps - 2.0 * t, 2.0 * t, log_terms()),
Singularity::new(eps, 2.0 * t, vec![AsymptTerm::power(1.0, touching)]),
Singularity::new(eps + 2.0 * t, 2.0 * t, log_terms()),
],
prefactor,
}
}
}
impl ContinuousSF for LiebDOS {
fn support(&self) -> Segment {
self.edges
}
fn regular(&self, omega: f64) -> f64 {
let ax = ((omega - self.eps) / (2.0 * self.t)).abs();
let y = (ax - 1.0) * (ax + 1.0);
let logs_subtracted = if y == 0.0 {
2.0 * self.prefactor * std::f64::consts::LN_2
} else if y.abs() < Self::SERIES_THRESHOLD {
let l = (4.0 / y.abs()).ln();
self.prefactor
* ((y / (1.0 + ax)) * l
+ 2.0 * std::f64::consts::LN_2
+ 0.25 * ax * y.powi(2) * (l - 1.0))
} else {
self.prefactor * (ax * (1.0 - y.powi(2)).elliptic_k() + y.abs().ln())
};
logs_subtracted - self.singularities[1].value(omega)
}
fn singularities(&self) -> &[Singularity] {
&self.singularities
}
fn shifted(&self, by: f64) -> Box<dyn ContinuousSF> {
Box::new(LiebDOS {
eps: self.eps + by,
edges: self.edges.shifted(by),
singularities: self.singularities.each_ref().map(|s| s.shifted(by)),
..self.clone()
})
}
fn mirrored(&self, omega: f64) -> Box<dyn ContinuousSF> {
Box::new(LiebDOS {
eps: omega - self.eps,
edges: self.edges.mirrored(omega),
singularities: mirrored_in_order(&self.singularities, omega),
..self.clone()
})
}
}
pub fn lieb(eps: f64, t: f64) -> SpectralFunction {
SpectralFunction::from_discrete_continuous(
DiscreteSF::one_resonance(eps, 1.0 / 3.0),
vec![(Arc::new(LiebDOS::new(eps, t)), 2.0 / 3.0)],
)
}
pub fn simple_cubic(eps: f64, t: f64) -> SpectralFunction {
assert!(t > 0.0, "hopping constant must be positive");
chain(eps, t).conv(&square(0.0, t), None)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models;
use crate::util;
use approx::assert_relative_eq;
fn compute_moment(dos: &SpectralFunction, order: i32) -> f64 {
dos.integrate(|omega| omega.powi(order), None)
.unwrap()
.value
}
fn central_to_moments(eps: f64, mu: [f64; 6]) -> Vec<f64> {
let mu: Vec<f64> = std::iter::once(1.0).chain(mu).collect();
(0..mu.len())
.map(|n| {
let c_row = util::binomials(n);
(0..=n)
.map(|k| c_row[k] * eps.powi((n - k) as i32) * mu[k])
.sum()
})
.collect()
}
fn even_central_moments(mu2: f64, mu4: f64, mu6: f64) -> [f64; 6] {
[0.0, mu2, 0.0, mu4, 0.0, mu6]
}
#[test]
fn discrete() {
let levels = vec![-1.0, 0.0, 2.0];
let weights = vec![0.5, 0.5, 0.25];
let dos = models::discrete(&levels, &weights);
for order in 0..=6 {
let moment = compute_moment(&dos, order);
let moment_ref = levels
.iter()
.zip(&weights)
.map(|(level, weight)| level.powi(order) * weight)
.sum();
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
#[test]
fn flat() {
let eps = 0.5f64;
let d = 2.0f64;
let delta = 0.2f64;
use std::f64::consts::PI;
let a = d / delta;
let mu2 = d.powi(2) * (PI.powi(2) + a.powi(2)) / (3.0 * a.powi(2));
let mu4 = mu2 * (3.0 * a.powi(2) + 7.0 * PI.powi(2)) * delta.powi(2) / 5.0;
let mu6 = (3.0 * a.powi(6)
+ 21.0 * a.powi(4) * PI.powi(2)
+ 49.0 * a.powi(2) * PI.powi(4)
+ 31.0 * PI.powi(6))
* delta.powi(6)
/ 21.0;
let moments_ref = central_to_moments(eps, even_central_moments(mu2, mu4, mu6));
let dos = models::flat(eps, d, delta);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
fn check_asympt_int<C: ContinuousSF>(dos: &C, expected: &[f64]) {
let support = dos.support();
let singularities = dos.singularities();
assert_eq!(singularities.len(), expected.len());
for (sing, &e) in singularities.iter().zip(expected) {
assert_relative_eq!(sing.integral(support), e, max_relative = 1e-14);
}
}
#[test]
fn asympt_int() {
use std::f64::consts::{LN_2, PI, SQRT_2};
let (eps, t) = (0.5f64, 2.0f64);
check_asympt_int(&SemicircleDOS::new(eps, 2.0 * t), &[16.0 / (3.0 * PI); 2]);
check_asympt_int(&ChainDOS::new(eps, t), &[7.0 / (3.0 * PI); 2]);
for z in [3u32, 6, 50] {
let zf = f64::from(z);
let s = 16.0 / (3.0 * PI) * zf * (zf - 1.0) / (zf - 2.0).powi(2);
check_asympt_int(&BetheDOS::new(z, eps, t), &[s; 2]);
}
check_asympt_int(
&SquareDOS::new(eps, t),
&[4.0 / PI.powi(2) * (1.0 + 2.0 * LN_2)],
);
for t in [t, -0.7] {
check_asympt_int(
&TriangularDOS::new(eps, t),
&[9.0 / (4.0 * PI.powi(2)) * (3.0 + LN_2)],
);
}
let log_weight = (9.0 + 3.0 * LN_2) / (2.0 * PI.powi(2));
check_asympt_int(
&HoneycombDOS::new(eps, t),
&[log_weight, 3.0 * 3.0f64.sqrt() / PI, log_weight],
);
let log_weight = 4.0 * (SQRT_2 - (1.0 + SQRT_2).ln()) / PI.powi(2);
check_asympt_int(&LiebDOS::new(eps, t), &[log_weight, 2.0 / PI, log_weight]);
for r in [-0.5f64, 0.0, 0.5, 1.0, 1.5] {
check_asympt_int(&PowerLawDOS::new(eps, r, 2.0), &[1.0]);
}
check_asympt_int(&PowerLawDOS::new(eps, 2.5, 2.0), &[]);
for r in [0.5f64, 1.0, 1.5] {
check_asympt_int(&PseudogapDOS::new(eps, r, 2.0), &[1.0]);
}
check_asympt_int(&PseudogapDOS::new(eps, 2.5, 2.0), &[0.0]);
}
#[test]
fn flat_sharp() {
let eps = 0.5f64;
let d = 2.0f64;
let moments_ref = central_to_moments(
eps,
even_central_moments(d.powi(2) / 3.0, d.powi(4) / 5.0, d.powi(6) / 7.0),
);
let dos = models::flat(eps, d, 0.0);
assert_eq!(dos.support(), Some(Segment::new(eps - d, eps + d)));
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
#[test]
fn gaussian() {
let eps = 1.0f64;
let sigma = 3.0f64;
let moments_ref = central_to_moments(
eps,
even_central_moments(sigma.powi(2), 3.0 * sigma.powi(4), 15.0 * sigma.powi(6)),
);
let dos = models::gaussian(eps, sigma);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
#[test]
fn semicircle() {
let eps = 0.5f64;
let t = 2.0f64;
let r = 2.0 * t;
let moments_ref = central_to_moments(
eps,
even_central_moments(r.powi(2) / 4.0, r.powi(4) / 8.0, 5.0 * r.powi(6) / 64.0),
);
let dos = models::semicircle(eps, r);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
#[test]
fn powerlaw() {
let eps = 0.5f64;
let w = 2.0f64;
for r in [-0.5f64, 0.0, 0.5, 1.0, 2.5] {
let dos = models::powerlaw(eps, r, w);
assert_eq!(dos.support(), Some(Segment::new(eps, eps + w)));
let a = |omega: f64| (r + 1.0) * (omega - eps).powf(r) / w.powf(r + 1.0);
for omega in [eps + 1e-3, eps + 0.7, eps + 1.3, eps + w] {
assert_relative_eq!(dos.continuous_at(omega), a(omega), max_relative = 1e-12);
}
assert_eq!(
dos.continuous_at(eps),
if r < 0.0 { f64::INFINITY } else { a(eps) }
);
assert_eq!(dos.continuous_at(eps - 0.5 * w), 0.0);
assert_eq!(dos.continuous_at(eps + 1.5 * w), 0.0);
let mu = |n: i32| (r + 1.0) * w.powi(n) / (f64::from(n) + r + 1.0);
let moments_ref = central_to_moments(eps, [mu(1), mu(2), mu(3), mu(4), mu(5), mu(6)]);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
}
#[test]
fn pseudogap() {
let eps = 0.5f64;
let d = 2.0f64;
for r in [0.5f64, 1.0, 2.5] {
let dos = models::pseudogap(eps, r, d);
assert_eq!(dos.support(), Some(Segment::new(eps - d, eps + d)));
let a = |omega: f64| (1.0 + r) * (omega - eps).abs().powf(r) / (2.0 * d.powf(1.0 + r));
for omega in [eps - d, eps - 0.7, eps, eps + 1.3, eps + d] {
assert_relative_eq!(dos.continuous_at(omega), a(omega), max_relative = 1e-12);
}
assert_eq!(dos.continuous_at(eps - 1.5 * d), 0.0);
let mu = |n: i32| (1.0 + r) * d.powi(n) / (f64::from(n) + 1.0 + r);
let moments_ref = central_to_moments(eps, even_central_moments(mu(2), mu(4), mu(6)));
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
}
#[test]
fn chain() {
let eps = 0.5f64;
let t = 2.0f64;
let moments_ref = central_to_moments(
eps,
even_central_moments(2.0 * t.powi(2), 6.0 * t.powi(4), 20.0 * t.powi(6)),
);
let dos = models::chain(eps, t);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
#[test]
fn bethe() {
let eps = 0.5f64;
let t = 2.0f64;
for z in [2u32, 3, 4, 10, 100] {
let zf = f64::from(z);
let moments_ref = central_to_moments(
eps,
even_central_moments(
zf * t.powi(2),
zf * (2.0 * zf - 1.0) * t.powi(4),
zf * (5.0 * zf.powi(2) - 6.0 * zf + 2.0) * t.powi(6),
),
);
let dos = models::bethe(z, eps, t);
assert_eq!(
dos.support(),
Some(Segment::new(
eps - 2.0 * (zf - 1.0).sqrt() * t,
eps + 2.0 * (zf - 1.0).sqrt() * t
))
);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
}
#[test]
fn bethe_chain_limit() {
let (eps, t) = (0.5f64, 2.0f64);
let (bethe, chain) = (models::bethe(2, eps, t), models::chain(eps, t));
assert_eq!(bethe.support(), chain.support());
for omega in [eps - 2.0 * t, eps - 1.5, eps, eps + 3.0, eps + 2.0 * t] {
assert_eq!(bethe.continuous_at(omega), chain.continuous_at(omega));
}
}
#[test]
fn bethe_continuous_at() {
use std::f64::consts::PI;
let (eps, t) = (0.5f64, 2.0f64);
for z in [3u32, 6, 50] {
let (zf, dos) = (f64::from(z), models::bethe(z, eps, t));
let d = 2.0 * (zf - 1.0).sqrt() * t;
let a = |omega: f64| {
let domega: f64 = omega - eps;
zf / (2.0 * PI) * (d.powi(2) - domega.powi(2)).sqrt()
/ ((zf * t).powi(2) - domega.powi(2))
};
for x in [-0.999, -0.5, 0.0, 0.25, 0.999] {
let omega = eps + x * d;
assert_relative_eq!(dos.continuous_at(omega), a(omega), max_relative = 1e-10);
}
assert_eq!(dos.continuous_at(eps - d), 0.0);
assert_eq!(dos.continuous_at(eps + d), 0.0);
assert_eq!(dos.continuous_at(eps + 1.5 * d), 0.0);
}
}
#[test]
#[should_panic(expected = "coordination number z must be at least 2")]
fn bethe_invalid_z() {
let _ = models::bethe(1, 0.5, 2.0);
}
#[test]
fn square_regular_near_singularity() {
let (eps, t) = (0.5f64, 2.0f64);
let dos = SquareDOS::new(eps, t);
let prefactor = 1.0 / (2.0 * std::f64::consts::PI.powi(2) * t);
assert_eq!(dos.regular(eps), 0.0);
for e in 2..=16 {
for sign in [-1.0f64, 1.0] {
let omega = eps + sign * 10f64.powi(-e);
let ax = 10f64.powi(-e) / (4.0 * t);
let ref_value = prefactor * 0.25 * ax.powi(2) * ((4.0 / ax).ln() - 1.0);
assert_relative_eq!(dos.regular(omega), ref_value, max_relative = 1e-4);
}
}
}
#[test]
fn square() {
let eps = 0.5f64;
let t = 2.0f64;
let moments_ref = central_to_moments(
eps,
even_central_moments(4.0 * t.powi(2), 36.0 * t.powi(4), 400.0 * t.powi(6)),
);
let dos = models::square(eps, t);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
#[test]
fn triangular() {
let eps = 0.5f64;
for t in [2.0f64, -0.7] {
let moments_ref = central_to_moments(
eps,
[
0.0,
6.0 * t.powi(2),
-12.0 * t.powi(3),
90.0 * t.powi(4),
-360.0 * t.powi(5),
2040.0 * t.powi(6),
],
);
let dos = models::triangular(eps, t);
assert_eq!(
dos.support(),
Some(Segment::new(
eps + (-6.0 * t).min(3.0 * t),
eps + (-6.0 * t).max(3.0 * t)
))
);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
}
#[test]
fn triangular_regular_near_singularity() {
let (eps, t) = (0.5f64, 2.0f64);
let dos = TriangularDOS::new(eps, t);
let prefactor = 1.0 / (std::f64::consts::PI.powi(2) * t);
let ref_values = [
(1, 0.168390121477016, -0.0938944124091616),
(4, 0.0408118425415933, -0.0378744776978792),
(7, 0.00799423604376689, -0.00791868158506950),
(10, 0.00137611250776708, -0.00137446721459707),
(20, 2.58250123354371e-6, -2.58249818693858e-6),
];
assert_eq!(dos.regular(eps + 2.0 * t), 0.0);
for (e, ref_plus, ref_minus) in ref_values {
for (sign, ref_value) in [(1.0, ref_plus), (-1.0, ref_minus)] {
let d = sign * 2f64.powi(-e);
let omega = eps + (2.0 + d) * t;
assert_relative_eq!(
dos.regular(omega),
prefactor * ref_value,
max_relative = 1e-6
);
}
}
}
#[test]
fn honeycomb() {
let eps = 0.5f64;
let t = 2.0f64;
let moments_ref = central_to_moments(
eps,
even_central_moments(3.0 * t.powi(2), 15.0 * t.powi(4), 93.0 * t.powi(6)),
);
let dos = models::honeycomb(eps, t);
assert_eq!(
dos.support(),
Some(Segment::new(eps - 3.0 * t, eps + 3.0 * t))
);
assert_eq!(dos.continuous_at(eps - t), f64::INFINITY);
assert_eq!(dos.continuous_at(eps + t), f64::INFINITY);
assert_relative_eq!(dos.continuous_at(eps), 0.0, epsilon = 1e-15);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
#[test]
fn honeycomb_dirac_point() {
use std::f64::consts::PI;
let eps = 0.5f64;
for t in [1.0f64, 2.5] {
let dos = HoneycombDOS::new(eps, t);
assert_eq!(dos.singularities().len(), 3);
assert_eq!(dos.singularities()[1].position(), eps);
let coefficient = 1.0 / (3.0f64.sqrt() * PI * t * t);
let band = models::honeycomb(eps, t);
for h in [10, 20, 30].map(|e| 2f64.powi(-e)) {
assert_relative_eq!(
dos.singularities()[1].value(eps + h) / h,
coefficient,
max_relative = 1e-12
);
assert_relative_eq!(
band.continuous_at(eps + h) / h,
coefficient,
max_relative = 1e-6
);
}
let r0 = dos.regular(eps);
for h in [1e-2f64, 1e-3] {
let slope = (dos.regular(eps + h) - r0) / h;
assert!(
slope.abs() < 0.01 * coefficient,
"R still kinks at the Dirac point: {slope:.3e}"
);
}
}
}
#[test]
fn honeycomb_regular_near_singularity() {
let (eps, t) = (0.5f64, 2.0f64);
let dos = HoneycombDOS::new(eps, t);
let prefactor = 1.0 / (std::f64::consts::PI.powi(2) * t);
let dirac = std::f64::consts::PI / 3.0f64.sqrt();
for omega_p in [eps - t, eps + t] {
assert_relative_eq!(
dos.regular(omega_p),
-prefactor * (0.75 * std::f64::consts::LN_2 + dirac),
max_relative = 1e-14
);
}
let ref_values = [
(1, 0.0943101136887941, -1.29999066584090),
(4, -0.389118215772244, -0.654568957739481),
(7, -0.497232083057124, -0.542574386667219),
(10, -0.516265866766906, -0.523456614923520),
(20, -0.519854395427088, -0.519866375415643),
];
for (e, ref_plus, ref_minus) in ref_values {
for (sign, ref_value) in [(1.0f64, ref_plus), (-1.0, ref_minus)] {
let delta = sign * 2f64.powi(-e);
for band in [-1.0f64, 1.0] {
let omega = eps + band * (1.0 + delta) * t;
assert_relative_eq!(
dos.regular(omega),
prefactor * (ref_value - dirac * (1.0 + delta)),
max_relative = 1e-8
);
}
}
}
}
#[test]
fn kagome() {
let eps = 0.5f64;
for t in [2.0f64, -0.5] {
let moments_ref = central_to_moments(
eps,
[
0.0,
4.0 * t.powi(2),
4.0 * t.powi(3),
28.0 * t.powi(4),
60.0 * t.powi(5),
264.0 * t.powi(6),
],
);
let dos = models::kagome(eps, t);
let omega_min = eps + (-2.0 * t).min(4.0 * t);
let omega_max = eps + (-2.0 * t).max(4.0 * t);
assert_eq!(dos.support(), Some(Segment::new(omega_min, omega_max)));
assert_relative_eq!(dos.total_weight(), 1.0, max_relative = 1e-14);
assert_eq!(dos.discrete().len(), 1);
assert_eq!(dos.discrete().resonances()[0].eps, eps - 2.0 * t);
assert_relative_eq!(
dos.discrete().resonances()[0].weight,
1.0 / 3.0,
max_relative = 1e-14
);
assert_eq!(dos.continuous_at(eps), f64::INFINITY);
assert_eq!(dos.continuous_at(eps + 2.0 * t), f64::INFINITY);
assert_relative_eq!(dos.continuous_at(eps + t), 0.0, epsilon = 1e-15);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
}
#[test]
fn lieb() {
use std::f64::consts::{PI, SQRT_2};
let eps = 0.5f64;
let t = 2.0f64;
let moments_ref = central_to_moments(
eps,
even_central_moments(
8.0 * t.powi(2) / 3.0,
40.0 * t.powi(4) / 3.0,
224.0 * t.powi(6) / 3.0,
),
);
let dos = models::lieb(eps, t);
let half_width = 2.0 * SQRT_2 * t;
assert_eq!(
dos.support(),
Some(Segment::new(eps - half_width, eps + half_width))
);
assert_relative_eq!(dos.total_weight(), 1.0, max_relative = 1e-14);
assert_eq!(dos.discrete().len(), 1);
assert_eq!(dos.discrete().resonances()[0].eps, eps);
assert_relative_eq!(
dos.discrete().resonances()[0].weight,
1.0 / 3.0,
max_relative = 1e-14
);
assert_eq!(dos.continuous_at(eps - 2.0 * t), f64::INFINITY);
assert_eq!(dos.continuous_at(eps + 2.0 * t), f64::INFINITY);
assert_relative_eq!(dos.continuous_at(eps), 0.0, epsilon = 1e-15);
for omega_e in [eps - half_width, eps + half_width] {
assert_relative_eq!(
dos.continuous_at(omega_e),
SQRT_2 / (3.0 * PI * t),
max_relative = 1e-12
);
}
assert_eq!(dos.continuous_at(eps + 1.1 * half_width), 0.0);
for (order, moment_ref) in moments_ref.iter().enumerate() {
let moment = compute_moment(&dos, order as i32);
assert_relative_eq!(moment, moment_ref, max_relative = 1e-10);
}
}
#[test]
fn lieb_band_touching() {
use std::f64::consts::PI;
let eps = 0.5f64;
for t in [1.0f64, 2.5] {
let dos = LiebDOS::new(eps, t);
assert_eq!(dos.singularities().len(), 3);
assert_eq!(dos.singularities()[1].position(), eps);
let coefficient = 1.0 / (4.0 * PI * t * t);
for h in [10, 20, 30].map(|e| 2f64.powi(-e)) {
assert_relative_eq!(
dos.singularities()[1].value(eps + h) / h,
coefficient,
max_relative = 1e-12
);
let a = dos.regular(eps + h)
+ dos
.singularities()
.iter()
.map(|s| s.value(eps + h))
.sum::<f64>();
assert_relative_eq!(a / h, coefficient, max_relative = 1e-6);
}
let r0 = dos.regular(eps);
for h in [1e-2f64, 1e-3] {
let slope = (dos.regular(eps + h) - r0) / h;
assert!(
slope.abs() < 0.01 * coefficient,
"R still kinks where the bands touch: {slope:.3e}"
);
}
}
}
#[test]
fn every_bounded_model_convolves() {
let cases: [(&str, SpectralFunction, SpectralFunction); 8] = [
(
"honeycomb",
super::honeycomb(0.0, 1.0),
super::chain(0.0, 1.0),
),
("kagome", super::kagome(0.0, 1.0), super::chain(0.0, 1.0)),
("lieb", super::lieb(0.0, 1.0), super::chain(0.0, 1.0)),
("bethe", super::bethe(3, 0.0, 1.0), super::chain(0.0, 1.0)),
(
"pseudogap",
super::pseudogap(0.0, 1.0, 1.0),
super::chain(0.0, 1.0),
),
(
"powerlaw",
super::powerlaw(0.0, -0.5, 1.0),
super::chain(0.0, 1.0),
),
(
"triangular against square",
super::triangular(0.0, 1.0),
super::square(0.0, 1.0),
),
(
"honeycomb against itself",
super::honeycomb(0.0, 1.0),
super::honeycomb(0.0, 1.0),
),
];
for (name, a, b) in cases {
let c = a.conv(&b, Some(1e-11));
let weight = a.total_weight() * b.total_weight();
assert_relative_eq!(c.total_weight(), weight, max_relative = 1e-9);
assert_relative_eq!(
c.integrate(|_| 1.0, None).unwrap().value,
weight,
max_relative = 1e-7,
);
let mean = |sf: &SpectralFunction| sf.integrate(|w: f64| w, None).unwrap().value;
assert_relative_eq!(
mean(&c),
mean(&a) * b.total_weight() + a.total_weight() * mean(&b),
max_relative = 1e-7,
epsilon = 1e-9,
);
let reach = c.support().unwrap();
for i in 0..=200 {
let omega = reach.min() + reach.length() * f64::from(i) / 200.0;
assert!(
!c.continuous_at(omega).is_nan(),
"{name} left no number at all at {omega}"
);
}
}
}
#[test]
#[should_panic(expected = "bounded supports")]
fn conv_needs_a_bounded_support() {
let _ = super::gaussian(0.0, 0.5).conv(&super::chain(0.0, 1.0), None);
}
#[test]
fn simple_cubic_dos() {
let (eps, t) = (0.3f64, 1.4f64);
let sc = simple_cubic(eps, t);
assert_relative_eq!(sc.total_weight(), 1.0, max_relative = 1e-9);
assert!(sc.discrete().is_empty());
assert_relative_eq!(
sc.integrate(|_| 1.0, None).unwrap().value,
1.0,
max_relative = 1e-8
);
for outside in [eps - 6.1 * t, eps + 6.1 * t] {
assert_eq!(sc.continuous_at(outside), 0.0);
}
assert!(sc.continuous_at(eps) > 0.0);
for (order, known) in [(2i32, 6.0f64), (4, 90.0), (6, 1860.0)] {
let moment = sc
.integrate(|omega: f64| (omega - eps).powi(order), None)
.unwrap()
.value;
assert_relative_eq!(moment, known * t.powi(order), max_relative = 1e-7);
}
}
#[test]
fn simple_cubic_van_hove_points() {
let t = 1.0f64;
let sc = simple_cubic(0.0, t);
let (csf, _) = &sc.continuous[0];
let positions: Vec<f64> = csf.singularities().iter().map(|s| s.position()).collect();
assert_eq!(positions, vec![-6.0 * t, -2.0 * t, 2.0 * t, 6.0 * t]);
for saddle in [-2.0 * t, 2.0 * t] {
let sing = csf
.singularities()
.iter()
.find(|s| s.position() == saddle)
.unwrap();
assert!(!sing.is_trivial());
let side = if saddle < 0.0 { -1.0 } else { 1.0 };
let at = |d: f64| sing.value(saddle + side * d);
let (near, far) = (1e-8f64, 1e-6f64);
let a = (at(far) - at(near)) / (far.sqrt() - near.sqrt());
let c = at(near) - a * near.sqrt();
assert_relative_eq!(
a,
-3.0 / (4.0 * std::f64::consts::PI.powi(2) * t.powf(1.5)),
max_relative = 1e-6
);
let third = 1e-10f64;
assert_relative_eq!(at(third), c + a * third.sqrt(), max_relative = 1e-12);
}
for edge in [-6.0 * t, 6.0 * t] {
let sing = csf
.singularities()
.iter()
.find(|s| s.position() == edge)
.unwrap();
assert!(!sing.is_trivial());
let (d, side) = (1e-8f64, if edge < 0.0 { 1.0 } else { -1.0 });
assert_relative_eq!(
sing.value(edge + side * d) / d.sqrt(),
1.0 / (4.0 * std::f64::consts::PI.powi(2) * t.powf(1.5)),
max_relative = 1e-6
);
}
}
#[test]
#[should_panic(expected = "hopping constant must be positive")]
fn simple_cubic_zero_hopping() {
let _ = simple_cubic(0.0, 0.0);
}
#[test]
fn lieb_regular_near_singularity() {
let (eps, t) = (0.5f64, 2.0f64);
let dos = LiebDOS::new(eps, t);
let prefactor = 1.0 / (std::f64::consts::PI.powi(2) * t);
let touching = std::f64::consts::PI / 2.0;
for omega_p in [eps - 2.0 * t, eps + 2.0 * t] {
assert_relative_eq!(
dos.regular(omega_p),
prefactor * (2.0 * std::f64::consts::LN_2 - touching),
max_relative = 1e-14
);
}
let ref_values = [
(2, 1.98946838014527, 0.881213016813116),
(4, 1.61182181901004, 1.17635167283123),
(7, 1.42986716906016, 1.34321545818198),
(10, 1.39374613100041, 1.37885427306285),
(15, 1.38663282082393, 1.38595591927928),
(20, 1.3863082429017, 1.38628047936183),
(40, 1.38629436114574, 1.38629436109404),
];
for (e, ref_plus, ref_minus) in ref_values {
for (sign, ref_value) in [(1.0f64, ref_plus), (-1.0, ref_minus)] {
let delta = sign * 2f64.powi(-e);
for band in [-1.0f64, 1.0] {
let omega = eps + band * (1.0 + delta) * 2.0 * t;
assert_relative_eq!(
dos.regular(omega),
prefactor * (ref_value - touching * (1.0 + delta)),
max_relative = 1e-8
);
}
}
}
}
}