Python TensorField_3D Examples

Example #1

logger.debug(' r: {}\n{}'.format(r_global.shape, r_global[0, :]))
logger.debug('th: {}\n{}'.format(theta_global.shape, theta_global[0, :]))
logger.debug('ph: {}\n{}'.format(phi_global.shape, phi_global[0, :]))

z, R = r_global * np.cos(theta_global), r_global * np.sin(
    theta_global)  # global

grid_slices = phi_layout.slices(domain.dealias)
phi = domain.grid(0, scales=domain.dealias)[grid_slices[0], :, :]
theta = B.grid(1, dimensions=3)[:, grid_slices[1], :]  # local
r = B.grid(2, dimensions=3)[:, :, grid_slices[2]]  # local

weight_theta = B.weight(1, dimensions=3)[:, grid_slices[1], :]
weight_r = B.weight(2, dimensions=3)[:, :, grid_slices[2]]

om = ball.TensorField_3D(1, B, domain)
u = ball.TensorField_3D(1, B, domain)
p = ball.TensorField_3D(0, B, domain)
T = ball.TensorField_3D(0, B, domain)
DT = ball.TensorField_3D(1, B, domain)

u_rhs = ball.TensorField_3D(1, B, domain)
p_rhs = ball.TensorField_3D(0, B, domain)
T_rhs = ball.TensorField_3D(0, B, domain)

# initial condition
T['g'] = 0.5 * (1 - r**2) + 0.1 / 8. * np.sqrt(35 / np.pi) * r**3 * (
    1 - r**2) * (np.cos(3 * phi) + np.sin(3 * phi)) * np.sin(theta)**3

# build state vector
state_vector = StateVector(u, p, T)

Example #2

File: scalar_multiphase.py Project: kburns/nonlocal_diffusion_sphere

weight_theta = B.weight(1,dimensions=3)[:,grid_slices[1],:]
weight_r = B.weight(2,dimensions=3)[:,:,grid_slices[2]]

# BC array
local_rell_shape = r_ell_layout.local_shape(scales=domain.dealias)
BC_shape = np.array(local_rell_shape)[:-1]
BC = np.zeros(BC_shape,dtype=np.complex128)

for ell in range(ell_start,ell_end+1):
    ell_local = ell-ell_start
    for m in range(m_start,m_end+1):
        m_local = m-m_start
        BC[m_local,ell_local] = f(m,ell)

T  = ball.TensorField_3D(0,B,domain)
T_rhs = ball.TensorField_3D(0,B,domain)

# initial condition
T['g'] = 50 * (0.5*(1-r**2) + 1/8.*np.sqrt(35/np.pi)*r**3*(1-r**2)*(np.cos(3*phi)+np.sin(3*phi))*np.sin(theta)**3)

# build state vector
state_vector = StateVector(T)
NL = StateVector(T)
timestepper = timesteppers.SBDF2(StateVector, T)

# build matrices
M,L,P,LU = [],[],[],[]
for ell in range(ell_start,ell_end+1):
    N = B.N_max - B.N_min(ell-B.R_max)
    M_ell,L_ell = matrices(N,ell)

Example #3

File: paper_BVP.py Project: gonihalevi/dedalus-sw

r_basis_3D = de.Fourier('r', N_max + 1, interval=(0, 1), dealias=N_dealias)
domain_3D = de.Domain([phi_basis_3D, theta_basis_3D, r_basis_3D],
                      grid_dtype=np.float64,
                      comm=comm,
                      mesh=mesh)

domain_3D.global_coeff_shape = np.array([L_max + 1, L_max + 1, N_max + 1])
domain_3D.distributor = Distributor(domain_3D, comm, mesh)

phi_layout = domain_3D.distributor.layouts[3]
grid_slices = phi_layout.slices(domain_3D.dealias)
phi = domain_3D.grid(0, scales=domain_3D.dealias)
theta = B_3D.grid(1, dimensions=3)[:, grid_slices[1], :]  # local
r = B_3D.grid(2, dimensions=3)[:, :, grid_slices[2]]  # local

H = ball.TensorField_3D(1, B_3D, domain_3D)
H2 = ball.TensorField_3D(1, B_3D, domain_3D)
A = ball.TensorField_3D(1, B_3D, domain_3D)

H['g'][1] = -3. / 2. * r * (-1 + 4 * r**2 - 6 * r**4 +
                            3 * r**6) * (np.cos(phi) + np.sin(phi))
H['g'][2] = -3./4.*r*(-1+r**2)*np.cos(theta)* \
                 ( 3*r*(2-5*r**2+4*r**4)*np.sin(theta)
                  +2*(1-3*r**2+3*r**4)*(np.cos(phi)-np.sin(phi)))

for ell in range(1, L_max + 1):
    N = N_max - B_3D.N_min(ell - R_max)

    Z = B_3D.op('0', N, 0, ell)

    xim = B_3D.xi(-1, ell)

Example #4

File: marti_dynamo_benchmark.py Project: gonihalevi/dedalus-sw

N_theta = int((L_max+1)*L_dealias)
N_r     = int((N_r+1)*N_dealias)
B = ball.Ball(N_max,L_max,N_theta=N_theta,N_r=N_r,R_max=R_max,ell_min=ell_start,ell_max=ell_end,m_min=m_start,m_max=m_end,a=0)
theta_global = B.grid(0)
r_global = B.grid(1)
z, R = r_global*np.cos(theta_global), r_global*np.sin(theta_global) # global

grid_slices = phi_layout.slices(domain.dealias)
phi = domain.grid(0,scales=domain.dealias)[grid_slices[0],:,:]
theta = B.grid(1,dimensions=3)[:,grid_slices[1],:] # local
r = B.grid(2,dimensions=3)[:,:,grid_slices[2]] # local

weight_theta = B.weight(1,dimensions=3)
weight_r = B.weight(2,dimensions=3)

Du = ball.TensorField_3D(2,B,domain)
u  = ball.TensorField_3D(1,B,domain)
p  = ball.TensorField_3D(0,B,domain)
T  = ball.TensorField_3D(0,B,domain)
DT = ball.TensorField_3D(1,B,domain)
A  = ball.TensorField_3D(1,B,domain)
H  = ball.TensorField_3D(1,B,domain)
DH = ball.TensorField_3D(2,B,domain)
pi = ball.TensorField_3D(0,B,domain)

u_rhs = ball.TensorField_3D(1,B,domain)
p_rhs = ball.TensorField_3D(0,B,domain)
T_rhs = ball.TensorField_3D(0,B,domain)
A_rhs = ball.TensorField_3D(1,B,domain)
pi_rhs= ball.TensorField_3D(0,B,domain)

Example #5

File: marti_hydro_benchmark.py Project: gonihalevi/dedalus-sw

              m_max=m_end,
              a=0.)
theta_global = B.grid(0)
r_global = B.grid(1)
z, R = r_global * np.cos(theta_global), r_global * np.sin(
    theta_global)  # global

grid_slices = phi_layout.slices(domain.dealias)
phi = domain.grid(0, scales=domain.dealias)[grid_slices[0], :, :]
theta = B.grid(1, dimensions=3)[:, grid_slices[1], :]  # local
r = B.grid(2, dimensions=3)[:, :, grid_slices[2]]  # local

weight_theta = B.weight(1, dimensions=3)
weight_r = B.weight(2, dimensions=3)

Du = ball.TensorField_3D(2, B, domain)
u = ball.TensorField_3D(1, B, domain)
p = ball.TensorField_3D(0, B, domain)

u_rhs = ball.TensorField_3D(1, B, domain)
p_rhs = ball.TensorField_3D(0, B, domain)

# create boundary conditions
BC_vec = ball.TensorField_3D(1, B, domain)
BC_vec['g'][0] = 0.  # u_r = 0
BC_vec['g'][1] = -u0 * r**2 * np.cos(theta) * np.cos(phi)
BC_vec['g'][2] = u0 * r**2 * np.sin(phi)

BC_vec.require_grid_space()

local_rell_shape = r_ell_layout.local_shape(scales=domain.dealias)