def timeloop0(self, nsteps, IC, lambda_):
# set initial condition:
self.u.values = self.g(IC)
# rough approximation to du/dt=0:
self.um.values = self.u.values.copy()
# get right storage for efficient F77 communication:
self.u.values = to_fortran(self.u.values)
self.um.values = to_fortran(self.um.values)
self.up.values = to_fortran(self.up.values)
self.lambda_.values = to_fortran(self.g(lambda_))
wave2D.dump(self.u.values, 0, 0.0)
# optimal time step:
self.dt = 1.0/self.lambda_.max()/\
sqrt(1.0/self.g.dx**2+1.0/self.g.dy**2)
t = 0
for timelevel in range(nsteps):
t += self.dt
print 'solve at time', t
self.up.values = solve_at_this_time_step(\
self.up.values, self.u.values, self.um.values,
self.lambda_.values, self.dt)
wave2D.dump(self.u.values, timelevel, t)
self.um.values = self.u.values.copy()
self.u.values = self.up.values.copy()
def timeloop0(self, nsteps, IC, lambda_):
# set initial condition:
self.u .values = self.g(IC)
# rough approximation to du/dt=0:
self.um.values = self.u.values.copy()
# get right storage for efficient F77 communication:
self.u .values = to_fortran(self.u .values)
self.um.values = to_fortran(self.um.values)
self.up.values = to_fortran(self.up.values)
self.lambda_.values = to_fortran(self.g(lambda_))
wave2D.dump(self.u.values, 0, 0.0)
# optimal time step:
self.dt = 1.0/self.lambda_.max()/\
sqrt(1.0/self.g.dx**2+1.0/self.g.dy**2)
t = 0
for timelevel in range(nsteps):
t += self.dt
print 'solve at time', t
self.up.values = solve_at_this_time_step(\
self.up.values, self.u.values, self.um.values,
self.lambda_.values, self.dt)
wave2D.dump(self.u.values, timelevel, t)
self.um.values = self.u .values.copy()
self.u .values = self.up.values.copy()
def timeloop(self, nsteps, IC, lambda_):
# set initial condition:
self.u.values = self.g(IC)
# rough approximation to du/dt=0:
self.um.values = self.u.values.copy()
# get right storage for efficient F77 communication:
self.u.values = to_fortran(self.u.values)
self.um.values = to_fortran(self.um.values)
self.up.values = to_fortran(self.up.values)
self.lambda_.values = to_fortran(self.g(lambda_))
# short forms for reading or in-place modifications:
u = self.u.values
um = self.um.values
up = self.up.values
l = self.lambda_.values
dx = self.g.dx
dy = self.g.dy
wave2D.dump(u, 0, 0.0)
# optimal time step:
self.dt = 1.0 / self.lambda_.max() / sqrt(1.0 / dx**2 + 1.0 / dy**2)
t = 0
for timelevel in range(nsteps):
t += self.dt
print 'solve at time', t
# u = ... is okay, think about it; u is forgotten
# when we leave this routine, but solve_at_this_time_step
# performs in-place modifications of the array u pointed
# to and points to (the same array)
# NO: u=... is not okay, need u[:,:] as in-place mod.
# understand why!
u[:, :] = solve_at_this_time_step(up, u, um, l, self.dt)
wave2D.dump(u, timelevel, t)
um[:, :] = u # in-place update
u[:, :] = up
def timeloop(self, nsteps, IC, lambda_):
# set initial condition:
self.u .values = self.g(IC)
# rough approximation to du/dt=0:
self.um.values = self.u.values.copy()
# get right storage for efficient F77 communication:
self.u .values = to_fortran(self.u .values)
self.um.values = to_fortran(self.um.values)
self.up.values = to_fortran(self.up.values)
self.lambda_.values = to_fortran(self.g(lambda_))
# short forms for reading or in-place modifications:
u = self.u.values
um = self.um.values
up = self.up.values
l = self.lambda_.values
dx = self.g.dx; dy = self.g.dy
wave2D.dump(u, 0, 0.0)
# optimal time step:
self.dt = 1.0/self.lambda_.max()/sqrt(1.0/dx**2+1.0/dy**2)
t = 0
for timelevel in range(nsteps):
t += self.dt
print 'solve at time', t
# u = ... is okay, think about it; u is forgotten
# when we leave this routine, but solve_at_this_time_step
# performs in-place modifications of the array u pointed
# to and points to (the same array)
# NO: u=... is not okay, need u[:,:] as in-place mod.
# understand why!
u[:,:] = solve_at_this_time_step(up, u, um, l, self.dt)
wave2D.dump(u, timelevel, t)
um[:,:] = u # in-place update
u [:,:] = up
