def _correct_postprocessing(self, restart_timestep): "Removes data from casedir found at timestep>restart_timestep." playlog = self._pp.get_playlog('r') playlog_to_remove = {} for k, v in playlog.items(): if int(k) >= restart_timestep: #playlog_to_remove[k] = playlog.pop(k) playlog_to_remove[k] = playlog[k] playlog.close() MPI.barrier(mpi_comm_world()) if on_master_process(): playlog = self._pp.get_playlog() [playlog.pop(k) for k in playlog_to_remove.keys()] playlog.close() MPI.barrier(mpi_comm_world()) all_fields_to_clean = [] for k, v in playlog_to_remove.items(): if "fields" not in v: continue else: all_fields_to_clean += v["fields"].keys() all_fields_to_clean = list(set(all_fields_to_clean)) for fieldname in all_fields_to_clean: self._clean_field(fieldname, restart_timestep)
def store_params(self, params): """Store parameters in casedir as params.pickle and params.txt. Forwarded to a Saver-instance. """ self._saver.store_params(params) MPI.barrier(mpi_comm_world())
def compute(self, get): u = get(self.valuename) if u is None: return None if not hasattr(self, "u"): self.before_first_compute(get) if LooseVersion(dolfin_version()) > LooseVersion("1.6.0"): rank = len(u.ufl_shape) else: rank = u.rank() if rank > 0: u = u.split() U = [] for i, _u in enumerate(u): U.append(_interpolate(self.us[i], _u)) #U.append(self._ft.interpolate_nonmatching_mesh(_u, self.us.function_space())) MPI.barrier(mpi_comm_world()) self.assigner.assign(self.u, U) else: _interpolate(self.u, u) MPI.barrier(mpi_comm_world()) # FIXME: This gives a PETSc-error (VecCopy). Unnecessary interpolation used instead. #self.u.assign(U) #self.u.assign(interpolate(U, self.u.function_space())) return self.u
def _clean_casedir(self): "Cleans out all files produced by cbcpost in the current casedir." MPI.barrier(mpi_comm_world()) if on_master_process(): if os.path.isdir(self.get_casedir()): try: playlog = self._fetch_playlog() except: playlog = None if playlog is not None: all_fields = [] for v in playlog.values(): all_fields += v.get("fields", {}).keys() all_fields = list(set(all_fields)) playlog.close() for field in all_fields: rmtree(os.path.join(self.get_casedir(), field)) for f in [ "mesh.hdf5", "play.db", "params.txt", "params.pickle" ]: if os.path.isfile(os.path.join(self.get_casedir(), f)): os.remove(os.path.join(self.get_casedir(), f)) MPI.barrier(mpi_comm_world())
def casedir(request): # Some code here copied from dolfin_utils dev: # Get directory name of test_foo.py file testfile = request.module.__file__ testfiledir = os.path.dirname(os.path.abspath(testfile)) # Construct name test_foo_tempdir from name test_foo.py testfilename = os.path.basename(testfile) outputname = testfilename.replace(".py", "_casedir") # Get function name test_something from test_foo.py function = request.function.__name__ # Join all of these to make a unique path for this test function basepath = os.path.join(testfiledir, outputname) casedir = os.path.join(basepath, function) # Unlike the dolfin_utils tempdir fixture, here we make sure the directory is _deleted_: gc.collect() # Workaround for possible dolfin deadlock MPI.barrier(mpi_comm_world()) try: # Only on root node in parallel if MPI.size(mpi_comm_world()) == 1 or MPI.rank(mpi_comm_world()) == 0: shutil.rmtree(casedir) except: pass MPI.barrier(mpi_comm_world()) return casedir
def store_mesh(self, mesh, cell_domains=None, facet_domains=None): """Store mesh in casedir to mesh.hdf5 (dataset Mesh) in casedir. Forwarded to a Saver-instance. """ self._saver.store_mesh(mesh, cell_domains, facet_domains) MPI.barrier(mpi_comm_world())
def gc_barrier(): """Internal utility to easily switch on and off calls to gc.collect() and MPI.barrier(world) in all fixtures here. Helps make the tests deterministic when debugging. """ gc.collect() if MPI.size(mpi_comm_world()) > 1: MPI.barrier(mpi_comm_world())
def pytest_runtest_teardown(item, nextitem): # Carry out additional teardown if hasattr(item, "_runtest_teardown_function"): item._runtest_teardown_function() # Do the normal teardown item.teardown() # Add a MPI barrier in parallel MPI.barrier(MPI.comm_world)
def pytest_runtest_teardown(item, nextitem): # Do the normal teardown item.teardown() # Add a MPI barrier in parallel if has_pybind11(): MPI.barrier(MPI.comm_world) else: MPI.barrier(mpi_comm_world())
def find_solution_presence(pp, playlog, fields): "Search play-log to find where solution items are saved in a loadable format" present_solution = defaultdict(list) functions = dict() metadatas = dict() for ts, data in playlog.items(): for fieldname in data.get("fields", []): # Continue if field in a format we can't read back if not any([saveformat in loadable_formats for saveformat in data["fields"][fieldname]["save_as"]]): continue # Check if field is present and part of solution we're searching for is_present = False if fields == "default" and data["fields"][fieldname]["type"] == "SolutionField": is_present = True elif fieldname in fields: is_present = True if is_present: function = None metadata = metadatas.setdefault(fieldname, shelve.open(os.path.join(pp.get_savedir(fieldname), "metadata.db"), 'r')) if 'hdf5' in data["fields"][fieldname]["save_as"]: filename = os.path.join(pp.get_savedir(fieldname), fieldname+'.hdf5') if fieldname in functions: function = functions[fieldname] else: function = functions.setdefault(fieldname, create_function_from_metadata(pp, fieldname, metadata, 'hdf5')) present_solution[fieldname].append(Loadable(filename, fieldname, ts, data["t"], 'hdf5', function)) elif 'xml' in data["fields"][fieldname]["save_as"]: filename = os.path.join(pp.get_savedir(fieldname), fieldname+str(ts)+'.xml') if fieldname in functions: function = functions[fieldname] else: function = functions.setdefault(fieldname, create_function_from_metadata(pp, fieldname, metadata, 'xml')) present_solution[fieldname].append(Loadable(filename, fieldname, ts, data["t"], 'xml', function)) elif 'xml.gz' in data["fields"][fieldname]["save_as"]: filename = os.path.join(pp.get_savedir(fieldname), fieldname+str(ts)+'.xml.gz') if fieldname in functions: function = functions[fieldname] else: function = functions.setdefault(fieldname, create_function_from_metadata(pp, fieldname, metadata, 'xml.gz')) present_solution[fieldname].append(Loadable(filename, fieldname, ts, data["t"], 'xml.gz', function)) elif 'shelve' in data["fields"][fieldname]["save_as"]: filename = os.path.join(pp.get_savedir(fieldname), fieldname+'.db') present_solution[fieldname].append(Loadable(filename, fieldname, ts, data["t"], "shelve", None)) [f.close() for f in metadatas.values()] MPI.barrier(mpi_comm_world()) return present_solution
def _clean_shelve(self, fieldname, del_metadata): shelvefilename = os.path.join(self._pp.get_savedir(fieldname), fieldname+".db") if on_master_process(): if os.path.isfile(shelvefilename): shelvefile = shelve.open(shelvefilename, 'c') for k,v in del_metadata.items(): if 'shelve' in v: shelvefile.pop(str(k)) shelvefile.close() MPI.barrier(mpi_comm_world())
def _clean_hdf5(self, fieldname, del_metadata): delete_from_hdf5_file = ''' namespace dolfin { #include <hdf5.h> void delete_from_hdf5_file(const MPI_Comm comm, const std::string hdf5_filename, const std::string dataset, const bool use_mpiio) { //const hid_t plist_id = H5Pcreate(H5P_FILE_ACCESS); // Open file existing file for append //hid_t file_id = H5Fopen(filename.c_str(), H5F_ACC_RDWR, plist_id); hid_t hdf5_file_id = HDF5Interface::open_file(comm, hdf5_filename, "a", use_mpiio); H5Ldelete(hdf5_file_id, dataset.c_str(), H5P_DEFAULT); HDF5Interface::close_file(hdf5_file_id); } } ''' cpp_module = compile_extension_module( delete_from_hdf5_file, additional_system_headers=["dolfin/io/HDF5Interface.h"]) hdf5filename = os.path.join(self._pp.get_savedir(fieldname), fieldname + '.hdf5') if not os.path.isfile(hdf5filename): return for k, v in del_metadata.items(): if 'hdf5' not in v: continue else: cpp_module.delete_from_hdf5_file( mpi_comm_world(), hdf5filename, v['hdf5']['dataset'], MPI.size(mpi_comm_world()) > 1) hdf5tmpfilename = os.path.join(self._pp.get_savedir(fieldname), fieldname + '_tmp.hdf5') #import ipdb; ipdb.set_trace() MPI.barrier(mpi_comm_world()) if on_master_process(): # status, result = getstatusoutput("h5repack -V") status, result = -1, -1 if status != 0: cbc_warning( "Unable to run h5repack. Will not repack hdf5-files before replay, which may cause bloated hdf5-files." ) else: subprocess.call("h5repack %s %s" % (hdf5filename, hdf5tmpfilename), shell=True) os.remove(hdf5filename) os.rename(hdf5tmpfilename, hdf5filename) MPI.barrier(mpi_comm_world())
def wrapper(func, *args, **kwargs): # Run function rv = func(*args, **kwargs) # Collect garbage of temporaries of the function # and return collectively gc.collect() MPI.barrier(MPI.comm_world) return rv
def run(): mesh = dl.UnitSquareMesh(50, 50) Vr = dl.FunctionSpace(mesh, 'Lagrange', 1) Vphi = dl.FunctionSpace(mesh, 'Lagrange', 2) Vphidofmap = Vphi.dofmap().dofs() test, trial = dl.TestFunction(Vphi), dl.TrialFunction(Vphi) u, v = dl.Function(Vphi), dl.Function(Vphi) rho = dl.Function(Vr) Mweak = dl.inner(rho * test, trial) * dl.dx Mprime = LumpedMassMatrixPrime(Vr, Vphi, None) h = 1e-5 fact = [1.0, -1.0] RHO = \ [dl.interpolate(dl.Expression('2.0 + sin(n*pi*x[0])*sin(n*pi*x[1])', n=1.0, degree=10), Vr), \ dl.interpolate(dl.Expression('2.0 + sin(n*pi*x[0])*sin(n*pi*x[1])', n=8.0, degree=10), Vr), \ dl.interpolate(dl.Expression('2.0 + sin(2*pi*x[0])*sin(1*pi*x[1])*(x[0]<0.5)', degree=10), Vr), \ dl.interpolate(dl.Expression('2.0 + 2.0*(x[0]<0.5)*(x[1]<0.5) - 1.8*(x[0]>=0.5)*(x[1]<0.5)', degree=10), Vr)] np.random.seed(11) locsize = len(u.vector().array()) for jj, rho1 in enumerate(RHO): if mpirank == 0: print '\nmedium {}'.format(jj) setfct(rho, rho1) M = dl.assemble(Mweak) Ml = LumpedMatrixSolverS(Vphi) Ml.set_operator(M) Mprime.updater(Ml.ratio) for ii in range(5): rndvecu = np.random.randn(Vphi.dim()) rndvecv = np.random.randn(Vphi.dim()) if mpirank == 0: print 'test {}'.format(ii) rnddir = dl.interpolate(dl.Expression('2.0+sin(n*pi*x[0])*sin(n*pi*x[1])',\ n=ii+1, degree=10), Vr) setfct(u, rndvecu[Vphidofmap]) setfct(v, rndvecv[Vphidofmap]) analytical = rnddir.vector().inner( Mprime.get_gradient(u.vector(), v.vector())) uMv = [] for ff in fact: setfct(rho, rho1) rho.vector().axpy(ff * h, rnddir.vector()) M = dl.assemble(Mweak) Ml = LumpedMatrixSolverS(Vphi) Ml.set_operator(M) uMv.append(u.vector().inner(Ml * v.vector())) fd = (uMv[0] - uMv[1]) / (2 * h) err = np.abs((analytical - fd) / analytical) if mpirank == 0: print 'analytical={}, fd={}, err={}'.format( analytical, fd, err), if err < 1e-6: print '\t =>> OK!!' else: print '' MPI.barrier(mycomm)
def test_mpset(): #set_log_level(DEBUG) # Print parameters and their values #mpset.show() # Check that assignment out of range raises # FIXME: dolfin/parameter/Parameter.cpp is broken. # It doesn't raise when assigning a value out of range; # see 921c56cee4f50f016a07f49a5e90f6627c7317a6 # with pytest.raises(RuntimeError): # mpset["discretization"]["N"] = 1 # with pytest.raises(RuntimeError): # mpset["model"]["mobility"]["beta"] = 2.0 with pytest.raises(RuntimeError): mpset["model"]["mobility"]["m"] = 0.0 # Try to add parameter mpset.add("foo", "bar") assert mpset["foo"] == "bar" # Try direct access to a parameter mpset["foo"] = "bar_" assert mpset["foo"] == "bar_" # Try to write parameters to a file comm = mpi_comm_world() tempdir = "/tmp/pytest-of-fenics" fname = tempdir + "/foo.xml" mpset.write(comm, fname) if MPI.rank(comm) == 0: assert os.path.isfile(fname) MPI.barrier(comm) # wait until the file is written # Change back value of parameter 'foo' mpset["foo"] = "bar" assert mpset["foo"] == "bar" # Try to read parameters back mpset.read(fname) assert mpset["foo"] == "bar_" MPI.barrier(comm) # wait until each process finishes reading if MPI.rank(comm) == 0: os.remove(fname) del fname # Check that every other call points to the same object assert id(MuflonParameterSet()) == id(mpset) # Cleanup set_log_level(INFO) mpset.refresh()
def backup_playlog(self): "Create a backup of the playlog" if MPI.rank(mpi_comm_world()) == 0: casedir = self.postproc.get_casedir() playlog_file = os.path.join(casedir, "play.db") i = 0 backup_file = playlog_file + ".bak" + str(i) while os.path.isfile(backup_file): i += 1 backup_file = playlog_file + ".bak" + str(i) os.system("cp %s %s" % (playlog_file, backup_file)) MPI.barrier(mpi_comm_world())
def pytest_runtest_teardown(item): """Collect garbage after every test to force calling destructors which might be collective""" # Do the normal teardown item.teardown() # Collect the garbage (call destructors collectively) del item # NOTE: How are we sure that 'item' does not hold references # to temporaries and someone else does not hold a reference # to 'item'?! Well, it seems that it works... gc.collect() MPI.barrier(MPI.comm_world)
def print_reference(results): "Print nicely formatted values for gluing into code as a reference" MPI.barrier(MPI.comm_world) if MPI.rank(MPI.comm_world) == 0: print("reference = {", end=' ') for (i, result) in enumerate(results): if i > 0: print(" ", end=' ') print("(\"%s\", %d): %.16g" % result, end=' ') if i < len(results) - 1: print(",") else: print("}") MPI.barrier(MPI.comm_world)
def pytest_runtest_teardown(item): """Collect garbage after every test to force calling destructors which might be collective""" # Do the normal teardown item.teardown() # Collect the garbage (call destructors collectively) del item # NOTE: How are we sure that 'item' does not hold references # to temporaries and someone else does not hold a reference # to 'item'?! Well, it seems that it works... gc.collect() MPI.barrier(mpi_comm_world())
def _create_tempdir(request): # Get directory name of test_foo.py file testfile = request.module.__file__ testfiledir = os.path.dirname(os.path.abspath(testfile)) # Construct name test_foo_tempdir from name test_foo.py testfilename = os.path.basename(testfile) outputname = testfilename.replace(".py", "_tempdir_{}".format( worker_id(request))) # Get function name test_something from test_foo.py function = request.function.__name__ # Join all of these to make a unique path for this test function basepath = os.path.join(testfiledir, outputname) path = os.path.join(basepath, function) # Add a sequence number to avoid collisions when tests are # otherwise parameterized if MPI.rank(MPI.comm_world) == 0: _create_tempdir._sequencenumber[path] += 1 sequencenumber = _create_tempdir._sequencenumber[path] sequencenumber = MPI.sum(MPI.comm_world, sequencenumber) else: sequencenumber = MPI.sum(MPI.comm_world, 0) path += "__" + str(sequencenumber) # Delete and re-create directory on root node if MPI.rank(MPI.comm_world) == 0: # First time visiting this basepath, delete the old and create # a new if basepath not in _create_tempdir._basepaths: _create_tempdir._basepaths.add(basepath) if os.path.exists(basepath): shutil.rmtree(basepath) # Make sure we have the base path test_foo_tempdir for # this test_foo.py file if not os.path.exists(basepath): os.mkdir(basepath) # Delete path from old test run if os.path.exists(path): shutil.rmtree(path) # Make sure we have the path for this test execution: # e.g. test_foo_tempdir/test_something__3 if not os.path.exists(path): os.mkdir(path) MPI.barrier(MPI.comm_world) return path
def _clean_files(self, fieldname, del_metadata): for k, v in del_metadata.items(): for i in v.values(): MPI.barrier(mpi_comm_world()) try: i["filename"] except: continue fullpath = os.path.join(self._pp.get_savedir(fieldname), i['filename']) if on_master_process(): os.remove(fullpath) MPI.barrier(mpi_comm_world()) """
def print_errors(errors): MPI.barrier(MPI.comm_world) if MPI.rank(MPI.comm_world) == 0: print("Checking results") print("----------------") for (mesh_file, degree, norm, ref, diff) in errors: print("(%s, %d):\t" % (mesh_file, degree), end=' ') if diff is None: print("missing reference") else: print("*** ERROR", end=' ') print( "(norm = %.16g, reference = %.16g, relative diff = %.16g)" % (norm, ref, diff)) MPI.barrier(MPI.comm_world)
def create_initial_folders(folder, restart_folder, sys_comp, tstep, info_red, scalar_components, output_timeseries_as_vector, **NS_namespace): """Create necessary folders.""" info_red("Creating initial folders") # To avoid writing over old data create a new folder for each run if MPI.rank(MPI.comm_world) == 0: try: makedirs(folder) except OSError: pass MPI.barrier(MPI.comm_world) newfolder = path.join(folder, 'data') if restart_folder: newfolder = path.join(newfolder, restart_folder.split('/')[-2]) else: if not path.exists(newfolder): newfolder = path.join(newfolder, '1') else: #previous = listdir(newfolder) previous = [f for f in listdir(newfolder) if not f.startswith('.')] previous = max(map(eval, previous)) if previous else 0 newfolder = path.join(newfolder, str(previous + 1)) MPI.barrier(MPI.comm_world) if MPI.rank(MPI.comm_world) == 0: if not restart_folder: #makedirs(path.join(newfolder, "Voluviz")) #makedirs(path.join(newfolder, "Stats")) #makedirs(path.join(newfolder, "VTK")) makedirs(path.join(newfolder, "Timeseries")) makedirs(path.join(newfolder, "Checkpoint")) tstepfolder = path.join(newfolder, "Timeseries") tstepfiles = {} comps = sys_comp if output_timeseries_as_vector: comps = ['p', 'u'] + scalar_components for ui in comps: tstepfiles[ui] = XDMFFile( MPI.comm_world, path.join(tstepfolder, ui + '_from_tstep_{}.xdmf'.format(tstep))) tstepfiles[ui].parameters["rewrite_function_mesh"] = False tstepfiles[ui].parameters["flush_output"] = True return newfolder, tstepfiles
def create_initial_folders(folder, restart_folder, sys_comp, tstep, info_red, scalar_components, output_timeseries_as_vector, **NS_namespace): """Create necessary folders.""" info_red("Creating initial folders") # To avoid writing over old data create a new folder for each run if MPI.rank(MPI.comm_world) == 0: try: makedirs(folder) except OSError: pass MPI.barrier(MPI.comm_world) newfolder = path.join(folder, 'data') if restart_folder: newfolder = path.join(newfolder, restart_folder.split('/')[-2]) else: if not path.exists(newfolder): newfolder = path.join(newfolder, '1') else: previous = listdir(newfolder) previous = max(map(eval, previous)) if previous else 0 newfolder = path.join(newfolder, str(previous + 1)) MPI.barrier(MPI.comm_world) if MPI.rank(MPI.comm_world) == 0: if not restart_folder: #makedirs(path.join(newfolder, "Voluviz")) #makedirs(path.join(newfolder, "Stats")) #makedirs(path.join(newfolder, "VTK")) makedirs(path.join(newfolder, "Timeseries")) makedirs(path.join(newfolder, "Checkpoint")) tstepfolder = path.join(newfolder, "Timeseries") tstepfiles = {} comps = sys_comp if output_timeseries_as_vector: comps = ['p', 'u'] + scalar_components for ui in comps: tstepfiles[ui] = XDMFFile(MPI.comm_world, path.join( tstepfolder, ui + '_from_tstep_{}.xdmf'.format(tstep))) tstepfiles[ui].parameters["rewrite_function_mesh"] = False tstepfiles[ui].parameters["flush_output"] = True return newfolder, tstepfiles
def _create_tempdir(request): # Get directory name of test_foo.py file testfile = request.module.__file__ testfiledir = os.path.dirname(os.path.abspath(testfile)) # Construct name test_foo_tempdir from name test_foo.py testfilename = os.path.basename(testfile) outputname = testfilename.replace(".py", "_tempdir") # Get function name test_something from test_foo.py function = request.function.__name__ # Join all of these to make a unique path for this test function basepath = os.path.join(testfiledir, outputname) path = os.path.join(basepath, function) # Add a sequence number to avoid collisions when tests are otherwise parameterized if MPI.rank(mpi_comm_world()) == 0: _create_tempdir._sequencenumber[path] += 1 sequencenumber = _create_tempdir._sequencenumber[path] sequencenumber = MPI.sum(mpi_comm_world(), sequencenumber) else: sequencenumber = MPI.sum(mpi_comm_world(), 0) path += "__" + str(sequencenumber) # Delete and re-create directory on root node if MPI.rank(mpi_comm_world()) == 0: # First time visiting this basepath, delete the old and create a new if basepath not in _create_tempdir._basepaths: _create_tempdir._basepaths.add(basepath) #if os.path.exists(basepath): # shutil.rmtree(basepath) # Make sure we have the base path test_foo_tempdir for this test_foo.py file if not os.path.exists(basepath): os.mkdir(basepath) # Delete path from old test run #if os.path.exists(path): # shutil.rmtree(path) # Make sure we have the path for this test execution: e.g. test_foo_tempdir/test_something__3 if not os.path.exists(path): os.mkdir(path) MPI.barrier(mpi_comm_world()) return path
def checkpoint(dvp_, default_variables, checkpoint_folder, mesh, **namespace): """Utility function for storing the current parameters and the last two time steps""" # Only update variables that exists in default_variables default_variables.update( (k, namespace[k]) for k in (default_variables.keys() & namespace.keys())) # Dump default parameters if MPI.rank(MPI.comm_world) == 0: with open(str(checkpoint_folder.joinpath("default_variables.pickle")), "bw") as f: pickle.dump(default_variables, f) # Dump physical fields fields = _get_fields(dvp_, mesh) # Write fields to temporary file to avoid corruption of existing checkpoint for name, field in fields: checkpoint_path = str( checkpoint_folder.joinpath("tmp_" + name + ".xdmf")) with XDMFFile(MPI.comm_world, checkpoint_path) as f: f.write_checkpoint(field, name) # Move to correct checkpoint name MPI.barrier(MPI.comm_world) if MPI.rank(MPI.comm_world) == 0: for name, _ in fields: for suffix in [".h5", ".xdmf"]: new_name = checkpoint_folder.joinpath("checkpoint_" + name + suffix) if new_name.exists(): checkpoint_folder.joinpath("tmp_" + name + suffix).replace(new_name) else: checkpoint_folder.joinpath("tmp_" + name + suffix).rename(new_name) # Rename link in xdmf file with open(new_name, "r") as f: text = f.read().replace("tmp_", "checkpoint_") with open(new_name, "w") as f: f.write(text)
def create_initial_folders(folder, restart_folder, fields, tstep, parameters): """ Create initial folders """ info_cyan("Creating folders.") makedirs_safe(folder) MPI.barrier(mpi_comm_world()) if restart_folder: newfolder = restart_folder.split("Checkpoint")[0] else: previous_list = os.listdir(folder) if len(previous_list) == 0: newfolder = os.path.join(folder, "1") else: previous = max([ int(entry) if entry.isdigit() else 0 for entry in previous_list ]) newfolder = os.path.join(folder, str(previous + 1)) MPI.barrier(mpi_comm_world()) tstepfolder = os.path.join(newfolder, "Timeseries") makedirs_safe(tstepfolder) makedirs_safe(os.path.join(newfolder, "Statistics")) settingsfolder = os.path.join(newfolder, "Settings") makedirs_safe(settingsfolder) makedirs_safe(os.path.join(newfolder, "Checkpoint")) # Initialize timestep files tstepfiles = dict() for field in fields: filename = os.path.join(tstepfolder, field + "_from_tstep_{}.xdmf".format(tstep)) tstepfiles[field] = XDMFFile(mpi_comm_world(), filename) tstepfiles[field].parameters["rewrite_function_mesh"] = False tstepfiles[field].parameters["flush_output"] = True # Dump settings if mpi_is_root(): dump_parameters( parameters, os.path.join(settingsfolder, "parameters_from_tstep_{}.dat".format(tstep))) return newfolder, tstepfiles
def safe_mkdir(dir): """Create directory without exceptions in parallel.""" # Create directory if not os.path.isdir(dir): try: os.makedirs(dir, mode=0775) except: # Allow race condition when multiple processes # work in same directory, ignore exception. pass # Wait for all processes to finish, hopefully somebody # managed to create the directory... MPI.barrier(mpi_comm_world()) # Warn if this failed if not os.path.isdir(dir): #warning("FAILED TO CREATE DIRECTORY %s" % (dir,)) Exception("FAILED TO CREATE DIRECTORY %s" % (dir,))
def finalize_all(self): "Finalize all Fields after last timestep has been computed." finalized = [] for name in self._sorted_fields_keys: if name in self._finalized: continue field = self._fields[name] fp = field.params if fp.finalize and (fp.safe or fp.plot or fp.save) and name not in fp: self.get(name, compute=False, finalize=True) finalized.append(field) t = self._cache[0].get("t", -1e16) timestep = self._cache[0].get("timestep", -1e16) self._saver.update(t, timestep, self._cache[0], finalized) self._saver._flush_data() self._plotter.update(t, timestep, self._cache[0], finalized) self._saver._close_shelves() MPI.barrier(mpi_comm_world())
def _clean_xdmf(self, fieldname, del_metadata): basename = os.path.join(self._pp.get_savedir(fieldname), fieldname) if os.path.isfile(basename + ".xdmf"): MPI.barrier(mpi_comm_world()) i = 0 while True: h5_filename = basename + "_RS" + str(i) + ".h5" if not os.path.isfile(h5_filename): break i = i + 1 xdmf_filename = basename + "_RS" + str(i) + ".xdmf" MPI.barrier(mpi_comm_world()) if on_master_process(): os.rename(basename + ".h5", h5_filename) os.rename(basename + ".xdmf", xdmf_filename) f = open(xdmf_filename, 'r').read() new_f = open(xdmf_filename, 'w') new_f.write( f.replace( os.path.split(basename)[1] + ".h5", os.path.split(h5_filename)[1])) new_f.close() MPI.barrier(mpi_comm_world())
def update_all(self, solution, t, timestep): "Updates cache, plan, play log and executes plan." MPI.barrier(mpi_comm_world()) # TODO: Better design solution to making these variables accessible the right places? self._solution = solution # Update play log self._saver._update_playlog(t, timestep) # Update cache to keep what's needed later according to plan, forget what we don't need self._update_cache(t, timestep) # Plan what we need to compute now and in near future based on action triggers and dependencies self._plan, self._finalize_plan, self._last_trigger_time = \ self._planner.update(self._fields, self._full_dependencies, self._dependencies, t, timestep) self._timer.completed("PP: updated plan.") # Compute what's needed according to plan self._execute_plan(t, timestep) self._timer.completed("PP: execute plan") triggered_or_finalized = [] for name in self._cache[0]: if (name in self._finalize_plan or self._last_trigger_time[name][1] == timestep): triggered_or_finalized.append(self._fields[name]) self._saver.update(t, timestep, self._cache[0], triggered_or_finalized) self._timer.completed("PP: completed saving") self._plotter.update(t, timestep, self._cache[0], triggered_or_finalized) self._timer.completed("PP: completed plotting") self._update_all_count += 1 MPI.barrier(mpi_comm_world())
def save_checkpoint(tstep, t, w_, w_1, newfolder, parameters): """ Save checkpoint files. A part of this is taken from the Oasis code.""" checkpointfolder = os.path.join(newfolder, "Checkpoint") parameters["num_processes"] = MPI.size(mpi_comm_world()) parameters["t_0"] = t parameters["tstep"] = tstep parametersfile = os.path.join(checkpointfolder, "parameters.dat") parametersfile_old = parametersfile + ".old" if mpi_is_root(): # In case of failure, keep old file. if os.path.exists(parametersfile): os.system("mv {0} {1}".format(parametersfile, parametersfile_old)) dump_parameters(parameters, parametersfile) MPI.barrier(mpi_comm_world()) h5filename = os.path.join(checkpointfolder, "fields.h5") h5filename_old = h5filename + ".old" # In case of failure, keep old file. if mpi_is_root() and os.path.exists(h5filename): os.system("mv {0} {1}".format(h5filename, h5filename_old)) h5file = HDF5File(mpi_comm_world(), h5filename, "w") h5file.flush() for field in w_: info_red("Storing subproblem: " + field) MPI.barrier(mpi_comm_world()) h5file.write(w_[field], field + "/current") if field in w_1: h5file.write(w_1[field], field + "/previous") MPI.barrier(mpi_comm_world()) h5file.close() # Since program is still running, delete the old files. remove_safe(h5filename_old) MPI.barrier(mpi_comm_world()) remove_safe(parametersfile_old)
def save_checkpoint_solution_h5(tstep, q_, q_1, newfolder, u_components, NS_parameters): """Overwrite solution in Checkpoint folder. For safety reasons, in case the solver is interrupted, take backup of solution first. Must be restarted using the same mesh-partitioning. This will be fixed soon. (MM) """ checkpointfolder = path.join(newfolder, "Checkpoint") NS_parameters["num_processes"] = MPI.size(MPI.comm_world) if MPI.rank(MPI.comm_world) == 0: if path.exists(path.join(checkpointfolder, "params.dat")): system('cp {0} {1}'.format( path.join(checkpointfolder, "params.dat"), path.join(checkpointfolder, "params_old.dat"))) f = open(path.join(checkpointfolder, "params.dat"), 'wb') pickle.dump(NS_parameters, f) MPI.barrier(MPI.comm_world) for ui in q_: h5file = path.join(checkpointfolder, ui + '.h5') oldfile = path.join(checkpointfolder, ui + '_old.h5') # For safety reasons... if path.exists(h5file): if MPI.rank(MPI.comm_world) == 0: system('cp {0} {1}'.format(h5file, oldfile)) MPI.barrier(MPI.comm_world) ### newfile = HDF5File(MPI.comm_world, h5file, 'w') newfile.flush() newfile.write(q_[ui].vector(), '/current') if ui in u_components: newfile.write(q_1[ui].vector(), '/previous') if path.exists(oldfile): if MPI.rank(MPI.comm_world) == 0: system('rm {0}'.format(oldfile)) MPI.barrier(MPI.comm_world) if MPI.rank(MPI.comm_world) == 0 and path.exists( path.join(checkpointfolder, "params_old.dat")): system('rm {0}'.format(path.join(checkpointfolder, "params_old.dat")))
def save_checkpoint_solution_h5(tstep, q_, q_1, newfolder, u_components, NS_parameters): """Overwrite solution in Checkpoint folder. For safety reasons, in case the solver is interrupted, take backup of solution first. Must be restarted using the same mesh-partitioning. This will be fixed soon. (MM) """ checkpointfolder = path.join(newfolder, "Checkpoint") NS_parameters["num_processes"] = MPI.size(MPI.comm_world) if MPI.rank(MPI.comm_world) == 0: if path.exists(path.join(checkpointfolder, "params.dat")): system('cp {0} {1}'.format(path.join(checkpointfolder, "params.dat"), path.join(checkpointfolder, "params_old.dat"))) f = open(path.join(checkpointfolder, "params.dat"), 'wb') pickle.dump(NS_parameters, f) MPI.barrier(MPI.comm_world) for ui in q_: h5file = path.join(checkpointfolder, ui + '.h5') oldfile = path.join(checkpointfolder, ui + '_old.h5') # For safety reasons... if path.exists(h5file): if MPI.rank(MPI.comm_world) == 0: system('cp {0} {1}'.format(h5file, oldfile)) MPI.barrier(MPI.comm_world) ### newfile = HDF5File(MPI.comm_world, h5file, 'w') newfile.flush() newfile.write(q_[ui].vector(), '/current') if ui in u_components: newfile.write(q_1[ui].vector(), '/previous') if path.exists(oldfile): if MPI.rank(MPI.comm_world) == 0: system('rm {0}'.format(oldfile)) MPI.barrier(MPI.comm_world) newfile.close() if MPI.rank(MPI.comm_world) == 0 and path.exists(path.join(checkpointfolder, "params_old.dat")): system('rm {0}'.format(path.join(checkpointfolder, "params_old.dat")))
V = FunctionSpace(mesh, 'Lagrange', q) Vl = FunctionSpace(mesh, 'Lagrange', 1) Dt = h/(q*alpha*c) if myrank == 0: print '\n\th = {} - Dt = {}'.format(h, Dt) Wave = AcousticWave({'V':V, 'Vl':Vl, 'Vr':Vl}) Wave.timestepper = 'backward' Wave.lump = True Wave.exact = interpolate(uex_expr, V) Wave.bc = DirichletBC(V, ubc, u0_boundary) Wave.update({'lambda':lam, 'rho':rho, 't0':0.0, 'tf':tf, 'Dt':Dt,\ 'u0init':interpolate(u0_expr, V), 'utinit':Function(V)}) sol, error = Wave.solve() ERROR.append(error) if myrank == 0: print 'relative error = {:.5e}'.format(error) if not mycomm == None: MPI.barrier(mycomm) if myrank == 0: # Order of convergence: CONVORDER = [] for ii in range(len(ERROR)-1): CONVORDER.append(np.log(ERROR[ii+1]/ERROR[ii])/np.log((1./NN[ii+1])/(1./NN[ii]))) print '\n\norder of convergence:', CONVORDER # Save plots: try: boolplot = int(sys.argv[1]) except: boolplot = 0 if boolplot > 0: filename, ext = splitext(sys.argv[0])
rho2 = Function(Vr) try: myrun = int(sys.argv[1]) except: myrun = 2 if myrun == 1: weak_1 = lam1*inner(nabla_grad(trial), nabla_grad(test))*dx weak_2 = inner(lam2*nabla_grad(trial), nabla_grad(test))*dx weak_V = inner(lamV*nabla_grad(trial), nabla_grad(test))*dx lam1.vector()[:] = 1.0 if mpirank == 0: print 'Start assembling K1' MPI.barrier(mpicomm) t0 = time() K1 = assemble(weak_1) MPI.barrier(mpicomm) t1 = time() if mpirank == 0: print 'Time to assemble K1 = {}'.format(t1-t0) lam2.vector()[:] = 1.0 if mpirank == 0: print 'Start assembling K2' MPI.barrier(mpicomm) t0 = time() K2 = assemble(weak_2) MPI.barrier(mpicomm) t1 = time() if mpirank == 0: print 'Time to assemble K2 = {}'.format(t1-t0)