def _setup_original_domain(self, np=None):
"""
Create sequential domain and partition
"""
verbose = self.verbose
outname = self.outname
partition_dir = self.partition_dir
if np is None:
np = numprocs
# Only create the sequential domain on processor 0
if myid == 0:
if verbose: print 'CREATING PARTITIONED DOMAIN'
# Let's see if we have already pickled this domain
pickle_name = outname+'_P%g_%g.pickle'% (1,0)
pickle_name = join(partition_dir,pickle_name)
if os.path.exists(pickle_name):
if verbose: print 'Saved domain seems to already exist'
else:
domain = self.setup_domain(self)
if verbose: print 'Saving Domain'
sequential_distribute_dump(domain, 1, partition_dir=partition_dir, verbose=verbose)
# Now partition the domain
if verbose: print 'Load in saved sequential pickled domain'
domain = sequential_distribute_load_pickle_file(pickle_name, np=1, verbose = verbose)
par_pickle_name = outname+'_P%g_%g.pickle'% (np,0)
par_pickle_name = join(partition_dir,par_pickle_name)
if os.path.exists(par_pickle_name):
if verbose: print 'Saved partitioned domain seems to already exist'
else:
if verbose: print 'Dump partitioned domains'
sequential_distribute_dump(domain, np, partition_dir=partition_dir, verbose=verbose)
barrier()
#===============================================================================
# Setup parallel domain
#===============================================================================
if myid == 0 and verbose: print 'LOADING PARTITIONED DOMAIN'
self.domain = sequential_distribute_load(filename=join(partition_dir,outname), verbose = self.verbose)
def setup_mesh(project, setup_initial_conditions=None):
"""
Code to make the mesh (initial domain)
The geometry is made on processor 0, then dumped and reloaded
This reduces the memory demands
INPUT: project == the project module
OUTPUT: domain
"""
if myid == 0:
if verbose:
print "Hello from processor ", myid
#
# HERE, WE MAKE/PARTITION/READ THE MESH
# This can lead to memory savings in parallel runs
# (possibly because of limitations of python memory management)
#
# Let's see if we have already pickled this domain
pickle_name = "domain" + "_P%g_%g.pickle" % (1, 0)
pickle_name = join(project.partition_dir, pickle_name)
if os.path.exists(pickle_name):
if verbose:
print "Saved domain seems to already exist"
else:
if verbose:
print "CREATING PARTITIONED DOMAIN"
domain = build_mesh(project)
if setup_initial_conditions is not None:
# Set the initial conditions in serial
setup_initial_conditions.setup_initial_conditions(domain, project)
# If pypar is not available don't use sequential_distribute stuff
# (it will fail)
if pypar_available:
if verbose:
print "Saving Domain"
sequential_distribute_dump(domain, 1, partition_dir=project.partition_dir, verbose=verbose)
# If pypar is not available don't use sequential_distribute stuff (it
# will fail)
if pypar_available:
# Now partition the domain
par_pickle_name = "domain" + "_P%g_%g.pickle" % (numprocs, 0)
par_pickle_name = join(project.partition_dir, par_pickle_name)
if os.path.exists(par_pickle_name):
if verbose:
print "Saved partitioned domain seems to already exist"
else:
if verbose:
print "Load in saved sequential pickled domain"
domain = sequential_distribute_load_pickle_file(pickle_name, np=1, verbose=verbose)
if verbose:
print "Dump partitioned domains"
sequential_distribute_dump(domain, numprocs, partition_dir=project.partition_dir, verbose=verbose)
# This can reduce the memory demands if the domain was made above
# Even better to have an existing partition (i.e. stop here and
# rerun)
domain = None
gc.collect()
else:
domain = None
if verbose:
print "Hello from processor ", myid
barrier()
# print 'Distributing domain'
# domain=distribute(domain)
# barrier()
# If pypar is not available don't use sequential_distribute stuff (it will
# fail)
if pypar_available:
if myid == 0:
print "LOADING PARTITIONED DOMAIN"
domain = sequential_distribute_load(filename=join(project.partition_dir, "domain"), verbose=verbose)
# #########################################################################
# Set output directories
# #########################################################################
domain.set_name(project.scenario) # Name of sww file
domain.set_datadir(project.output_dir) # Store sww output here
# Needs more changes for this to work
# domain.set_checkpointing(checkpoint_time=project.checkpoint_time)
# #########################################################################
# Miscellanious numerics
# #########################################################################
domain.set_flow_algorithm(project.flow_algorithm)
# Force zero beta values [hopefully integrated into source]
# print 'Warning: Forcing everything to first order'
# domain.beta_w=0.
# domain.beta_uh=0.
# domain.beta_vh=0.
# domain.beta_w_dry=0.
# domain.beta_uh_dry=0.
# domain.beta_vh_dry=0.
# Adjust velocity computation for max quantities
# domain.velocity_protection=1.0e-05
# Adjust CFL
# domain.set_CFL(0.9)
# Optionally store vertex values uniquely (large file sizes!)
domain.set_store_vertices_uniquely(project.store_vertices_uniquely)
if project.use_local_extrapolation_and_flux_updating:
domain.set_local_extrapolation_and_flux_updating()
if project.store_elevation_every_timestep:
domain.quantities_to_be_stored["elevation"] = 2
else:
domain.quantities_to_be_stored["elevation"] = 1
return domain
def setup_mesh(project, setup_initial_conditions=None):
"""
Code to make the mesh (initial domain)
The geometry is made on processor 0, then dumped and reloaded
This reduces the memory demands
INPUT: project == the project module
OUTPUT: domain
"""
if myid == 0:
if verbose:
print 'Hello from processor ', myid
#
# HERE, WE MAKE/PARTITION/READ THE MESH
# This can lead to memory savings in parallel runs
# (possibly because of limitations of python memory management)
#
# Let's see if we have already pickled this domain
pickle_name = 'domain' + '_P%g_%g.pickle' % (1, 0)
pickle_name = join(project.partition_dir, pickle_name)
if os.path.exists(pickle_name):
if verbose:
print 'Saved domain seems to already exist'
else:
if verbose:
print 'CREATING PARTITIONED DOMAIN'
domain = build_mesh(project)
if setup_initial_conditions is not None:
# Set the initial conditions in serial
setup_initial_conditions.setup_initial_conditions(
domain, project)
# If pypar is not available don't use sequential_distribute stuff
# (it will fail)
if pypar_available:
if verbose:
print 'Saving Domain'
sequential_distribute_dump(domain,
1,
partition_dir=project.partition_dir,
verbose=verbose)
# If pypar is not available don't use sequential_distribute stuff (it
# will fail)
if pypar_available:
# Now partition the domain
par_pickle_name = 'domain' + '_P%g_%g.pickle' % (numprocs, 0)
par_pickle_name = join(project.partition_dir, par_pickle_name)
if os.path.exists(par_pickle_name):
if verbose:
print 'Saved partitioned domain seems to already exist'
else:
if verbose:
print 'Load in saved sequential pickled domain'
domain = \
sequential_distribute_load_pickle_file(
pickle_name, np=1, verbose=verbose)
if verbose:
print 'Dump partitioned domains'
sequential_distribute_dump(domain,
numprocs,
partition_dir=project.partition_dir,
verbose=verbose)
# This can reduce the memory demands if the domain was made above
# Even better to have an existing partition (i.e. stop here and
# rerun)
domain = None
gc.collect()
else:
domain = None
if verbose:
print 'Hello from processor ', myid
barrier()
# print 'Distributing domain'
# domain=distribute(domain)
# barrier()
# If pypar is not available don't use sequential_distribute stuff (it will
# fail)
if pypar_available:
if myid == 0:
print 'LOADING PARTITIONED DOMAIN'
domain = \
sequential_distribute_load(
filename=join(project.partition_dir, 'domain'),
verbose=verbose)
# #########################################################################
# Set output directories
# #########################################################################
domain.set_name(project.scenario) # Name of sww file
domain.set_datadir(project.output_dir) # Store sww output here
# Needs more changes for this to work
# domain.set_checkpointing(checkpoint_time=project.checkpoint_time)
# #########################################################################
# Miscellanious numerics
# #########################################################################
domain.set_flow_algorithm(project.flow_algorithm)
# Force zero beta values [hopefully integrated into source]
# print 'Warning: Forcing everything to first order'
# domain.beta_w=0.
# domain.beta_uh=0.
# domain.beta_vh=0.
# domain.beta_w_dry=0.
# domain.beta_uh_dry=0.
# domain.beta_vh_dry=0.
# Adjust velocity computation for max quantities
# domain.velocity_protection=1.0e-05
# Adjust CFL
# domain.set_CFL(0.9)
# Optionally store vertex values uniquely (large file sizes!)
domain.set_store_vertices_uniquely(project.store_vertices_uniquely)
if project.use_local_extrapolation_and_flux_updating:
domain.set_local_extrapolation_and_flux_updating()
if project.store_elevation_every_timestep:
domain.quantities_to_be_stored['elevation'] = 2
else:
domain.quantities_to_be_stored['elevation'] = 1
return domain