def before_first_compute(self, get): u = get(self.valuename) if u is None: return None V = u.function_space() element = V.ufl_element() #family = element.family() #degree = element.degree() spaces = SpacePool(self.mesh) FS = spaces.get_custom_space(element.family(), element.degree(), element.value_shape()) if LooseVersion(dolfin_version()) > LooseVersion("1.6.0"): rank = len(u.ufl_shape) else: rank = u.rank() if rank > 0: FS_scalar = spaces.get_custom_space(element.family(), element.degree(), ()) self.assigner = FunctionAssigner(FS, [FS_scalar]*FS.num_sub_spaces()) self.us = [] for i in range(FS.num_sub_spaces()): self.us.append(Function(FS_scalar)) self.u = Function(FS, name=self.name)
def before_first_compute(self, get): u = get(self.valuename) assert isinstance( u, Function), "Can only extract boundary values of Function-objects" FS = u.function_space() spaces = SpacePool(FS.mesh()) element = FS.ufl_element() #FS_boundary = spaces.get_space(FS.ufl_element().degree(), FS.num_sub_spaces(), boundary=True) FS_boundary = spaces.get_custom_space(element.family(), element.degree(), element.value_shape(), boundary=True) local_dofmapping = mesh_to_boundarymesh_dofmap(spaces.BoundaryMesh, FS, FS_boundary) #self._keys = local_dofmapping.keys() self._keys = np.array(local_dofmapping.keys(), dtype=np.intc) #self._values = local_dofmapping.values() self._values = np.array(local_dofmapping.values(), dtype=np.intc) self._temp_array = np.zeros(len(self._keys), dtype=np.float_) self.u_bdry = Function(FS_boundary)
def before_first_compute(self, get): u = get("Velocity") V = u.function_space() spaces = SpacePool(V.mesh()) degree = V.ufl_element().degree() if degree <= 1: Q = spaces.get_grad_space(V, shape=(spaces.d,)) else: if degree > 2: cbc_warning("Unable to handle higher order WSS space. Using CG1.") Q = spaces.get_space(1,1) Q_boundary = spaces.get_space(Q.ufl_element().degree(), 1, boundary=True) self.v = TestFunction(Q) self.tau = Function(Q, name="WSS_full") self.tau_boundary = Function(Q_boundary, name="WSS") local_dofmapping = mesh_to_boundarymesh_dofmap(spaces.BoundaryMesh, Q, Q_boundary) self._keys = np.array(local_dofmapping.keys(), dtype=np.intc) self._values = np.array(local_dofmapping.values(), dtype=np.intc) self._temp_array = np.zeros(len(self._keys), dtype=np.float_) Mb = assemble(inner(TestFunction(Q_boundary), TrialFunction(Q_boundary))*dx) self.solver = create_solver("gmres", "jacobi") self.solver.set_operator(Mb) self.b = Function(Q_boundary).vector() self._n = FacetNormal(V.mesh())
def create_function_from_metadata(pp, fieldname, metadata, saveformat): "Create a function from metadata" assert metadata['type'] == 'Function' # Load mesh if saveformat == 'hdf5': mesh = Mesh() hdf5file = HDF5File(mpi_comm_world(), os.path.join(pp.get_savedir(fieldname), fieldname+'.hdf5'), 'r') hdf5file.read(mesh, "Mesh", False) del hdf5file elif saveformat == 'xml' or saveformat == 'xml.gz': mesh = Mesh() hdf5file = HDF5File(mpi_comm_world(), os.path.join(pp.get_savedir(fieldname), "mesh.hdf5"), 'r') hdf5file.read(mesh, "Mesh", False) del hdf5file # Replace loaded mesh if same mesh is loaded previously mesh = MeshPool(mesh, tolerance=0.0) shape = eval(metadata["element_value_shape"]) degree = eval(metadata["element_degree"]) family = eval(metadata["element_family"]) # Get space from existing function spaces if mesh is the same spaces = SpacePool(mesh) space = spaces.get_custom_space(family, degree, shape) return Function(space, name=fieldname)
def test_default_save(mesh, casedir): spacepool = SpacePool(mesh) Q = spacepool.get_space(1, 0) V = spacepool.get_space(1, 1) mff = MockFunctionField(Q, dict(save=True)) mvff = MockVectorFunctionField(V, dict(save=True)) mtf = MockTupleField(dict(save=True)) msf = MockScalarField(dict(save=True)) pp = PostProcessor(dict(casedir=casedir)) pp.add_fields([mff, mvff, mtf, msf]) pp.update_all({}, 0.0, 0) pp.update_all({}, 0.1, 1) pp.update_all({}, 0.2, 2) pp.finalize_all() for mf in [mff, mvff]: assert os.path.isdir(pp.get_savedir(mf.name)) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), "metadata.db")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + ".hdf5")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + ".h5")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + ".xdmf")) assert len(os.listdir(pp.get_savedir(mf.name))) == 4 md = shelve.open(os.path.join(pp.get_savedir(mf.name), "metadata.db"), 'r') assert 'hdf5' in md["0"] assert 'hdf5' in md['saveformats'] assert 'xdmf' in md["0"] assert 'xdmf' in md['saveformats'] assert set(md['saveformats']) == set(['hdf5', 'xdmf']) md.close() for mf in [mtf, msf]: assert os.path.isdir(pp.get_savedir(mf.name)) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), "metadata.db")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + ".db")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + ".txt")) md = shelve.open(os.path.join(pp.get_savedir(mf.name), "metadata.db"), 'r') assert 'txt' in md["0"] assert 'txt' in md['saveformats'] assert 'shelve' in md["0"] assert 'shelve' in md['saveformats'] assert set(md['saveformats']) == set(['txt', 'shelve']) md.close()
def before_first_compute(self, get): u = get("Velocity") mesh = u.function_space().mesh() spaces = SpacePool(mesh) DG0 = spaces.get_space(0, 0) self._v = TestFunction(DG0) self._cfl = Function(DG0) self._hF = Circumradius(mesh) self._hK = CellVolume(mesh)
def before_first_compute(self, get): u = get("Velocity") mesh = u.function_space().mesh() spaces = SpacePool(mesh) DG0 = spaces.get_space(0, 0) self._v = TestFunction(DG0) self._cfl = Function(DG0) self._hF = Circumradius(mesh) self._hK = CellVolume(mesh)
def before_first_compute(self, get): u = get("Velocity") U = u.function_space() spaces = SpacePool(U.mesh()) if self.params.expr2function == "assemble": V = spaces.get_space(0, 0) else: V = spaces.get_space(2*U.ufl_element().degree(), 0) self._function = Function(V, name=self.name)
def before_first_compute(self, get): u = get("Velocity") U = u.function_space() spaces = SpacePool(U.mesh()) if self.params.expr2function == "assemble": V = spaces.get_space(0, 0) else: V = spaces.get_space(2 * U.ufl_element().degree(), 0) self._function = Function(V, name=self.name)
def test_basic_replay(mesh, casedir): spacepool = SpacePool(mesh) Q = spacepool.get_space(1,0) V = spacepool.get_space(1,1) pp = PostProcessor(dict(casedir=casedir)) pp.add_fields([ MockFunctionField(Q, dict(save=True)), MockVectorFunctionField(V, dict(save=True)) ]) replay_fields = lambda save: [Norm("MockFunctionField", dict(save=save)), Norm("MockVectorFunctionField", dict(save=save)), TimeIntegral("Norm_MockFunctionField", dict(save=save)),] rf_names = [f.name for f in replay_fields(False)] # Add fields, but don't save (for testing) pp.add_fields(replay_fields(False)) # Solutions to check against checks = {} pp.update_all({}, 0.0, 0) checks[0] = dict([(name, pp.get(name)) for name in rf_names]) pp.update_all({}, 0.1, 1) checks[1] = dict([(name, pp.get(name)) for name in rf_names]) pp.update_all({}, 0.2, 2) pp.finalize_all() checks[2] = dict([(name, pp.get(name)) for name in rf_names]) # Make sure that nothing is saved yet for name in rf_names: assert not os.path.isfile(os.path.join(pp.get_savedir(name), name+".db")) # ----------- Replay ----------------- pp = PostProcessor(dict(casedir=casedir)) pp.add_fields([ MockFunctionField(Q), MockVectorFunctionField(V), ]) # This time, save the fields pp.add_fields(replay_fields(True)) replayer = Replay(pp) replayer.replay() # Test that replayed solution is the same as computed in the original "solve" for name in rf_names: data = shelve.open(os.path.join(pp.get_savedir(name), name+".db"), 'r') for i in range(3): assert data.get(str(i), None) == checks[i][name] or abs(data.get(str(i), None) - checks[i][name]) < 1e-8 data.close()
def test_dolfinplot(mesh): pp = PostProcessor() spacepool = SpacePool(mesh) Q = spacepool.get_space(1, 0) V = spacepool.get_space(1, 1) pp.add_field(MockFunctionField(Q, dict(plot=True))) pp.add_field(MockVectorFunctionField(V, dict(plot=True))) pp.update_all({}, 0.0, 0) pp.update_all({}, 0.1, 1) pp.update_all({}, 0.6, 2) pp.update_all({}, 1.6, 3)
def test_xmlgz_save(mesh, casedir): spacepool = SpacePool(mesh) Q = spacepool.get_space(1, 0) V = spacepool.get_space(1, 1) mff = MockFunctionField(Q, dict(save=True, save_as="xml.gz")) mvff = MockVectorFunctionField(V, dict(save=True, save_as="xml.gz")) pp = PostProcessor(dict(casedir=casedir)) pp.add_fields([mff, mvff]) pp.update_all({}, 0.0, 0) pp.update_all({}, 0.1, 1) pp.update_all({}, 0.2, 2) pp.finalize_all() for mf, FS in [(mff, Q), (mvff, V)]: assert os.path.isdir(pp.get_savedir(mf.name)) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), "metadata.db")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), "mesh.hdf5")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "0.xml.gz")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "1.xml.gz")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "2.xml.gz")) md = shelve.open(os.path.join(pp.get_savedir(mf.name), "metadata.db"), 'r') assert 'xml.gz' in md["0"] assert 'xml.gz' in md["1"] assert 'xml.gz' in md["2"] assert 'xml.gz' in md['saveformats'] assert md['saveformats'] == ['xml.gz'] md.close() assert len(os.listdir(pp.get_savedir(mf.name))) == 1 + 1 + 3 # Read back for i in ["0", "1", "2"]: f = Function( FS, os.path.join(pp.get_savedir(mf.name), mf.name + i + ".xml.gz")) assert norm(f) == norm(pp.get(mf.name))
def before_first_compute(self, get): u = get("Velocity") U = u.function_space() spaces = SpacePool(U.mesh()) if self.params.expr2function == "assemble": degree = 0 elif True: degree = 1 else: # TODO: Use accurate degree? Plotting will be projected to CG1 anyway... degree = 2 * (U.ufl_element().degree() - 1) V = spaces.get_space(degree, 0) self._function = Function(V, name=self.name)
def before_first_compute(self, get): u = get("Velocity") assert len(u) == 2, "Can only compute stream function for 2D problems" V = u.function_space() spaces = SpacePool(V.mesh()) degree = V.ufl_element().degree() V = spaces.get_space(degree, 0) psi = TrialFunction(V) self.q = TestFunction(V) a = dot(grad(psi), grad(self.q))*dx() self.bc = DirichletBC(V, Constant(0), DomainBoundary()) self.A = assemble(a) self.L = Vector() self.bc.apply(self.A) self.solver = KrylovSolver(self.A, "cg") self.psi = Function(V)
def before_first_compute(self, get): u = get("Velocity") assert len(u) == 2, "Can only compute stream function for 2D problems" V = u.function_space() spaces = SpacePool(V.mesh()) degree = V.ufl_element().degree() V = spaces.get_space(degree, 0) psi = TrialFunction(V) self.q = TestFunction(V) a = dot(grad(psi), grad(self.q)) * dx() self.bc = DirichletBC(V, Constant(0), DomainBoundary()) self.A = assemble(a) self.L = Vector() self.bc.apply(self.A) self.solver = KrylovSolver(self.A, "cg") self.psi = Function(V)
def test_hdf5_save(mesh, casedir): spacepool = SpacePool(mesh) Q = spacepool.get_space(1, 0) V = spacepool.get_space(1, 1) mff = MockFunctionField(Q, dict(save=True, save_as="hdf5")) mvff = MockVectorFunctionField(V, dict(save=True, save_as="hdf5")) pp = PostProcessor(dict(casedir=casedir)) pp.add_fields([mff, mvff]) pp.update_all({}, 0.0, 0) pp.update_all({}, 0.1, 1) pp.update_all({}, 0.2, 2) pp.finalize_all() for mf, FS in [(mff, Q), (mvff, V)]: assert os.path.isdir(pp.get_savedir(mf.name)) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), "metadata.db")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + ".hdf5")) md = shelve.open(os.path.join(pp.get_savedir(mf.name), "metadata.db"), 'r') assert 'hdf5' in md["0"] assert 'hdf5' in md["1"] assert 'hdf5' in md["2"] assert 'hdf5' in md['saveformats'] assert md['saveformats'] == ['hdf5'] md.close() assert len(os.listdir(pp.get_savedir(mf.name))) == 2 # Read back hdf5file = HDF5File( mpi_comm_world(), os.path.join(pp.get_savedir(mf.name), mf.name + ".hdf5"), 'r') f = Function(FS) for i in ["0", "1", "2"]: hdf5file.read(f, mf.name + i) assert norm(f) == norm(pp.get(mf.name))
def test_spacepool_base_functionality(mesh): p = SpacePool(mesh) d = mesh.geometry().dim() spaces = [] shapes = [(), (3,), (2,4)] degrees = [0,1,2] for shape in shapes: for degree in degrees: V = p.get_custom_space("DG", degree, shape) assert V.ufl_element().degree() == degree assert V.ufl_element().value_shape() == shape rank = len(shape) shape2 = (d,)*rank U = p.get_space(degree, rank) assert U.ufl_element().degree() == degree assert U.ufl_element().value_shape() == shape2 spaces.append((V,U)) k = 0 for shape in shapes: for degree in degrees: V0, U0 = spaces[k]; k += 1 V = p.get_custom_space("DG", degree, shape) U = p.get_space(degree, len(shape)) assert id(V0) == id(V) assert id(U0) == id(U)
def before_first_compute(self, get): u = get("Velocity") V = u.function_space() spaces = SpacePool(V.mesh()) degree = V.ufl_element().degree() if degree <= 1: Q = spaces.get_grad_space(V, shape=(spaces.d, )) else: if degree > 2: cbc_warning( "Unable to handle higher order WSS space. Using CG1.") Q = spaces.get_space(1, 1) Q_boundary = spaces.get_space(Q.ufl_element().degree(), 1, boundary=True) self.v = TestFunction(Q) self.tau = Function(Q, name="WSS_full") self.tau_boundary = Function(Q_boundary, name="WSS") local_dofmapping = mesh_to_boundarymesh_dofmap(spaces.BoundaryMesh, Q, Q_boundary) self._keys = np.array(local_dofmapping.keys(), dtype=np.intc) self._values = np.array(local_dofmapping.values(), dtype=np.intc) self._temp_array = np.zeros(len(self._keys), dtype=np.float_) Mb = assemble( inner(TestFunction(Q_boundary), TrialFunction(Q_boundary)) * dx) self.solver = create_solver("gmres", "jacobi") self.solver.set_operator(Mb) self.b = Function(Q_boundary).vector() self._n = FacetNormal(V.mesh())
def test_grad_spaces(mesh): p = SpacePool(mesh) d = mesh.geometry().dim() #Q = get_custom_space("CG", 1, (1,)) Q = p.get_space(1,0) DQ = p.get_grad_space(Q) assert DQ.ufl_element().family() == "Discontinuous Lagrange" assert DQ.ufl_element().degree() == Q.ufl_element().degree()-1 assert DQ.ufl_element().value_shape() == (d,) V = p.get_space(2,1) DV = p.get_grad_space(V) assert DV.ufl_element().family() == "Discontinuous Lagrange" assert DV.ufl_element().degree() == V.ufl_element().degree()-1 assert DV.ufl_element().value_shape() == (d,d) W = p.get_space(2,2) DW = p.get_grad_space(W) assert DW.ufl_element().family() == "Discontinuous Lagrange" assert DW.ufl_element().degree() == V.ufl_element().degree()-1 assert DW.ufl_element().value_shape() == (d,d,d)
def __init__(self, mesh, u_degree, p_degree, u_family="auto", p_family="auto"): self.spacepool = SpacePool(mesh) assert isinstance(u_degree, int) assert isinstance(p_degree, int) assert isinstance(u_family, str) assert isinstance(p_family, str) self.u_degree = u_degree self.p_degree = p_degree self.u_family = u_family self.p_family = p_family self._spaces = {} # Get dimensions for convenience cell = mesh.ufl_cell() self.gdim = cell.geometric_dimension() self.tdim = cell.topological_dimension() self.gdims = range(self.gdim) self.tdims = range(self.tdim) # For compatibility, remove when code has been converted self.d = self.gdim self.dims = self.gdims
class NSSpacePool(): "A function space pool with custom named spaces for use with Navier-Stokes schemes." def __init__(self, mesh, u_degree, p_degree, u_family="auto", p_family="auto"): self.spacepool = SpacePool(mesh) assert isinstance(u_degree, int) assert isinstance(p_degree, int) assert isinstance(u_family, str) assert isinstance(p_family, str) self.u_degree = u_degree self.p_degree = p_degree self.u_family = u_family self.p_family = p_family self._spaces = {} # Get dimensions for convenience cell = mesh.ufl_cell() self.gdim = cell.geometric_dimension() self.tdim = cell.topological_dimension() self.gdims = range(self.gdim) self.tdims = range(self.tdim) # For compatibility, remove when code has been converted self.d = self.gdim self.dims = self.gdims @property def U(self): "Scalar valued space for velocity components." return self.spacepool.get_space(self.u_degree, 0, family=self.u_family) @property def V(self): "Vector valued space for velocity vector." return self.spacepool.get_space(self.u_degree, 1, family=self.u_family) @property def Q(self): "Scalar valued space for pressure." return self.spacepool.get_space(self.p_degree, 0, family=self.p_family) @property def DU0(self): "Scalar valued space for gradient component of single velocity component." return self.spacepool.get_space(self.u_degree-1, 0, family=self.u_family) @property def DU(self): "Vector valued space for gradients of single velocity components." return self.spacepool.get_space(self.u_degree-1, 1, family=self.u_family) @property def DV(self): "Tensor valued space for gradients of velocity vector." return self.spacepool.get_space(self.u_degree-1, 2, family=self.u_family) @property def DQ0(self): "Scalar valued space for pressure gradient component." return self.spacepool.get_space(self.p_degree-1, 0, family=self.p_family) @property def DQ(self): "Vector valued space for pressure gradient." return self.spacepool.get_space(self.p_degree-1, 1, family=self.p_family) @property def W(self): "Mixed velocity-pressure space." space = self._spaces.get("W") if space is None: if LooseVersion(dolfin_version()) > LooseVersion("1.6.0"): space = FunctionSpace(self.spacepool.mesh, MixedElement(self.V.ufl_element(),self.Q.ufl_element())) else: space = self.V*self.Q self._spaces["W"] = space return space
def test_pvd_save(mesh, casedir): spacepool = SpacePool(mesh) Q = spacepool.get_space(1, 0) V = spacepool.get_space(1, 1) mff = MockFunctionField(Q, dict(save=True, save_as="pvd")) mvff = MockVectorFunctionField(V, dict(save=True, save_as="pvd")) pp = PostProcessor(dict(casedir=casedir)) pp.add_fields([mff, mvff]) pp.update_all({}, 0.0, 0) pp.update_all({}, 0.1, 1) pp.update_all({}, 0.2, 2) pp.finalize_all() for mf, FS in [(mff, Q), (mvff, V)]: assert os.path.isdir(pp.get_savedir(mf.name)) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), "metadata.db")) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + ".pvd")) if MPI.size(mpi_comm_world()) == 1: assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "%0.6d.vtu" % 0)) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "%0.6d.vtu" % 1)) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "%0.6d.vtu" % 2)) else: assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "%0.6d.pvtu" % 0)) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "%0.6d.pvtu" % 1)) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "%0.6d.pvtu" % 2)) for i in range(MPI.size(mpi_comm_world())): assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "_p%d_%0.6d.vtu" % (i, 0))) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "_p%d_%0.6d.vtu" % (i, 1))) assert os.path.isfile( os.path.join(pp.get_savedir(mf.name), mf.name + "_p%d_%0.6d.vtu" % (i, 2))) md = shelve.open(os.path.join(pp.get_savedir(mf.name), "metadata.db"), 'r') assert 'pvd' in md["0"] assert 'pvd' in md["1"] assert 'pvd' in md["2"] assert md['saveformats'] == ['pvd'] md.close() assert len(os.listdir(pp.get_savedir(mf.name))) == 1 + 1 + 3 + int( MPI.size(mpi_comm_world()) != 1) * MPI.size(mpi_comm_world()) * 3