Base

PhysicalMedium{Dim,FieldDim}

An abstract type used to represent the physical medium, the dimension of the field, and the number of spatial dimensions. We expect every sub-type of PhysicalMedium{Dim,1} to have a field c which is the complex wave speed.

ScalarMedium{Dim}

An type used to represent a scalar wave which satisfies a Helmoholtz equations. Dim represents the number of spatial dimensions.

A tuples of vectors of the field close to the boundary of the shape. The field is calculated from sim::FrequencySimulation, but the PhysicalMedium inside and outside of the shape are assumed to be given by insidemedium and outsidemedium.

estimate_regular_basis_order(medium::PhysicalMedium, ω::Number, radius::Number; tol = 1e-6)

Extract the dimension of the field of this physical property

Extract the dimension of the field of this type of physical property

the field inside an AbstractParticle a some given point x.

Basis of outgoing wave. A series expansion in this basis should converge to any scattered field outside of a ball which contains the scatterer.

A basis for regular functions, that is, smooth functions. A series expansion in this basis should converge to any regular function within a ball.

Extract the dimension of the space that this physical property lives in

Extract the dimension of the space that this type of physical property lives in

complex_legendre_array(l_max::Int, z::Complex{T})

returns a vector of all associated legendre functions with degree l <= l_max. The degree and order (indices) of the elements of the vector are given by spherical_harmonics_indices(l_max::Int).

The associated legendre polynomials are taken from the package AssociatedLegendrePolynomials.jl.

diffbessel(f::Function,m,x,n::Int)

Differentiates 'n' times any bessel function 'f' of order 'm' and at the argument 'x'.

m-th Derivative of Hankel function of the first kind

Derivative of Bessel function of first kind

Derivative of Hankel function of the first kind

diffhankelh1(m,x,n::Int)

Differentiates 'n' times the hankelh1 function of order 'm' and at the argument 'x'.

diffsbessel(f::Function,m,x)

Differentiates the spherical bessel function 'f' (for any spherical bessel). The order is 'm' and the argument is 'x'. Note 'x' can be a complex number.

gaunt_coefficient(l1,m1,l2,m2,l3,m3)

A version of the Gaunt coefficients which are used to write the product of two spherical harmonics. If Y_{l,m} is a complex spherical harmonic, with the typical phase conventions from quantum mechanics, then:

gaunt_coefficient(l1,m1,l2,m2,l3,m3) = 4*π*im^{l2+l3-l1} Integral[Y_{l1,m1}*conj(Y_{l2,m2})*conj(Y_{l3,m3})]

where the integral is over the solid angle.

The most standard gaunt coefficients G(l1,m1;l2,m2;l3) are related through the identity:

4pi * G(l1,m1;l2,m2;l3) = im^(l1-l2-l3) * (-1)^m2 * gaunt_coefficient(l1,m1,l2,-m2,l3,m1+m2)

shankelh1(m,x)

Returns the spherical hankel function of the first kind. The order is 'm' and the argument is 'x'. Note 'x' can be a complex number.

spherical_harmonics(l_max::Int, θ::Complex{T}, φ::Union{T,Complex{T}})

returns a vector of all spherical harmonics with degree l <= l_max with complex arguments. The degree and order (indices) of the elements of the vector are given by spherical_harmonics_indices(l_max::Int).

spherical_harmonics(l_max::Int, θ::T, φ::T)

Returns a vector of all the spherial harmonics $Y_{(l,m)}(\theta,\phi)$ for all the degrees l and orders m. The degree and order (indices) of the elements of the vector are given by spherical_harmonics_indices(l_max::Int).

spherical_harmonics_dθ(l_max::Int, θ::T, φ::T)

Returns a vector of all $\partial Y_{(l,m)}(\theta,\phi) / \partial \theta$ for all the degrees l and orders m.

Abstract idea which defines the external boundary of object.

Shape(shape::Shape; addtodimensions = 0.0, vector_translation = zeros(...), kws...)

Alter the shape depending on the keywords.

in(vector, shape)::Bool

Returns true if vector is in interior of shape, false otherwise.

issubset(shape1, shape2)::Bool

Returns true if shape1 is entirely contained within shape2, false otherwise (also works with particles).

iscongruent(p1::Shape, p2::Shape)::Bool
≅(p1::Shape, p2::Shape)::Bool

True if shapes are the same but in different positions (origins), standard mathematical definition.

volume(shape::Shape)::NTuple{Function,Dim)

Returns Tuple of Dim Functions which define outer boundary of shape when given boundary coordinate t∈[0,1]

Returns a set of points on the boundary of a 3D shape.

Returns a set of points on the boundary of a 2D shape.

Returns box which completely encloses the shapes

Generic helper function which tests if boundary coordinate is between 0 and 1

congruent(s::Shape, x)::Shape

Create shape congruent to s but with origin at x

iscongruent(p1::Shape, p2::Shape)::Bool
≅(p1::Shape, p2::Shape)::Bool

True if shapes are the same but in different positions (origins), standard mathematical definition.

name(shape::Shape)::String

Name of a shape

number_type(shape::Shape)::DataType

Number type which is used to describe shape, defaults to the eltype of the origin vector.

origin(shape::Shape)::SVector

Origin of shape, typically the center

outer_radius(shape::Shape)

The radius of a circle which completely contains the shape

points_in_shape(Shape; resolution = 20, xres = resolution, yres = resolution,
         exclude_region = EmptyShape(region), kws...)

returns (x_vec, region_inds) where x_vec is a vector of points that cover a box which bounds Shape, and region_inds is an array of linear indices such that x_vec[region_inds] are points contained Shape. For 3D we use zres instead of yres.

volume(shape::Shape)

Volume of a shape

Halfspace(normal::AbstractVector{T} [, origin::AbstractVector{T}=zeros()])

A halfspace defined by all the points $\mathbf x$ that satify $(\mathbf x - \mathbf o) \cdot \mathbf n < 0$ where $\mathbf n$ is the unit normal and $\mathbf o$ is the origin.

Plate(normal::AbstractVector{T}, width::T, [, origin::AbstractVector{T}=zeros()])

A plate defined by all the points $\mathbf x$ that satify $|(\mathbf x - \mathbf o) \cdot \mathbf n| < w /2$ where $\mathbf n$ is the unit normal, $\mathbf o$ is the origin, and $w$ is the width.

Box([origin::AbstractVector{T}=zeros(),] dimensions::AbstractVector{T})

A Box for 2D and 3D with axis aligned sides, defined by dimensions and origin (at the center).

Box(points::Vector{v} where v <: AbstractVector)

A Box for any dimension with axis aligned sides, that is a minimal cover for the points.

Return SVector with the coordinates of the bottom left of a rectangle

Returns a vector of SVector with the coordinates of the corners of the box

Return SVector with the coordinates of the top right of a rectangle

EmptyShape{Dim}

An empty shape with no points.

A shape which contains all particles,$x > x_0$, necessary to simulate a plane-wave scattering from an infinite medium, for a reciever at the focal point, for time $t < D / c$, where $c$ is the sound speed of the background medium, and $D$ is some chosen focal distance. The plane-wave travels towards the positive direction of the $x$ axis.

More precisely, if the focal point is at $(x_f,y_f)$ then the interior of the shape is defined as $(y - y_f)^2 < (D + x_0)^2 - x_f^2 - 2(D + x_0 - x_f)x$ and $x > min(x_0, x_f)$ where $D$ is the focal distance.

Object we can scatter waves off

Subtypes will contain information about shape and material properties. Most crucially, they will implement the t_matrix function

Particle(medium::PhysicalMedium, shape::Shape)

Create particle with inner medium and shape (dimensions must agree).

CapsuleParticle(outer::Particle, inner::Particle)

A particle within another particle, both with the same shape type and origin.

iscongruent(p1::AbstractParticle, p2::AbstractParticle)::Bool
≅(p1::AbstractParticle, p2::AbstractParticle)::Bool

Returns true if medium and shape of particles are the same, ignoring origin, false otherwise.

Represent any source (incident) wave

Subtypes may have a symmetry (such as PlaneSource) and will contain information about physical medium.

PlaneSource(medium::P, amplitude::SVector, direction::SVector)

Is a struct type which describes a plane-wave source that drives/forces the whole system. It has three fields: a physical medium, an amplitude of the source, and the direction the propagate in direction.

For any given angular frequency ω, the PlaneSource has the value $e^{i ω/c \mathbf v \cdot \mathbf x }$ at the point $\mathbf x$, where $c$ is the medium wavespeed and $\mathbf v$ is the direction.

RegularSource(medium::P, field::Function, coef::Function)

Is a struct type which describes the source field that drives/forces the whole system. It is also known as an incident wave. It has three fields RegularSource.medium, RegularSource.field, and RegularSource.coef.

The source field at the position 'x' and angular frequency 'ω' is given by

x = [1.0,0.0]
ω = 1.0
RegularSource.field(x,ω)

The field RegularSource.coef regularbasisfunction(medium::Acoustic{T,2}, ω::T)

regular_spherical_coefficients(source::RegularSource)

return a function which can calculate the coefficients of a regular spherical wave basis.

regular_spherical_source(PhysicalMedium,regular_coefficients; amplitude = one(T), position = zeros(T,Dim))

$c_n =$regular_coefficients[n], $x_o=$position, and let $v_n(kx)$ represent the regular spherical basis with wavenumber $k$ at position $x$. The above returns a source where source.field(x,ω) =$\sum_n c_n v_n(kx -k x_0)$

Check that the source functions return the correct types

source_expand(RegularSource, centre; basis_order = 4)

Returns a function of (x,ω) which approximates the value of the source at (x,ω). That is, the source is written in terms of a regular basis expansion centred at centre.

See also: DiscreteImpulse, frequency_to_time

ContinuousImpulse{T<:AbstractFloat}

A struct used to represent an analytic impulse function. Has two fields: in_time a function of time t, and in_freq a function of the angular frequency ω. in_freq should be the Fourier transform of in_time, though this is not enforced.

We use the Fourier transform convention: F(ω) = ∫ f(t)exp(imωt) dt, f(t) = (2π)^(-1) * ∫ F(ω)exp(-imωt) dω.

An impluse f(t) is convoluted in time with the field u(t), however we avoid the convolution by working with the fourier transform F(ω) of the impulse f(t), which results in

frequency to time: (2π)^(-1) * ∫ F(ω)U(ω)exp(-imωt) dω

See also: ContinuousImpulse, frequency_to_time, DiscreteGaussianImpulse

DiscreteImpulse{T<:AbstractFloat}

A struct used to represent a numerical impulse. Only the fields: in_freq which is the frequency response vector, and the frequency vector ω are required to use this struct to use in the function frequency_to_time.

See also: ContinuousImpulse, TimeDiracImpulse

DiscreteGaussianImpulse(t_vec[, ω_vec])

Returns a discretised gaussian impulse.

Dirac Delta function of unit area in the frequency domain centred at ω=ω0.

Warning: in frequency space this is a singuarity and so may lead to unexpected behaviour.

See also: ContinuousImpulse, TimeDiracImpulse

GaussianImpulse(maxω[; σ = 3.0/maxω^2])

Returns a gaussian impulse function, which in the frequency domain is exp(-σ*ω^2)*(2sqrt(σ*pi)).

TimeDiracImpulse(t0::T)

Dirac Delta function of unit area in the time domain centred at t=t0.

Warning: in the time domain this is a singuarity and so may lead to unexpected behaviour.

continuous_to_discrete_impulse(impulse::ContinuousImpulse, t_vec, ω_vec = t_to_ω(t_vec); t_shift = 0.0, ω_shift = 0.0)

Returns a DiscreteImpulse by sampling impulse. The signal can be shifted in time and frequency by choosing t_shit and ω_shift.

Check that the continuous impulse functions return the correct types

Check that the discrete impulse vectors are the right sizes

Returns the first element of array which isn't zero (assumes elements are increasing and distinct)

Convert a FrequencySimulationResult into a TimeSimulationResult by using the inverse fourier transform. Assumes only positive frequencies and a real time signal

frequency_to_time(field_mat::AbstractArray, ω_vec::AbstractVector,
    t_vec::AbstractArray = ω_to_t(ω_vec);
    method = :DFT,
    impulse::ContinuousImpulse = TimeDiracImpulse(zero(T)),
    discrete_impulse::DiscreteImpulse = continuous_to_discrete_impulse(impulse, t_vec, ω_vec))

See also: DiscreteImpulse, ContinuousImpulse

Calculates the time response from the frequency response by approximating an inverse Fourier transform. The time signal is assumed to be real and the frequenices ω_vec are assumed to be positive (can include zero) and sorted. The result is convoluted in time ωith the user specified impulse.

We use the Fourier transform convention: F(ω) = ∫ f(t)exp(imωt) dt f(t) = (2π)^(-1) * ∫ F(ω)exp(-imωt) dt

To easily sample any time, the default is not FFT, but a discrete version of the transform above.

The inverse of ωtot if ω_vec[1] == 0

Convert a TimeSimulationResult into a FrequencySimulationResult by using the fourier transform. Assumes only positive frequencies and a real time signal

function time_to_frequency(field_mat::AbstractArray, t_vec::AbstractVector,
    ω_vec::AbstractArray = t_to_ω(t_vec);
    method = :DFT,
    impulse::ContinuousImpulse = TimeDiracImpulse(zero(T)),
    discrete_impulse::DiscreteImpulse = continuous_to_discrete_impulse(impulse, t_vec, ω_vec)
)

The inverse of the function frequencytotime (only an exact inverse when using :DFT integration). We use the Fourier transform convention: F(ω) = ∫ f(t)exp(imω*t) dt

returns an array of time from the frequency array ωvec. Uses the same convention for sampling the time as the discrete Fourier transfrom. Assumes ωvec is ordered and non-negative.

FrequencySimulation([particles::AbstractParticles=[],]
                    source::AbstractSource)

Build a FrequencySimulation. If particles are not provided, an empty array is used.

After building, you can run the simulation to get a FrequencySimulationResult.

run(sim::FrequencySimulation, x, ω; basis_order=5)

Run the simulation sim for the position x and angular frequency ω.

Position can be an SVector or Vector{SVector} and frequency can be a float or vector of floats.

run(sim::FrequencySimulation, region::Shape;
    res=20, xres=res, yres=res, basis_order=5)

Run the simulation sim for a grid of positions in region and for angular frequency ω.

Frequency can be a float or vector of floats. The resolution of the grid points is defined by xres and yres.

Struct to hold results of a FrequencySimulation

basis_coefficients(sim::FrequencySimulation, ω::AbstractFloat; basis_order::Int=5)::Matrix{Complex}

Return coefficients for bases around each particle for a given simulation and angular frequency (ω).

field(result::SimulationResult, [i::Integer, j::Integer])

Get field from result, optionally specifying indices.

Returns single value of/matrix of complex SVectors() if vector field, and complex float if scalar field.

Create the matrix S which will be inverted to find the scattering coefficients.

t_matrix(particle, medium, ω, order)

Returns a finite T-matrix, with size depending on order, for a specific particle within a medium with specific physical properties.

t_matrix(Particle{2,Acoustic{T,2},Sphere{T,2}}, Acoustic{T,2}, ω, order)

The T-matrix for a 2D circlular acoustic particle in a 2D acoustic medium.

t_matrix(Particle{2,Acoustic{T,2},Sphere{T,2}}, Acoustic{T,2}, ω, order)

The T-matrix for a 2D isotropic Helmholtz resonator in a 2D acoustic medium.

t_matrix(Particle{2,Acoustic{T,2},Sphere{T,2}}, Acoustic{T,2}, ω, order)

The T-matrix for a 2D non-isotropic Helmholtz resonator in a 2D acoustic medium.

t_matrix(CapsuleParticle{2,Acoustic{T,2},Sphere{T,2}}, Acoustic{T,2}, ω, order)

The T-matrix for a 2D circlular capsule particle in an acoustic medium.

t_matrix(Particle{3,Acoustic{T,3},Sphere{T,3}}, Acoustic{T,3}, ω, order)

The T-matrix for a 3D spherical acoustic particle in a 3D acoustic medium.

get_t_matrices(PhysicalMedium, Vector{Particles}, ω, basis_order::Integer)

Returns vector of T-matrices from a vector of particles in a specific domain. Can save computation if multiple of the same kind of particle are present in the vector.