def eval_f(self, u, t):
"""
Routine to compute the RHS
Args:
u (dtype_u): the particles
t (float): current time (not used here)
Returns:
dtype_f: RHS
"""
me = acceleration(self.init, val=0.0)
# compute the acceleration due to gravitational forces
# ... only with respect to the sun
if self.params.sun_only:
for i in range(1, self.init[-1]):
dx = u.pos.values[:, i] - u.pos.values[:, 0]
r = np.sqrt(np.dot(dx, dx))
df = self.G * dx / (r**3)
me.values[:, i] -= u.m[0] * df
# ... or with all planets involved
else:
for i in range(self.init[-1]):
for j in range(i):
dx = u.pos.values[:, i] - u.pos.values[:, j]
r = np.sqrt(np.dot(dx, dx))
df = self.G * dx / (r**3)
me.values[:, i] -= u.m[j] * df
me.values[:, j] += u.m[i] * df
return me
def build_f(self, f, part, t):
"""
Helper function to assemble the correct right-hand side out of B and E field
Args:
f (dtype_f): the field values
part (dtype_u): the current particles data
t (float): the current time
Returns:
acceleration: correct RHS of type acceleration
"""
if not isinstance(part, particles):
raise ProblemError('something is wrong during build_f, got %s' %
type(part))
N = self.params.nparts
rhs = acceleration((3, self.params.nparts))
for n in range(N):
rhs.values[:, n] = part.q[n] / part.m[n] * (
f.elec.values[:, n] +
np.cross(part.vel.values[:, n], f.magn.values[:, n]))
return rhs
def eval_f(self, u, t):
"""
Routine to compute the RHS
Args:
u (dtype_u): the particles
t (float): current time (not used here)
Returns:
dtype_f: RHS
"""
me = acceleration(1)
me.values[:] = -self.params.k * u.pos.values
return me
def eval_f(self, u, t):
"""
Routine to compute the RHS
Args:
u (dtype_u): the particles
t (float): current time (not used here)
Returns:
dtype_f: RHS
"""
me = acceleration(2)
me.values[0] = -u.pos.values[0] - 2 * u.pos.values[0] * u.pos.values[1]
me.values[
1] = -u.pos.values[1] - u.pos.values[0]**2 + u.pos.values[1]**2
return me
def eval_f(self, u, t):
"""
Routine to compute the RHS
Args:
u (dtype_u): the particles
t (float): current time (not used here)
Returns:
dtype_f: RHS
"""
me = acceleration(self.init, val=0.0)
self.fast_acceleration(self.params.npart, self.params.alpha,
u.pos.values,
me.values[1:self.params.npart - 1])
return me
def restrict(self, F):
"""
Dummy restriction routine
Args:
F: the fine level data
"""
if isinstance(F, particles):
G = particles(F)
elif isinstance(F, fields):
G = fields(F)
elif isinstance(F, acceleration):
G = acceleration(F)
else:
raise TransferError("Unknown type of fine data, got %s" % type(F))
return G
def prolong(self, G):
"""
Dummy prolongation routine
Args:
G: the coarse level data
"""
if isinstance(G, particles):
F = particles(G)
elif isinstance(G, fields):
F = fields(G)
elif isinstance(G, acceleration):
F = acceleration(G)
else:
raise TransferError("Unknown type of coarse data, got %s" % type(G))
return F
def build_f(self, f, part, t):
"""
Helper function to assemble the correct right-hand side out of B and E field
Args:
f: wannabe right-hand side, actually the E field
part: particle data
t: current time
Returns:
correct RHS of type acceleration
"""
assert isinstance(part, particles)
rhs = acceleration((3, self.nparts))
rhs.values[:, 0] = part.q[:] / part.m[:] * \
(f.elec.values[:, 0] + np.cross(part.vel.values[:, 0], f.magn.values[:, 0]))
return rhs
def check_datatypes_particles(init):
from pySDC.implementations.datatype_classes.particles import particles
from pySDC.implementations.datatype_classes.particles import acceleration
p1 = particles(init)
p2 = particles(p1)
p5 = particles(init)
p1.pos.values[:] = 1.0
p2.pos.values[:] = 2.0
p1.vel.values[:] = 10.0
p2.vel.values[:] = 20.0
p3 = p1 + p2
p4 = p1 - p2
p5.pos = 0.1 * p1.vel
p6 = p1
p7 = abs(p1)
a1 = acceleration(init)
a2 = acceleration(a1)
p8 = particles(p1)
a1.values[:] = 100.0
a2.values[:] = 200.0
a3 = a1 + a2
p8.vel = 0.1 * a1
p8.pos = 0.1 * (0.1 * a1)
assert isinstance(p3, type(p1))
assert isinstance(p4, type(p1))
assert isinstance(p5.pos, type(p1.pos))
assert isinstance(p6, type(p1))
assert isinstance(p7, float)
assert isinstance(a2, type(a1))
assert isinstance(p8.pos, type(p1.pos))
assert isinstance(p8.vel, type(p1.vel))
assert isinstance(0.1 * 0.1 * a1, type(p1.vel))
assert p2 is not p1
assert p3 is not p1
assert p4 is not p1
assert p5 is not p1
assert p6 is p1
assert a2 is not a1
assert a3 is not a1
assert np.shape(p3.pos.values) == np.shape(p1.pos.values)
assert np.shape(p4.pos.values) == np.shape(p1.pos.values)
assert np.shape(p3.vel.values) == np.shape(p1.vel.values)
assert np.shape(p4.vel.values) == np.shape(p1.vel.values)
assert np.shape(a2.values) == np.shape(a1.values)
assert np.all(p3.pos.values == 3.0)
assert np.all(p4.pos.values == -1.0)
assert np.all(p3.vel.values == 30.0)
assert np.all(p4.vel.values == -10.0)
assert np.all(p5.pos.values == 1.0)
assert p7 >= 0
assert np.all(p8.pos.values == 1.0)
assert np.all(p8.vel.values == 10.0)
assert np.all(a3.values == 300.0)
