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)