def plot_quadrature(ax, geometry, order, boundary=False, min_radius=10, max_radius=50, show_colorbar=False, show_labels=False): """ Plot quadrature points for the given geometry and integration order. The points are plotted as circles/spheres with radii given by quadrature weights - the weights are mapped to [`min_radius`, `max_radius`] interval. """ if not boundary: gel, coors, weights = _get_qp(geometry, order) else: gel, coors, weights = _get_bqp(geometry, order) dim = coors.shape[1] ax = _get_axes(ax, dim) plot_geometry(ax, gel) plot_weighted_points(ax, coors, weights, min_radius=min_radius, max_radius=max_radius, show_colorbar=show_colorbar) if show_labels: label_points(ax, coors) return ax, coors, weights
def plot_edges(ax, gel, length, show=False): """ Plot edges of a geometry element as numbered arrows. """ dim = gel.dim ax = _get_axes(ax, dim) l2 = 0.5 * length for ii, edge in enumerate(gel.edges): cc = gel.coors[edge] centre = 0.5 * cc.sum(axis=0) vdir = (cc - centre) normalize_vectors(vdir) cc = l2 * vdir + centre draw_arrow(ax, cc, length=0.3*length, linewidth=3, color='b') if dim == 3: cx, cy, cz = centre ax.text(cx, cy, cz, ii, color='b', fontsize=10, weight='light') else: cx, cy = centre ax.text(cx, cy, ii, color='b', fontsize=10, weight='light') return ax
def plot_weighted_points(ax, coors, weights, min_radius=10, max_radius=50, show_colorbar=False, show=False): """ Plot points with given coordinates as circles/spheres with radii given by weights. """ dim = coors.shape[1] ax = _get_axes(ax, dim) wmin, wmax = weights.min(), weights.max() if (wmax - wmin) < 1e-12: nweights = weights * max_radius / wmax else: nweights = ((weights - wmin) * (max_radius - min_radius) / (wmax - wmin) + min_radius) if dim == 3: sc = ax.scatter(coors[:, 0], coors[:, 1], coors[:, 2], s=nweights, c=weights, alpha=1) else: sc = ax.scatter(coors[:, 0], coors[:, 1], s=nweights, c=weights, alpha=1) if show_colorbar: plt.colorbar(sc) if show: plt.show() return ax
def mark_subdomains(ax, cmesh, cell_tasks, size=None, icolor=0, alpha=1.0, mask=False): """ Mark cells of subdomains corresponding to each task by a different color. Plots nothing in 3D. """ if size is None: size = cell_tasks.max() + 1 coors = cmesh.coors dim = cmesh.dim ax = pd._get_axes(ax, dim) if dim == 3: return ax conn = cmesh.get_conn(dim, 0) color = nm.zeros(4) color[-1] = alpha for ic, vertices in enumerate(conn.indices.reshape((conn.num, -1))): cv = coors[vertices] if dim == 2: if mask: cc = cv.mean(0) cv = cc + 0.3 * (cv - cc) if not mask or cell_tasks[ic] > 0: color[icolor] = (float(cell_tasks[ic]) + 1) / size ax.fill(*cv.T, color=color) return ax
def label_local_entities(ax, cmesh, edim, color='b', fontsize=10, show=False): """ Label mesh topology entities using cell-local ids. """ coors = cmesh.get_centroids(edim) dim = cmesh.dim centres = cmesh.get_centroids(dim) conn = cmesh.get_conn(dim, edim) off = conn.offsets ax = _get_axes(ax, dim) eps = 0.1 oeps = 1.0 - eps for ii in xrange(conn.num): for ic, ie in enumerate(conn.indices[off[ii]:off[ii+1]]): # Shift labels towards the cell centre. cc = oeps * coors[ie] + eps * centres[ii] if dim == 3: ax.text(cc[0], cc[1], cc[2], ic, color=color, fontsize=fontsize) else: ax.text(cc[0], cc[1], ic, color=color, fontsize=fontsize) if show: plt.show() return ax
def plot_control_mesh(ax, control_points, label=False): """ Plot the control mesh of a NURBS given by its control points. """ dim = control_points.shape[-1] ax = _get_axes(ax, dim) shape = control_points.shape conn, desc = get_tensor_product_conn(nm.array(shape[:-1])) gel = GeometryElement(desc) coors = control_points.reshape((-1, dim)) ax = pd.plot_mesh(ax, coors, conn, gel.edges) pd.plot_points(ax, coors) if label: for ii, cc in enumerate(coors): if dim == 3: cx, cy, cz = cc ax.text(cx, cy, cz, '%d' % ii, color='g', fontsize=12, weight='bold') else: cx, cy = cc ax.text(cx, cy, '%d' % ii, color='g', fontsize=12, weight='bold') return ax
def label_local_entities(ax, cmesh, edim, color='b', fontsize=10, **kwargs): """ Label mesh topology entities using cell-local ids. """ coors = cmesh.get_centroids(edim) coors = _to2d(coors) dim = cmesh.dim centres = cmesh.get_centroids(dim) cmesh.setup_connectivity(dim, edim) conn = cmesh.get_conn(dim, edim) off = conn.offsets ax = _get_axes(ax, dim) eps = 0.015 * fontsize oeps = 1.0 - eps for ii in range(conn.num): for ic, ie in enumerate(conn.indices[off[ii]:off[ii+1]]): # Shift labels towards the cell centre. cc = oeps * coors[ie] + eps * centres[ii] ax.text(*cc.T, s=ic, color=color, fontsize=fontsize, horizontalalignment='center', verticalalignment='center', **kwargs) return ax
def plot_nurbs_basis_1d(ax, nurbs, n_points=100, x_axis="parametric", legend=False): """ Plot a 1D NURBS basis. """ ax = _get_axes(ax, 2) ga = nurbs.greville()[0] n_fun = nurbs.weights.shape[0] line = nm.linspace(ga[0], ga[-1], n_points) for ii in range(n_fun): field = nm.zeros(n_fun) field[ii] = 1.0 vals = nurbs.evaluate(fields=field, u=line) if x_axis == "parametric": ax.plot(line, vals, label="%d" % ii) else: coors = nurbs(u=line)[:, x_axis] ax.plot(coors, vals, label="%d" % ii) if legend: ax.legend() return ax
def plot_iso_lines(ax, nurbs, color="b", n_points=100): """ Plot the NURBS object using iso-lines in Greville abscissae coordinates. """ dim = nurbs.dim ax = _get_axes(ax, dim) gas = nurbs.greville() if dim == 1: ga = gas[0] x0 = nm.linspace(ga[0], ga[-1], n_points) vals = nurbs(x0) if vals.shape[1] == 1: ax.plot(x0, vals[:, 0], color) else: # Assume curve in 2D. ax.plot(vals[:, 0], vals[:, 1], color) elif dim == 2: ga0 = gas[0] ga1 = gas[1] x1 = nm.linspace(ga1[0], ga1[-1], n_points) for x0 in ga0: vals = nurbs(x0, x1) ax.plot(vals[:, 0], vals[:, 1], color) x0 = nm.linspace(ga0[0], ga0[-1], n_points) for x1 in ga0: vals = nurbs(x0, x1) ax.plot(vals[:, 0], vals[:, 1], color) else: ga0 = gas[0] ga1 = gas[1] ga2 = gas[2] x2 = nm.linspace(ga2[0], ga2[-1], n_points) for x0 in ga0: for x1 in ga1: vals = nurbs(x0, x1, x2) ax.plot(vals[:, 0], vals[:, 1], vals[:, 2], color) x1 = nm.linspace(ga1[0], ga1[-1], n_points) for x0 in ga0: for x2 in ga2: vals = nurbs(x0, x1, x2) ax.plot(vals[:, 0], vals[:, 1], vals[:, 2], color) x0 = nm.linspace(ga0[0], ga0[-1], n_points) for x1 in ga1: for x2 in ga2: vals = nurbs(x0, x1, x2) ax.plot(vals[:, 0], vals[:, 1], vals[:, 2], color) return ax
def label_points(ax, coors): """ Label points with their indices. """ dim = coors.shape[1] ax = _get_axes(ax, dim) shift = 0.02 * (coors.max(0) - coors.min(0)) ccs = coors + shift for ic, cc in enumerate(ccs): ax.text(*cc, s='%d' % ic, color='b')
def plot_entities(ax, cmesh, edim, color='b', size=10): """ Plot mesh topology entities using scatter plot. """ coors = cmesh.get_centroids(edim) coors = _to2d(coors) dim = cmesh.dim ax = _get_axes(ax, dim) ax.scatter(*coors.T, s=size, c=color) return ax
def label_global_entities(ax, cmesh, edim, color='b', fontsize=10): """ Label mesh topology entities using global ids. """ coors = cmesh.get_centroids(edim) coors = _to2d(coors) dim = cmesh.dim ax = _get_axes(ax, dim) for ii, cc in enumerate(coors): ax.text(*cc.T, s=ii, color=color, fontsize=fontsize) return ax
def plot_cmesh(ax, cmesh, wireframe_opts=None, entities_opts=None): """ Convenience function for plotting all entities of a finite element mesh. Pass `plot()` arguments to `wireframe_opts` dict. Pass `'color'`, `'label_global'`, `'label_global'` for `text()` color and font sizes arguments and `'size'` for `scatter()` to each dict for topological entities in `entities_opts` list. Examples -------- >>> # 2D mesh. >>> plot_cmesh(None, cmesh, wireframe_opts = {'color' : 'k', 'linewidth' : 2}, entities_opts=[ {'color' : 'k', 'label_local' : 8, 'size' : 20}, {'color' : 'b', 'label_global' : 12, 'label_local' : 8, 'size' : 10}, {'color' : 'r', 'label_global' : 12, 'size' : 20}, ]) """ dim = cmesh.dim ax = _get_axes(ax, dim) if wireframe_opts is None: wireframe_opts = {} if wireframe_opts.get('color') is not None: ax = plot_wireframe(ax, cmesh, **wireframe_opts) if entities_opts is None: entities_opts = [{}] * dim for ii, entity_opts in enumerate(entities_opts): if entity_opts.get('color') is not None: fsg = entity_opts.pop('label_global', 0) fsl = entity_opts.pop('label_local', 0) size = entity_opts.pop('size', 10) ax = plot_entities(ax, cmesh, ii, size=size, **entity_opts) if fsg: ax = label_global_entities(ax, cmesh, ii, fontsize=fsg, **entity_opts) if fsl: ax = label_local_entities(ax, cmesh, ii, fontsize=fsl, **entity_opts) return ax
def plot_points(ax, points, marker, **kwargs): from sfepy.postprocess.plot_dofs import _get_axes dim = points.shape[1] ax = _get_axes(ax, dim) px, py = points[:, 0], points[:, 1] if dim == 2: ax.plot(px, py, marker, **kwargs) else: pz = points[:, 2] ax.plot(px, py, pz, marker, **kwargs) return ax
def label_dofs(ax, coors, dofs, colors): """ Label DOFs using the given colors. """ from sfepy.postprocess.plot_dofs import _get_axes dim = coors.shape[1] ax = _get_axes(ax, dim) for gdof in dofs: cd = coors[gdof] ax.text(*cd.T, s='%d' % gdof, color=colors[gdof], fontsize=12, weight='bold') return ax
def plot_faces(ax, gel, radius, n_point, show=False): """ Plot faces of a 3D geometry element as numbered oriented arcs. An arc centre corresponds to the first node of a face. It points from the first edge towards the last edge of the face. """ dim = gel.dim ax = _get_axes(ax, dim) if dim < 3: return ax for ii, face in enumerate(gel.faces): cc = gel.coors[face] t1 = cc[1, :] - cc[0, :] t2 = cc[-1, :] - cc[0, :] n = nm.cross(t1, t2) nt1 = nm.linalg.norm(t1) nt2 = nm.linalg.norm(t2) angle = nm.arccos(nm.dot(t1, t2) / (nt1 * nt2)) da = angle / (n_point - 1) mtx = make_axis_rotation_matrix(n, da) rt = cc[0] + radius * t1 / nt1 coors = [rt] for ip in range(n_point - 1): rt = nm.dot(mtx.T, (rt - cc[0])) + cc[0] coors.append(rt) coors = nm.array(coors, dtype=nm.float64) centre = coors.sum(axis=0) / coors.shape[0] draw_arrow(ax, coors, length=0.3*radius, linewidth=3, color='r') if dim == 3: cx, cy, cz = centre ax.text(cx, cy, cz, ii, color='r', fontsize=10, weight='light') else: cx, cy = centre ax.text(cx, cy, ii, color='r', fontsize=10, weight='light') return ax
def plot_wireframe(ax, cmesh, color='k'): """ Plot a finite element mesh as a wireframe using edges connectivity. """ coors = cmesh.coors coors = _to2d(coors) dim = cmesh.dim ax = _get_axes(ax, dim) edges = cmesh.get_conn(1, 0) for edge_vertices in edges.indices.reshape((edges.num, 2)): cc = coors[edge_vertices] ax.plot(*cc.T, color=color) return ax
def plot_polygon(ax, polygon): from sfepy.postprocess.plot_dofs import _get_axes dim = polygon.shape[1] ax = _get_axes(ax, dim) pp = nm.r_[polygon, polygon[:1]] px, py = pp[:, 0], pp[:, 1] if dim == 2: ax.plot(px, py) else: pz = pp[:, 2] ax.plot(px, py, pz) return ax
def label_global_entities(ax, cmesh, edim, color='b', fontsize=10, **kwargs): """ Label mesh topology entities using global ids. """ coors = cmesh.get_centroids(edim) coors = _to2d(coors) dim = cmesh.dim ax = _get_axes(ax, dim) for ii, cc in enumerate(coors): ax.text(*cc.T, s=ii, color=color, fontsize=fontsize, horizontalalignment='center', verticalalignment='center', **kwargs) return ax
def plot_bezier_mesh(ax, control_points, conn, degrees, label=False): """ Plot the Bezier mesh of a NURBS given by its control points and connectivity. """ dim = control_points.shape[-1] ax = _get_axes(ax, dim) edges = _get_edges(conn.shape[1], nm.asarray(degrees) + 1) ax = pd.plot_mesh(ax, control_points, conn, edges) pd.plot_points(ax, control_points) if label: ax = pd.plot_global_dofs(ax, control_points, conn) return ax
def plot_faces(ax, gel, radius, n_point, show=False): """ Plot faces of a 3D geometry element as numbered oriented arcs. An arc centre corresponds to the first node of a face. It points from the first edge towards the last edge of the face. """ dim = gel.dim ax = _get_axes(ax, dim) if dim < 3: return ax for ii, face in enumerate(gel.faces): cc = gel.coors[face] t1 = cc[1, :] - cc[0, :] t2 = cc[-1, :] - cc[0, :] n = nm.cross(t1, t2) nt1 = nm.linalg.norm(t1) nt2 = nm.linalg.norm(t2) angle = nm.arccos(nm.dot(t1, t2) / (nt1 * nt2)) da = angle / (n_point - 1) mtx = make_axis_rotation_matrix(n, da) rt = cc[0] + radius * t1 / nt1 coors = [rt] for ip in range(n_point - 1): rt = nm.dot(mtx.T, (rt - cc[0])) + cc[0] coors.append(rt) coors = nm.array(coors, dtype=nm.float64) centre = coors.sum(axis=0) / coors.shape[0] draw_arrow(ax, coors, length=0.3 * radius, linewidth=3, color='r') if dim == 3: cx, cy, cz = centre ax.text(cx, cy, cz, ii, color='r', fontsize=10, weight='light') else: cx, cy = centre ax.text(cx, cy, ii, color='r', fontsize=10, weight='light') return ax
def plot_entities(ax, cmesh, edim, color='b', size=10, show=False): """ Plot mesh topology entities using scatter plot. """ coors = cmesh.get_centroids(edim) dim = cmesh.dim ax = _get_axes(ax, dim) if dim == 3: ax.scatter(coors[:, 0], coors[:, 1], coors[:, 2], s=size, c=color) else: ax.scatter(coors[:, 0], coors[:, 1], s=size, c=color) if show: plt.show() return ax
def plot_quadrature(ax, geometry, order, min_radius=10, max_radius=50, show_colorbar=False): """ Plot quadrature points for the given geometry and integration order. The points are plotted as circles/spheres with radii given by quadrature weights - the weights are mapped to [`min_radius`, `max_radius`] interval. """ gel, coors, weights = _get_qp(geometry, order) dim = coors.shape[1] ax = _get_axes(ax, dim) plot_geometry(ax, gel) plot_weighted_points(ax, coors, weights, min_radius=min_radius, max_radius=max_radius, show_colorbar=show_colorbar) return ax
def plot_bezier_nurbs_basis_1d(ax, control_points, weights, degrees, cs, conn, n_points=20): """ Plot a 1D NURBS basis using the Bezier extraction and local Bernstein basis. """ from sfepy.discrete.iga.iga import eval_variable_in_qp ax = _get_axes(ax, 2) n_fun = weights.shape[0] line = nm.linspace(0, 1, n_points)[:, None] for ii in range(n_fun): variable = nm.zeros((n_fun, 1)) variable[ii] = 1.0 coors, vals, dets = eval_variable_in_qp(variable, line, control_points, weights, degrees, cs, conn) plt.plot(coors[:, 0], vals) return ax
def plot_edges(ax, gel, length): """ Plot edges of a geometry element as numbered arrows. """ dim = gel.dim ax = _get_axes(ax, dim) l2 = 0.5 * length for ii, edge in enumerate(gel.edges): cc = gel.coors[edge] centre = 0.5 * cc.sum(axis=0) vdir = (cc - centre) normalize_vectors(vdir) cc = l2 * vdir + centre draw_arrow(ax, cc, length=0.3 * length, linewidth=3, color='b') ax.text(*centre, s=ii, color='b', fontsize=10, weight='light') return ax
def plot_control_mesh(ax, control_points, label=False): """ Plot the control mesh of a NURBS given by its control points. """ dim = control_points.shape[-1] ax = _get_axes(ax, dim) shape = control_points.shape conn, desc = get_tensor_product_conn(nm.array(shape[:-1])) gel = GeometryElement(desc) coors = control_points.reshape((-1, dim)) ax = pd.plot_mesh(ax, coors, conn, gel.edges) pd.plot_points(ax, coors) if label: for ii, cc in enumerate(coors): ax.text(*cc, s="%d" % ii, color="g", fontsize=12, weight="bold") return ax
def label_global_entities(ax, cmesh, edim, color='b', fontsize=10, show=False): """ Label mesh topology entities using global ids. """ coors = cmesh.get_centroids(edim) dim = cmesh.dim ax = _get_axes(ax, dim) for ii, cc in enumerate(coors): if dim == 3: ax.text(cc[0], cc[1], cc[2], ii, color=color, fontsize=fontsize) else: ax.text(cc[0], cc[1], ii, color=color, fontsize=fontsize) if show: plt.show() return ax
def plot_parametric_mesh(ax, knots): """ Plot the parametric mesh of a NURBS given by its knots. """ knots = _get_knots_tuple(knots) dim = len(knots) ax = _get_axes(ax, dim) uknots = [nm.unique(ii) for ii in knots] shape = [len(ii) for ii in uknots] ngrid = nm.mgrid[[slice(ii) for ii in shape]] coors = nm.r_[[uknots[ii][ig].ravel() for ii, ig in enumerate(ngrid)]].T conn, desc = get_tensor_product_conn(nm.array(shape)) gel = GeometryElement(desc) ax = pd.plot_mesh(ax, coors, conn, gel.edges) pd.plot_points(ax, coors) return ax
def plot_control_mesh(ax, control_points, label=False): """ Plot the control mesh of a NURBS given by its control points. """ dim = control_points.shape[-1] ax = _get_axes(ax, dim) shape = control_points.shape conn, desc = get_tensor_product_conn(nm.array(shape[:-1])) gel = GeometryElement(desc) coors = control_points.reshape((-1, dim)) ax = pd.plot_mesh(ax, coors, conn, gel.edges) pd.plot_points(ax, coors) if label: for ii, cc in enumerate(coors): ax.text(*cc, s='%d' % ii, color='g', fontsize=12, weight='bold') return ax
def plot_wireframe(ax, cmesh, color='k', show=False): """ Plot a finite element mesh as a wireframe using edges connectivity. """ coors = cmesh.coors dim = cmesh.dim edges = cmesh.get_conn(1, 0) ax = _get_axes(ax, dim) for edge_vertices in edges.indices.reshape((edges.num, 2)): cc = coors[edge_vertices] if dim == 3: ax.plot(cc[:, 0], cc[:, 1], cc[:, 2], color) else: ax.plot(cc[:, 0], cc[:, 1], color) if show: plt.show() return ax
def label_local_entities(ax, cmesh, edim, color='b', fontsize=10): """ Label mesh topology entities using cell-local ids. """ coors = cmesh.get_centroids(edim) coors = _to2d(coors) dim = cmesh.dim centres = cmesh.get_centroids(dim) cmesh.setup_connectivity(dim, edim) conn = cmesh.get_conn(dim, edim) off = conn.offsets ax = _get_axes(ax, dim) eps = 0.1 oeps = 1.0 - eps for ii in xrange(conn.num): for ic, ie in enumerate(conn.indices[off[ii]:off[ii + 1]]): # Shift labels towards the cell centre. cc = oeps * coors[ie] + eps * centres[ii] ax.text(*cc.T, s=ic, color=color, fontsize=fontsize) return ax