Skip to main content

​
Overview

The field module provides classes for representing data fields in spectral space. Fields can be scalars, vectors, or tensors, and support arithmetic operations, differential operators, and layout transformations between grid and coefficient space.

​
Field Classes

​
Field

Field(dist=None, bases=None, tensorsig=(), dtype=np.float64, name=None)
General field class for storing spectral data.

​
Parameters

  • dist (Distributor, optional): Distributor object for parallelization
  • bases (tuple of Basis, optional): Spectral bases for each dimension
  • tensorsig (tuple of CoordinateSystems, optional): Tensor signature
  • dtype (dtype, optional): Data type (default: np.float64)
  • name (str, optional): Field name

​
Attributes

  • data (ndarray): Field data in current layout
  • layout: Current data layout (‘c’ for coefficients, ‘g’ for grid)
  • domain (Domain): Field domain
  • tensorsig (tuple): Tensor signature

​
Methods

[‘g’] - Access grid-space data 
field['g'] = data  # Set grid values
data = field['g']  # Get grid values
[‘c’] - Access coefficient-space data 
field['c'] = coeffs  # Set coefficients
coeffs = field['c']  # Get coefficients
change_scales(scales) - Change dealiasing scales 
field.change_scales(2)  # Dealias to 2x resolution
field.change_scales((1, 2, 1))  # Per-axis scales
copy() - Create a copy 
field_copy = field.copy()

​
Arithmetic Operations

Fields support standard arithmetic: 
f3 = f1 + f2      # Addition
f3 = f1 - f2      # Subtraction  
f3 = f1 * f2      # Multiplication (NCC)
f3 = f1 / f2      # Division
f3 = f1 ** 2      # Powers
f3 = -f1          # Negation

​
Example

import dedalus.public as d3
import numpy as np

# Setup
coords = d3.CartesianCoordinates('x', 'y')
dist = d3.Distributor(coords, dtype=np.float64)
xbasis = d3.RealFourier(coords['x'], size=64, bounds=(0, 2*np.pi))
ybasis = d3.RealFourier(coords['y'], size=64, bounds=(0, 2*np.pi))

# Create field
u = dist.Field(bases=(xbasis, ybasis), name='u')

# Set values in grid space  
x, y = dist.local_grids(xbasis, ybasis)
u['g'] = np.sin(x) * np.cos(y)

# Access coefficients
coeffs = u['c']

​
ScalarField

ScalarField(dist, bases=None, dtype=np.float64, name=None)
Convenience constructor for scalar fields (empty tensor signature).

​
Example

import dedalus.public as d3

coords = d3.CartesianCoordinates('x', 'y', 'z')
dist = d3.Distributor(coords)  

T = dist.ScalarField(name='T')  # Temperature

​
VectorField

VectorField(dist, coordsys, bases=None, dtype=np.float64, name=None)
Convenience constructor for vector fields.

​
Parameters

  • coordsys (CoordinateSystem): Coordinate system for vector components
  • Other parameters same as Field

​
Example

import dedalus.public as d3  
import numpy as np

coords = d3.CartesianCoordinates('x', 'y', 'z')
dist = d3.Distributor(coords)

# Create velocity vector
u = dist.VectorField(coords, name='u')

# Set components  
u['g'][0] = 1.0  # u_x
u['g'][1] = 0.0  # u_y  
u['g'][2] = 0.0  # u_z

​
TensorField

TensorField(dist, coordsys_out, coordsys_in=None, bases=None, dtype=np.float64, name=None)
Convenience constructor for tensor fields.

​
Parameters

  • coordsys_out (CoordinateSystem): Output coordinate system
  • coordsys_in (CoordinateSystem, optional): Input coordinate system (default: same as output)
  • Other parameters same as Field

​
Example

import dedalus.public as d3

coords = d3.CartesianCoordinates('x', 'y')  
dist = d3.Distributor(coords)

# Create stress tensor
τ = dist.TensorField(coords, name='tau')

# Set components
τ['g'][0, 0] = 1.0  # τ_xx
τ['g'][0, 1] = 0.0  # τ_xy
τ['g'][1, 0] = 0.0  # τ_yx  
τ['g'][1, 1] = 1.0  # τ_yy

​
Field Properties

​
Tensor Operations

T - Transpose tensor components 
A_T = A.T  # Transpose
H - Hermitian transpose (conjugate transpose) 
A_H = A.H  # Conjugate transpose

​
Component Access

real - Real part 
f_real = f.real
imag - Imaginary part 
f_imag = f.imag

​
Advanced Usage

​
Non-Constant Coefficients (NCCs)

Fields can be used as non-constant coefficients in equations: 
import dedalus.public as d3

# Setup domain
coord = d3.Coordinate('x')  
dist = d3.Distributor(coord)
xbasis = d3.ChebyshevT(coord, size=64, bounds=(0, 1))

# Variable coefficient
kappa = dist.Field(bases=xbasis)  
x = dist.local_grid(xbasis)
kappa['g'] = 1 + x**2

# Use in equation
u = dist.Field(bases=xbasis)
problem = d3.LBVP([u])
problem.add_equation("kappa*dx(u) = 1")  # kappa is an NCC

​
Interpolation

Fields can be called to interpolate: 
# Interpolate to specific point
value = field(x=0.5, y=0.3)

​
See Also

Build docs developers (and LLMs) love

Get started for freeTalk to us