def numpy_to_dolfin_old(nodes, elements): """ Deprecated version of numpy_to_dolfin. To be removed? """ tmpfile = "tmp.xml" if rank == 0: with open(tmpfile, "w") as f: f.write(""" <?xml version="1.0" encoding="UTF-8"?> <dolfin xmlns:dolfin="http://www.fenics.org/dolfin/"> <mesh celltype="triangle" dim="2"> <vertices size="%d">""" % len(nodes)) for i, pt in enumerate(nodes): f.write('<vertex index="%d" x="%g" y="%g"/>' % ( i, pt[0], pt[1])) f.write(""" </vertices> <cells size="%d">""" % len(elements)) for i, element in enumerate(elements): f.write('<triangle index="%d" v0="%d" v1="%d" v2="%d"/>' % ( i, element[0], element[1], element[2])) f.write(""" </cells> </mesh> </dolfin>""") comm.Barrier() mesh = df.Mesh(tmpfile) comm.Barrier() if rank == 0 and os.path.exists(tmpfile): os.remove(tmpfile) return mesh
def make_1d_mesh_from_points(Xs): N = len(Xs) mesh = dolfin.Mesh() ed = dolfin.MeshEditor() ed.open(mesh, 'interval', 1, 1) ed.init_vertices(N) av = ed.add_vertex for i, x in enumerate(Xs): av(i, [x]) ed.init_cells(N-1) ac = ed.add_cell for i in range(N-1): ac(i, [i, i+1]) ed.close() mesh.init() mesh.order() return mesh
def __init__(self, title, logger, subdomaininfo, facetinfo, refinement_info): self.mesh_dir = "mesh/" self.meshname = str(title) + '_mesh' self.mesh_file = self.mesh_dir + self.meshname + '.h5' self.mesh = d.Mesh() self.logger = logger self.logger.info("Loading mesh") hdf = d.HDF5File(self.mesh.mpi_comm(), self.mesh_file, "r") hdf.read(self.mesh, "/mesh", False) self.cells = d.MeshFunction('size_t', self.mesh, self.mesh.geometric_dimension()) self.facets = d.MeshFunction('size_t', self.mesh, self.mesh.geometric_dimension() - 1) hdf.read(self.cells, "/subdomains") hdf.read(self.facets, "/facets") self.dimension = self.mesh.topology().dim() self.subdomaininfo = subdomaininfo self.facetinfo = facetinfo self.refinement_info = refinement_info self.logger.info("Loaded mesh") if self.refinement_info is not None: self.refine()
def build_mesh(vertices, cells, cell_type): '''Mesh defined by its vertices, cells''' cell_tdim = cell_type.topological_dimension() gdim = cell_type.geometric_dimension() # Consistency assert gdim == vertices.shape[1] assert cell_type.num_vertices() == cells.shape[1] mesh = df.Mesh() editor = df.MeshEditor() editor.open(mesh, cell_type.cellname(), cell_tdim, gdim) editor.init_cells(len(cells)) editor.init_vertices(len(vertices)) for i, v in enumerate(vertices): editor.add_vertex(i, v) for i, c in enumerate(cells): editor.add_cell(i, c) editor.close() return mesh
def __init__(self, h5_file): """__init__. :param h5_file: """ self.mesh = df.Mesh() hdf = df.HDF5File(self.mesh.mpi_comm(), h5_file, "r") hdf.read(self.mesh, "/mesh", False) dim = self.mesh.topology().dim() self.subdomains = df.MeshFunction("size_t", self.mesh, dim) hdf.read(self.subdomains, "/subdomains") self.boundaries = df.MeshFunction("size_t", self.mesh, dim - 1) hdf.read(self.boundaries, "/boundaries") #Used in the program self.nv = df.FacetNormal(self.mesh) #normal vector self.ds = df.Measure("ds", domain=self.mesh, subdomain_data=self.boundaries) self.dS = df.Measure("dS", domain=self.mesh, subdomain_data=self.boundaries)
def save_serialized_mesh(): print 'Importing dolfin, takes a bit of time...' import dolfin print 'Done importing dolfin.' resolution = 96 mesh_full_filename = 'data/mesh_res_%d_full.xml' % resolution mesh_3d = dolfin.Mesh(mesh_full_filename) # NOTE: This is temporary. These are parameters of the mesh (when it was # created in full_dendrite_mesh.py) and we should package them in a # different way. SCALE_FACTOR = 50.0 STARTING_X = SCALE_FACTOR * 0.0 STARTING_Y = SCALE_FACTOR * 0.0 STARTING_Z = SCALE_FACTOR * 1.0 STARTING_K = SCALE_FACTOR * 0.01 initial_point = np.array((STARTING_X, STARTING_Y, STARTING_Z)) mesh_wrapper = Mesh.from_mesh(mesh_3d, initial_point, STARTING_K) serialized_mesh_filename = 'data/serialized_mesh_res_%d.npz' % resolution mesh_wrapper.serialize_mesh(serialized_mesh_filename)
def load_with_meshio(meshFile, dimension): # input mesh file name and path witout file extension # dimension = max spatial dimension of the mesh # (typically 2 or 3 for 2D or 3D) # read in the mesh mesh = dl.Mesh() with dl.XDMFFile(meshFile + ".xdmf") as infile: infile.read(mesh) # read in the facet boundaries mvc = dl.MeshValueCollection("size_t", mesh, dimension - 1) with dl.XDMFFile(meshFile + "_facet_region.xdmf") as infile: infile.read(mvc, "name_to_read") facet_regions = dl.cpp.mesh.MeshFunctionSizet(mesh, mvc) # read in the defined physical regions mvc2 = dl.MeshValueCollection("size_t", mesh, dimension) with dl.XDMFFile(meshFile + ".xdmf") as infile: infile.read(mvc2, "name_to_read") physical_regions = dl.cpp.mesh.MeshFunctionSizet(mesh, mvc2) return mesh, facet_regions, physical_regions
def generate_mesh(self): import meshio geo = self.user_define_pygmsh_geo() r = self.pygmsh_generate_mesh(geo) d = PygmshMakeRegions().process(cells=r['cells'], cell_data=r['cell_data'], field_data=r['field_data'], dim=r['dim']) with tempfile.TemporaryDirectory() as tmpdir: mesh_file = osp.join(str(tmpdir), 'mesh.xdmf') meshio.write_points_cells(mesh_file, r['points'], r['cells'], cell_data=r['cell_data']) with dolfin.XDMFFile(mesh_file) as file: mesh = dolfin.Mesh() file.read(mesh) cf = dolfin.MeshFunction('size_t', mesh, r['dim'], 0) file.read(cf) self.mesh = mesh self.cf = cf # initialize facets-cells mapping D = self.dim mesh.init(D - 1, D) # TODO: turn physical objects with dim-1 into facetfunction self.cell_regions = d['tag_to_cell_values'] self.cell_regions['domain'] = domain_cvs = set() for cvs in d['tag_to_cell_values'].values(): domain_cvs.update(cvs)
def __init__(self, mesh_file, facet_ids_file=None, cell_ids_file=None): #: A :class:`dolfin.Mesh` containing the mesh. self.mesh = dolfin.Mesh(mesh_file) # Read facet markers if facet_ids_file is None: facet_ids_file = (os.path.splitext(mesh_file)[0] + "_facet_region.xml") # Read cell markers if cell_ids_file is None: cell_ids_file = (os.path.splitext(mesh_file)[0] + "_physical_region.xml") #: A :class:`dolfin.FacetFunction` containing the surface markers. self.facet_ids = dolfin.MeshFunction("size_t", self.mesh, facet_ids_file) #: A :class:`dolfin.Measure` for the facet parts. self._ds = dolfin.Measure('ds')(subdomain_data=self.facet_ids) #: A :class:`dolfin.CellFunction` containing the area markers. self.cell_ids = dolfin.MeshFunction("size_t", self.mesh, cell_ids_file) #: A :class:`dolfin.Measure` for the cell subdomains. self._dx = dolfin.Measure("dx")(subdomain_data=self.cell_ids)
def load_embedding(folder): '''Load embedding''' h5_file = os.path.join(folder, 'mesh.h5') embedding_mesh = df.Mesh() h5 = df.HDF5File(embedding_mesh.mpi_comm(), h5_file, 'r') h5.read(embedding_mesh, 'embedding_mesh', False) edge_coloring = df.MeshFunction('size_t', embedding_mesh, 1, 0) h5.read(edge_coloring, 'edge_coloring') vertex_map = np.loadtxt(os.path.join(folder, 'vertex_map.txt')) edge_encoding = EdgeMap( pickle.load(open(os.path.join(folder, 'edge_encoding_0.pkl'), 'rb')), pickle.load(open(os.path.join(folder, 'edge_encoding_1.pkl'), 'rb'))) nc_edge_encoding = EdgeMap( pickle.load(open(os.path.join(folder, 'nc_edge_encoding_0.pkl'), 'rb')), pickle.load(open(os.path.join(folder, 'nc_edge_encoding_1.pkl'), 'rb'))) return LineMeshEmbedding(embedding_mesh, vertex_map, edge_coloring, edge_encoding, nc_edge_encoding)
def __load_mesh_hdf5(mesh_file): """ Load dolfin mesh from an HDF5 file. Parameters ---------- mesh_file : str Name of the file containing the mesh information Returns ------- mesh : dolfin.cpp.mesh.Mesh This function returns a dolfin mesh object. """ # Check dolfin for HDF5 support if not dlf.has_hdf5(): msg = 'The current installation of dolfin does not support HDF5 files.' raise SoftwareNotAvailable(msg) # Check file extension if mesh_file[-3:] == '.h5': f = dlf.HDF5File(MPI_COMM_WORLD, mesh_file, 'r') mesh = dlf.Mesh() f.read(mesh, 'mesh', False) f.close() else: msg = 'The file extension provided must be \'.h5\'.' raise ValueError(msg) return mesh
def main(): parser = argparse.ArgumentParser(description="Trace particles") parser.add_argument("mesh_file", type=str, help="Path to mesh file") parser.add_argument("u_file", type=str, help="Path to velocity field file") parser.add_argument("out_file", type=str, help="Path to .xdmf file to save to") args = parser.parse_args() mesh = df.Mesh() with df.HDF5File(mesh.mpi_comm(), args.mesh_file, "r") as h5f_mesh: h5f_mesh.read(mesh, "/mesh", False) V = df.VectorFunctionSpace(mesh, "CG", 1) u = df.Function(V) with df.HDF5File(mesh.mpi_comm(), args.u_file, "r") as h5f_u: h5f_u.read(u, "/velocity") xdmff = df.XDMFFile(mesh.mpi_comm(), args.out_file) xdmff.parameters["rewrite_function_mesh"] = False xdmff.parameters["flush_output"] = True xdmff.write(u, float(0.))
def write_xdmf_to_h5(xdmfdir, hdf5file): import dolfin as df # Read .xdmf mesh into a FEniCS Mesh mesh = df.Mesh() with df.XDMFFile("%s/mesh.xdmf" % xdmfdir) as infile: infile.read(mesh) # Read cell data to a MeshFunction (of dim n) n = mesh.topology().dim() subdomains = df.MeshFunction("size_t", mesh, n) with df.XDMFFile("%s/subdomains.xdmf" % xdmfdir) as infile: infile.read(subdomains, "subdomains") # Read facet data to a MeshFunction (of dim n-1) boundaries = df.MeshFunction("size_t", mesh, n-1, 0) with df.XDMFFile("%s/boundaries.xdmf" % xdmfdir) as infile: infile.read(boundaries, "boundaries") # Write all files into a single h5 file. hdf = df.HDF5File(mesh.mpi_comm(), hdf5file, "w") hdf.write(mesh, "/mesh") hdf.write(subdomains, "/subdomains") hdf.write(boundaries, "/boundaries") hdf.close()
def update_geometry(geometry, u=None, regen_fibers=True, *args): new_mesh = df.Mesh(geometry.mesh) if u is not None: U = move(new_mesh, u, -1.0, *args) else: U = u new_geometry = copy_geometry(new_mesh, geometry) fields = ["fiber", "sheet", "sheet_normal"] local_basis = ["circumferential", "radial", "longitudinal"] for attr in fields + local_basis: if hasattr(geometry, attr) and getattr(geometry, attr) is not None: regen = regen_fibers if attr == "fiber" else False f0 = getattr(geometry, attr).copy() f = update_vector_field(f0, new_mesh, U, regen_fibers=regen) setattr(new_geometry, attr, f) return new_geometry
def create_3d_mesh(mesh, h=1): assert mesh.topology().dim() == 2 for cell in df.cells(mesh): print cell print cell.entities(0) print cell.get_vertex_coordinates() nv = mesh.num_vertices() nc = mesh.num_cells() mesh3 = df.Mesh() editor = df.MeshEditor() editor.open(mesh3, 3, 3) editor.init_vertices(2 * nv) editor.init_cells(3 * nc) for v in df.vertices(mesh): i = v.global_index() p = v.point() editor.add_vertex(i, p.x(), p.y(), 0) editor.add_vertex(i + nv, p.x(), p.y(), h) gid = 0 for c in df.cells(mesh): #gid = c.global_index() i, j, k = c.entities(0) print i, j, k editor.add_cell(gid, i, j, k, i + nv) gid = gid + 1 editor.add_cell(gid, j, j + nv, k, i + nv) gid = gid + 1 editor.add_cell(gid, k, k + nv, j + nv, i + nv) gid = gid + 1 editor.close() return mesh3
def load_geometry_from_h5( h5name, h5group="", fendo=None, fepi=None, include_sheets=True, comm=mpi_comm_world(), ): """Load geometry and other mesh data from a h5file to an object. If the file contains muliple fiber fields you can spefify the angles, and if the file contais sheets and cross-sheets this can also be included :param str h5name: Name of the h5file :param str h5group: The group within the file :param int fendo: Helix fiber angle (endocardium) (if available) :param int fepi: Helix fiber angle (epicardium) (if available) :param bool include_sheets: Include sheets and cross-sheets :returns: An object with geometry data :rtype: object """ logger.info("\nLoad mesh from h5") # Set default groups ggroup = "{}/geometry".format(h5group) mgroup = "{}/mesh".format(ggroup) lgroup = "{}/local basis functions".format(h5group) fgroup = "{}/microstructure/".format(h5group) if not os.path.isfile(h5name): raise IOError("File {} does not exist".format(h5name)) # Check that the given file contains # the geometry in the given h5group if not io_utils.check_h5group(h5name, mgroup, delete=False, comm=comm): msg = ("Warning!\nGroup: '{}' does not exist in file:" "\n{}").format(mgroup, h5name) with h5py.File(h5name) as h: keys = h.keys() msg += "\nPossible values for the h5group are {}".format(keys) raise IOError(msg) # Create a dummy object for easy parsing class Geometry(object): pass geo = Geometry() with dolfin.HDF5File(comm, h5name, "r") as h5file: # Load mesh mesh = dolfin.Mesh(comm) io_utils.read_h5file(h5file, mesh, mgroup, True) geo.mesh = mesh # Get mesh functions for dim, attr in zip(range(4), ["vfun", "efun", "ffun", "cfun"]): dgroup = "{}/mesh/meshfunction_{}".format(ggroup, dim) mf = dolfin.MeshFunction("size_t", mesh, dim, mesh.domains()) if h5file.has_dataset(dgroup): io_utils.read_h5file(h5file, mf, dgroup) setattr(geo, attr, mf) load_local_basis(h5file, lgroup, mesh, geo) load_microstructure(h5file, fgroup, mesh, geo, include_sheets) # Load the boundary markers markers = load_markers(h5file, mesh, ggroup, dgroup) geo.markers = markers origmeshgroup = "{}/original_geometry".format(h5group) if h5file.has_dataset(origmeshgroup): original_mesh = dolfin.Mesh(comm) io_utils.read_h5file(h5file, original_mesh, origmeshgroup, True) setattr(geo, "original_geometry", original_mesh) for attr in [ "f0", "s0", "n0", "r0", "c0", "l0", "cfun", "vfun", "efun", "ffun" ]: if not hasattr(geo, attr): setattr(geo, attr, None) return geo
import os, shutil import dolfin as df # Info # from finmag.util.helpers import set_logging_level # set_logging_level("INFO") # set_logging_level("DEBUG") # Geometries from finmag.util.mesh_templates import Nanodisk # MESH ------------------------------------------------------------------------ mesh_file = 'mesh/nanocylinder.xml.gz' if os.path.exists(mesh_file): mesh = df.Mesh(mesh_file) else: mesh = Nanodisk(d=183, h=21, center=(0, 0, 0), valign='bottom', name='nano_cylinder').create_mesh( maxh=2, save_result=True, filename='nanocylinder', directory='mesh', ) # Simulation and energies ----------------------------------------------------- # Bulk
def _inputsort(obj): import dolfin u = None mesh = None if not utils.isSequence(obj): obj = [obj] for ob in obj: inputtype = str(type(ob)) # printc('inputtype is', inputtype, c=2) if "vedo" in inputtype: # skip vtk objects, will be added later continue if "dolfin" in inputtype or "ufl" in inputtype: if "MeshFunction" in inputtype: mesh = ob.mesh() if ob.dim() > 0: printc('MeshFunction of dim>0 not supported.', c=1) printc('Try e.g.: MeshFunction("size_t", mesh, 0)', c=1, italic=1) printc('instead of MeshFunction("size_t", mesh, 1)', c=1, strike=1) else: #printc(ob.dim(), mesh.num_cells(), len(mesh.coordinates()), len(ob.array())) V = dolfin.FunctionSpace(mesh, "CG", 1) u = dolfin.Function(V) v2d = dolfin.vertex_to_dof_map(V) u.vector()[v2d] = ob.array() elif "Function" in inputtype or "Expression" in inputtype: u = ob elif "ufl.mathfunctions" in inputtype: # not working u = ob elif "Mesh" in inputtype: mesh = ob elif "algebra" in inputtype: mesh = ob.ufl_domain() #print('algebra', ob.ufl_domain()) if "str" in inputtype: mesh = dolfin.Mesh(ob) if u and not mesh and hasattr(u, "function_space"): V = u.function_space() if V: mesh = V.mesh() if u and not mesh and hasattr(u, "mesh"): mesh = u.mesh() #printc('------------------------------------') #printc('mesh.topology dim=', mesh.topology().dim()) #printc('mesh.geometry dim=', mesh.geometry().dim()) #if u: printc('u.value_rank()', u.value_rank()) #if u and u.value_rank(): printc('u.value_dimension()', u.value_dimension(0)) # axis=0 ##if u: printc('u.value_shape()', u.value_shape()) return (mesh, u)
#-----------------read--mesh------------- filename = 'test_2d.vtk' mesh = meshio.read(filename, file_format="vtk") points = mesh.points cells = mesh.cells meshio.write_points_cells( "test_2d.xml", points, cells, ) import os os.system('gmsh -2 test_2d.vtk -format msh2') os.system('dolfin-convert test_2d.msh mesh_2d.xml') mesh = df.Mesh("mesh_2d.xml") import matplotlib.pyplot as plt plt.figure(1) df.plot(mesh) # plt.show() ''' 3. Define traction bc subdomains ''' #-----------define-heating-boundary------- class HeatBoundaryAll(df.SubDomain): def inside(self, x, on_boundary):
def mesh_import_fun(mesh_naming): #import mesh return do.Mesh(mesh_naming)
r_int, r_int, )) # Create the mesh diag = np.sqrt(L**2 + (3 * lex)**2) resolut = diag / 3. mesh = mshr.generate_mesh(ntube, resolut) # Output Mesh outp = file('mesh_info.dat', 'w') outp.write(finmag.util.meshes.mesh_info(mesh)) # Save mesh to file file = df.File("nanotube.xml") file << mesh # ############################################# # ###### SIMULATION # Import mesh from the 'xml' file produced by the mesh generator script mesh = df.Mesh('nanotube.xml') # MATERIAL PARAMETERS Ms = 7.96e5 # A m**-1 saturation magnetisation # Inititate the simulation object with the lengths in nm sim = Sim(mesh, Ms, unit_length=1e-9) sim.add(Demag())
endo_apex_marker = geometry.markers['ENDOPT'][0] endo_apex_idx = geometry.vfun.array().tolist().index(endo_apex_marker) endo_apex = geometry.mesh.coordinates()[endo_apex_idx, :] endo_apex_pos = endo_apex + u(endo_apex) print(('\n\nGet longitudinal position of endocardial apex: {:.4f} mm' '').format(endo_apex_pos[0])) epi_apex_marker = geometry.markers['EPIPT'][0] epi_apex_idx = geometry.vfun.array().tolist().index(epi_apex_marker) epi_apex = geometry.mesh.coordinates()[epi_apex_idx, :] epi_apex_pos = epi_apex + u(epi_apex) print(('\n\nGet longitudinal position of epicardial apex: {:.4f} mm' '').format(epi_apex_pos[0])) V = dolfin.VectorFunctionSpace(geometry.mesh, "CG", 1) u_int = dolfin.interpolate(u, V) mesh = dolfin.Mesh(geometry.mesh) dolfin.ALE.move(mesh, u_int) fig = plt.figure() dolfin.plot(geometry.mesh, color='b', edgecolor='k', title='Original geometry') dolfin.plot(mesh, color='r', alpha=0.3, title='Inflating ellipsoid') ax = plt.gca() ax.view_init(elev=-83, azim=-179) fig.savefig('problem2.png')
def xml_to_gmsh(mesh, results=None): """ function iterates through mesh and results (field) data both provided in .xml format and writes a output .msh file with the field data read in as node data. The output file same name as the field file passed or if no filed file passed will have name of input mesh. :param mesh: (.xml) Mesh that is to be written to a file :param field: (.xml) results data """ # get output file if results == None: fname = mesh.rstrip("xml") + "msh" output = open(fname, 'w') else: fname = results.rstrip("xml") + "msh" output = open(fname, 'w') # read files into dolfin format mesh = dolf.Mesh(mesh) Q = dolf.FunctionSpace(mesh, 'CG', 1) if results != None: field = dolf.Function(Q) dolf.File(results) >> field cell_type = mesh.type().cell_type() nodes = mesh.coordinates() n_nodes = mesh.num_vertices() nodes = p.hstack( (nodes, p.zeros((n_nodes, 3 - p.shape(mesh.coordinates())[1])))) cells = mesh.cells() n_cells = mesh.num_cells() output.write("$MeshFormat\n" + "2.2 0 8\n" + "$EndMeshFormat\n" + "$Nodes \n" + "{0:d}\n".format(n_nodes)) for ii, node in enumerate(nodes): output.write("{0:d} {1} {2} {3}\n".format(ii + 1, node[0], node[1], node[2])) output.write("$EndNodes\n") output.write("$Elements\n" + "{0:d}\n".format(n_cells)) for ii, cell in enumerate(cells): if cell_type == 1: output.write("{0:d} 1 0 {1:d} {2:d}\n".format( ii + 1, int(cell[0] + 1), int(cell[1] + 1))) elif cell_type == 2: output.write("{0:d} 2 0 {1:d} {2:d} {3:d}\n".format( ii + 1, int(cell[0] + 1), int(cell[1] + 1), int(cell[2] + 1))) elif cell_type == 3: output.write("{0:d} 4 0 {1:d} {2:d} {3:d} {4:d}\n".format( ii + 1, int(cell[0] + 1), int(cell[1] + 1), int(cell[2] + 1), int(cell[3] + 1))) else: print "Unknown cell type" output.write("$EndElements\n") if results != None: output.write("$NodeData\n" + "1\n" + "\"NodalValues\"\n" + "0\n" + # zero real tags "3\n" + # three integer tags "0\n" + # the time step "1\n" + #1-component (scalar) field "{0:d}\n".format(len(nodes))) for ii, node in enumerate(nodes): output.write("{0:d} {1:g}\n".format(ii + 1, field(node[0], node[1]))) output.write("$EndNodeData\n") output.close() # There is some numerical precision error that prevents files created by # this script from being converted back into xml by dolfin-convert opening the file in gmsh and resaving fixes this print 'calling gmsh...' s.call(['gmsh', fname, '-2'])
def __init__(self, tfml_file, system_name='magma', p_name='Pressure', f_name='Porosity', c_name='c', n_name='n', m_name='m', d_name='d', N_name='N', h_squared_name='h_squared', x0_name='x0'): """read the tfml_file and use libspud to populate the internal parameters c: wavespeed n: permeability exponent m: bulk viscosity exponent d: wave dimension N: number of collocation points x0: coordinate wave peak h_squared: the size of the system in compaction lengths squared (h/delta)**2 """ # initialize libspud and extract parameters libspud.clear_options() libspud.load_options(tfml_file) # get model dimension self.dim = libspud.get_option("/geometry/dimension") self.system_name = system_name # get solitary wave parameters path = "/system::" + system_name + "/coefficient::" scalar_value = "/type::Constant/rank::Scalar/value::WholeMesh/constant" vector_value = "/type::Constant/rank::Vector/value::WholeMesh/constant::dim" c = libspud.get_option(path + c_name + scalar_value) n = int(libspud.get_option(path + n_name + scalar_value)) m = int(libspud.get_option(path + m_name + scalar_value)) d = float(libspud.get_option(path + d_name + scalar_value)) N = int(libspud.get_option(path + N_name + scalar_value)) self.h = np.sqrt( libspud.get_option(path + h_squared_name + scalar_value)) self.x0 = np.array(libspud.get_option(path + x0_name + vector_value)) self.swave = SolitaryWave(c, n, m, d, N) self.rmax = self.swave.r[-1] self.tfml_file = tfml_file # check that d <= dim assert (d <= self.dim) # sort out appropriate index for calculating distance r if d == 1: self.index = [self.dim - 1] else: self.index = range(0, int(d)) # check that the origin point is the correct dimension assert (len(self.x0) == self.dim) #read in information for constructing Function space and dolfin objects # get the mesh parameters and reconstruct the mesh meshtype = libspud.get_option("/geometry/mesh/source[0]/name") if meshtype == 'UnitSquare': number_cells = libspud.get_option( "/geometry/mesh[0]/source[0]/number_cells") diagonal = libspud.get_option( "/geometry/mesh[0]/source[0]/diagonal") mesh = df.UnitSquareMesh(number_cells[0], number_cells[1], diagonal) elif meshtype == 'Rectangle': x0 = libspud.get_option( "/geometry/mesh::Mesh/source::Rectangle/lower_left") x1 = libspud.get_option( "/geometry/mesh::Mesh/source::Rectangle/upper_right") number_cells = libspud.get_option( "/geometry/mesh::Mesh/source::Rectangle/number_cells") diagonal = libspud.get_option( "/geometry/mesh[0]/source[0]/diagonal") mesh = df.RectangleMesh(x0[0], x0[1], x1[0], x1[1], number_cells[0], number_cells[1], diagonal) elif meshtype == 'UnitCube': number_cells = libspud.get_option( "/geometry/mesh[0]/source[0]/number_cells") mesh = df.UnitCubeMesh(number_cells[0], number_cells[1], number_cells[2]) elif meshtype == 'Box': x0 = libspud.get_option( "/geometry/mesh::Mesh/source::Box/lower_back_left") x1 = libspud.get_option( "/geometry/mesh::Mesh/source::Box/upper_front_right") number_cells = libspud.get_option( "/geometry/mesh::Mesh/source::Box/number_cells") mesh = df.BoxMesh(x0[0], x0[1], x0[2], x1[0], x1[1], x1[2], number_cells[0], number_cells[1], number_cells[2]) elif meshtype == 'UnitInterval': number_cells = libspud.get_option( "/geometry/mesh::Mesh/source::UnitInterval/number_cells") mesh = df.UnitIntervalMesh(number_cells) elif meshtype == 'Interval': number_cells = libspud.get_option( "/geometry/mesh::Mesh/source::Interval/number_cells") left = libspud.get_option( "/geometry/mesh::Mesh/source::Interval/left") right = libspud.get_option( "/geometry/mesh::Mesh/source::Interval/right") mesh = df.IntervalMesh(number_cells, left, right) elif meshtype == 'File': mesh_filename = libspud.get_option( "/geometry/mesh::Mesh/source::File/file") print "tfml_file = ", self.tfml_file, "mesh_filename=", mesh_filename mesh = df.Mesh(mesh_filename) else: df.error("Error: unknown mesh type " + meshtype) #set the functionspace for n-d solitary waves path = "/system::" + system_name + "/field::" p_family = libspud.get_option(path + p_name + "/type/rank/element/family") p_degree = libspud.get_option(path + p_name + "/type/rank/element/degree") f_family = libspud.get_option(path + f_name + "/type/rank/element/family") f_degree = libspud.get_option(path + f_name + "/type/rank/element/degree") pe = df.FiniteElement(p_family, mesh.ufl_cell(), p_degree) ve = df.FiniteElement(f_family, mesh.ufl_cell(), f_degree) e = pe * ve self.functionspace = df.FunctionSpace(mesh, e) #work out the order of the fields for i in xrange( libspud.option_count("/system::" + system_name + "/field")): name = libspud.get_option("/system::" + system_name + "/field[" + ` i ` + "]/name") if name == f_name: self.f_index = i if name == p_name: self.p_index = i
2 6 "Copper" ''' d.set_log_active(False) meshpath = '../Mesh/' if len(sys.argv) > 1: meshname = sys.argv[1] else: meshname = 'MeshDiskwithHoleAuto' # meshname = meshname + '_refined' mesh_file = meshpath + meshname + '.h5' if not os.path.isfile(mesh_file): print("Specify correct name for meshfile!") sys.exit(0) mesh = d.Mesh() hdf = d.HDF5File(mesh.mpi_comm(), mesh_file, "r") hdf.read(mesh, "/mesh", False) cells = d.MeshFunction("size_t", mesh, dim=2) hdf.read(cells, "/subdomains") facets = d.MeshFunction("size_t", mesh, dim=1) hdf.read(facets, "/facets") datafileHDF5 = d.HDF5File(mesh.mpi_comm(), "TemperatureDevelopment_test.h5", "w") datafile = open('TemperatureDevelopment_test.dat', 'w') d.plot(mesh) plt.show() """Let's start with some functions and parameters needed for the whole model""" T_0 = d.Constant(300.)
def __init__(self, mesh=None, mesh_file=None, region=None, size=None, center=np.zeros(3), nseg=None, element_length=None, element_type='Lagrange 1', offset=1.0): """Finite-element basis with given support and resolution. Args: mesh(dolfin.Mesh): mesh_file(str): Explicit specification of finite-element mesh as a dolfin.Mesh object or a dolfin-format mesh file. region (Subregion) __OR__ size, center (v3): nseg (list of int) __OR__ element_length(float) If mesh and mesh_file are both absent, the mesh is taken to be a rectangular or cubic lattice over the box-shaped domain given by region (if present) or (size,center). If nseg is specified, nseg[d] is the number of segments into which the dth linear dimension of the region is discretized. Otherwise, element_length (scalar,float) specifies a target discretization lengthscale. If element_length is None, it is taken from options['element_length'] element_type(str): The type of finite-element basis function defined on the mesh, expressed as a compound string of the form 'family degree' for functions of finite-element family *family* and nonnegative-integer degree *degree*. For example, 'Lagrange 1' and 'Lagrange 2' correspond to the usual linear and quadratic functions supported on triangles/tetrahedra. For more information on finite-element types, consult e.g. 1. The FENICS documentation: https://fenicsproject.org/docs/dolfin/1.5.0/python/programmers-reference/mesh/index.html 2. The "Periodic Table of Finite Elements:" http://femtable.org/ """ if 'dolfin' not in sys.modules: msg = 'failed to load dolfin (FENICS) module, needed for FiniteElementBasis' raise ImportError(msg) if mesh_file is not None: mesh = df.Mesh(mesh_file) if mesh is not None: # get bounding box from mesh coordinates pmin, pmax = [ op(mesh.coordinates(), 0) for op in [np.amin, np.amax] ] (center, size) = (0.5 * (pmax + pmin), (pmax - pmin)) else: (center, size) = (v3(region.center), v3(region.size)) if region else (v3(center), v3(size)) if not element_length: element_length = np.amax(size) / 10.0 nn = nseg if nseg else [ int(np.ceil(s / element_length)) for s in size ] nd = 3 if (len(nn) == 3 and nn[2] > 0) else 2 pmin, pmax = [df.Point(center + pm * size) for pm in [-0.5, 0.5]] if nd == 2: mesh = df.RectangleMesh(pmin, pmax, nn[0], nn[1], diagonal='left') else: mesh = df.BoxMesh(pmin, pmax, nn[0], nn[1], nn[2]) family, degree = element_type.split()[0:2] self.fs = df.FunctionSpace(mesh, family, int(degree)) super().__init__(self.fs.dim(), size=size, center=center, offset=offset)
k = 0 fx_tmp = fx.value(x0 + (beta**k) * grad_f0, t_s) # ipdb.set_trace() while (fx_tmp - fx0 > alpha * (beta**k) * qpval and k < k_max): # ipdb.set_trace() k = k + 1 fx_tmp = fx.value(x0 + (beta**k) * grad_f0, t_s) # print str(k) if k >= k_max: print "Armijo reaches step limit." # ipdb.set_trace() return (k, fx_tmp) mesh_drt = "./test_geo/seperateTT3" mesh = dl.Mesh(mesh_drt + '.xml') subdomains = dl.MeshFunction("size_t", mesh, (mesh_drt + "_physical_region.xml")) boundaries = dl.MeshFunction("size_t", mesh, (mesh_drt + "_facet_region.xml")) ### cost function's (OP) parameter yeta0 = 1.0 yeta1 = 0.08 bp0 = [13.0, 13.0, 12.0] bp1 = [3.0, 6.0, 11.0] alpha = 0.1 beta = 0.7 alpha_i = 0.05 # 1E-5 beta_i = 0.75 epsl = 1E-6 # 1E-5 lp_step = 20
parser = argparse.ArgumentParser() parser.add_argument("--experiment", "-e", type=str, default=None, help='folder containing xdmf data') parser.add_argument("--stride", "-s", type=int, default=10, help='stride of temporal sampling') parser.add_argument("--xres", "-nx", type=int, default=100, help='spatial resolution (points)') args, unknown = parser.parse_known_args() print(args) if args.experiment is not None: rootdir = args.experiment print(rootdir) stride = args.stride params, data, signature = load_data(rootdir) # import pdb; pdb.set_trace() mesh = dolfin.Mesh(comm, os.path.join(rootdir, 'mesh.xml')) V_alpha = dolfin.FunctionSpace(mesh, "CG", 1) load_min = params['time_stepping']['load_min'] load_max = params['time_stepping']['load_max'] nsteps = params['time_stepping']['nsteps'] Lx = params['geometry']['Lx'] onedim = False if not onedim: Ly = params['geometry']['Ly'] xs = np.linspace(-Lx/2, Lx/2, args.xres) y0 = 0. load_steps = np.linspace(load_min, load_max, nsteps)
solver_parameters={ "newton_solver": { "relative_tolerance": 1e-4, "maximum_iterations": 100 } }) return v if __name__ == "__main__": dl.set_log_active(False) np.random.seed(1) sep = "\n" + "#" * 80 + "\n" print sep, "Set up the mesh and finite element spaces.\n", "Compute wind velocity", sep mesh = dl.refine(dl.Mesh("ad_20.xml")) wind_velocity = computeVelocityField(mesh) Vh = dl.FunctionSpace(mesh, "Lagrange", 2) print "Number of dofs: {0}".format(Vh.dim()) print sep, "Set up Prior Information and model", sep true_initial_condition = dl.interpolate( dl.Expression( 'min(0.5,exp(-100*(pow(x[0]-0.35,2) + pow(x[1]-0.7,2))))'), Vh).vector() orderPrior = 2 if orderPrior == 1: gamma = 1
def traction_test(ell=0.05, ell_e=.1, degree=1, n=3, nu=0., load_min=0, load_max=2, loads=None, nsteps=20, Lx=1., Ly=0.1, outdir="outdir", postfix='', savelag=1, sigma_D0=1., periodic=False, continuation=False, checkstability=True, configString='', test=True): # constants # ell = ell Lx = Lx load_min = load_min load_max = load_max nsteps = nsteps outdir = outdir loads = loads savelag = 1 nu = dolfin.Constant(nu) ell = dolfin.Constant(ell) ell_e = ell_e E = dolfin.Constant(1.0) K = E.values()[0] / ell_e**2. sigma_D0 = E n = n # h = ell.values()[0]/n h = max(ell.values()[0] / n, .005) cell_size = h continuation = continuation isPeriodic = periodic config = json.loads(configString) if configString != '' else '' cmd_parameters = { 'material': { "ell": ell.values()[0], "ell_e": ell_e, "K": K, "E": E.values()[0], "nu": nu.values()[0], "sigma_D0": sigma_D0.values()[0] }, 'geometry': { 'Lx': Lx, 'Ly': Ly, 'n': n, }, 'experiment': { 'test': test, 'periodic': isPeriodic, 'signature': '' }, 'stability': { 'checkstability': checkstability, 'continuation': continuation }, 'time_stepping': { 'load_min': load_min, 'load_max': load_max, 'nsteps': nsteps, 'outdir': outdir, 'postfix': postfix, 'savelag': savelag }, 'alt_min': {}, "code": {} } # -------------------- for par in parameters: parameters[par].update(cmd_parameters[par]) if config: for par in config: parameters[par].update(config[par]) # else: # parameters['material']['ell_e'] = Lx = parameters['geometry']['Lx'] Ly = parameters['geometry']['Ly'] ell = parameters['material']['ell'] ell_e = parameters['material']['ell_e'] BASE_DIR = os.path.dirname(os.path.realpath(__file__)) fname = "film" print(BASE_DIR) os.path.isfile(fname) signature = hashlib.md5(str(parameters).encode('utf-8')).hexdigest() if parameters['experiment']['test'] == True: outdir += '-{}'.format(cmd_parameters['time_stepping']['postfix']) else: outdir += '-{}{}'.format(signature, cmd_parameters['time_stepping']['postfix']) outdir = outdir + '-cont' parameters['time_stepping']['outdir'] = outdir Path(outdir).mkdir(parents=True, exist_ok=True) print('Outdir is: ' + outdir) with open(os.path.join(outdir, 'rerun.sh'), 'w') as f: configuration = deepcopy(parameters) configuration['time_stepping'].pop('outdir') str(configuration).replace("\'True\'", "True").replace("\'False\'", "False") rerun_cmd = 'python3 {} --config="{}"'.format( os.path.basename(__file__), configuration) f.write(rerun_cmd) with open(os.path.join(outdir, 'parameters.pkl'), 'w') as f: json.dump(parameters, f) with open(os.path.join(outdir, 'signature.md5'), 'w') as f: f.write(signature) print(parameters) # boundary_meshfunction = dolfin.MeshFunction("size_t", mesh, "meshes/%s-%s_facet_region.xml"%(fname, signature)) # cells_meshfunction = dolfin.MeshFunction("size_t", mesh, "meshes/%s-%s_physical_region.xml"%(fname, signature)) # ------------------ geometry_parameters = parameters['geometry'] geom_signature = hashlib.md5( str(geometry_parameters).encode('utf-8')).hexdigest() meshfile = "%s/meshes/%s-%s.xml" % (BASE_DIR, fname, geom_signature) # cmd_parameters['experiment']['signature']=signature if os.path.isfile(meshfile): print("Meshfile %s exists" % meshfile) mesh = dolfin.Mesh("meshes/%s-%s.xml" % (fname, geom_signature)) else: print("Creating meshfile: %s" % meshfile) print(('DEBUG: (-Lx/2. ={} , -Ly/2.={})'.format(Lx / 2., -Ly / 2.))) geom = mshr.Rectangle(dolfin.Point(-Lx / 2., -Ly / 2.), dolfin.Point(Lx / 2., Ly / 2.)) mesh = mshr.generate_mesh(geom, n * int(float(Lx / ell))) print(meshfile) mesh_xdmf = dolfin.XDMFFile("meshes/%s-%s.xdmf" % (fname, geom_signature)) mesh_xdmf.write(mesh) if rank == 0: meshf = dolfin.File(os.path.join(outdir, "mesh.xml")) meshf << mesh V_u = dolfin.VectorFunctionSpace(mesh, "CG", 1) V_alpha = dolfin.FunctionSpace(mesh, "CG", 1) u = dolfin.Function(V_u, name="Total displacement") alpha = dolfin.Function(V_alpha, name="Damage") bcs_alpha = [] bcs_u = [ DirichletBC(V_u, Constant((0., 0)), '(near(x[0], %f) or near(x[0], %f))' % (-Lx / 2., Lx / 2.)) ] left = dolfin.CompiledSubDomain("near(x[0], -Lx/2.)", Lx=Lx) right = dolfin.CompiledSubDomain("near(x[0], Lx/2.)", Lx=Lx) bottom = dolfin.CompiledSubDomain("near(x[1],-Ly/2.)", Ly=Ly) top = dolfin.CompiledSubDomain("near(x[1],Ly/2.)", Ly=Ly) mf = dolfin.MeshFunction("size_t", mesh, 1, 0) right.mark(mf, 1) left.mark(mf, 2) bottom.mark(mf, 3) state = [u, alpha] Z = dolfin.FunctionSpace( mesh, dolfin.MixedElement([u.ufl_element(), alpha.ufl_element()])) z = dolfin.Function(Z) v, beta = dolfin.split(z) dx = dolfin.Measure("dx", metadata=form_compiler_parameters, domain=mesh) ds = dolfin.Measure("ds", subdomain_data=mf) # Files for output file_out = dolfin.XDMFFile(os.path.join(outdir, "output.xdmf")) file_eig = dolfin.XDMFFile(os.path.join(outdir, "perturbations.xdmf")) file_con = dolfin.XDMFFile(os.path.join(outdir, "continuation.xdmf")) file_bif = dolfin.XDMFFile( os.path.join(outdir, "bifurcation_postproc.xdmf")) for f in [file_out, file_eig, file_con, file_bif]: f.parameters["functions_share_mesh"] = True f.parameters["flush_output"] = True # Problem definition foundation_density = 1. / 2. * 1. / ell_e**2. * dot(u, u) model = DamagePrestrainedElasticityModel( state, E, nu, ell, sigma_D0, user_functional=foundation_density, eps0t=Expression([['t', 0.], [0., 0.]], t=0., degree=0)) # import pdb; .set_trace() model.dx = dx model.ds = ds energy = model.total_energy_density(u, alpha) * dx # Alternate minimization solver solver = solvers.AlternateMinimizationSolver( energy, [u, alpha], [bcs_u, bcs_alpha], parameters=parameters['alt_min']) rP = model.rP(u, alpha, v, beta) * dx + 1 / ell_e**2. * dot(v, v) * dx rN = model.rN(u, alpha, beta) * dx stability = StabilitySolver(mesh, energy, [u, alpha], [bcs_u, bcs_alpha], z, parameters=parameters['stability']) # stability = StabilitySolver(mesh, energy, [u, alpha], [bcs_u, bcs_alpha], z, parameters = parameters['stability'], rayleigh=[rP, rN]) # if isPeriodic: # stability = StabilitySolver(mesh, energy, [u, alpha], [bcs_u, bcs_alpha], z, # parameters = stability_parameters, # constrained_domain = PeriodicBoundary(Lx)) # else: # stability = StabilitySolver(mesh, energy, [u, alpha], [bcs_u, bcs_alpha], z, parameters = parameters['stability']) load_steps = np.linspace(load_min, load_max, parameters['time_stepping']['nsteps']) if loads: load_steps = loads time_data = [] linesearch = LineSearch(energy, [u, alpha]) alpha_old = dolfin.Function(alpha.function_space()) lmbda_min_prev = 0.000001 bifurcated = False bifurcation_loads = [] save_current_bifurcation = False bifurc_count = 0 alpha_bif = dolfin.Function(V_alpha) alpha_bif_old = dolfin.Function(V_alpha) bifurcation_loads = [] tot_energy = model.elastic_energy_density(model.eps(u), alpha)*dx + \ 1./2.*1/ell_e**2. * dot(u, u)*dx + \ model.damage_dissipation_density(alpha)*dx cont_atol = 1e-3 for it, load in enumerate(load_steps): model.eps0t.t = load alpha_old.assign(alpha) ColorPrint.print_warn('Solving load t = {:.2f}'.format(load)) # First order stability conditions (time_data_i, am_iter) = solver.solve() # Second order stability conditions (stable, negev) = stability.solve(solver.problem_alpha.lb) ColorPrint.print_pass( 'Current state is{}stable'.format(' ' if stable else ' un')) # import pdb; pdb.set_trace() mineig = stability.mineig if hasattr(stability, 'mineig') else 0.0 # print('DEBUG: lmbda min', lmbda_min_prev) # print('DEBUG: mineig', mineig) Deltav = (mineig - lmbda_min_prev) if hasattr(stability, 'eigs') else 0 if (mineig + Deltav) * (lmbda_min_prev + dolfin.DOLFIN_EPS) < 0 and not bifurcated: bifurcated = True # save 3 bif modes print('DEBUG: About to bifurcate load ', load, 'step', it) bifurcation_loads.append(load) bifurc_count += 1 lmbda_min_prev = mineig if hasattr(stability, 'mineig') else 0. if stable: solver.update() else: # Continuation iteration = 1 energy_pre = dolfin.assemble(tot_energy) alpha_bif.assign(alpha) alpha_bif_old.assign(alpha_old) while stable == False and iteration < 30: # linesearch perturbation_v = stability.perturbation_v perturbation_beta = stability.perturbation_beta h_opt, (hmin, hmax), energy_perturbations = linesearch.search( [u, alpha, alpha_old], perturbation_v, perturbation_beta) # import pdb; pdb.set_trace() # if h_opt != 0: if h_opt > cont_atol: save_current_bifurcation = True # admissible uval = u.vector()[:] + h_opt * perturbation_v.vector()[:] aval = alpha.vector( )[:] + h_opt * perturbation_beta.vector()[:] u.vector()[:] = uval alpha.vector()[:] = aval u.vector().vec().ghostUpdate() alpha.vector().vec().ghostUpdate() (time_data_i, am_iter) = solver.solve() (stable, negev) = stability.solve(alpha_old) ColorPrint.print_pass( ' Continuation iteration #{}, current state is{}stable' .format(iteration, ' ' if stable else ' un')) energy_post = dolfin.assemble(tot_energy) ener_diff = energy_post - energy_pre ColorPrint.print_warn( 'DEBUG: step {}, iteration {}, En_post - En_pre ={}'. format(it, iteration, energy_post - energy_pre)) iteration += 1 if ener_diff < 0: bifurcated = False else: # warn ColorPrint.print_warn( 'DEBUG: Found (almost) zero increment, we are stuck in the matrix' ) ColorPrint.print_warn('DEBUG: h_opt = {}'.format(h_opt)) ColorPrint.print_warn('DEBUG: Continuing load program') break solver.update() # stable == True # modes = np.where(stability.eigs < 0)[0] # with file_bif as file: # leneigs = len(modes) # maxmodes = min(3, leneigs) # for n in range(maxmodes): # mode = dolfin.project(stability.linsearch[n]['beta_n'], V_alpha) # modename = 'beta-%d'%n # print(modename) # file.write_checkpoint(mode, modename, 0, append=True) # bifurc_count += 1 time_data_i["load"] = load time_data_i["stable"] = stable time_data_i["dissipated_energy"] = dolfin.assemble( model.damage_dissipation_density(alpha) * dx) time_data_i["foundation_energy"] = dolfin.assemble( 1. / 2. * 1 / ell_e**2. * dot(u, u) * dx) time_data_i["membrane_energy"] = dolfin.assemble( model.elastic_energy_density(model.eps(u), alpha) * dx) time_data_i["elastic_energy"] = time_data_i[ "membrane_energy"] + time_data_i["foundation_energy"] time_data_i["eigs"] = stability.eigs if hasattr(stability, 'eigs') else np.inf time_data_i["stable"] = stability.stable time_data_i["# neg ev"] = stability.negev # import pdb; pdb.set_trace() _sigma = model.stress(model.eps(u), alpha) e1 = dolfin.Constant([1, 0]) _snn = dolfin.dot(dolfin.dot(_sigma, e1), e1) time_data_i["sigma"] = 1 / Ly * dolfin.assemble(_snn * model.ds(1)) time_data_i["S(alpha)"] = dolfin.assemble(1. / (model.a(alpha)) * model.dx) time_data_i["A(alpha)"] = dolfin.assemble((model.a(alpha)) * model.dx) time_data_i["avg_alpha"] = dolfin.assemble(alpha * model.dx) ColorPrint.print_pass( "Time step {:.4g}: it {:3d}, err_alpha={:.4g}".format( time_data_i["load"], time_data_i["iterations"], time_data_i["alpha_error"])) time_data.append(time_data_i) time_data_pd = pd.DataFrame(time_data) if np.mod(it, savelag) == 0: with file_out as f: f.write(alpha, load) f.write(u, load) f.write_checkpoint(alpha, "alpha-{}".format(it), 0, append=True) # with file_bif as f: print('DEBUG: written step ', it) if save_current_bifurcation: # modes = np.where(stability.eigs < 0)[0] time_data_i['h_opt'] = h_opt time_data_i['max_h'] = hmax time_data_i['min_h'] = hmin with file_bif as file: beta0v = dolfin.project(stability.perturbation_beta, V_alpha) file.write_checkpoint(beta0v, 'beta0', bifurc_count - 1, append=True) file.write_checkpoint(alpha_bif_old, 'alpha-old', bifurc_count - 1, append=True) file.write_checkpoint(alpha_bif, 'alpha-bif', bifurc_count - 1, append=True) file.write_checkpoint(alpha, 'alpha', bifurc_count - 1, append=True) np.save(os.path.join(outdir, 'energy_perturbations'), energy_perturbations, allow_pickle=True, fix_imports=True) with file_eig as file: _v = dolfin.project( dolfin.Constant(h_opt) * perturbation_v, V_u) _beta = dolfin.project( dolfin.Constant(h_opt) * perturbation_beta, V_alpha) _v.rename('perturbation displacement', 'perturbation displacement') _beta.rename('perturbation damage', 'perturbation damage') # import pdb; pdb.set_trace() f.write(_v, load) f.write(_beta, load) file.write_checkpoint(_v, 'perturbation_v', bifurc_count - 1, append=True) file.write_checkpoint(_beta, 'perturbation_beta', bifurc_count - 1, append=True) save_current_bifurcation = False time_data_pd.to_json(os.path.join(outdir, "time_data.json")) plt.figure() plt.plot(time_data_pd["load"].values(), time_data_pd["iterations"].values(), label='its') plt.semilogy() ax = plt.gca() ax2 = ax.twinx() ax2.plot(time_data_pd["load"].values(), time_data_pd["alpha_error"].values(), 'o', c='C1', label='alpha error') plt.savefig(os.path.join(outdir, 'am.pdf')) plt.legend() plt.close() # user_postprocess_timestep(alpha, parameters, load, xresol = 100) plt.figure() dolfin.plot(alpha) plt.savefig(os.path.join(outdir, "alpha.png")) plt.figure() dolfin.plot(u, mode="displacement") plt.savefig(os.path.join(outdir, "u.png")) _nu = parameters['material']['nu'] _E = parameters['material']['E'] _w1 = parameters['material']['sigma_D0']**2. / parameters['material']['E'] tc = np.sqrt(2 * _w1 / (_E * (1. - 2. * _nu) * (1. + _nu))) if parameters['stability']['checkstability'] == 'True': pp.plot_spectrum(parameters, outdir, time_data_pd.sort_values('load'), tc) # plt.show() print(time_data_pd) print() print('Output in: ' + outdir) return time_data_pd