Skip to content

Heap

dexter.HeapInitialConditions(thetas: NDArray1D, psips: NDArray1D, rhos: NDArray1D, zetas: NDArray1D, mus: NDArray1D)

Sets up the initial conditions of the Particles.

Example 
>>> import numpy as np
>>>
>>> # set initial conditions on the `r` space
>>> rs = np.linspace(0, geometry.r_wall, 40)
>>> psips = np.asarray([geometry.psip(r) for r in rs])
>>>
>>> initials = dx.HeapInitialConditions(
...     psips=psips,
...     zetas=np.zeros(len(psips)),
...     thetas=np.zeros(len(psips)),
...     rhos=1e-5 * np.ones(len(psips)),
...     mus=np.zeros(len(psips)),
... )
>>> print(len(initials))
40

Parameters:

  • thetas (NDArray1D) –

    The initial \(\theta\) angles.

  • psips (NDArray1D) –

    The initial poloidal magnetic fluxes \(\psi_p\).

  • rhos (NDArray1D) –

    The initial parallel gyro radii \(\rho\).

  • zetas (NDArray1D) –

    The initial \(\zeta\) angles.

  • mus (NDArray1D) –

    The magnetic moments \(mu\).

dexter.Heap(initial: HeapInitialConditions)

A collection of multiple Particles constructed from sets of Initial Conditions.

The particles are stored in arbitrary order.

Example 
>>> initials = dx.HeapInitialConditions(
...     psips=psips,
...     zetas=np.zeros(len(psips)),
...     thetas=np.zeros(len(psips)),
...     rhos=1e-5 * np.ones(len(psips)),
...     mus=np.zeros(len(psips)),
... )
>>>
>>> heap = dx.Heap(initials)

Constructs a Heap.

Parameters:

  • initials –

    The Particles' initial conditions sets.

dexter.Heap.poincare(qfactor: Qfactor, currents: Currents, bfield: Bfield, perturbation: Perturbation, params: MappingParameters) -> None

Calculates the Poincare map.

Parameters:

  • qfactor (Qfactor) –

    The equilibrium's qfactor.

  • currents (Currents) –

    The equilibrium's plasma current.

  • bfield (Bfield) –

    The equilibrium's magnetic field.

  • perturbation (Perturbation) –

    The equilibrium's perturbation.

  • params (MappingParameters) –

    The parameters of the Poincare mapping.

Example 
>>> heap = dx.Heap(initials)
>>> params = dx.MappingParameters("ConstTheta", np.pi, 100)
>>> heap.poincare(qfactor, currents, bfield, perturbation, params)

dexter.Heap.calculate_frequencies(qfactor: Qfactor, currents: Currents, bfield: Bfield, perturbation: Perturbation) -> None

Calculates the \(\omega_\theta\), \(\omega_\zeta\) and \(q_{kinetic}\) of the particles.

Tip

This method appears to be a bit sensitive to the solver's arithmetic error, so it's recommended to use the energy-adaptive-step method, and maybe tighten the tolerance a bit.

Parameters:

  • qfactor (Qfactor) –

    The equilibrium's qfactor.

  • currents (Currents) –

    The equilibrium's plasma current.

  • bfield (Bfield) –

    The equilibrium's magnetic field.

  • perturbation (Perturbation) –

    The equilibrium's perturbation.

Example 
>>> num = 5
>>> initials = dx.HeapInitialConditions(
...     thetas=np.ones(num),
...     psips=0.8 * geometry.psip_wall * np.ones(num),
...     rhos=np.linspace(1e-5, 5e-5, num),
...     zetas=np.zeros(num),
...     mus=np.zeros(num),
... )
>>>
>>> heap = dx.Heap(initials)
>>>
>>> heap.calculate_frequencies(
...     qfactor,
...     currents,
...     bfield,
...     perturbation=dx.Perturbation([])
... )

dexter.Heap.__getitem__(n: int) -> Particle

Returns the n-th particle.