def _init(self, driftersPerOceanModel=1):
"""
Initiating the ensemble by perturbing the input simulator and attaching drifters
"""
self.driftersPerOceanModel = np.int32(driftersPerOceanModel)
for i in range(self.numParticles + 1):
self.particles[i] = CDKLM16.CDKLM16(self.gpu_ctx, \
self.base_eta, self.base_hu, self.base_hv, \
self.base_H, \
self.nx, self.ny, self.dx, self.dy, self.dt, \
self.g, self.f, self.r, \
boundary_conditions=self.boundaryConditions, \
write_netcdf=False, \
small_scale_perturbation=True, \
small_scale_perturbation_amplitude=self.small_scale_perturbation_amplitude,
small_scale_perturbation_interpolation_factor=self.small_scale_perturbation_interpolation_factor)
if self.initialization_variance_factor_ocean_field != 0.0:
self.particles[i].perturbState(
q0_scale=self.initialization_variance_factor_ocean_field)
# Add drifters
drifters = GPUDrifterCollection.GPUDrifterCollection(
self.gpu_ctx,
self.driftersPerOceanModel,
observation_variance=self.observation_variance,
boundaryConditions=self.boundaryConditions,
initialization_cov_drifters=self.initialization_cov_drifters,
domain_size_x=self.nx * self.dx,
domain_size_y=self.ny * self.dy)
self.particles[i].attachDrifters(drifters)
def init(self, driftersPerOceanModel=1):
self.driftersPerOceanModel = driftersPerOceanModel
# Define mid-points for the different drifters
# Decompose the domain, so that we spread the drifters as much as possible
sub_domains_y = np.int(np.round(np.sqrt(self.driftersPerOceanModel)))
sub_domains_x = np.int(
np.ceil(1.0 * self.driftersPerOceanModel / sub_domains_y))
self.midPoints = np.empty((driftersPerOceanModel, 2))
for sub_y in range(sub_domains_y):
for sub_x in range(sub_domains_x):
drifter_id = sub_y * sub_domains_x + sub_x
if drifter_id >= self.driftersPerOceanModel:
break
self.midPoints[drifter_id,
0] = (sub_x +
0.5) * self.nx * self.dx / sub_domains_x
self.midPoints[drifter_id,
1] = (sub_y +
0.5) * self.ny * self.dy / sub_domains_y
for i in range(self.numParticles + 1):
self.particles[i] = CDKLM16.CDKLM16(self.gpu_ctx, \
self.base_eta, self.base_hu, self.base_hv, \
self.base_H, \
self.nx, self.ny, self.dx, self.dy, self.dt, \
self.g, self.f, self.r, \
boundary_conditions=self.boundaryConditions, \
write_netcdf=False, \
small_scale_perturbation=True, \
small_scale_perturbation_amplitude=self.small_scale_perturbation_amplitude)
if self.initialization_variance_factor_ocean_field != 0.0:
self.particles[i].perturbState(
q0_scale=self.initialization_variance_factor_ocean_field)
drifters = GPUDrifterCollection.GPUDrifterCollection(
self.gpu_ctx,
driftersPerOceanModel,
observation_variance=self.observation_variance,
boundaryConditions=self.boundaryConditions,
domain_size_x=self.nx * self.dx,
domain_size_y=self.ny * self.dy)
initPos = np.empty((self.driftersPerOceanModel, 2))
for d in range(self.driftersPerOceanModel):
initPos[d, :] = np.random.multivariate_normal(
self.midPoints[d, :], self.initialization_cov_drifters)
drifters.setDrifterPositions(initPos)
#print "drifter particles: ", drifter.getParticlePositions()
#print "drifter observations: ", drifter.getObservationPosition()
self.particles[i].attachDrifters(drifters)
# Put the initial positions into the observation array
self._addObservation(self.observeTrueDrifters())
def __init__(self,
gpu_ctx,
sim_args,
sim_ic,
num_particles,
drifter_positions=[],
observation_variance=0.01**2,
initialization_variance_factor_ocean_field=0.0):
"""
Constructor which creates num_particles slighly different ocean models
based on the same initial conditions
"""
self.logger = logging.getLogger(__name__)
self.gpu_ctx = gpu_ctx
self.sim_args = sim_args
self.observation_variance = observation_variance
self.initialization_variance_factor_ocean_field = initialization_variance_factor_ocean_field
# Build observation covariance matrix:
if np.isscalar(self.observation_variance):
self.observation_cov = np.eye(2) * self.observation_variance
self.observation_cov_inverse = np.eye(2) * (
1.0 / self.observation_variance)
else:
# Assume that we have a correctly shaped matrix here
self.observation_cov = self.observation_variance
self.observation_cov_inverse = np.linalg.inv(self.observation_cov)
# Generate ensemble members
self.logger.debug("Creating %d particles (ocean models)",
num_particles)
self.particles = [None] * num_particles
for i in range(num_particles):
self.particles[i] = CDKLM16.CDKLM16(self.gpu_ctx, **sim_ic,
**self.sim_args)
if self.initialization_variance_factor_ocean_field != 0.0:
self.particles[i].perturbState(
q0_scale=self.initialization_variance_factor_ocean_field)
# Attach drifters if requested
self.logger.debug("Attaching %d drifters", len(drifter_positions))
if (len(drifter_positions) > 0):
drifters = GPUDrifterCollection.GPUDrifterCollection(
self.gpu_ctx,
len(drifter_positions),
observation_variance=self.observation_variance,
boundaryConditions=sim_ic['boundary_conditions'],
domain_size_x=sim_args['nx'] * sim_args['dx'],
domain_size_y=sim_args['ny'] * sim_args['dy'])
drifters.setDrifterPositions(drifter_positions)
self.particles[i].attachDrifters(drifters)
def init(self, driftersPerOceanModel=1):
self.windSpeed = 2.0
self.directions = np.random.rand(self.numParticles + 1) * 360
self.windX, self.windY = self.XandYfromDirections(self.directions)
#print "Directions: ", self.directions
self.driftersPerOceanModel = driftersPerOceanModel
self.windT = np.zeros((1), dtype=np.float32)
for i in range(self.numParticles + 1):
wX = [self.windX[i] * np.ones((2, 2), dtype=np.float32)]
wY = [self.windY[i] * np.ones((2, 2), dtype=np.float32)]
wind = WindStress.WindStress(self.windT, wX, wY)
#print ("Init with wind :", (wX, wY))
self.particles[i] = CDKLM16.CDKLM16(self.gpu_ctx, \
self.base_eta, self.base_hu, self.base_hv, \
self.base_H, \
self.nx, self.ny, self.dx, self.dy, self.dt, \
self.g, self.f, self.r, \
wind_stress=wind, \
boundary_conditions=self.boundaryConditions, \
write_netcdf=False)
if i == self.numParticles:
# All particles done, only the observation is left,
# and for the observation we only use one drifter, regardless of the
# number in the other particles.
driftersPerOceanModel = 1
drifters = GPUDrifterCollection.GPUDrifterCollection(
self.gpu_ctx,
driftersPerOceanModel,
observation_variance=self.observation_variance,
boundaryConditions=self.boundaryConditions,
domain_size_x=self.nx * self.dx,
domain_size_y=self.ny * self.dy)
initPos = np.random.multivariate_normal(
self.midPoint, self.initialization_cov_drifters,
driftersPerOceanModel)
drifters.setDrifterPositions(initPos)
#print "drifter particles: ", drifter.getParticlePositions()
#print "drifter observations: ", drifter.getObservationPosition()
self.particles[i].attachDrifters(drifters)
# Put the initial positions into the observation array
self._addObservation(self.observeTrueDrifters())
print("Added init to observation array")
def attachDrifters(self, drifter_positions):
for i in range(self.numParticles):
# Attach drifters if requested
self.logger.debug("Attaching %d drifters", len(drifter_positions))
if (len(drifter_positions) > 0):
drifters = GPUDrifterCollection.GPUDrifterCollection(
self.gpu_ctx,
len(drifter_positions),
observation_variance=self.observation_variance,
boundaryConditions=self.data_args['boundary_conditions'],
domain_size_x=self.data_args['nx'] * self.data_args['dx'],
domain_size_y=self.data_args['ny'] * self.data_args['dy'])
drifters.setDrifterPositions(drifter_positions)
self.particles[i].attachDrifters(drifters)
self.drifterForecast[i] = Observation.Observation()
self.drifterForecast[i].add_observation_from_sim(
self.particles[i])
def init(self):
self.sim = CDKLM16.CDKLM16(self.gpu_ctx, \
self.base_eta, self.base_hu, self.base_hv, \
self.base_H, \
self.nx, self.ny, self.dx, self.dy, self.dt, \
self.g, self.f, self.r, \
wind_stress=self.wind, \
boundary_conditions=self.boundaryConditions, \
write_netcdf=False)
# TO CHECK! Is it okay to have drifters as self.drifters - in order to easier reach its member functions?
self.drifters = GPUDrifterCollection.GPUDrifterCollection(self.gpu_ctx, self.numParticles,
observation_variance=self.observation_variance,
boundaryConditions=self.boundaryConditions,
domain_size_x=self.nx*self.dx, domain_size_y=self.ny*self.dy)
self.drifters.initializeUniform()
self.sim.attachDrifters(self.drifters)
def create_large_drifter_set(self, size, domain_x, domain_y):
self.largeDrifterSet = GPUDrifterCollection(self.gpu_ctx,
size,
domain_size_x=domain_x,
domain_size_y=domain_y)
def create_resampling_drifter_set(self):
self.resamplingDrifterSet = GPUDrifterCollection(
self.gpu_ctx, self.resampleNumDrifters)
def create_small_drifter_set(self):
self.smallDrifterSet = GPUDrifterCollection(self.gpu_ctx,
self.numDrifters,
self.observationVariance,
self.boundaryCondition)
netcdf_iterations = int(
(forecast_end_time - forecast_start_time) / netcdf_intervals)
observations_iterations = int(netcdf_intervals / observation_intervals)
for particle_id in range(ensemble.getNumParticles()):
if ensemble.particlesActive[particle_id]:
sim = ensemble.particles[particle_id]
tic = time.time()
next_obs_time = sim.t
drifters = GPUDrifterCollection.GPUDrifterCollection(
gpu_ctx,
num_drifters,
boundaryConditions=ensemble.getBoundaryConditions(),
domain_size_x=ensemble.getDomainSizeX(),
domain_size_y=ensemble.getDomainSizeY())
drifters.setDrifterPositions(drifter_start_positions)
sim.attachDrifters(drifters)
forecast_file_name = forecastFileBase + str(particle_id).zfill(
4) + ".bz2"
observations = Observation.Observation()
observations.add_observation_from_sim(sim)
for netcdf_it in range(netcdf_iterations):
for obs_it in range(observations_iterations):
next_obs_time += observation_intervals
def simulate_gpuocean_deterministic(source_url, domain, initx, inity,
sim_args, norkyst_data = True, erode_land = 1,
wind_drift_factor = 0.0, rescale=0,
forecast_file = None, start_forecast_hours = 0, duration = 23,
ocean_state_file = None, netcdf_frequency = 5 ):
"""
source_url: url or local file or list of either with fielddata in NetCDF-format
domain: array/list on form [x0,x1,y0,y1] defining the domain for the simulation
initx, inity = initial coordinates of single drifter or lists with coordinates for multiple drifters.
In local cartesian coordinates of simulation-domain.
norkyst_data: (default True) If True, assumes data from norkyst800. Else, works with norfjords160m(and probably other ROMS data).
sim_args, erode_land, observation_type: arguments needed for simulator and observation object. sim_args must be given.
wind_drift_factor: fraction of wind-speed at which objects will be advected. Default is 0 (no direct wind-drift)
rescale: factor setting resolution of simulation-grid. 0 indicates no rescaling(original resolution),
while any other number changes the resolution (ie 2 gives double resolution)
forecast_file: optional file for storing trajectory (pickle)
ocean_state_file: optional file for storing ocean state (netcdf)
netcdf_frequency: frequency(in hours) for storing of ocean states.
start_forecast_hours = number hours after which to start simulating drifttrajectories(ocean model starts at beginning of field-data)
Default is at beginning of field-data.
forecast_duration = duration of simulation(including possibly only ocean simulation). Default is 24 hours.
"""
end_forecast_hours = start_forecast_hours + duration
#Create simulator
data_args = NetCDFInitialization.getInitialConditions(source_url, domain[0], domain[1], domain[2],domain[3] ,
timestep_indices = None,norkyst_data = norkyst_data, erode_land = erode_land, download_data = False)
if wind_drift_factor:
wind_data = data_args.pop('wind', None)
else:
wind_data = None
if rescale:
data_args = NetCDFInitialization.rescaleInitialConditions(data_args, scale=rescale)
sim = CDKLM16.CDKLM16(**sim_args, **NetCDFInitialization.removeMetadata(data_args))
#Forecast
observation_type = dautils.ObservationType.UnderlyingFlow
observation_args = {'observation_type': observation_type,
'nx': sim.nx, 'ny': sim.ny,
'domain_size_x': sim.nx*sim.dx,
'domain_size_y': sim.ny*sim.dy,
'land_mask': sim.getLandMask()
}
trajectory_forecast = Observation.Observation(**observation_args)
#Drifters
#Assumes initx, inity same format/shape
if type(initx) is not list:
initx = [initx]
inity = [inity]
num_drifters = len(initx)
drifters = GPUDrifterCollection.GPUDrifterCollection(sim_args['gpu_ctx'], num_drifters, wind = wind_data,
wind_drift_factor = wind_drift_factor,
boundaryConditions = sim.boundary_conditions,
domain_size_x = trajectory_forecast.domain_size_x,
domain_size_y = trajectory_forecast.domain_size_y,
gpu_stream = sim.gpu_stream)
drifter_pos_init = np.array([initx, inity]).T
try:
if ocean_state_file is not None:
print("Storing ocean state to netCDF-file: " + ocean_state_file)
ncfile = Dataset(ocean_state_file, 'w')
var = {}
var['eta'], var['hu'], var['hv'] = sim.download(interior_domain_only=False)
_, var['Hm'] = sim.downloadBathymetry(interior_domain_only=False)
ny, nx = var['eta'].shape
# Create dimensions
ncfile.createDimension('time', None) # unlimited
ncfile.createDimension('x', nx)
ncfile.createDimension('y', ny)
ncvar = {}
# Create variables for dimensions
ncvar['time'] = ncfile.createVariable('time', 'f8', ('time',))
ncvar['x'] = ncfile.createVariable('x', 'f4', ('x',))
ncvar['y'] = ncfile.createVariable('y', 'f4', ('y',))
# Fill dimension variables
ncvar['x'][:] = np.linspace(0, nx*sim.dx, nx)
ncvar['y'][:] = np.linspace(0, ny*sim.dy, ny)
# Create static variables
ncvar['Hm'] = ncfile.createVariable('Hm', 'f8', ('y', 'x',), zlib=True)
ncvar['Hm'][:,:] = var['Hm'][:,:]
# Create time varying data variables
for varname in ['eta', 'hu', 'hv']:
ncvar[varname] = ncfile.createVariable(varname, 'f8', ('time', 'y', 'x',), zlib=True)
ncvar['num_iterations'] = ncfile.createVariable('num_iterations', 'i4', ('time',))
#Run simulation
num_total_hours = end_forecast_hours
five_mins_in_an_hour = 12
sub_dt = 5*60 # five minutes
progress = Common.ProgressPrinter(5)
pp = display(progress.getPrintString(0), display_id=True)
netcdf_counter = 0
for hour in range(num_total_hours):
if hour == start_forecast_hours:
# Attach drifters
drifters.setDrifterPositions(drifter_pos_init)
sim.attachDrifters(drifters)
trajectory_forecast.add_observation_from_sim(sim)
for mins in range(five_mins_in_an_hour):
t = sim.step(sub_dt)
if hour >= start_forecast_hours:
trajectory_forecast.add_observation_from_sim(sim)
if ocean_state_file is not None and hour%netcdf_frequency == 0:
var['eta'], var['hu'], var['hv'] = sim.download(interior_domain_only=False)
ncvar['time'][netcdf_counter] = sim.t
ncvar['num_iterations'][netcdf_counter] = sim.num_iterations
abort=False
for varname in ['eta', 'hu', 'hv']:
ncvar[varname][netcdf_counter,:,:] = var[varname][:,:] #np.ma.masked_invalid(var[varname][:,:])
if (np.any(np.isnan(var[varname]))):
print("Variable " + varname + " contains NaN values!")
abort=True
netcdf_counter += 1
if (abort):
print("Aborting at t=" + str(sim.t))
ncfile.sync()
break
pp.update(progress.getPrintString(hour/(end_forecast_hours-1)))
if forecast_file is not None:
trajectory_forecast.to_pickle(forecast_file)
except Exception as e:
print("Something went wrong:" + str(e))
raise e
finally:
if ocean_state_file is not None:
ncfile.close()
return trajectory_forecast
def simulate_gpuocean_deterministic(source_url,
domain,
initx,
inity,
sim_args,
erode_land=1,
wind_drift_factor=0.0,
rescale=0,
outfolder=None,
start_forecast_hours=0,
forecast_duration=23):
"""
source_url: url or local file or list of either with fielddata in NetCDF-format
domain: array/list on form [x0,x1,y0,y1] defining the domain for the simulation
initx, inity = initial coordinates of single drifter or lists with coordinates for multiple drifters.
In local cartesian coordinates of simulation-domain.
sim_args, erode_land, observation_type: arguments needed for simulator and observation object. sim_args must be given.
wind_drift_factor: fraction of wind-speed at which objects will be advected. Default is 0 (no direct wind-drift)
rescale: factor setting resolution of simulation-grid. 0 indicates no rescaling(original resolution),
while any other number changes the resolution (ie 2 gives double resolution)
outfolder: outfolder
start_forecast_hours = number hours after which to start simulating drifttrajectories(ocean model starts at beginning of field-data)
Default is at beginning of field-data.
forecast_duration = duration of simulation(including possibly only ocean simulation). Default is 24 hours.
"""
end_forecast_hours = start_forecast_hours + forecast_duration
#Create simulator
data_args = NetCDFInitialization.getInitialConditions(
source_url,
domain[0],
domain[1],
domain[2],
domain[3],
timestep_indices=None,
erode_land=erode_land,
download_data=False)
if wind_drift_factor:
wind_data = data_args.pop('wind', None)
else:
wind_data = None
if rescale:
data_args = NetCDFInitialization.rescaleInitialConditions(
data_args, scale=rescale)
sim = CDKLM16.CDKLM16(**sim_args,
**NetCDFInitialization.removeMetadata(data_args))
#Forecast
observation_type = dautils.ObservationType.UnderlyingFlow
observation_args = {
'observation_type': observation_type,
'nx': sim.nx,
'ny': sim.ny,
'domain_size_x': sim.nx * sim.dx,
'domain_size_y': sim.ny * sim.dy,
'land_mask': sim.getLandMask()
}
trajectory_forecast = Observation.Observation(**observation_args)
if outfolder is not None:
trajectory_forecast_filename = 'trajectory_forecast_' + str(
start_forecast_hours) + '_to_' + str(
end_forecast_hours) + '.pickle'
#Drifters
#Assumes initx, inity same format/shape
if type(initx) is not list:
initx = [initx]
inity = [inity]
num_drifters = len(initx)
drifters = GPUDrifterCollection.GPUDrifterCollection(
sim_args['gpu_ctx'],
num_drifters,
wind=wind_data,
wind_drift_factor=wind_drift_factor,
boundaryConditions=sim.boundary_conditions,
domain_size_x=trajectory_forecast.domain_size_x,
domain_size_y=trajectory_forecast.domain_size_y,
gpu_stream=sim.gpu_stream)
drifter_pos_init = np.array([initx, inity]).T
#Run simulation
num_total_hours = end_forecast_hours
five_mins_in_an_hour = 12
sub_dt = 5 * 60 # five minutes
progress = Common.ProgressPrinter(5)
pp = display(progress.getPrintString(0), display_id=True)
for hour in range(num_total_hours):
if hour == start_forecast_hours:
# Attach drifters
drifters.setDrifterPositions(drifter_pos_init)
sim.attachDrifters(drifters)
trajectory_forecast.add_observation_from_sim(sim)
for mins in range(five_mins_in_an_hour):
t = sim.step(sub_dt)
if hour >= start_forecast_hours:
trajectory_forecast.add_observation_from_sim(sim)
pp.update(progress.getPrintString(hour / (end_forecast_hours - 1)))
if outfolder is not None:
trajectory_forecast.to_pickle(trajectory_forecast_path)
return trajectory_forecast
def generateTruth(gpu_ctx,
destination_dir,
duration_in_days=13,
duration_in_hours=0,
folder_name=None,
log_to_screen=False):
"""
This funtion generates a truth simulation that will be the subject for
data assimilation experiments. It is based on the DoubleJetCase parameters
and initial conditions, and is (by default) spun up for 3 days before starting
to write its state to file. The generated data set should cover time range from
day 3 to day 13.
The end time of the truth is duration_in_days + duration_in_hours.
"""
#--------------------------------------------------------------
# PARAMETERS
#--------------------------------------------------------------
# This file takes no parameters, as it is should clearly define a specific truth.
# If we come to a time where we need to specify a lot of different truths, we can introduce argparser again.
# Time parameters
start_time = 3 * 24 * 60 * 60 # 3 days
end_time = (duration_in_days * 24 + duration_in_hours) * 60 * 60
simulation_time = end_time - start_time
observation_frequency = 5 * 60 # 5 minutes
netcdf_frequency = 60 * 60 # every hour
# Drifter parameters:
num_drifters = 64
assert (os.path.exists(destination_dir)
), 'destination_dir does not exist: ' + str(destination_dir)
# File parameters:
folder = os.path.join(
destination_dir,
"truth_" + datetime.datetime.now().strftime("%Y_%m_%d-%H_%M_%S"))
if folder_name is not None:
folder = os.path.join(destination_dir, folder_name)
assert (not os.path.exists(folder)
), 'The directory ' + folder + ' already exists!'
os.makedirs(folder)
netcdf_filename = os.path.join(folder, "double_jet_case_truth.nc")
drifter_filename = os.path.join(folder, "drifter_observations.pickle")
if log_to_screen:
print("------ Generating initial ensemble ---------------")
if log_to_screen: print("Writing truth to file: " + netcdf_filename)
# Create CUDA context
device_name = gpu_ctx.cuda_device.name()
#--------------------------------------------------------------
# Creating the Case (including spin up)
#--------------------------------------------------------------
if log_to_screen: print("Initializing the truth")
tic = time.time()
sim = None
doubleJetCase = None
try:
doubleJetCase = DoubleJetCase.DoubleJetCase(
gpu_ctx, DoubleJetCase.DoubleJetPerturbationType.IEWPFPaperCase)
doubleJetCase_args, doubleJetCase_init = doubleJetCase.getInitConditions(
)
if (np.any(np.isnan(doubleJetCase_init["eta0"]))):
print(" `-> ERROR: Not a number in spinup, aborting!")
raise RuntimeError('Not a number in spinup')
toc = time.time()
if log_to_screen:
print("\n{:02.4f} s: ".format(toc - tic) +
"Generated initial conditions at day 3")
#--------------------------------------------------------------
# Initialize the truth from the Case (spin up is done in the Case)
#--------------------------------------------------------------
toc = time.time()
if log_to_screen:
print("\n{:02.4f} s: ".format(toc - tic) +
"Generated initial conditions for truth")
#netcdf_args = {}
netcdf_args = {
'write_netcdf': True,
'netcdf_filename': netcdf_filename
}
tic = time.time()
sim = CDKLM16.CDKLM16(**doubleJetCase_args, **doubleJetCase_init,
**netcdf_args)
toc = time.time()
if log_to_screen:
print("\n{:02.4f} s: ".format(toc - tic) +
"Truth simulator initiated")
t = sim.t
if log_to_screen:
print("Three days = " + str(start_time) +
" seconds, but sim.t = " + str(sim.t) + ". Same? " +
str(start_time == sim.t))
assert (round(start_time) == round(
sim.t)), 'Spin up time seems to be wrong'
#--------------------------------------------------------------
# Create drifters at t = 3 days
#--------------------------------------------------------------
drifters = GPUDrifterCollection.GPUDrifterCollection(
gpu_ctx,
num_drifters,
boundaryConditions=doubleJetCase_args['boundary_conditions'],
domain_size_x=sim.nx * sim.dx,
domain_size_y=sim.ny * sim.dy)
sim.attachDrifters(drifters)
#--------------------------------------------------------------
# Create observation object and write the first drifter positions
#--------------------------------------------------------------
observations = Observation.Observation(domain_size_x=sim.nx * sim.dx,
domain_size_y=sim.ny * sim.dy,
nx=sim.nx,
ny=sim.ny)
# Configure observations to register static positions
observations.setBuoyCellsByFrequency(25, 25)
observations.add_observation_from_sim(sim)
netcdf_iterations = int(simulation_time / netcdf_frequency)
observation_sub_iterations = int(netcdf_frequency /
observation_frequency)
if log_to_screen: print("We will now make " + str(netcdf_iterations) + " iterations with writing netcdf, and " + \
str(observation_sub_iterations) + " subiterations with registering drifter positions.")
theoretical_time = start_time
########################
# Main simulation loop #
########################
tic = time.time()
time_error = 0
for netcdf_it in range(netcdf_iterations):
for observation_sub_it in range(observation_sub_iterations):
next_obs_time = t + observation_frequency
# Step until next observation
sim.dataAssimilationStep(next_obs_time, write_now=False)
# Store observation
observations.add_observation_from_sim(sim)
t = sim.t
time_error += t - next_obs_time
theoretical_time += observation_frequency
sim.writeState()
if netcdf_it % 10 == 0:
# Check that everything looks okay
eta, hu, hv = sim.download()
if (np.any(np.isnan(eta))):
raise RuntimeError('Not a number at time ' + str(sim.t))
sub_t = time.time() - tic
if log_to_screen:
print("{:02.4f} s into loop: ".format(sub_t) +
"Done with netcdf iteration " + str(netcdf_it) +
" of " + str(netcdf_iterations))
toc = time.time()
if log_to_screen:
print("{:02.4f} s: ".format(toc - tic) +
"Done with generating thruth")
if log_to_screen: print("sim.t: " + str(sim.t))
########################
# Simulation loop DONE #
########################
# Dump drifter observations to file:
tic = time.time()
observations.to_pickle(drifter_filename)
toc = time.time()
if log_to_screen:
print("\n{:02.4f} s: ".format(toc - tic) +
"Drifter observations written to " + drifter_filename)
return os.path.abspath(folder)
except:
raise
finally:
if sim is not None:
sim.cleanUp()
if doubleJetCase is not None:
doubleJetCase.cleanUp()
if log_to_screen:
print("\n{:02.4f} s: ".format(toc - tic) +
"Clean up simulator done.")
def create_large_drifter_set(self, size, domain_x, domain_y):
return GPUDrifterCollection(self.cl_ctx,
size,
domain_size_x=domain_x,
domain_size_y=domain_y)
