# Function reference

The following symbols are exported by AutoBZCore.jl

## Domains

`AutoBZCore.PuncturedInterval`

— Type`PuncturedInterval(s)`

Represent an interval `(a, b)`

with interior points deleted by `s = (a, c1, ..., cN, b)`

, so that the integration algorithm can avoid the points `c1, ..., cN`

for e.g. discontinuities. `s`

must be a tuple or vector.

`AutoBZCore.HyperCube`

— Type`HyperCube(a, b)`

Represents a hypercube spanned by the vertices `a, b`

, which must be iterables of the same length.

`AutoBZCore.load_bz`

— Function```
load_bz(bz::AbstractBZ, [T::Type=Float64])
load_bz(bz::AbstractBZ, A::AbstractMatrix, [B::AbstractMatrix])
```

Interface to loading Brillouin zones.

**Arguments**

`bz::AbstractBZ`

: a kind of Brillouin zone to construct, e.g.`FBZ`

or`IBZ`

`T::Type`

: a numeric type to set the precision of the domain (default:`Float64`

)`A::AbstractMatrix`

: a $d \times d$ matrix whose columns are the real-space lattice vectors of a $d$-dimensional crystal`B::AbstractMatrix`

: a $d \times d$ matrix whose columns are the reciprocal-space lattice vectors of a $d$-dimensional Brillouin zone (default:`A' \ 2πI`

)

!!! note "Assumptions" `AutoBZCore`

assumes that all calculations occur in the reciprocal lattice basis, since that is the basis in which Wannier interpolants are most efficiently described. See `SymmetricBZ`

for details. We also assume that the integrands are cheap to evaluate, which is why we provide adaptive methods in the first place, so that return types can be determined at runtime (and mechanisms are in place for compile time as well)

`AutoBZCore.SymmetricBZ`

— Type`SymmetricBZ(A, B, lims::AbstractIteratedLimits, syms; atol=sqrt(eps()))`

Data type representing a Brillouin zone reduced by a set of symmetries, `syms`

with iterated integration limits `lims`

, both of which are assumed to be in the lattice basis (since the Fourier series is). `A`

and `B`

should be identically-sized square matrices containing the real and reciprocal basis vectors in their columns.

This type assumes all integration limit data is in the reciprocal lattice basis with fractional coordinates, where the FBZ is just the hypercube spanned by the vertices (0,…,0) & (1,…,1). If necessary, use `A`

or `B`

to rotate these quantities into the convention.

`lims`

should be limits compatible with IteratedIntegration.jl. `syms`

should be an iterable collection of point group symmetries compatible with AutoSymPTR.jl.

## Brillouin-zone kinds

`AutoBZCore.AbstractBZ`

— Type`AbstractBZ{d}`

Abstract supertype for all Brillouin zone data types parametrized by dimension.

`AutoBZCore.FBZ`

— Type`FBZ{N} <: AbstractBZ`

Singleton type representing first/full Brillouin zones of `N`

dimensions. By default, `N`

is nothing and the dimension is obtained from input files.

`AutoBZCore.IBZ`

— Type`IBZ <: AbstractBZ`

Singleton type representing irreducible Brillouin zones. Load SymmetryReduceBZ.jl to use this.

`AutoBZCore.InversionSymIBZ`

— Type`InversionSymIBZ{N} <: AbstractBZ`

Singleton type representing Brillouin zones with full inversion symmetry

Only expect this to work for systems with orthogonal lattice vectors

`AutoBZCore.CubicSymIBZ`

— Type`CubicSymIBZ{N} <: AbstractBZ`

Singleton type representing Brillouin zones with full cubic symmetry

Only expect this to work for systems with orthogonal lattice vectors

## Symmetry representations

`AutoBZCore.AbstractSymRep`

— Type`AbstractSymRep`

Abstract supertype of symmetry representation traits.

`AutoBZCore.SymRep`

— Function`SymRep(f)`

`SymRep`

specifies the symmetry representation of the integral of the function `f`

. When you define a new integrand, you can choose to implement this trait to specify how the integral is transformed under the symmetries of the lattice in order to map the integral of `f`

on the IBZ to the result for the FBZ.

New types for `SymRep`

should also extend a corresponding method for `AutoBZCore.symmetrize_`

.

`AutoBZCore.TrivialRep`

— Type`TrivialRep()`

Symmetry representation of objects with trivial transformation under the group.

`AutoBZCore.UnknownRep`

— Type`UnknownRep()`

Fallback symmetry representation for array types without a user-defined `SymRep`

.

`AutoBZCore.symmetrize_`

— Function`symmetrize_(rep::AbstractSymRep, bz::SymmetricBZ, x)`

Transform `x`

under representation `rep`

using the symmetries in `bz`

to obtain the result of an integral on the FBZ from `x`

, which was calculated on the IBZ.

## Internal

The following docstrings belong to internal functions that may change between versions of AutoBZCore.

`AutoBZCore.trapz`

— Function`trapz(n::Integer)`

Return the weights and nodes on the standard interval [-1,1] of the trapezoidal rule.

`AutoBZCore.cube_automorphisms`

— Function`cube_automorphisms(::Val{d}) where d`

return a generator of the symmetries of the cube in `d`

dimensions including the identity.

`AutoBZCore.batchparam`

— Function`batchparam(ps, nthreads)`

If the cost of a calculation smoothly varies with the parameters `ps`

, then batch `ps`

into `nthreads`

groups where the `i`

th element of group `j`

is `ps[j+(i-1)*nthreads]`

along the longest axis of `ps`

. We assume that multidimensional arrays of parameters have smoothest cost along their longest axis

`AutoBZCore.symmetrize`

— Function```
symmetrize(f, ::SymmetricBZ, xs...)
symmetrize(f, ::SymmetricBZ, x::Union{Number,AbstractArray{<:Any,0}})
```

Transform `x`

by the symmetries of the parametrization used to reduce the domain, thus mapping the value of `x`

on the parametrization to the full domain.

`AutoBZCore.FourierValue`

— Type`FourierValue(x, s)`

A container used by `FourierIntegrand`

to pass a point, `x`

, and the value of a Fourier series evaluated at the point, `s`

, to integrands. The properties `x`

and `s`

of a `FourierValue`

store the point and evaluated series, respectively.