Krang api

• Krang.AbsorptiveIntensity
• Krang.AbstractCamera
• Krang.AbstractGeometry
• Krang.AbstractLevelSetGeometry
• Krang.AbstractLightTrait
• Krang.AbstractMaterial
• Krang.AbstractMetric
• Krang.AbstractPixel
• Krang.AbstractScreen
• Krang.AbstractSymmetryTrait
• Krang.AngularCache
• Krang.AxisymmetricTrait
• Krang.ConeGeometry
• Krang.ElectronSynchrotronPowerLawIntensity
• Krang.ElectronSynchrotronPowerLawPolarization
• Krang.FastLightTrait
• Krang.IntensityCamera
• Krang.IntensityPixel
• Krang.IntensityPixelArray
• Krang.IntensityScreen
• Krang.Kerr
• Krang.Mesh
• Krang.MeshGeometry
• Krang.NonAxisymmetricTrait
• Krang.SlowLightIntensityCamera
• Krang.SlowLightIntensityPixel
• Krang.SlowLightIntensityPixelArray
• Krang.SlowLightIntensityScreen
• Krang.SlowLightTrait
• Krang.ThermalSynchrotron
• Krang.Gt
• Krang.Gθ
• Krang.Gϕ
• Krang.I0_inf
• Krang.I1_inf_m_I0_terms
• Krang.I2_inf_m_I0_terms
• Krang.Im_inf_m_I0_terms
• Krang.Ip_inf_m_I0_terms
• Krang.Ir
• Krang.Ir_inf
• Krang.Ir_s
• Krang.It
• Krang.It_inf
• Krang.It_w_I0_terms
• Krang.Iϕ
• Krang.Iϕ_inf
• Krang.Iϕ_w_I0_terms
• Krang.S1
• Krang.S2
• Krang._Gθ_setup
• Krang._Gθ_subimage
• Krang._Gϕt
• Krang._absGθo_Gθhat
• Krang._accumulate
• Krang._emission_coordinates
• Krang._intensity_pixel_type
• Krang._intersection
• Krang._isreal2
• Krang._slow_light_intensity_pixel_type
• Krang._θs
• Krang.absGto_Gthat
• Krang.absGθo_Gθhat
• Krang.absGϕo_Gϕhat
• Krang.blackbody
• Krang.boyer_lindquist_to_quasi_cartesian_kerr_schild
• Krang.boyer_lindquist_to_quasi_cartesian_kerr_schild_fast_light
• Krang.emission_azimuth
• Krang.emission_coordinates
• Krang.emission_coordinates_fast_light
• Krang.emission_inclination
• Krang.emission_radius
• Krang.get_radial_roots
• Krang.horizon
• Krang.inclination
• Krang.jac_bl_d_zamo_u
• Krang.jac_bl_u_zamo_d
• Krang.jac_fluid_u_zamo_d
• Krang.jac_zamo_d_bl_u
• Krang.jac_zamo_u_bl_d
• Krang.lightTrait
• Krang.metric
• Krang.metric_dd
• Krang.metric_uu
• Krang.mino_time
• Krang.p_bl_d
• Krang.p_zamo_u
• Krang.penrose_walker
• Krang.r_potential
• Krang.radial_inf_integrals_case2
• Krang.radial_inf_integrals_case3
• Krang.radial_inf_integrals_case4
• Krang.radial_inf_integrals_m_I0_terms
• Krang.radial_integrals
• Krang.radial_w_I0_terms_integrals_case2
• Krang.radial_w_I0_terms_integrals_case3
• Krang.radial_w_I0_terms_integrals_case4
• Krang.regularizedS1
• Krang.regularizedS2
• Krang.regularized_Pi
• Krang.regularized_R1
• Krang.regularized_R2
• Krang.roots
• Krang.screen_coordinate
• Krang.screen_polarization
• Krang.symmetryTrait
• Krang.synchrotronIntensity
• Krang.synchrotronPolarization
• Krang.synchrotron_emission_frame
• Krang.thermalSynchrotronIntensity
• Krang.thermal_synchrotron_shape
• Krang.total_mino_time
• Krang.α
• Krang.αboundary
• Krang.β
• Krang.βboundary
• Krang.η
• Krang.θ_potential
• Krang.λ

Raytracing Functions

Krang.emission_radius Function

emission_radius(
    pix::Krang.AbstractPixel,
    θs,
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Bool}

Emission radius for point originating at inclination θs whose nth order image appears at the screen coordinate (α, β). Returns 0 if the emission coordinates do not exist for that screen coordinate.

Arguments

• pix : Pixel information

• θs : Emission inclination

• isindir : Is emission to observer direct or indirect

• n : Image index

source

emission_radius(
    pix::Krang.AbstractPixel,
    cache::Krang.AngularCache{T},
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Bool}

emission_radius for a sub-image of a cone.

Identical to emission_radius(pix, cache.θs, isindir, n), but it reads Gθs, Gθo and Ĝθ out of the Krang.AngularCache.

Arguments

• pix : Pixel information

• cache : The angular solve for this ray and emission inclination

• isindir : Is emission to observer direct or indirect

• n : Image index

source

emission_radius(
    pix::Krang.AbstractPixel,
    τ
) -> Tuple{Any, Any, Any, Bool}

Emission radius for point originating at at Mino time τ whose image appears at the screen coordinate (α, β). Returns 0 if the emission coordinates do not exist for that screen coordinate.

Arguments

-pix : Pixel information

• τ : Mino time

source

Krang.emission_inclination Function

emission_inclination(
    pix::Krang.AbstractPixel,
    rs,
    νr
) -> NTuple{6, Any}

Emission inclination for a point originating at radius rs whose image appears at screen coordinate (α, β).

Arguments

• pix : Pixel information

• rs : Emission radius

• νr : Sign of radial velocity direction at emission. This is always positive for case 3 and case 4 geodesics.

source

emission_inclination(
    pix::Krang.AbstractPixel,
    τ
) -> NTuple{6, Any}

Emission inclination for point at Mino time τ whose image appears at screen coordinate (α, β).

Arguments

• pix : Pixel information

• τ : Mino Time

source

Krang.emission_coordinates_fast_light Function

emission_coordinates_fast_light(
    pix::Krang.AbstractPixel,
    θs,
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Bool}

Emission radius and azimuthal angle for point originating at inclination θs whose nth order image appears at the screen coordinate (α, β) for an observer located at inclination θo.

Arguments

• pix : Pixel information

• θs : Emission Inclination

• isindir : Whether emission to observer is direct or indirect

• n : Image index

source

emission_coordinates_fast_light(
    pix::Krang.AbstractPixel,
    cache::Krang.AngularCache{T},
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Bool}

emission_coordinates_fast_light for a sub-image of a cone.

Identical to emission_coordinates_fast_light(pix, cache.θs, isindir, n), but it reads Gθs, Gθo and Ĝθ out of the Krang.AngularCache.

Arguments

• pix : Pixel information

• cache : The angular solve for this ray and emission inclination

• isindir : Is emission to observer direct or indirect

• n : Image index

source

emission_coordinates_fast_light(
    pix::Krang.AbstractPixel,
    τ
) -> Tuple{Any, Any, Any, Any, Any, Bool}

Ray trace a point that appears at the screen coordinate (α, β) for an observer located at inclination θo

Arguments

• pix : Pixel information

• τ : Mino Time

source

Krang.emission_coordinates Function

emission_coordinates(
    pix::Krang.AbstractPixel,
    θs,
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Any, Bool}

Emission radius and azimuthal angle for point originating at inclination θs whose nth order image appears at the screen coordinate (α, β) for an observer located at inclination θo.

Arguments

• pix : Pixel information

• θs : Emission Inclination

• isindir : Whether emission to observer is direct or indirect

• n : Image index

source

emission_coordinates(
    pix::Krang.AbstractPixel,
    cache::Krang.AngularCache{T},
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Any, Bool}

emission_coordinates for a sub-image of a cone.

Identical to emission_coordinates(pix, θs, isindir, n), but it reads Gθs, Gθo and Ĝθ out of the Krang.AngularCache.

Arguments

• pix : Pixel information

• cache : The angular solve for this ray and emission inclination

• isindir : Whether emission to observer is direct or indirect

• n : Image index

source

emission_coordinates(
    pix::Krang.AbstractPixel,
    τ
) -> Tuple{Any, Any, Any, Any, Any, Any, Bool}

Ray trace a point that appears at the screen coordinate (α, β) for an observer located at inclination θo

Arguments

• pix : Pixel information

• τ : Mino Time

source

Krang.mino_time Function

mino_time(pix, rs, νr) -> Any

Mino time of trajectory between an observer at infinity and point at radius rs

Arguments

• pix : Pixel information

• rs : Emission radius

• νr : Sign of the radial velocity at emission.

source

mino_time(pix::Krang.AbstractPixel, θs, isindir, n) -> Any

Mino time of trajectory between two inclinations for a given screen coordinate

Arguments

• pix : Pixel information

• θs : Emission inclination

• isindir : Is the path direct or indirect?

• n : nth image in orde of amount of minotime traversed

source

Metric Functions

Krang.AbstractMetric Type

abstract type AbstractMetric

Abstract Metric Type

source

Krang.Kerr Type

struct Kerr{T} <: Krang.AbstractMetric

Kerr Metric in Boyer Lindquist Coordinates

• mass: M = mass

• spin: a = J/M, where J is the angular momentum and M is the mass of the black hole.

source

Krang.metric_uu Function

metric_uu(metric::Krang.AbstractMetric, args...) -> Any

Returns the inverse metric in some representation (usually as an nxn matrix).

source

metric_uu(metric::Kerr{T}, r, θ) -> Any

Inverse Kerr metric in Boyer Lindquist (BL) coordinates.

source

metric_uu(metric::Kerr{T}, coordinates) -> Any

Inverse Kerr metric in Boyer Lindquist (BL) coordinates.

Arguments

• metric : Kerr metric

• coordinates : Coordinates (t, r, θ, ϕ)

source

Krang.metric_dd Function

metric_dd(metric::Krang.AbstractMetric, args...) -> Any

Returns the metric in some representation (usually as an nxn matrix).

source

metric_dd(metric::Kerr{T}, r, θ) -> Any

Kerr metric in Boyer Lindquist (BL) coordinates.

source

metric_dd(metric::Kerr{T}, coordinates) -> Any

Kerr metric in Boyer Lindquist (BL) coordinates.

Arguments

• metric : Kerr metric

• coordinates : Coordinates (t, r, θ, ϕ)

source

Krang.horizon Function

horizon(metric::Kerr{T}) -> Any

Outer Horizon for the Kerr metric.

source

Krang.λ Function

λ(pix::Krang.AbstractPixel) -> Any

λ(pix::AbstractPixel)

Calculate the λ value for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The λ value of the pixel.

source

λ(_::Kerr, α, θo) -> Any

Energy reduced azimuthal angular momentum

Arguments

• metric: Kerr

• α: Horizontal Bardeen screen coordinate

• θo: Observer inclination

source

Krang.η Function

η(pix::Krang.AbstractPixel) -> Any

η(pix::AbstractPixel)

Calculate the η value for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The η value of the pixel.

source

η(metric::Kerr, α, β, θo) -> Any

Energy reduced Carter integral

Arguments

• metric: Kerr

• α: Horizontal Bardeen screen coordinate

• β: Bardeen vertical coordinate

• θo: Observer inclination

source

Radial Integrals

Krang.r_potential Function

r_potential(metric::Kerr, η, λ, r) -> Any

Radial potential of spacetime

Arguments

• metric: Kerr{T} metric

• η : Reduced Carter constant

• λ : Reduced azimuthal angular momentum

• r : Boyer Lindquist radius

source

Krang.get_radial_roots Function

get_radial_roots(metric::Kerr{T}, η, λ) -> NTuple{4, Any}

Returns roots of $r^4+(a^2-\eta -{\lambda }^2)r^2+2(\eta +(a-\lambda {)}^2)r-a^2\eta$

Arguments

• metric: Kerr{T} metric

• η : Reduced Carter constant

• λ : Reduced azimuthal angular momentum

source

Krang.Ir Function

Ir(pix::Krang.AbstractPixel, νr::Bool, rs) -> Any

Returns the antiderivative $I_r=\int \frac{dr}{\sqrt{\mathcal{R}\mathcal{(}\mathcal{r}\mathcal{)}}}$. See r_potential(x) for an implementation of $\mathcal{R}(r)$.

Arguments

• pix : Pixel information

• νr : Sign of radial velocity direction at emission. This is always positive for case 3 and case 4 geodesics.

• rs : Emission radius

source

Angular Integrals

Krang.θ_potential Function

θ_potential(metric::Kerr, η, λ, θ) -> Any

Theta potential of a Kerr black hole

Arguments

• metric: Kerr{T} metric

• η : Reduced Carter constant

• λ : Reduced azimuthal angular momentum

• θ : Boyer Lindquist inclination

source

Krang.Gθ Function

Gθ(
    pix::Krang.AbstractPixel,
    θs,
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Bool, Bool}

Returns the antiderivative $G_{\theta }=\int \frac{d\theta }{\sqrt{\mathrm{\Theta }(\theta )}}$. See θ_potential(x) for an implementation of $\mathrm{\Theta }(heta)$.

Arguments

• pix : Pixel information

• θs : Emission inclination

• isindir : Is the path direct or indirect?

• n : nth image ordered by minotime

source

Krang._Gθ_setup Function

_Gθ_setup(
    met::Kerr,
    θo,
    ηtemp,
    λtemp,
    Go,
    Ghat,
    θs
) -> Tuple{Any, Any, Any, Bool, Any, Bool}

The part of Gθ that does not depend on the sub-image index n.

Returns (Gθs, Gθo, Ĝθ, isvortical, isincone, issuccess), with Gθo carrying the sign the vortical geodesic branch gives it. issuccess is false when the ray never reaches θs.

Arguments

• met : Kerr metric

• θo : Observer inclination

• ηtemp, λtemp : Reduced Carter constant and azimuthal angular momentum

• Go, Ghat : The cached pair from Krang.absGθo_Gθhat

• θs : Emission inclination

source

Krang._Gθ_subimage Function

_Gθ_subimage(
    setup,
    signβ,
    θo,
    θs,
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Any, Bool}

Gθ for one sub-image

source

Krang.Gϕ Function

Gϕ(
    pix::Krang.AbstractPixel,
    θs,
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Any, Bool}

Returns the antiderivative $G_{\varphi }=\int \frac{d\theta }{{\sin }^2\theta \sqrt{\mathrm{\Theta }(\theta )}}$, the azimuthal companion of Gθ. See θ_potential(x) for an implementation of $\mathrm{\Theta }(\theta )$.

Returns (Gϕ, Gs, Go, Ghat, isvortical, issuccess). When both this and Gt are wanted at the same inclination, Krang._Gϕt computes the shared angular setup once.

Arguments

• pix : Pixel information

• θs : Emission inclination

• isindir : Is the path direct or indirect?

• n : nth image ordered by minotime

source

Krang.Gt Function

Gt(
    pix::Krang.AbstractPixel,
    θs,
    isindir,
    n
) -> Tuple{Any, Any, Any, Any, Any, Bool}

Returns the antiderivative $G_t=\int \frac{{\cos }^2\theta d\theta }{\sqrt{\mathrm{\Theta }(\theta )}}$, the time companion of Gθ. See θ_potential(x) for an implementation of $\mathrm{\Theta }(\theta )$.

Returns (Gt, Gs, Go, Ghat, isvortical, issuccess). When both this and Gϕ are wanted at the same inclination, Krang._Gϕt computes the shared angular setup once.

Arguments

• pix : Pixel information

• θs : Emission inclination

• isindir : Is the path direct or indirect?

• n : nth image ordered by minotime

source

Krang._Gϕt Function

_Gϕt(
    pix::Krang.AbstractPixel,
    θs,
    isindir,
    n
) -> Tuple{Any, Any, Bool}

Returns (Gϕ, Gt, issuccess): the ϕ and t angular antiderivatives of Gϕ and Gt for the same emission inclination.

Both share the whole angular setup — η, λ, the turning points up/um, the modulus k and the amplitude asin(args) — and differ only in which elliptic integral they evaluate at that amplitude. The emission_coordinates methods always want both, so computing the setup once avoids doing it twice. Results are bit-identical to calling Gϕ and Gt separately.

source

Krang._θs Function

_θs(
    metric::Kerr{T},
    signβ,
    θo,
    η,
    λ,
    τ,
    Go,
    Ghat
) -> NTuple{6, Any}

_θs(metric, signβ, θo, η, λ, τ, Go, Ghat)

Emission inclination at Mino time τ, with the angular antiderivative pair (Go, Ghat) =_absGθo_Gθhat` supplied by the caller.

source

Krang._absGθo_Gθhat Function

_absGθo_Gθhat(metric::Kerr{T}, θo, η, λ) -> Tuple{Any, Any}

Returns (|Gθo|, Ĝθ): the magnitude of the Gθ antiderivative evaluated at the observer inclination, and the half-period Ĝθ between angular turning points.

Both depend only on the metric, θo, η and λ, so they are constant along a ray and are cached on the pixel – see Krang.absGθo_Gθhat for the accessor. Every sub-image index n reuses the same pair, which is what makes the angular inversion cheap.

source

Screen Coordinates

Krang.α Function

α(_::Kerr, λ, θo) -> Any

Horizontal Bardeen Screen Coordinate

Arguments

• metric: Kerr

• α: Horizontal Bardeen screen coordinate

• θo: Observer inclination

source

Krang.β Function

β(metric::Kerr, λ, η, θo) -> Any

Vertical Bardeen Screen Coordinate

Arguments

• metric: Kerr

• λ: Energy-reduced azimuthal angular momentum

• η: Energy reduced Carter integral

• θo: Observer inclination

source

Krang.αboundary Function

αboundary(metric::Kerr, θs) -> Any

Defines a horizontal boundary on the assymptotic observer's screen that emission that from θs must fall within.

Arguments

• metric: Kerr metric

• θs : Emission Inclination

source

Krang.βboundary Function

βboundary(metric::Kerr, α, θo, θs) -> Any

Defines a vertical boundary on the assymptotic observer's screen that emission that from θs must fall within.

Arguments

• metric: Kerr{T} metric

• α : Horizontal Bardeen screen coordinate

• θo : Observer inclination

• θs : Emission Inclination

source

Local Frame transformations

Krang.p_bl_d Function

p_bl_d(
    metric::Kerr{T},
    r,
    θ,
    η,
    λ,
    νr::Bool,
    νθ::Bool
) -> Any

Returns the momentum form in the Boyer-Lindquist basis.

source

Krang.jac_bl_u_zamo_d Function

jac_bl_u_zamo_d(metric::Kerr{T}, r, θ) -> Any

Returns the tetrad that takes the ZAMO vector to the Boyer-Lindquist basis.

The tetrad is:

    √(A/(ΣΔ))    0        0             0
    0            √(Δ/Σ)   0             0
    0            0        0            -1/√Σ
    2ar/√(ΣΔA)   0        √(Σ/A)csc(θ)  0

source

jac_bl_u_zamo_d(metric::Kerr{T}, r, θ, v_u) -> Any

Returns the ZAMO vector in the Boyer-Lindquist basis.

Applies the tetrad above without forming it.

source

Krang.jac_zamo_u_bl_d Function

jac_zamo_u_bl_d(metric::Kerr{T}, r, θ) -> Any

Returns the tetrad that transforms the Boyer-Lindquist vector to the ZAMO basis.

The tetrad is (Eq 3.2 1972ApJ...178..347B):

    √((ΣΔ)/A)           0        0    0
    0                   √(Σ/Δ)   0    0
    -(2ar sin(θ))/√(AΣ) 0        0    √(A/Σ)sin(θ)
    0                   0       -√Σ   0

source

jac_zamo_u_bl_d(metric::Kerr{T}, r, θ, v_u) -> Any

Transforms the Boyer-Lindquist vector to the ZAMO basis.

Applies the tetrad above without forming it.

source

Krang.jac_bl_d_zamo_u Function

jac_bl_d_zamo_u(metric::Kerr{T}, r, θ) -> Any

Returns the tetrad that takes the ZAMO covector to the Boyer-Lindquist basis.

The tetrad is:

    √((ΣΔ)/A)   0        -2ar sin(θ)/√(AΣ)   0
    0           √(Σ/Δ)    0                  0
    0           0         0                 -√Σ
    0           0         √(A/Σ)sin(θ)       0

source

jac_bl_d_zamo_u(metric::Kerr{T}, r, θ, v_d) -> Any

Returns the ZAMO covector in the Boyer-Lindquist basis.

Applies the tetrad above without forming it.

source

Krang.jac_zamo_d_bl_u Function

jac_zamo_d_bl_u(metric::Kerr{T}, r, θ) -> Any

Returns the tetrad that transforms the Boyer-Lindquist covector to the ZAMO basis.

The tetrad is (Eq 3.1 1972ApJ...178..347B):

    √(A/(ΣΔ))   0        0        2ar/√(AΔΣ)
    0           √(Δ/Σ)   0        0
    0           0        0        √(Σ/A)csc(θ)
    0           0       -1/√Σ     0

source

jac_zamo_d_bl_u(metric::Kerr{T}, r, θ, v_d) -> Any

Transforms the Boyer-Lindquist covector to the ZAMO basis.

Applies the tetrad above without forming it.

source

Krang.jac_fluid_u_zamo_d Function

jac_fluid_u_zamo_d(_::Kerr{T}, β, θ, φ) -> Any

Returns the Jacobian that takes the ZAMO vector into the frame of a fluid moving with speed β along the direction (θ, φ). Pass -β for the inverse boost.

The Jacobian is:

    γ            -βγcosφsinθ                   -βγsinφsinθ                -βγcosθ
    -βγcosφsinθ  cos²θcos²φ+γcos²φsin²θ+sin²φ  (γ-1)cosφsin²θsinφ         (γ-1)cosθcosφsinθ
    -βγsinθsinφ  (γ-1)cosφsin²θsinφ            cos²φ+(cos²θ+γsin²θ)sin²φ  (γ-1)cosθsinθsinφ
    -βγcosθ      (γ-1)cosθcosφsinθ             (γ-1)cosθsinθsinφ          γcos²θ+sin²θ

source

jac_fluid_u_zamo_d(_::Kerr{T}, β, θ, φ, v_u) -> Any

Returns the ZAMO vector in the frame of a fluid moving with speed β along the direction (θ, φ). Pass -β for the inverse boost.

Applies the Jacobian above without forming it. Its spatial block is δᵢⱼ + (γ-1)n̂ᵢn̂ⱼ for n̂ = (sin(θ)cos(φ), sin(θ)sin(φ), cos(θ)), so the product is the boost γ(vᵗ - β n̂⋅v⃗), v⃗ + ((γ-1)n̂⋅v⃗ - γβvᵗ)n̂.

source

Krang.p_zamo_u Function

p_zamo_u(
    metric::Kerr{T},
    r,
    θ,
    η,
    λ,
    νr::Bool,
    νθ::Bool
) -> Any

Returns the photon momentum in the ZAMO basis.

Composes p_bl_d, metric_uu and jac_zamo_u_bl_d. The frame-dragging term the metric puts into p^ϕ is the one the tetrad subtracts off again, so the composition is:

    p^t̂ = (1 - ωλ)/α
    p^r̂ = ±√R/√(ΣΔ)
    p^ϕ̂ = λ/ϖ
    p^θ̂ = ∓√Θ/√Σ

with lapse α = √(ΣΔ/A), frame-dragging rate ω = 2ar/A and cylindrical radius ϖ = sin(θ)√(A/Σ).

source

Polarization

Krang.screen_polarization Function

screen_polarization(
    metric::Kerr{T},
    κ::Complex,
    θ,
    α,
    β
) -> Tuple{Any, Any}

Returns the screen polarization associated with a killing spinor κ as seen seen by an asymptotic observer.

source

Krang.penrose_walker Function

penrose_walker(
    metric::Kerr{T},
    r,
    θ,
    p_u::AbstractVector,
    f_u::AbstractVector
) -> Tuple{Any, Any}

Returns the Penrose walker constant for a photon with momentum p_u emitted from a fluid particle with momentum f_u.

source

Krang.synchrotronIntensity Function

synchrotronIntensity(
    metric::Kerr{T},
    α,
    β,
    ri,
    θs,
    θo,
    magnetic_field::StaticArraysCore.SArray{Tuple{3}, T, 1, 3},
    βfluid::StaticArraysCore.SArray{Tuple{3}, T, 1, 3},
    νr::Bool,
    θsign::Bool
) -> Tuple{Any, Any, Any}

Calculates the intensity of a photon emitted from a fluid particle with momentum f_u and observed by an asymptotic observer.

source

Krang.synchrotronPolarization Function

synchrotronPolarization(
    metric::Kerr{T},
    α,
    β,
    ri,
    θs,
    θo,
    magnetic_field::StaticArraysCore.SArray{Tuple{3}, T, 1, 3},
    βfluid::StaticArraysCore.SArray{Tuple{3}, T, 1, 3},
    νr::Bool,
    θsign::Bool
) -> NTuple{4, Any}

Calculates the polarization of a photon emitted from a fluid particle with momentum f_u and observed by an asymptotic observer.

source

Krang.synchrotron_emission_frame Function

synchrotron_emission_frame(
    metric::Kerr{T},
    α,
    β,
    ri,
    θs,
    θo,
    magnetic_field::StaticArraysCore.SArray{Tuple{3}, T, 1, 3},
    βfluid::StaticArraysCore.SArray{Tuple{3}, T, 1, 3},
    νr::Bool,
    θsign::Bool
) -> NTuple{4, Any}

Returns the photon momentum and synchrotron emission vector in the fluid frame, shared by Krang.synchrotronIntensity and Krang.synchrotronPolarization.

Returns (p_zamo_u, p_fluid_u, vec, norm), where vec = p̂_fluid × B and norm = |vec| + eps(T).

source

Krang.thermalSynchrotronIntensity Function

thermalSynchrotronIntensity(
    metric::Kerr{T},
    α,
    β,
    ri,
    θs,
    θo,
    magnetic_field::StaticArraysCore.SArray{Tuple{3}, T, 1, 3},
    βfluid::StaticArraysCore.SArray{Tuple{3}, T, 1, 3},
    νr::Bool,
    θsign::Bool,
    ν,
    n_th,
    temperature,
    rg
) -> Tuple{Any, Any}

Emissivity, source function and optical depth of a Krang.ThermalSynchrotron slab at the emission point of a ray.

Returns (g³Bν, τ) in SI units: the source function redshifted to the observer, and the optical depth of the slab. The emissivity carries an extra factor of c, which is what makes τ = jν/Bν * ℓ/c dimensionless.

Arguments

• metric : Kerr metric

• α, β : Bardeen screen coordinates

• ri, θs : Emission radius and inclination

• θo : Observer inclination

• magnetic_field : Magnetic field at the emission radius, in Gauss

• βfluid : Fluid velocity (speed, inclination, azimuth)

• νr, θsign : Signs of the radial and polar momenta at emission

• ν : Observed frequency, in Hz

• n_th : Number density at the emission radius, in m⁻³

• temperature : Electron temperature at the emission radius, in K

• rg : Gravitational radius GM/c², in metres

source

Krang.thermal_synchrotron_shape Function

thermal_synchrotron_shape(x) -> Any

Analytic approximation to the thermal synchrotron integral, eq. A18 of Dexter (2016); the fit is originally that of Mahadevan, Narayan & Yi (1996), who quote a maximum error of 0.0036. It stands in for $R(x)={\int }_x^{\mathrm{\infty }}{K}_{5/3}(\xi )d\xi$ and holds for x > 1.

$$I(x)=2.5651(1+1.92x^{-1/3}+0.9977x^{-2/3})\exp (-1.8899x^{1/3})$$

Arguments

• x : Frequency in units of the critical frequency, ν/ν_c

source

Krang.blackbody Function

blackbody(ν, temperature) -> Any

Planck function $B_{\nu }$ in SI units (W m⁻² Hz⁻¹ sr⁻¹).

Arguments

• ν : Frequency in Hz

• temperature : Temperature in K

source

Meshes, Geometries and Materials

Krang.Mesh Type

struct Mesh{G<:Krang.AbstractGeometry, M<:Krang.AbstractMaterial}

Pairs an AbstractGeometry with the AbstractMaterial that emits on it. A Scene is a tuple of these, and rendering sums each mesh's contribution to every pixel.

source

Krang.MeshGeometry Type

MeshGeometry(mesh::GeometryBasics.Mesh)

Wrap a GeometryBasics.Mesh for ray tracing.

source

Krang.AbstractLevelSetGeometry Type

AbstractLevelSetGeometry{T}

Abstract geometry represented by a functor geometry(x, y, z) whose zero set defines a surface in quasi-Cartesian Kerr-Schild coordinates.

source

Krang.ElectronSynchrotronPowerLawIntensity Type

struct ElectronSynchrotronPowerLawIntensity{N, T} <: Krang.AbstractMaterial

A struct representing the linear polarization intensity of synchrotron radiation from electrons following a power-law energy distribution. This model is based on the material described in https://doi.org/10.3847/1538-4357/abf117.

Fields

- `magnetic_field::SVector{3, T}`: The magnetic field vector components (x, y, z).
- `fluid_velocity::SVector{3, T}`: The fluid velocity vector components (speed, inclination angle, azimuthal angle).
- `spectral_index::T`: The spectral index of the electron energy distribution.
- `R::T`: The characteristic radius of the emissivity profile.
- `p1::T`: The first power-law index.
- `p2::T`: The second power-law index.
- `subimgs::NTuple{N, Int}`: The sub-images to ray trace.

source

Krang.ElectronSynchrotronPowerLawPolarization Type

struct ElectronSynchrotronPowerLawPolarization{N, T} <: Krang.AbstractMaterial

A struct representing the linear polarization of synchrotron radiation from electrons following a power-law energy distribution. This model is based on the material described in https://doi.org/10.3847/1538-4357/abf117.

Fields

- `magnetic_field::SVector{3, T}`: The magnetic field vector components (x, y, z).
- `fluid_velocity::SVector{3, T}`: The fluid velocity vector components (speed, inclination angle, azimuthal angle).
- `spectral_index::T`: The spectral index of the electron energy distribution.
- `R::T`: The characteristic radius of the emissivity profile.
- `p1::T`: The first power-law index.
- `p2::T`: The second power-law index.
- `subimgs::NTuple{N, Int}`: The sub-images to ray trace.

source

Krang.ThermalSynchrotron Type

struct ThermalSynchrotron{N, T} <: Krang.AbstractMaterial

A synchrotron emitting disk of thermal (Maxwell-Jüttner) electrons whose density, temperature and magnetic field each follow a power law in radius. Emission is absorbed on its way out, so the material returns a Krang.AbsorptiveIntensity and render performs the radiative transfer across sub-images.

Follows the model of Desire, Cárdenas-Avendaño & Chael (2025) (their eqs. 13-14), with the thermal synchrotron integral replaced by the Krang.thermal_synchrotron_shape approximation,

$$j_{\nu }=\frac{k_e{n}_{th}{q}_e^2\nu }{2\sqrt{3}{\Theta }_e^2}I(\nu /{\nu }_c),{\nu }_c=\frac{3}{4\pi }\frac{q_{e}B\sin {\theta }_b}{m_e}{\Theta }_e^2,{\Theta }_e=\frac{k_B{T}_e}{m_e{c}^2},$$

with absorption set by Kirchhoff's law, ${\alpha }_{\nu }=j_{\nu }/B_{\nu }$, and an optical depth $\tau ={\alpha }_{\nu }\ell /c$. The ray crosses a shell of angular thickness $\Delta \theta =1/2$ about the emitting 2D surface, so $\ell =(r_s{r}_g/2){\ell }_p$ with ${\ell }_p=|p^{\hat{t}}/p^{\hat{\theta }}|$, the obliquity of the ray to the surface normal $\hat{\theta }$. This quantity diverges for a ray traveling parallel to the emitting surface. Note the proper thickness is $\sqrt{g_{\theta \theta }}\Delta \theta =\sqrt{r_s^2+a^2{\cos }^2{\theta }_s}\Delta \theta$ to first order in $\Delta \theta$, so taking it to be $r_s{r}_g\Delta \theta$ is exact only for the equatorial disk; the depth through a cone is underestimated by $\sqrt{1+a^2{\cos }^2{\theta }_s/r_s^2}$, which reaches a few per cent close to the horizon.

The emissivity is evaluated at the observed frequency and the result is redshifted by $g^3$.

Radii are in gravitational radii and rg is specified in metres. Every other quantity is SI except for the magnetic field, which is in Gauss.

Fields

- `magnetic_field::SVector{3, T}`: Magnetic field vector `(x, y, z)` at `rb`, in Gauss.
- `fluid_velocity::SVector{3, T}`: Fluid velocity `(speed, inclination, azimuth)`.
- `p_dens::T`: Power-law index of the number density.
- `p_temp::T`: Power-law index of the electron temperature.
- `p_b::T`: Power-law index of the magnetic field magnitude.
- `n_th0::T`: Number density at `rb`, in m⁻³.
- `t_e0::T`: Electron temperature at `rb`, in K.
- `rb::T`: Reference radius, in gravitational radii.
- `ν::T`: Observed frequency, in Hz.
- `rg::T`: Gravitational radius `GM/c²`, in metres.
- `subimgs::NTuple{N, Int}`: The sub-images to ray trace.

source

Material Traits

These pick the emission-coordinate call a material needs; see examples/custom-material-example.jl for how a custom material sets them.

Krang.AbstractLightTrait Type

abstract type AbstractLightTrait

Trait that selects whether a material needs the coordinate time of emission. SlowLightTrait materials get the full ts from emission_coordinates; FastLightTrait materials skip it, and ts is reported as zero.

source

Krang.FastLightTrait Type

struct FastLightTrait <: Krang.AbstractLightTrait

Material does not use the emission time, so the time integrals are skipped.

source

Krang.SlowLightTrait Type

struct SlowLightTrait <: Krang.AbstractLightTrait

Material depends on the emission time, so ts is computed.

source

Krang.lightTrait Function

lightTrait(
    _::Krang.AbstractMaterial
) -> Krang.FastLightTrait

lightTrait(material::AbstractMaterial)

Return the AbstractLightTrait of material. Defaults to SlowLightTrait; materials that do not need the emission time should define

Krang.lightTrait(::MyMaterial) = Krang.FastLightTrait()

source

Krang.AbstractSymmetryTrait Type

abstract type AbstractSymmetryTrait

Trait that selects which emission-coordinate call a material needs. Materials whose emissivity does not depend on the emission azimuth ϕs are AxisymmetricTrait and only need the (cheaper) emission radius; everything else is NonAxisymmetricTrait.

source

Krang.AxisymmetricTrait Type

struct AxisymmetricTrait <: Krang.AbstractSymmetryTrait

Material is axisymmetric: ϕs is not needed, so only the emission radius is computed.

source

Krang.NonAxisymmetricTrait Type

struct NonAxisymmetricTrait <: Krang.AbstractSymmetryTrait

Material depends on the emission azimuth, so related quantities are computed.

source

Krang.symmetryTrait Function

symmetryTrait(
    _::Krang.AbstractMaterial
) -> Krang.AxisymmetricTrait

symmetryTrait(material::AbstractMaterial)

Return the AbstractSymmetryTrait of material. Defaults to NonAxisymmetricTrait; axisymmetric materials should define

Krang.symmetryTrait(::MyMaterial) = Krang.AxisymmetricTrait()

source

Krang.AbsorptiveIntensity Type

struct AbsorptiveIntensity{T}

An intensity carried along a ray together with the optical depth accumulated with it.

Fields

• I::Any: Intensity accumulated so far

• τ::Any: Optical depth accumulated so far

source

Krang._accumulate Function

_accumulate(
    observation,
    contribution
) -> Krang.AbsorptiveIntensity

_accumulate(observation, contribution)

Add contribution to what a ray has already picked up.

    I += exp(-τ) * I_new
    τ += τ_new

source

Krang._intersection Function

_intersection(
    _::Krang.FastLightTrait,
    _::Krang.AxisymmetricTrait,
    pix,
    θs,
    isindir,
    n
) -> Tuple{Krang.Intersection, Bool}

_intersection(::AbstractLightTrait, ::AbstractSymmetryTrait, pix, θs, isindir, n)
_intersection(::AbstractLightTrait, ::AbstractSymmetryTrait, pix, cache::AngularCache, isindir, n)

Emission coordinates on the θs cone, dispatching on the material's AbstractLightTrait and AbstractSymmetryTrait. Fast-light materials skip the emission time and axisymmetric ones also skip the emission azimuth; skipped coordinates are reported as zero. The second form takes the sub-image independent part of the angular solve from a Krang.AngularCache rather than recomputing it.

source

Krang.AngularCache Type

struct AngularCache{T}

The angular solve of a ray that is shared by all sub-images at a given θs.

Fields

• θs::Any: Emission inclination this cache was built for

• Gθs::Any: The θs angular antiderivative

• Gθo::Any: |Gθo|, carrying the sign the vortical branch gives it

• Gθhat::Any: Half period Ĝθ between angular turning points

• isvortical::Bool: Whether the ray is vortical (η < 0)

• isincone::Bool: |cos θs| < |cos θo|, the test Gθ branches on

• βreject::Bool: Whether the screen boundary rejects this ray; only computed for a θs outside the observer's cone, the one case a caller reads it

• issuccess::Bool: Whether the ray reaches θs at all

source

Pixel Related Functions

Krang.absGθo_Gθhat Function

absGθo_Gθhat(
    pix::Krang.AbstractPixel
) -> Tuple{T6, T6} where T6

absGθo_Gθhat(pix::AbstractPixel)

Calculate the pair (|Gθo|, Gθhat) for a given pixel: the angular antiderivative at the observer, and the same antiderivative over a half orbit. The two names are the two returned quantities, not a quotient.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The 2-tuple (|Gθo|, Gθhat) of the pixel.

source

Krang.I1_inf_m_I0_terms Function

I1_inf_m_I0_terms(pix::Krang.AbstractPixel) -> Any

I1_inf_m_I0_terms(pix::AbstractPixel)

Calculate the I1 infinity minus I0 terms for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The I1 infinity minus I0 terms of the pixel.

source

Krang.radial_inf_integrals_m_I0_terms Function

radial_inf_integrals_m_I0_terms(
    pix::Krang.AbstractPixel
) -> NTuple{4, Any}

radial_inf_integrals_m_I0_terms(pix::AbstractPixel)

Calculate the radial infinity minus I0 terms for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The radial infinity minus I0 terms of the pixel.

source

Krang.inclination Function

inclination(pix::Krang.AbstractPixel) -> Any

inclination(pix::AbstractPixel)

Get the inclination angle (θo) of a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The inclination angle (θo) of the pixel.

source

Krang.metric Function

metric(pix::Krang.AbstractPixel) -> Any

metric(pix::AbstractPixel)

Get the space time metric.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The space time metric

source

Krang.absGto_Gthat Function

absGto_Gthat(
    pix::Krang.AbstractPixel
) -> Tuple{T14, T14} where T14

absGto_Gthat(pix::AbstractPixel)

Calculate the pair (|Gto|, Gthat) for a given pixel: the angular antiderivative at the observer, and the same antiderivative over a half orbit. The two names are the two returned quantities, not a quotient.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The 2-tuple (|Gto|, Gthat) of the pixel.

source

Krang.screen_coordinate Function

screen_coordinate(
    pix::Krang.AbstractPixel
) -> Tuple{T2, T2} where T2

screen_coordinate(pix::AbstractPixel)

Get the screen coordinates of a given pixel.

Arguments

• pix::AbstractPixel: The pixel for which to get the screen coordinates.

Returns

• The screen coordinates of the pixel.

source

Krang.Ip_inf_m_I0_terms Function

Ip_inf_m_I0_terms(pix::Krang.AbstractPixel) -> Any

Ip_inf_m_I0_terms(pix::AbstractPixel)

Calculate the Ip infinity minus I0 terms for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The Ip infinity minus I0 terms of the pixel.

source

Krang.I2_inf_m_I0_terms Function

I2_inf_m_I0_terms(pix::Krang.AbstractPixel) -> Any

I2_inf_m_I0_terms(pix::AbstractPixel)

Calculate the I2 infinity minus I0 terms for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The I2 infinity minus I0 terms of the pixel.

source

Krang.roots Function

roots(pix::Krang.AbstractPixel) -> NTuple{4, T3} where T3

roots(pix::AbstractPixel)

Calculate the radial roots for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The radial roots of the pixel.

source

Krang.Im_inf_m_I0_terms Function

Im_inf_m_I0_terms(pix::Krang.AbstractPixel) -> Any

Im_inf_m_I0_terms(pix::AbstractPixel)

Calculate the Im infinity minus I0 terms for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The Im infinity minus I0 terms of the pixel.

source

Krang.absGϕo_Gϕhat Function

absGϕo_Gϕhat(
    pix::Krang.AbstractPixel
) -> Tuple{T13, T13} where T13

absGϕo_Gϕhat(pix::AbstractPixel)

Calculate the pair (|Gϕo|, Gϕhat) for a given pixel: the angular antiderivative at the observer, and the same antiderivative over a half orbit. The two names are the two returned quantities, not a quotient.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The 2-tuple (|Gϕo|, Gϕhat) of the pixel.

source

Krang.I0_inf Function

I0_inf(pix::Krang.AbstractPixel) -> Any

I0_inf(pix::AbstractPixel)

Calculate the I0 infinity value for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The I0 infinity value of the pixel.

source

Krang.total_mino_time Function

total_mino_time(pix::Krang.AbstractPixel) -> Any

total_mino_time(pix::AbstractPixel)

Return the total possible Mino time for a ray associated with a pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The total possible Mino time for a ray associated with the pixel.

source

total_mino_time(
    metric::Kerr{T},
    roots::NTuple{4, T} where T
) -> Any

Returns the maximum mino time that can be accrued along a ray.

Arguments

• metric : Kerr metric

• roots : Roots of the radial potential

source

Misc

Krang._isreal2 Function

_isreal2(num) -> Any

Checks if a complex number is real to within √eps of its own magnitude (or √eps absolute, whichever is larger).

source

Krang.regularized_Pi Function

regularized_Pi(n, ϕ, k) -> Any

Regularized elliptic integral of the third kind

Arguments

• n: Parameter

• ϕ: Arguments

• k: Parameter

source

regularized_Pi(n, ϕ, k, Fϕ) -> Any

regularized_Pi with F(ϕ|k) supplied by the caller.

Inside one radial-integral case every elliptic integral is evaluated at the same amplitude and modulus, so F(ϕ, k) comes up several times with identical arguments — five times in case 4, twice in case 3. Threading the value through computes it once. The _*_at_F variants below exist for the same reason.

source

Krang.radial_inf_integrals_case4 Function

radial_inf_integrals_case4(
    metric::Kerr{T},
    roots::NTuple{4, T} where T
) -> NTuple{4, Any}

Returns the radial integrals for the case where there are no real roots in the radial potential

source

Krang.It_w_I0_terms Function

It_w_I0_terms(
    metric::Kerr{T},
    rs,
    τ,
    roots::NTuple{4, T} where T,
    λ,
    νr
) -> Any

Returns the antiderivative $I_t=\int \frac{r^2\mathrm{\Delta }+2Mr(r^2+a^2-a\lambda )}{\sqrt{\mathrm{\Delta }\mathcal{R}\mathcal{(}\mathcal{r}\mathcal{)}}}dr$ with I0 terms.

See r_potential(x) for an implementation of $\mathcal{R}(r)$.

Arguments

• metric: Kerr{T} metric

• roots : Radial roots

• λ : Reduced azimuthal angular momentum

• νr : Radial emission direction (Only necessary for case 1&2 geodesics)

source

Krang.Ir_inf Function

Ir_inf(pix::Krang.AbstractPixel) -> Any

Ir_inf(pix::AbstractPixel)

Calculate the Ir infinity value for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The Ir infinity value of the pixel.

source

Ir_inf(metric::Kerr{T}, roots) -> Any

Returns the antiderivative $I_r=\int \frac{dr}{\sqrt{\mathcal{R}\mathcal{(}\mathcal{r}\mathcal{)}}}$ evaluated at infinity. See r_potential(x) for an implementation of $\mathcal{R}(r)$.

Arguments

• metric: Kerr{T} metric

• roots : Roots of the radial potential

source

Krang.emission_azimuth Function

emission_azimuth(
    pix::Krang.AbstractPixel,
    θs,
    rs,
    τ,
    νr,
    isindir,
    n
) -> Any

Emission azimuth for point at Mino time τ whose image appears at screen coordinate (α, β).

Arguments

• pix : Pixel information

• θs : Emission Inclination

• rs :Emission radius

• τ : Mino Time

• νr : Sign of radial velocity direction at emission. This is always positive for case 3 and case 4 geodesics.

source

emission_azimuth(
    pix::Krang.AbstractPixel,
    rs,
    τ,
    νr,
    Gϕtemp
) -> Any

Emission azimuth from an already-computed Gϕ.

For callers that already hold Gϕ and would otherwise pay for a second pass through Gϕ, which redoes the whole angular setup.

Arguments

• pix : Pixel information

• rs : Emission radius

• τ : Mino Time

• νr : Sign of radial velocity direction at emission. This is always positive for case 3 and case 4 geodesics.

• Gϕtemp : The ϕ angular antiderivative for this emission inclination

source

Krang._emission_coordinates Function

_emission_coordinates(
    pix::Krang.AbstractPixel,
    θs,
    τ,
    isindir,
    n,
    isincone
) -> Tuple{Any, Any, Any, Any, Any, Bool}

The radial inversion and the t and ϕ integrals of emission_coordinates, once the Mino time of the sub-image is known. Shared by its cached and uncached entry points.

Arguments

• pix : Pixel information

• θs : Emission Inclination

• τ : Mino time of the sub-image

• isindir : Whether emission to observer is direct or indirect

• n : Image index

• isincone : Whether |cos θs| < |cos θo|

source

Krang.ConeGeometry Type

struct ConeGeometry{T, A} <: Krang.AbstractGeometry

Cone Geometry with half opening angle opening_angle.

source

Krang.Iϕ Function

Iϕ(pix::Krang.AbstractPixel, rs, τ, νr) -> Any

Returns the antiderivative $I_{\varphi }=\int \frac{a(2Mr-a\lambda )}{\mathrm{\Delta }\sqrt{\mathcal{R}(r)}}dr$. See r_potential(x) for an implementation of $\mathcal{R}(r)$.

Arguments

• pix: SlowLightIntensityPixel

• rs : Emission radius

• τ : Mino time

• νr : Sign of radial velocity direction at emission. This is always positive for case 3 and case 4 geodesics.

source

Krang.SlowLightIntensityCamera Type

struct SlowLightIntensityCamera{S<:Krang.SlowLightIntensityScreen} <: Krang.AbstractCamera

Camera that caches slow light raytracing information for an observer sitting at radial infinity. The frame of this observer is alligned with the Boyer-Lindquist frame.

source

Krang.Iϕ_w_I0_terms Function

Iϕ_w_I0_terms(metric::Kerr{T}, rs, τ, roots, νr, λ) -> Any

Returns the antiderivative $I_{\varphi }=\int \frac{a(2Mr-a\lambda )}{\sqrt{\mathrm{\Delta }\mathcal{R}\mathcal{(}\mathcal{r}\mathcal{)}}}dr$ with full I0 terms.

See r_potential(x) for an implementation of $\mathcal{R}(r)$.

Arguments

• metric: Kerr{T} metric

• τ: Minotime

• roots : Radial roots

• νr : Radial emission direction (Only necessary for case 1&2 geodesics)

• λ : Reduced azimuthal angular momentum

source

Krang.SlowLightIntensityPixel Type

struct SlowLightIntensityPixel{T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17} <: Krang.AbstractPixel

Slow Light Intensity Pixel Type. Each Pixel is associated with a single ray, and caches some information about the ray. On top of what an IntensityPixel caches, a slow light pixel also caches the antiderivatives needed to recover the azimuthal angle and the coordinate time of emission.

source

Krang.Iϕ_inf Function

Iϕ_inf(pix::Krang.AbstractPixel) -> Any

Iϕ_inf(pix::AbstractPixel)

Calculate the Iϕ infinity terms for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The Iϕ infinity terms of the pixel.

source

Iϕ_inf(metric::Kerr{T}, roots, λ) -> Any

Returns the antiderivative $I_{\varphi }=\int \frac{a(2Mr-a\lambda )}{\sqrt{\mathrm{\Delta }\mathcal{R}\mathcal{(}\mathcal{r}\mathcal{)}}}dr$ evaluated at infinity without I0 terms.

See r_potential(x) for an implementation of $\mathcal{R}(r)$.

Arguments

• metric: Kerr{T} metric

• roots : Radial roots

• λ : Reduced azimuthal angular momentum

source

Krang.radial_inf_integrals_case3 Function

radial_inf_integrals_case3(
    metric::Kerr{T},
    roots::NTuple{4, T} where T
) -> NTuple{4, Any}

Returns the radial integrals for the case where there are two real roots in the radial potential

source

Krang.AbstractPixel Type

abstract type AbstractPixel

Abstract Pixel Type

source

Krang.radial_w_I0_terms_integrals_case2 Function

radial_w_I0_terms_integrals_case2(
    metric::Kerr{T},
    rs,
    roots::NTuple{4, T} where T,
    τ,
    νr
) -> Tuple

Returns the radial integrals for the case where there are four real roots in the radial potential, with roots outside the horizon.

source

Krang.SlowLightIntensityScreen Type

struct SlowLightIntensityScreen{T, M<:AbstractArray{T, 2}, MC<:AbstractArray{Complex{T}, 2}} <: Krang.AbstractScreen

Screen of slow-light pixels, stored as a struct of arrays: one array per cached geodesic invariant rather than one SlowLightIntensityPixel per screen position.

metric and the inclination θo are constant across the screen, so they are held once here instead of being duplicated into every pixel. SlowLightIntensityPixel is lazily constructed when screen.pixels is indexed. This layout is what allows the cached invariants to cross a Reactant.@compile boundary as data.

source

Krang.radial_w_I0_terms_integrals_case4 Function

radial_w_I0_terms_integrals_case4(
    metric::Kerr{T},
    rs,
    roots::NTuple{4, T} where T,
    τ
) -> NTuple{4, Any}

Returns the radial integrals for the case where there are no real roots in the radial potential

source

Krang.radial_integrals Function

radial_integrals(
    pix::Krang.AbstractPixel,
    rs,
    τ,
    νr
) -> NTuple{5, Any}

Return the radial integrals

• pix: SlowLightIntensityPixel

• rs : Emission radius

• τ : Mino time

• νr : Sign of radial velocity direction at emission. This is always positive for case 3 and case 4 geodesics.

source

Krang.AbstractCamera Type

abstract type AbstractCamera

Abstract Observer Type

source

Krang.IntensityScreen Type

struct IntensityScreen{T, M<:AbstractArray{T, 2}, MC<:AbstractArray{Complex{T}, 2}} <: Krang.AbstractScreen

Screen of fast-light pixels, stored as a struct of arrays: one array per cached geodesic invariant rather than one IntensityPixel per screen position.

metric and the inclination θo are constant across the screen, so they are held once here instead of being duplicated into every pixel. IntensityPixel is lazily constructed when screen.pixels is indexed. This layout is what allows the cached invariants to cross a Reactant.@compile boundary as data.

source

Krang.It Function

It(pix::Krang.AbstractPixel, rs, τ, νr) -> Any

Returns the antiderivative $I_t=\int \frac{r^2\mathrm{\Delta }+2Mr(r^2+a^2-a\lambda )}{\mathrm{\Delta }\sqrt{\mathcal{R}(r)}}dr$. See r_potential(x) for an implementation of $\mathcal{R}(r)$.

Arguments

• pix: SlowLightIntensityPixel

• rs : Emission radius

• τ : Mino time

• νr : Sign of radial velocity direction at emission. This is always positive for case 3 and case 4 geodesics.

source

Krang.IntensityPixel Type

struct IntensityPixel{T1, T2, T3, T4, T5, T6, T7, T8, T9} <: Krang.AbstractPixel

Intensity Pixel Type. Each Pixel is associated with a single ray, and caches some information about the ray.

source

Krang.AbstractMaterial Type

abstract type AbstractMaterial

Abstract Material

source

Krang.AbstractScreen Type

abstract type AbstractScreen

Abstract Screen Type

source

Krang.radial_w_I0_terms_integrals_case3 Function

radial_w_I0_terms_integrals_case3(
    metric::Kerr{T},
    rs,
    roots::NTuple{4, T} where T,
    τ
) -> NTuple{4, Any}

Returns the radial integrals for the case where there are two real roots in the radial potential

source

Krang.IntensityCamera Type

struct IntensityCamera{S<:Krang.IntensityScreen} <: Krang.AbstractCamera

Camera that caches fast light raytracing information for an observer sitting at radial infinity. The frame of this observer is alligned with the Boyer-Lindquist frame.

source

Krang.Ir_s Function

Ir_s(metric::Kerr{T}, rs, roots, νr) -> Any

Returns the antiderivative $I_r=\int \frac{dr}{\sqrt{\mathcal{R}\mathcal{(}\mathcal{r}\mathcal{)}}}$. See r_potential(x) for an implementation of $\mathcal{R}(r)$.

Arguments

• metric: Kerr{T} metric

• rs : Emission radius

• roots : Roots of the radial potential

• νr : Radial emission direction (Only necessary for case 1&2 geodesics)

source

Krang.AbstractGeometry Type

abstract type AbstractGeometry

Abstract Geometry

source

Krang.radial_inf_integrals_case2 Function

radial_inf_integrals_case2(
    metric::Kerr{T},
    roots::NTuple{4, T} where T
) -> NTuple{4, Any}

Returns the radial integrals for the case where there are four real roots in the radial potential, with roots outside the horizon.

source

Krang.It_inf Function

It_inf(pix::Krang.AbstractPixel) -> Any

It_inf(pix::AbstractPixel)

Calculate the It infinity terms for a given pixel.

Arguments

• pix::AbstractPixel: The pixel of a screen.

Returns

• The It infinity terms of the pixel.

source

It_inf(
    metric::Kerr{T},
    roots::NTuple{4, T} where T,
    λ
) -> Any

Returns the antiderivative $I_t=\int \frac{r^2\mathrm{\Delta }+2Mr(r^2+a^2-a\lambda )}{\sqrt{\mathrm{\Delta }\mathcal{R}\mathcal{(}\mathcal{r}\mathcal{)}}}dr$ evaluated at infinity without I0 terms.

See r_potential(x) for an implementation of $\mathcal{R}(r)$.

Arguments

• metric: Kerr{T} metric

• roots : Radial roots

• λ : Reduced azimuthal angular momentum

source

Krang.boyer_lindquist_to_quasi_cartesian_kerr_schild Function

boyer_lindquist_to_quasi_cartesian_kerr_schild(
    metric::Kerr,
    tBL,
    rBL,
    θBL,
    ϕBL
) -> NTuple{4, Any}

Transforms from Boyer-Lindquist to Kerr-Schild coordinates

source

Krang.boyer_lindquist_to_quasi_cartesian_kerr_schild_fast_light Function

boyer_lindquist_to_quasi_cartesian_kerr_schild_fast_light(
    metric::Kerr{T},
    rBL,
    θBL,
    ϕBL
) -> Any

Transforms from Boyer-Lindquist to Kerr-Schild coordinates ignoring time

source

Krang.S1 Function

S1(α, φ, j, Fφ) -> Any

S1 with F(φ|j) supplied by the caller; see regularized_Pi.

source

Krang.S2 Function

S2(α, φ, j, Fφ, Eφ) -> Any

S2 with (F, E) at (φ, j) from the caller; see regularized_Pi.

source

Krang.regularizedS1 Function

regularizedS1(α, φ, j, Fφ) -> Any

regularizedS1 with F(φ|j) supplied by the caller; see regularized_Pi.

source

Krang.regularizedS2 Function

regularizedS2(α, φ, j, S1reg, Fφ, Eφ) -> Any

regularizedS2 with regularizedS1(α, φ, j) supplied by the caller.

regularizedS1 costs three elliptic evaluations, and every caller of regularizedS2 already evaluates it at the same (α, φ, j), so passing it in avoids repeating them.

source

Krang.regularized_R1 Function

regularized_R1(α, φ, j, Fφ) -> Any

regularized_R1 with F(φ|j) supplied by the caller; see regularized_Pi.

source

Krang.regularized_R2 Function

regularized_R2(α, φ, j, Fφ, Eφ) -> Any

regularized_R2 with (F, E) at (φ, j) from the caller; see regularized_Pi.

source

Krang.IntensityPixelArray Type

struct IntensityPixelArray{P, S<:Krang.IntensityScreen} <: AbstractArray{P, 2}

Lazy AbstractMatrix{<:IntensityPixel} view over an IntensityScreen. getindex assembles an IntensityPixel from the screen's field arrays, so existing code that iterates, indexes or broadcasts over screen.pixels keeps working unchanged.

source

Krang.SlowLightIntensityPixelArray Type

struct SlowLightIntensityPixelArray{P, S<:Krang.SlowLightIntensityScreen} <: AbstractArray{P, 2}

Lazy AbstractMatrix{<:SlowLightIntensityPixel} view over a SlowLightIntensityScreen. getindex assembles a SlowLightIntensityPixel from the screen's field arrays, so existing code that iterates, indexes or broadcasts over screen.pixels keeps working unchanged.

source

Krang._intensity_pixel_type Function

_intensity_pixel_type(
    _::Type{T}
) -> Type{Krang.IntensityPixel{T, T1, Complex{T2}, T3, T4, T5, T6, T7, T8}} where {T, T1, T2, T3, T4, T5, T6, T7, T8}

Concrete IntensityPixel type produced by a screen whose element type is T.

source

Krang._slow_light_intensity_pixel_type Function

_slow_light_intensity_pixel_type(
    _::Type{T}
) -> Type{Krang.SlowLightIntensityPixel{T, T1, Complex{T2}, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16}} where {T, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16}

Concrete SlowLightIntensityPixel type produced by a screen whose element type is T.

source