def test_innovations(self):
self.set_positions_small_set()
zero = 0.0
close = 0.2
far = -0.8
fasit = [[close, close], [close, zero], [zero, close]]
# smallDrifterSet is initially with periodic boundary conditions
assert2DListAlmostEqual(self, self.smallDrifterSet.getInnovations().tolist(), \
fasit, 6,
'innovations with periodic boundaries')
fasit = [[far, far], [far, zero], [zero, far]]
self.smallDrifterSet.setBoundaryConditions(
Common.BoundaryConditions(1, 1, 1, 1))
assert2DListAlmostEqual(self, self.smallDrifterSet.getInnovations().tolist(), \
fasit, 6,
'innovations with non-periodic boundaries')
fasit = [[close, far], [close, zero], [zero, far]]
self.smallDrifterSet.setBoundaryConditions(
Common.BoundaryConditions(1, 2, 1, 2))
assert2DListAlmostEqual(self, self.smallDrifterSet.getInnovations().tolist(), \
fasit, 6,
'innovations with periodic boundaries in east-west')
fasit = [[far, close], [far, zero], [zero, close]]
self.smallDrifterSet.setBoundaryConditions(
Common.BoundaryConditions(2, 1, 2, 1))
assert2DListAlmostEqual(self, self.smallDrifterSet.getInnovations().tolist(), \
fasit, 6,
'innovations with periodic boundaries in north-south')
def test_distances(self):
self.set_positions_small_set()
longDiag = np.sqrt(2 * 0.8 * 0.8)
longLine = 0.8
shortDiag = np.sqrt(0.2 * 0.2 + 0.2 * 0.2)
shortLine = 0.2
semiDiag = np.sqrt(0.2 * 0.2 + 0.8 * 0.8)
# smallDrifterSet is initially with periodic boundary conditions
assertListAlmostEqual(self, self.smallDrifterSet.getDistances().tolist(), \
[shortDiag, shortLine, shortLine], 6,
'distance with periodic boundaries')
self.smallDrifterSet.setBoundaryConditions(
Common.BoundaryConditions(1, 1, 1, 1))
assertListAlmostEqual(self, self.smallDrifterSet.getDistances().tolist(), \
[longDiag, longLine, longLine], 6,
'distances with non-periodic boundaries')
self.smallDrifterSet.setBoundaryConditions(
Common.BoundaryConditions(1, 2, 1, 2))
assertListAlmostEqual(self, self.smallDrifterSet.getDistances().tolist(), \
[semiDiag, shortLine, longLine], 6,
'distances with periodic boundaries in east-west')
self.smallDrifterSet.setBoundaryConditions(
Common.BoundaryConditions(2, 1, 2, 1))
assertListAlmostEqual(self, self.smallDrifterSet.getDistances().tolist(), \
[semiDiag, longLine, shortLine], 6,
'distances with periodic boundaries in north-south')
def fromfilename(cls, gpu_ctx, filename, cont_write_netcdf=True):
"""
Initialize and hotstart simulation from nc-file.
cont_write_netcdf: Continue to write the results after each superstep to a new netCDF file
filename: Continue simulation based on parameters and last timestep in this file
"""
# open nc-file
sim_reader = SimReader.SimNetCDFReader(filename,
ignore_ghostcells=False)
sim_name = str(sim_reader.get('simulator_short'))
assert sim_name == cls.__name__, \
"Trying to initialize a " + \
cls.__name__ + " simulator with netCDF file based on " \
+ sim_name + " results."
# read parameters
nx = sim_reader.get("nx")
ny = sim_reader.get("ny")
dx = sim_reader.get("dx")
dy = sim_reader.get("dy")
width = nx * dx
height = ny * dy
dt = sim_reader.get("dt")
g = sim_reader.get("g")
r = sim_reader.get("bottom_friction_r")
f = sim_reader.get("coriolis_force")
beta = sim_reader.get("coriolis_beta")
minmodTheta = sim_reader.get("minmod_theta")
timeIntegrator = sim_reader.get("time_integrator")
y_zero_reference_cell = sim_reader.get("y_zero_reference_cell")
try:
wind_stress_type = sim_reader.get("wind_stress_type")
wind = Common.WindStressParams(type=wind_stress_type)
except:
wind = WindStress.WindStress()
boundaryConditions = Common.BoundaryConditions( \
sim_reader.getBC()[0], sim_reader.getBC()[1], \
sim_reader.getBC()[2], sim_reader.getBC()[3], \
sim_reader.getBCSpongeCells())
h0 = sim_reader.getH()
# get last timestep (including simulation time of last timestep)
eta0, hu0, hv0, time0 = sim_reader.getLastTimeStep()
return cls(gpu_ctx, \
h0, eta0, hu0, hv0, \
nx, ny, \
dx, dy, dt, \
g, f, r, \
t=time0, \
wind_stress=wind, \
boundary_conditions=boundaryConditions, \
write_netcdf=cont_write_netcdf)
def setBoundaryConditions(self, bcSettings=1):
if (bcSettings == 1):
self.boundaryConditions = Common.BoundaryConditions()
elif (bcSettings == 2):
self.boundaryConditions = Common.BoundaryConditions(2, 2, 2, 2)
elif bcSettings == 3:
self.boundaryConditions = Common.BoundaryConditions(2, 1, 2, 1)
else:
self.boundaryConditions = Common.BoundaryConditions(1, 2, 1, 2)
def allocateBuffers(self, HCPU):
host_buffer = np.zeros((self.ny, self.nx))
self.eta = Common.CUDAArray2D(self.gpu_stream, self.nx, self.ny, 0, 0,
host_buffer)
self.hu = Common.CUDAArray2D(self.gpu_stream, self.nx, self.ny, 0, 0,
host_buffer)
self.hv = Common.CUDAArray2D(self.gpu_stream, self.nx, self.ny, 0, 0,
host_buffer)
self.H = Common.CUDAArray2D(self.gpu_stream, self.nx + 1, self.ny + 1,
0, 0, HCPU)
del host_buffer
def __init__(self, gpu_ctx, numDrifters, \
observation_variance=0.01, \
boundaryConditions=Common.BoundaryConditions(), \
initialization_cov_drifters=None, \
domain_size_x=1.0, domain_size_y=1.0, \
gpu_stream=None, \
block_width = 64):
super(GPUDrifterCollection, self).__init__(numDrifters,
observation_variance=observation_variance,
boundaryConditions=boundaryConditions,
domain_size_x=domain_size_x,
domain_size_y=domain_size_y)
# Define CUDA environment:
self.gpu_ctx = gpu_ctx
self.block_width = block_width
self.block_height = 1
# TODO: Where should the cl_queue come from?
# For sure, the drifter and the ocean simulator should use
# the same queue...
self.gpu_stream = gpu_stream
if self.gpu_stream is None:
self.gpu_stream = cuda.Stream()
self.sensitivity = 1.0
self.driftersHost = np.zeros((self.getNumDrifters() + 1, 2)).astype(np.float32, order='C')
self.driftersDevice = Common.CUDAArray2D(self.gpu_stream, \
2, self.getNumDrifters()+1, 0, 0, \
self.driftersHost)
self.drift_kernels = gpu_ctx.get_kernel("driftKernels.cu", \
defines={'block_width': self.block_width, 'block_height': self.block_height})
# Get CUDA functions and define data types for prepared_{async_}call()
self.passiveDrifterKernel = self.drift_kernels.get_function("passiveDrifterKernel")
self.passiveDrifterKernel.prepare("iifffiiPiPiPifiiiPif")
self.enforceBoundaryConditionsKernel = self.drift_kernels.get_function("enforceBoundaryConditions")
self.enforceBoundaryConditionsKernel.prepare("ffiiiPi")
self.local_size = (self.block_width, self.block_height, 1)
self.global_size = (\
int(np.ceil((self.getNumDrifters() + 2)/float(self.block_width))), \
1)
# Initialize drifters:
self.uniformly_distribute_drifters(initialization_cov_drifters=initialization_cov_drifters)
def setUp(self):
self.gpu_ctx = None
self.numDrifters = 3
self.observationVariance = 0.25
self.boundaryCondition = Common.BoundaryConditions(2, 2, 2, 2)
self.smallDrifterSet = None
# to be initialized by child class with above values
self.smallPositionSetHost = np.array([[0.9, 0.9], [0.9, 0.1],
[0.1, 0.9], [0.1, 0.1]])
self.resampleNumDrifters = 6
self.resamplingDriftersArray = np.zeros((7, 2))
for i in range(2):
self.resamplingDriftersArray[3 * i + 0, :] = [0.25, 0.35 + i * 0.3]
self.resamplingDriftersArray[3 * i + 1, :] = [0.4, 0.35 + i * 0.3]
self.resamplingDriftersArray[3 * i + 2, :] = [0.65, 0.35 + i * 0.3]
self.resamplingDriftersArray[6, :] = [0.25, 0.5]
self.resamplingDrifterSet = None
# to be initialized by child class wit resampleNumDrifters only.
self.resamplingVar = 1e-8
self.largeDrifterSet = None
def setUp(self):
#Set which CL device to use, and disable kernel caching
self.cl_ctx = make_cl_ctx()
# Make some host data which we can play with
self.nx = 3
self.ny = 5
self.nx_halo = 1
self.ny_halo = 2
self.dataShape = (self.ny + 2 * self.ny_halo,
self.nx + 2 * self.nx_halo)
self.buf1 = np.zeros(self.dataShape, dtype=np.float32, order='C')
self.buf2 = np.zeros(self.dataShape)
self.buf3 = np.zeros(self.dataShape, dtype=np.float32, order='C')
for j in range(self.dataShape[0]):
for i in range(self.dataShape[1]):
self.buf1[j, i] = i * 100 + j
self.buf2[j, i] = self.buf1[j, i]
self.buf3[j, i] = j * 1000 - i
self.explicit_free = False
self.device_name = self.cl_ctx.devices[0].name
self.cl_queue = pyopencl.CommandQueue(self.cl_ctx)
self.tests_failed = True
self.clarray = Common.OpenCLArray2D(self.cl_ctx, \
self.nx, self.ny, self.nx_halo, self.ny_halo, \
self.buf1)
def __init__(self,
numDrifters,
observation_variance=0.01,
boundaryConditions=Common.BoundaryConditions(),
initialization_cov_drifters=None,
domain_size_x=1.0,
domain_size_y=1.0):
"""
Creates a GlobalParticles object for drift trajectory ensemble.
numDrifters: number of drifters in the collection, not included the observation
observation_variance: uncertainty of observation position
boundaryConditions: BoundaryConditions object, relevant during re-initialization of particles.
"""
# Call parent constructor
super(CPUDrifterCollection,
self).__init__(numDrifters,
observation_variance=observation_variance,
boundaryConditions=boundaryConditions,
domain_size_x=domain_size_x,
domain_size_y=domain_size_y)
# One position for every particle plus observation
self.positions = np.zeros((self.numDrifters + 1, 2))
# Initialize drifters:
self.uniformly_distribute_drifters(
initialization_cov_drifters=initialization_cov_drifters)
def _setupGPU(self):
"""
Setting up kernel for reading observations, along with host and device buffers
"""
# Create observation buffer!
if self.observation_type == dautils.ObservationType.UnderlyingFlow or \
self.observation_type == dautils.ObservationType.DirectUnderlyingFlow:
zeros = np.zeros((self.driftersPerOceanModel, 2),
dtype=np.float32,
order='C')
self.observation_buffer = Common.CUDAArray2D(self.gpu_stream, \
2, self.driftersPerOceanModel, 0, 0, \
zeros)
# Generate kernels
self.observation_kernels = self.gpu_ctx.get_kernel("observationKernels.cu", \
defines={})
# Get CUDA functions and define data types for prepared_{async_}call()
self.observeUnderlyingFlowKernel = self.observation_kernels.get_function(
"observeUnderlyingFlow")
self.observeUnderlyingFlowKernel.prepare("iiffiiPiPiPifiPiPi")
self.local_size = (int(self.driftersPerOceanModel), 1, 1)
self.global_size = (1, 1)
def setUp(self):
self.gpu_ctx = Common.CUDAContext()
self.nx = 50
self.ny = 70
self.dx = 200.0
self.dy = 200.0
self.dt = 1
self.g = 9.81
self.f = 0.0
self.r = 0.0
self.A = 1
self.h0 = np.ones((self.ny + 2, self.nx + 2), dtype=np.float32) * 60
self.eta0 = np.zeros((self.ny + 2, self.nx + 2), dtype=np.float32)
self.u0 = np.zeros((self.ny + 2, self.nx + 1 + 2), dtype=np.float32)
self.v0 = np.zeros((self.ny + 1 + 2, self.nx + 2), dtype=np.float32)
self.ghosts = [1, 1, 1, 1] # north, east, south, west
self.etaRange = [-1, -1, 1, 1]
self.uRange = [-1, -2, 1, 2]
self.vRange = [-2, -1, 2, 1]
self.refEtaRange = self.etaRange
self.refURange = self.uRange
self.refVRange = self.vRange
self.boundaryConditions = None
self.T = 50.0
self.sim = None
def setUp(self):
self.gpu_ctx = Common.CUDAContext()
self.nx = 50
self.ny = 70
self.dx = 200.0
self.dy = 200.0
self.dt = 1
self.g = 9.81
self.f = 0.0
self.r = 0.0
self.h0 = None #np.ones((self.ny, self.nx), dtype=np.float32) * 60;
self.eta0 = None # np.zeros((self.ny, self.nx), dtype=np.float32);
self.u0 = None # np.zeros((self.ny, self.nx+1), dtype=np.float32);
self.v0 = None # np.zeros((self.ny+1, self.nx), dtype=np.float32);
self.T = 50.0
self.boundaryConditions = None #Common.BoundaryConditions()
self.ghosts = [1, 1, 1, 1]
self.arrayRange = None
self.sim = None
def generateInitialConditions(sim_args, water_depth):
from SWESimulators import CDKLM16, Common
assert (MPI.COMM_WORLD.rank == 0)
dataShape = (sim_args['ny'] + 4, sim_args['nx'] + 4)
dataShapeHi = (sim_args['ny'] + 5, sim_args['nx'] + 5)
sim_ic = {
'H': np.ones(dataShapeHi, dtype=np.float32) * water_depth,
'eta0': np.zeros(dataShape, dtype=np.float32),
'hu0': np.zeros(dataShape, dtype=np.float32),
'hv0': np.zeros(dataShape, dtype=np.float32)
}
#Very inefficient way of creating perturbed initial state, but works
cuda_ctx = Common.CUDAContext()
sim = CDKLM16.CDKLM16(cuda_ctx, **sim_args, **sim_ic)
sim.perturbState(q0_scale=100) # Create a random initial state
sim_ic['eta0'], sim_ic['hu0'], sim_ic['hv0'] = sim.download(
interior_domain_only=False)
sim_ic['H'] = sim.downloadBathymetry()[0]
sim = None
gc.collect()
return sim_ic
def setUp(self):
self.gpu_ctx = Common.CUDAContext()
self.sim = None
self.file_sim = None
self.printall = True
def setUp(self):
self.nx = 1
self.ny = 1
self.dx = 1.0
self.dy = 1.0
self.dt = 1.0
self.numParticles = 3
self.observationVariance = 0.5
self.boundaryCondition = Common.BoundaryConditions(2, 2, 2, 2)
self.smallParticleSet = None
# to be initialized by child class with above values
# create_small_particle_set:
self.cl_ctx = None
self.smallPositionSetHost = np.array([[0.9, 0.9], [0.9, 0.1],
[0.1, 0.9], [0.1, 0.1]])
self.resampleNumParticles = 6
self.resamplingParticleArray = np.zeros((7, 2))
self.resamplingObservationVariance = 0.1
for i in range(2):
self.resamplingParticleArray[3 * i + 0, :] = [0.25, 0.35 + i * 0.3]
self.resamplingParticleArray[3 * i + 1, :] = [0.4, 0.35 + i * 0.3]
self.resamplingParticleArray[3 * i + 2, :] = [0.65, 0.35 + i * 0.3]
self.resamplingParticleArray[6, :] = [0.25, 0.5]
self.resamplingParticleSet = None
# to be initialized by child class wit resampleNumParticles only.
self.resamplingVar = 1e-8
def setUp(self):
self.gpu_ctx = Common.CUDAContext()
self.nx = 50
self.ny = 70
self.dx = 200.0
self.dy = 200.0
self.dt = 0.95
self.g = 9.81
self.f = 0.0
self.r = 0.0
self.A = 1
#self.h0 = np.ones((self.ny+2, self.nx+2), dtype=np.float32) * 60;
self.waterHeight = 60
self.eta0 = None
self.u0 = None
self.v0 = None
self.Hi = None
self.Bi = None
self.ghosts = [2,2,2,2] # north, east, south, west
self.validDomain = np.array([2,2,2,2])
self.refRange = [-2, -2, 2, 2]
self.dataRange = self.refRange
self.boundaryConditions = None
self.T = 50.0
self.sim = None
def __init__(self, numDrifters, observation_variance=0.1, \
boundaryConditions=Common.BoundaryConditions(), \
domain_size_x=1.0, domain_size_y=1.0):
"""
Creates a GlobalParticles object for drift trajectory ensemble.
numDrifters: number of drifers in the collection, not included the observation
observation_variance: uncertainty of observation position
boundaryConditions: BoundaryConditions object, relevant during re-initialization of particles.
"""
self.numDrifters = numDrifters
# Observation index is the last particle
self.obs_index = self.numDrifters
self.observation_variance = observation_variance
self.positions = None # Needs to be allocated in the child class
# Should represent all particles plus observation
self.domain_size_x = domain_size_x
self.domain_size_y = domain_size_y
# Boundary conditions are read from a BoundaryConditions object
self.boundaryConditions = boundaryConditions
def cuda_context_handler(self, line):
args = magic_arguments.parse_argstring(self.cuda_context_handler, line)
self.logger = logging.getLogger(__name__)
self.logger.info("Registering %s in user workspace", args.name)
if args.name in self.shell.user_ns.keys():
self.logger.debug("Context already registered! Ignoring")
return
else:
self.logger.debug("Creating context")
use_cache = False if args.no_cache else True
self.shell.user_ns[args.name] = Common.CUDAContext(
blocking=args.blocking, use_cache=use_cache)
# this function will be called on exceptions in any cell
def custom_exc(shell, etype, evalue, tb, tb_offset=None):
self.logger.exception(
"Exception caught: Resetting to CUDA context %s", args.name)
while (cuda.Context.get_current() != None):
context = cuda.Context.get_current()
self.logger.info("Popping <%s>", str(context.handle))
cuda.Context.pop()
if args.name in self.shell.user_ns.keys():
self.logger.info(
"Pushing <%s>",
str(self.shell.user_ns[args.name].cuda_context.handle))
self.shell.user_ns[args.name].cuda_context.push()
else:
self.logger.error(
"No CUDA context called %s found (something is wrong)",
args.name)
self.logger.error("CUDA will not work now")
self.logger.debug(
"=================================================================="
)
# still show the error within the notebook, don't just swallow it
shell.showtraceback((etype, evalue, tb), tb_offset=tb_offset)
# this registers a custom exception handler for the whole current notebook
get_ipython().set_custom_exc((Exception, ), custom_exc)
# Handle CUDA context when exiting python
import atexit
def exitfunc():
self.logger.info("Exitfunc: Resetting CUDA context stack")
while (cuda.Context.get_current() != None):
context = cuda.Context.get_current()
self.logger.info("`-> Popping <%s>", str(context.handle))
cuda.Context.pop()
self.logger.debug(
"=================================================================="
)
atexit.register(exitfunc)
def setBoundaryConditions(self, bcSettings=1):
if (bcSettings == 1):
self.boundaryConditions = Common.BoundaryConditions()
#self.ghosts = [0,0,0,0] # north, east, south, west
self.arrayRange = [None, None, 0, 0]
elif (bcSettings == 2):
self.boundaryConditions = Common.BoundaryConditions(2, 2, 2, 2)
#self.ghosts = [1,1,0,0] # Both periodic
self.arrayRange = [-1, -1, 0, 0]
elif bcSettings == 3:
self.boundaryConditions = Common.BoundaryConditions(2, 1, 2, 1)
#self.ghosts = [1,0,0,0] # periodic north-south
self.arrayRange = [-1, None, 0, 0]
else:
self.boundaryConditions = Common.BoundaryConditions(1, 2, 1, 2)
#self.ghosts = [0,1,0,0] # periodic east-west
self.arrayRange = [None, -1, 0, 0]
def setUp(self):
self.sim = None
self.ensemble = None
self.iewpf = None
self.gpu_ctx = Common.CUDAContext()
self.setUpAndStartEnsemble()
def setGridInfo(self,
nx,
ny,
dx,
dy,
dt,
boundaryConditions=Common.BoundaryConditions(),
eta=None,
hu=None,
hv=None,
H=None):
self.nx = nx
self.ny = ny
self.dx = dx
self.dy = dy
self.dt = dt
# Default values for now:
self.initialization_variance = 10 * dx
self.midPoint = 0.5 * np.array([self.nx * self.dx, self.ny * self.dy])
self.initialization_cov = np.eye(2) * self.initialization_variance
self.boundaryConditions = boundaryConditions
assert (self.simType == 'CDKLM16'
), 'CDKLM16 is currently the only supported scheme'
#if self.simType == 'CDKLM16':
self.ghostCells = np.array([2, 2, 2, 2])
if self.boundaryConditions.isSponge():
sponge = self.boundaryConditions.getSponge()
for i in range(4):
if sponge[i] > 0:
self.ghostCells[i] = sponge[i]
dataShape = (ny + self.ghostCells[0] + self.ghostCells[2],
nx + self.ghostCells[1] + self.ghostCells[3])
self.base_eta = eta
self.base_hu = hu
self.base_hv = hv
self.base_H = H
# Create base initial data:
if self.base_eta is None:
self.base_eta = np.zeros(dataShape, dtype=np.float32, order='C')
if self.base_hu is None:
self.base_hu = np.zeros(dataShape, dtype=np.float32, order='C')
if self.base_hv is None:
self.base_hv = np.zeros(dataShape, dtype=np.float32, order='C')
# Bathymetry:
if self.base_H is None:
waterDepth = 10
self.base_H = np.ones((dataShape[0] + 1, dataShape[1] + 1),
dtype=np.float32,
order='C') * waterDepth
self.setParameters()
def setup_mpi(self, line):
args = magic_arguments.parse_argstring(self.setup_mpi, line)
logger = logging.getLogger('SWESimulators')
if args.name in self.shell.user_ns.keys():
logger.warning("MPI alreay set up, resetting")
self.shell.user_ns[args.name].shutdown()
self.shell.user_ns[args.name] = None
gc.collect()
self.shell.user_ns[args.name] = Common.IPEngine(args.num_engines)
def test_collection_mean(self):
self.set_positions_small_set()
periodicMean = [1-0.1/3, 1-0.1/3]
nonPeriodicMean = [(0.9 + 0.9 + 0.1)/3, (0.9 + 0.9 + 0.1)/3]
semiPeriodicMean = [nonPeriodicMean[0], periodicMean[1]]
assertListAlmostEqual(self, self.smallDrifterSet.getCollectionMean().tolist(),
periodicMean, 6,
'periodic mean')
self.smallDrifterSet.setBoundaryConditions(Common.BoundaryConditions(1,1,1,1))
assertListAlmostEqual(self, self.smallDrifterSet.getCollectionMean().tolist(),
nonPeriodicMean, 6,
'non-periodic mean')
self.smallDrifterSet.setBoundaryConditions(Common.BoundaryConditions(2,1,2,1))
assertListAlmostEqual(self, self.smallDrifterSet.getCollectionMean().tolist(),
semiPeriodicMean, 6,
'north-south-periodic mean')
def animateWind(wind_source, create_movie=True):
time = wind_source.t
max_stress = max(np.max(np.abs(wind_source.X)), np.max(np.abs(wind_source.Y)))
wind_stress = np.sqrt(wind_source.X**2, wind_source.Y**2)
fig = plt.figure(figsize=(12,3))
ax = [None]*3
sc = [None]*3
ax[0] = plt.subplot(1,3,1)
plt.title("Wind stress (total)")
sc[0] = plt.imshow(wind_stress[0], origin='lower', vmin=0, cmap='Reds')
plt.colorbar(shrink=0.6)
ax[1] = plt.subplot(1,3,2)
plt.title("Wind stress u")
sc[1] = plt.imshow(wind_source.X[0], origin='lower', cmap='bwr', vmin=-max_stress, vmax=max_stress)
plt.colorbar(shrink=0.6)
ax[2] = plt.subplot(1,3,3)
plt.title("Wind stress v")
sc[2] = plt.imshow(wind_source.Y[0], origin='lower', cmap='bwr', vmin=-max_stress, vmax=max_stress)
plt.colorbar(shrink=0.6)
progress = Common.ProgressPrinter(5)
pp = display(progress.getPrintString(0),display_id=True)
#Helper function which simulates and plots the solution
def animate(i):
fig.suptitle("Time = {:04.0f} h".format(time[i]/3600), fontsize=18)
fig.sca(ax[0])
sc[0].set_data(wind_stress[i])
fig.sca(ax[1])
sc[1].set_data(wind_source.X[i])
fig.sca(ax[2])
sc[2].set_data(wind_source.Y[i])
pp.update(progress.getPrintString(i / (len(time)-1)))
#Matplotlib for creating an animation
if (create_movie):
anim = animation.FuncAnimation(fig, animate, range(len(time)), interval=250)
plt.close(fig)
return anim
else:
pass
def _setGridInfo(self,
nx,
ny,
dx,
dy,
dt,
boundaryConditions=Common.BoundaryConditions(),
eta=None,
hu=None,
hv=None,
H=None):
"""
Declaring grid-related member variables
"""
self.nx = nx
self.ny = ny
self.dx = dx
self.dy = dy
self.dt = dt
self.boundaryConditions = boundaryConditions
assert (self.simType == 'CDKLM16'
), 'CDKLM16 is currently the only supported scheme'
self.ghostCells = np.array([2, 2, 2, 2])
if self.boundaryConditions.isSponge():
sponge = self.boundaryConditions.getSponge()
for i in range(4):
if sponge[i] > 0:
self.ghostCells[i] = sponge[i]
dataShape = (ny + self.ghostCells[0] + self.ghostCells[2],
nx + self.ghostCells[1] + self.ghostCells[3])
self.base_eta = eta
self.base_hu = hu
self.base_hv = hv
self.base_H = H
# Create base initial data:
if self.base_eta is None:
self.base_eta = np.zeros(dataShape, dtype=np.float32, order='C')
if self.base_hu is None:
self.base_hu = np.zeros(dataShape, dtype=np.float32, order='C')
if self.base_hv is None:
self.base_hv = np.zeros(dataShape, dtype=np.float32, order='C')
# Bathymetry:
if self.base_H is None:
waterDepth = 10
self.base_H = np.ones((dataShape[0] + 1, dataShape[1] + 1),
dtype=np.float32,
order='C') * waterDepth
def test_copy_buffer(self):
clarray2 = Common.CUDAArray2D(self.gpu_stream, \
self.nx, self.ny, self.nx_halo, self.ny_halo, \
self.buf3)
host_data_pre_copy = self.cudaarray.download(self.gpu_stream)
self.assertEqual(host_data_pre_copy.tolist(), self.buf1.tolist())
self.cudaarray.copyBuffer(self.gpu_stream, clarray2)
host_data_post_copy = self.cudaarray.download(self.gpu_stream)
self.assertEqual(host_data_post_copy.tolist(), self.buf3.tolist())
self.tests_failed = False
def test_copy_buffer(self):
clarray2 = Common.OpenCLArray2D(self.cl_ctx, \
self.nx, self.ny, self.nx_halo, self.ny_halo, \
self.buf3)
host_data_pre_copy = self.clarray.download(self.cl_queue)
self.assertEqual(host_data_pre_copy.tolist(), self.buf1.tolist())
self.clarray.copyBuffer(self.cl_queue, clarray2)
host_data_post_copy = self.clarray.download(self.cl_queue)
self.assertEqual(host_data_post_copy.tolist(), self.buf3.tolist())
self.tests_failed = False
def create_noise(self):
n, e, s, w = 1, 1, 1, 1
if self.periodicNS:
n, s = 2, 2
if self.periodicEW:
e, w = 2, 2
self.noise = OceanStateNoise(self.gpu_ctx,
self.gpu_stream,
self.nx,
self.ny,
self.dx,
self.dy,
Common.BoundaryConditions(n, e, s, w),
staggered=self.staggered)
def setUp(self):
#Set which CL device to use, and disable kernel caching
self.gpu_ctx = Common.CUDAContext()
# Make some host data which we can play with
self.nx = 3
self.ny = 5
self.nx_halo = 1
self.ny_halo = 2
self.dataShape = (self.ny + 2 * self.ny_halo,
self.nx + 2 * self.nx_halo)
self.buf1 = np.zeros(self.dataShape, dtype=np.float32, order='C')
self.dbuf1 = np.zeros(self.dataShape)
self.buf3 = np.zeros(self.dataShape, dtype=np.float32, order='C')
self.dbuf3 = np.zeros(self.dataShape)
for j in range(self.dataShape[0]):
for i in range(self.dataShape[1]):
self.buf1[j, i] = i * 100 + j
self.dbuf1[j, i] = self.buf1[j, i]
self.buf3[j, i] = j * 1000 - i
self.dbuf3[j, i] = self.buf3[j, i]
self.explicit_free = False
self.device_name = self.gpu_ctx.cuda_device.name()
self.gpu_stream = cuda.Stream()
self.tests_failed = True
self.cudaarray = Common.CUDAArray2D(self.gpu_stream, \
self.nx, self.ny, \
self.nx_halo, self.ny_halo, \
self.buf1)
self.double_cudaarray = None
def setUp(self):
self.gpu_ctx = Common.CUDAContext()
self.gpu_stream = cuda.Stream()
self.nx = 30
self.ny = 40
self.dx = 7.0
self.dy = 7.0
self.f = 0.02
self.g = 9.81
self.beta = 0.0
self.noise = None
self.ghost_cells_x = 2
self.ghost_cells_y = 2
self.datashape = (self.ny + 2 * self.ghost_cells_y,
self.nx + 2 * self.ghost_cells_x)
self.cutoff = 2
self.nx_nonPeriodic = self.nx + 2 * (2 + self.cutoff)
self.ny_nonPeriodic = self.ny + 2 * (2 + self.cutoff)
# Standard setup is non-staggered, periodic
self.staggered = False
self.periodicNS = True
self.periodicEW = True
# Total number of threads should be: 16, 32, 48, 64
# Corresponding to the number of blocks: 1, 2, 3, 4
self.glob_size_x = 3
self.glob_size_y = 3
self.glob_size_x_nonperiodic = 3
self.glob_size_y_nonperiodic = 3
self.glob_size_random_x = 1
self.glob_size_random_x_nonperiodic = 2
self.large_nx = 400
self.large_ny = 400
self.large_noise = None
self.floatMax = 2147483648.0
self.eta = None
self.hu = None
self.hv = None
self.H = None
