Source code for svcco.implicit.visualize.visualize

import numpy as np
import matplotlib.pyplot as plt
from matplotlib import gridspec
import seaborn as sn
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.colors as colors
from mpl_toolkits.mplot3d.art3d import Poly3DCollection
from concurrent.futures import ProcessPoolExecutor as PPE
from concurrent.futures import as_completed
from skimage import measure
from time import time
from tqdm import tqdm
from pickle import loads
#import pandas as pd
import vtk
import plotly.graph_objects as go

from ..tests.bumpy_sphere import bumpy_sphere

[docs]def mpu_meshgrid(mpu_object,buf=1.25,res=10,workers=1,k=None,plane_axis=None,plane_value=None,marching=False,gradient=False,record=False,global_f=False): dims = [] if not marching: for d in range(mpu_object.ddim): if d is plane_axis: continue dims.append(np.linspace(mpu_object.dim_range[d*2]-buf, mpu_object.dim_range[d*2+1]+buf,res)) else: res = res*1j x,y,z = np.ogrid[mpu_object.dim_range[0]-buf:mpu_object.dim_range[1]+buf:res, mpu_object.dim_range[2]-buf:mpu_object.dim_range[3]+buf:res, mpu_object.dim_range[4]-buf:mpu_object.dim_range[5]+buf:res] results = mpu_object.function_marching(x,y,z) return (x,y,z),results DIMS = np.meshgrid(*dims) DIMSf = [] for d in range(len(DIMS)): DIMSf.append(DIMS[d].flatten()) value = [] if plane_value is not None: plane_values = [plane_value]*len(DIMSf[0]) DIMSf.insert(plane_axis,plane_values) plane = np.array(plane_values).reshape(DIMS[0].shape) DIMS.insert(plane_axis,plane) if workers > 1: chunksize = len(DIMSf[0])//workers number_of_chunks = len(DIMSf[0])//chunksize executor = PPE(max_workers=workers) if global_f: pass elif k is not None: k = [k]*len(DIMSf[0]) DIMSf.append(k) else: k = [len(mpu_object.patches)]*len(DIMSf[0]) DIMSf.append(k) if not gradient: result_generator = executor.map(loads(mpu_object.pickled_DD[0]),zip(*DIMSf),chunksize=chunksize) else: result_generator = executor.map(loads(mpu_object.pickled_DD[1]),zip(*DIMSf),chunksize=chunksize) executor.shutdown(wait=True) if not gradient: results = [] for result in result_generator: results.append(result) results = np.array(results) results = results.reshape(DIMS[0].shape) else: u = [] v = [] w = [] for result in result_generator: u.append(result[0]) v.append(result[1]) w.append(result[2]) u = np.array(u) u = u.reshape(DIMS[0].shape) v = np.array(v) v = u.reshape(DIMS[0].shape) w = np.array(w) w = u.reshape(DIMS[0].shape) results = [u,v,w] else: time_data = [] results = [] if global_f: pass elif k is not None: k = [k]*len(DIMSf[0]) DIMSf.append(k) else: k = [len(mpu_object.patches)]*len(DIMSf[0]) DIMSf.append(k) if not gradient: for i in zip(*DIMSf): start = time() results.append(mpu_object.DD[0](i)) stop = time() - start time_data.append(stop) results = np.array(results) results = results.reshape(DIMS[0].shape) if record: results = time_data else: u = [] v = [] w = [] for i in zip(*DIMSf): start = time() results = mpu_object.DD[1](i) stop = time() - start time_data.append(stop) u.append(results[0]) v.append(results[1]) w.append(results[2]) u = np.array(u) u = u.reshape(DIMS[0].shape) v = np.array(v) v = v.reshape(DIMS[0].shape) w = np.array(w) w = w.reshape(DIMS[0].shape) results = [u,v,w] if record: results = time_data return DIMS,results
[docs]def plot_volume(mpu_object,resolution=20,workers=1,cmin=-1,cmax=0,surface_count=14,k=None,global_f=False,show_points=False): """ This function accepts a perfusion domain object instance and returns a figure object for rendering the domain for visualization. Parameters ---------- mpu_object: svcco.surface object instance resolution: int (default: 20) The number of points along each axis to sample when determining the contours of the implicit function representing the domain. The total number of sampled points scales cubically to the resolution size. (i.e. resolution=20; total_points=8000) workers: int (default: 1) The number of processes to split the function evaluations among. Becuase volume rendering can easily require tens of thousands of function evaluations """ DIMS,results = mpu_meshgrid(mpu_object,res=resolution,workers=workers,k=k,global_f=global_f) if show_points: fig = go.Figure(data=(go.Isosurface( x=DIMS[0].flatten(), y=DIMS[1].flatten(), z=DIMS[2].flatten(), value=results.flatten(), opacity=0.1, isomin=cmin, isomax=cmax, surface_count=surface_count),go.Scatter3d(x = mpu_object.points[:,0],y=mpu_object.points[:,1],z=mpu_object.points[:,2]))) else: fig = go.Figure(data=(go.Isosurface( x=DIMS[0].flatten(), y=DIMS[1].flatten(), z=DIMS[2].flatten(), value=results.flatten(), opacity=0.1, isomin=cmin, isomax=cmax, surface_count=surface_count))) fig.show() return fig
[docs]def plot_volume_individual(func,x_range,y_range,z_range,buf=1.25,res=20,surface_count=15,cmin=-1,cmax=0): res = res*1j x,y,z = np.ogrid[x_range[0]-buf:x_range[1]+buf:res, y_range[0]-buf:y_range[1]+buf:res, z_range[0]-buf:z_range[1]+buf:res] results = func(x,y,z) fig = go.Figure(data=(go.Isosurface( x=x.flatten(), y=y.flatten(), z=z.flatten(), value=results.flatten(), opacity=0.1, isomin=cmin, isomax=cmax, surface_count=surface_count))) fig.show()
[docs]def plot_slice_error(mpu_object,resolution=20,k=None,workers=1,plane_axis=2,plane_value=0,unit_scale='mm'): DIMS,results_exact = mpu_meshgrid(mpu_object,res=resolution,workers=workers, k=len(mpu_object.patches),plane_axis=plane_axis, plane_value=plane_value) DIMS,results_approximate = mpu_meshgrid(mpu_object,res=resolution,workers=workers, k=k,plane_axis=plane_axis,plane_value=plane_value) DIMSv,voxels = mpu_meshgrid(mpu_object,res=resolution,workers=workers, k=len(mpu_object.patches),marching=True) verts, faces, normals, values = measure.marching_cubes(voxels,level=0) verts *= np.array([np.diff(ar.flat)[0] for ar in [DIMSv[0],DIMSv[1],DIMSv[2]]]) verts += np.array([DIMSv[0].min(),DIMSv[1].min(),DIMSv[2].min()]) error = results_exact - results_approximate error_min = error.min() error_max = error.max() error_divide = max(abs(error_min),abs(error_max)) error = error/(error_divide) colormap = plt.cm.RdBu main_axes = list(range(len(DIMS))) main_axes.remove(plane_axis) axes_labels = ['x ({})'.format(unit_scale),'y ({})'.format(unit_scale),'z ({})'.format(unit_scale)] axes_labels_all = ['x ({})'.format(unit_scale),'y ({})'.format(unit_scale),'z ({})'.format(unit_scale)] axes_labels.remove(axes_labels[plane_axis]) fig = plt.figure(figsize=(12,6)) spec = gridspec.GridSpec(ncols=4, nrows=1, width_ratios=[1, 1, 1, 1.5]) ax1 = fig.add_subplot(spec[0]) ax2 = fig.add_subplot(spec[1]) ax3 = fig.add_subplot(spec[2]) ax4 = fig.add_subplot(spec[3],projection='3d') cax1 = ax1.contourf(DIMS[main_axes[0]],DIMS[main_axes[1]],results_exact,norm=colors.TwoSlopeNorm(0)) ax1.contour(DIMS[main_axes[0]],DIMS[main_axes[1]],results_exact,levels=[0],linewidths=(2,)) #ax1.set_title('Exact Interpolation \n {} Patches'.format(len(mpu_object.patches))) ax1.set_xlabel(axes_labels[0]) ax1.set_ylabel(axes_labels[1]) cax2 = ax2.contourf(DIMS[main_axes[0]],DIMS[main_axes[1]],results_approximate,norm=colors.TwoSlopeNorm(0)) ax2.contour(DIMS[main_axes[0]],DIMS[main_axes[1]],results_approximate,levels=[0],linewidths=(2,)) #ax2.set_title('Approximate Interpolation \n {} Patches'.format(k)) ax2.set_xlabel(axes_labels[0]) cax3 = ax3.contourf(DIMS[main_axes[0]],DIMS[main_axes[1]],error,cmap=colormap,norm=colors.TwoSlopeNorm(0)) #ax3.set_title('Relative Truncation Error') ax3.set_xlabel(axes_labels[0]) mesh = Poly3DCollection(verts[faces]) mesh.set_edgecolor('k') ax4.add_collection3d(mesh) ax4.plot_surface(DIMS[0],DIMS[1],DIMS[2],alpha=0.2,color='r') ax4.set_xlim(DIMSv[0].min(),DIMSv[0].max()) ax4.set_ylim(DIMSv[1].min(),DIMSv[1].max()) ax4.set_zlim(DIMSv[2].min(),DIMSv[2].max()) ax4.set_xlabel(axes_labels_all[0]) ax4.set_ylabel(axes_labels_all[1]) ax4.set_zlabel(axes_labels_all[2]) plt.draw() p0 = ax1.get_position().get_points().flatten() p1 = ax2.get_position().get_points().flatten() p2 = ax3.get_position().get_points().flatten() ax_cbar = fig.add_axes([p0[0], 0.1, p1[2]-p0[0], 0.05]) ax_cbar.set_in_layout(True) cbar1 = plt.colorbar(cax1, cax=ax_cbar, orientation='horizontal', pad=0.25) labels = cbar1.ax.get_xticklabels() cbar1.ax.set_xticklabels(labels, rotation=40) ax_cbar1 = fig.add_axes([p2[0], 0.1, p2[2]-p2[0], 0.05]) ax_cbar1.set_in_layout(True) cbar2 = plt.colorbar(cax3, cax=ax_cbar1, orientation='horizontal', pad=0.25) labels = cbar2.ax.get_xticklabels() cbar2.ax.set_xticklabels(labels, rotation=40) plt.subplots_adjust(bottom=0.25) plt.show()
[docs]def level_contour(mpu_object,resolution=20,k=2,buf=1.25,level=0,workers=1,plane_axis=2,plane_value=0.5,unit_scale='mm',name="untitled"): if plane_axis == 0: plane_value = (mpu_object.x_range[1]-mpu_object.x_range[0])*plane_value + mpu_object.x_range[0] elif plane_axis == 1: plane_value = (mpu_object.y_range[1]-mpu_object.y_range[0])*plane_value + mpu_object.y_range[0] elif plane_axis == 2: plane_value = (mpu_object.z_range[1]-mpu_object.z_range[0])*plane_value + mpu_object.z_range[0] DIMS,results_exact = mpu_meshgrid(mpu_object,res=resolution,workers=workers, k=k,plane_axis=plane_axis, plane_value=plane_value,buf=buf) colormap = plt.cm.RdBu main_axes = list(range(len(DIMS))) main_axes.remove(plane_axis) fig,ax = plt.subplots() CS = ax.contour(DIMS[main_axes[0]],DIMS[main_axes[1]],results_exact,levels=[level],linewidths=(2,)) #CS.collections[0].set_label(r"$\Gamma_{" +str(len(mpu_object.patches))+ r"}$") return CS
[docs]def plot_mpu_boundaries(mpu_object,resolution=20,k=[2],buf=1.25,level=0,workers=1,plane_axis=2,plane_value=0.5,test_size=100,unit_scale='mm',name="untitled"): if plane_axis == 0: plane_value = (mpu_object.x_range[1]-mpu_object.x_range[0])*plane_value + mpu_object.x_range[0] elif plane_axis == 1: plane_value = (mpu_object.y_range[1]-mpu_object.y_range[0])*plane_value + mpu_object.y_range[0] elif plane_axis == 2: plane_value = (mpu_object.z_range[1]-mpu_object.z_range[0])*plane_value + mpu_object.z_range[0] DIMS,results_exact = mpu_meshgrid(mpu_object,res=resolution,workers=workers, k=len(mpu_object.patches),plane_axis=plane_axis, plane_value=plane_value,buf=buf) APPROX = [] for ki in k: DIMS,approximate = mpu_meshgrid(mpu_object,res=resolution,workers=workers, k=ki,plane_axis=plane_axis,plane_value=plane_value) APPROX.append(approximate) colormap = plt.cm.RdBu main_axes = list(range(len(DIMS))) main_axes.remove(plane_axis) axes_labels = ['x ({})'.format(unit_scale),'y ({})'.format(unit_scale),'z ({})'.format(unit_scale)] axes_labels_all = ['x ({})'.format(unit_scale),'y ({})'.format(unit_scale),'z ({})'.format(unit_scale)] axes_labels.remove(axes_labels[plane_axis]) fig,ax = plt.subplots() #spec = gridspec.GridSpec(ncols=4, nrows=1, # width_ratios=[1, 1, 1, 1.5]) #ax1 = fig.add_subplot(spec[0]) #ax2 = fig.add_subplot(spec[1]) #ax3 = fig.add_subplot(spec[2]) #ax4 = fig.add_subplot(spec[3],projection='3d') positions = [] cax = ax.contourf(DIMS[main_axes[0]],DIMS[main_axes[1]],results_exact,norm=colors.TwoSlopeNorm(0),cmap="RdBu_r",alpha=0.5) CS = ax.contour(DIMS[main_axes[0]],DIMS[main_axes[1]],results_exact,levels=[level],linewidths=(2,)) CS.collections[0].set_label(r"$\Gamma_{" +str(len(mpu_object.patches))+ r"}$") #fmt = {CS.levels[0]:r"$\Gamma_{" +str(len(mpu_object.patches)) + r"}$"} #ax.clabel(CS,fmt=fmt,fontsize=10) for c,ap in enumerate(APPROX): tmp = ax.contour(DIMS[main_axes[0]],DIMS[main_axes[1]],ap,levels=[level],linewidths=(2,),linestyles='--') tmp.collections[0].set_label(r"$\Gamma_{" +str(k[c])+ r"}$") #fmt = {tmp.levels[0]:r"$\Gamma_{" +str(k[c])+ r"}$"} #ax.clabel(tmp,fmt=fmt,fontsize=10) plt.legend() pts = np.random.random((test_size,3)) xr = (np.min(DIMS[0].flatten()),np.max(DIMS[0].flatten())) yr = (np.min(DIMS[1].flatten()),np.max(DIMS[1].flatten())) zr = (np.min(DIMS[2].flatten()),np.max(DIMS[2].flatten())) pts[:,0] = (pts[:,0]*2-1)*(xr[1] - xr[0])/2 + (mpu_object.x_range[0] + mpu_object.x_range[1])/2 pts[:,1] = (pts[:,1]*2-1)*(yr[1] - yr[0])/2 + (mpu_object.y_range[0] + mpu_object.y_range[1])/2 pts[:,2] = (pts[:,2]*2-1)*(zr[1] - zr[0])/2 + (mpu_object.z_range[0] + mpu_object.z_range[1])/2 pts[:,plane_axis] = plane_value interior = [] exterior = [] interior_wrong = [] exterior_wrong = [] for i in range(pts.shape[0]): if mpu_object.within(pts[i,0],pts[i,1],pts[i,2],len(mpu_object.patches),level=level)[0]: if mpu_object.within(pts[i,0],pts[i,1],pts[i,2],k[0],level=level)[0]: interior.append(pts[i,:].tolist()) else: exterior_wrong.append(pts[i,:].tolist()) else: if not mpu_object.within(pts[i,0],pts[i,1],pts[i,2],k[0],level=level)[0]: exterior.append(pts[i,:].tolist()) else: interior_wrong.append(pts[i,:].tolist()) interior = np.array(interior) exterior = np.array(exterior) interior_wrong = np.array(interior_wrong) exterior_wrong = np.array(exterior_wrong) if interior.shape[0] > 0: if interior.shape[0] > 100: stop = 99 else: stop = None ax.scatter(interior[:stop,main_axes[0]],interior[:stop,main_axes[1]],c='blue',alpha=0.7) if exterior.shape[0] > 0: if exterior.shape[0] > 100: stop = 99 else: stop = None ax.scatter(exterior[:stop,main_axes[0]],exterior[:stop,main_axes[1]],c='red',alpha=0.7) if exterior_wrong.shape[0] > 0: if exterior_wrong.shape[0] > 100: stop = 99 else: stop = None ax.scatter(exterior_wrong[:stop,main_axes[0]],exterior_wrong[:stop,main_axes[1]],c='red',alpha=0.7,marker='x') if interior_wrong.shape[0] > 0: if interior_wrong.shape[0] > 100: stop = 99 else: stop = None ax.scatter(interior_wrong[:stop,main_axes[0]],interior_wrong[:stop,main_axes[1]],c='blue',alpha=0.7,marker='x') plt.savefig(name+'.svg', format="svg", bbox_inches='tight') return interior.shape[0],exterior.shape[0],interior_wrong.shape[0],exterior_wrong.shape[0],test_size
[docs]def plot_gradient(mpu_object,workers=1,k=None,resolution=20,plane_axis=2,plane_value=0, contour_overlay=True,unit_scale='mm'): DIMS,gradient = mpu_meshgrid(mpu_object,res=resolution,workers=workers, plane_axis=plane_axis,plane_value=plane_value, gradient=True) DIMS,gradient_approximate = mpu_meshgrid(mpu_object,res=resolution,workers=workers, plane_axis=plane_axis,plane_value=plane_value, k=k,gradient=True) if contour_overlay: DIMS_c,result = mpu_meshgrid(mpu_object,res=resolution,workers=workers, plane_axis=plane_axis,plane_value=plane_value) main_axes = list(range(len(DIMS))) main_axes.remove(main_axes[plane_axis]) #use del? fig = plt.figure(figsize=(6,5)) ax = fig.add_subplot(111) if contour_overlay: cax = ax.contourf(DIMS[main_axes[0]],DIMS[main_axes[1]],result,norm=colors.TwoSlopeNorm(0)) p0 = ax.get_position().get_points().flatten() ax_cbar = fig.add_axes([p0[0], 0.1, p0[2]-p0[0], 0.05]) ax_cbar.set_in_layout(True) cbar1 = plt.colorbar(cax, cax=ax_cbar, orientation='horizontal', pad=0.25) labels = cbar1.ax.get_xticklabels() cbar1.ax.set_xticklabels(labels, rotation=40) ax.quiver(DIMS[main_axes[0]],DIMS[main_axes[1]], gradient[main_axes[0]],gradient[main_axes[1]]) ax.quiver(DIMS[main_axes[0]],DIMS[main_axes[1]], gradient_approximate[main_axes[0]],gradient_approximate[main_axes[1]],color='r') axes_labels = ['x ({})'.format(unit_scale),'y ({})'.format(unit_scale),'z ({})'.format(unit_scale)] axes_labels.remove(axes_labels[plane_axis]) ax.set_xlabel(axes_labels[0]) ax.set_ylabel(axes_labels[1]) plt.subplots_adjust(bottom=0.25) plt.show()
[docs]def plot_gradient_error(mpu_object,workers=1,k=None,resolution=20,plane_axis=2,plane_value=0, contour_overlay=True,unit_scale='mm'): DIMS,gradient = mpu_meshgrid(mpu_object,res=resolution,workers=workers, plane_axis=plane_axis,plane_value=plane_value, gradient=True) DIMS,approximate = mpu_meshgrid(mpu_object,res=resolution,workers=workers, plane_axis=plane_axis,plane_value=plane_value, k=k,gradient=True) DIMS_c,result = mpu_meshgrid(mpu_object,res=resolution,workers=workers, plane_axis=plane_axis,plane_value=plane_value) gradient = [gradient[0].flatten(),gradient[1].flatten(),gradient[2].flatten()] approximate = [approximate[0].flatten(),approximate[1].flatten(),approximate[2].flatten()] alignment_error = [] magnitude_error = [] for i in range(len(gradient[0])): grad_mag = (gradient[0][i]**2+gradient[1][i]**2+gradient[2][i]**2)**(1/2) approx_mag = (approximate[0][i]**2+approximate[1][i]**2+approximate[2][i]**2)**(1/2) alignment_error.append((gradient[0][i]/grad_mag)*(approximate[0][i]/approx_mag)+(gradient[1][i]/grad_mag)*(approximate[1][i]/approx_mag)+ (gradient[2][i]/grad_mag)*(approximate[2][i]/approx_mag)) magnitude_error.append(grad_mag-approx_mag) fig = plt.figure() ax1 = fig.add_subplot(121) ax1.scatter(result.flatten(),alignment_error) ax1.set_xlabel('Contour Layer') ax1.set_ylabel('Alignment Difference') ax2 = fig.add_subplot(122) ax2.scatter(result.flatten(),magnitude_error) ax2.set_xlabel('Contour Layer') ax2.set_ylabel('Magnitude Difference') plt.show()
[docs]def plot_error(mpu_object,workers=1,k=None,resolution=20,plane_axis=2,plane_value=0): DIMS,result = mpu_meshgrid(mpu_object,workers=workers,res=resolution,plane_axis=plane_axis, plane_value=plane_value) DIMS,approx = mpu_meshgrid(mpu_object,workers=workers,k=k,res=resolution,plane_axis=plane_axis, plane_value=plane_value) fig = plt.figure() ax = fig.add_subplot(111) main_axes = list(range(len(DIMS))) main_axes.remove(main_axes[plane_axis]) contours = ax.contour(DIMS[main_axes[0]],DIMS[main_axes[1]],result) levels = contours.levels[1:-1] level_areas = [] level_error = [] error_per_area = [] resultf = result.flatten() approxf = approx.flatten() l0 = -1 a0 = 0 passed_levels = [] for idx, level in enumerate(levels): #contour = contours.collections[idx] #if len(contour.get_paths()) == 0: # continue #else: # passed_levels.append(level) #vs = contour.get_paths()[0].vertices #a = 0 #d0_0,d1_0 = vs[0] #for [d0_1,d1_1] in vs[1:]: # dd0 = d0_1 - d0_0 # dd1 = d1_1 - d1_0 # a += 0.5*(d1_0*dd0 - d0_0*dd1) # d0_0 = d0_1 # d1_0 = d1_1 #level_areas.append(a-a0) #a0 = a lower_filter = set(np.argwhere(l0<resultf).flatten()) upper_filter = set(np.argwhere(resultf<level).flatten()) bounded_filter = list(lower_filter.intersection(upper_filter)) level_error.append(np.mean(resultf[bounded_filter] - approxf[bounded_filter])) l0 = level #error_per_area.append(level_error[-1]/level_areas[-1]) plt.clf() plt.plot(levels,level_error) plt.show()
[docs]def plot_time(mpu_object,resolution=20,k_start=2,k_end=100,gradient=False,plane_axis=None,plane_value=None): all_time = [] mean_time = [] k_values = [] sd_time_values = [] all_error = [] mean_error = [] sd_error = [] all_k = [] #d_type = [] DIMS,exact = mpu_meshgrid(mpu_object,k=None,res=resolution,gradient=gradient, plane_axis=plane_axis,plane_value=plane_value) for i in tqdm(range(k_start,k_end+1),desc='Evaluating Time Grids '): k_values.append(i) DIMS,time_data = mpu_meshgrid(mpu_object,k=i,res=resolution,gradient=gradient, plane_axis=plane_axis,plane_value=plane_value, record=True) DIMS,approx = mpu_meshgrid(mpu_object,k=i,res=resolution,gradient=gradient, plane_axis=plane_axis,plane_value=plane_value) error = abs(exact.flatten() - approx.flatten()) k_tmp = [i]*len(error) #d_type.extend(['error']*len(error)) #d_type.extend(['time']*len(time_data)) mean_error.append(np.mean(error)) sd_error.append(np.std(error)) all_time.extend(time_data) mean_time.append(np.mean(time_data)) sd_time_values.append(np.std(time_data)) all_error.extend(error) all_k.extend(k_tmp) data = pd.DataFrame() data['times'] = all_time data['k'] = all_k data['error'] = all_error sn.lineplot(data=data,x='k',y='times') ax2 = plt.twinx() sn.lineplot(data=data,x='k',y='error',ax=ax2,color='red') plt.show()
[docs]def time_PU_global(mpu_object): start = time() mpu_object.solve() pu_time = time()-start start = time() mpu_object.solve(PU=False) global_time = time()-start return pu_time,global_time
#def pu_v_global(mpu_object,start=10,stop=40):
[docs]def show_path(points,points2): fig = plt.figure() ax = fig.add_subplot(111,projection='3d') ax.scatter3D(points[0,0],points[0,1],points[0,2],color='g') ax.scatter3D(points[1:,0],points[1:,1],points[1:,2],color='r') ax.scatter3D(points2[:,0],points2[:,1],points2[:,2],color='b') plt.show()
[docs]def show_mesh(points,points2,points3): fig = plt.figure() ax = fig.add_subplot(111,projection='3d') ax.scatter3D(points[:,0],points[:,1],points[:,2],color='r') ax.scatter3D(points2[:,0],points2[:,1],points2[:,2],color='b') ax.scatter3D(points3[:,0],points3[:,1],points3[:,2],color='g') plt.show()
[docs]def newton(mpu_object): f1 = mpu_object.function([1,1,1,None]) f2 = mpu_object.function([1.1,1,1,None]) g = np.array(mpu_object.gradient([1,1,1,None])) print('F1: {}'.format(f1)) print('F2: {}'.format(f2)) print('Ap: {}'.format(f1+np.dot(np.array([0.1,0,0]),g)))
[docs]def show_patches(mpu_object): patch_sets = [set(tuple([tuple(pp) for pp in p.points.tolist()])) for p in mpu_object.patches] unique_points = [] overlap_points = [] for patch_idx,patch_i in enumerate(patch_sets): patch_i_diff = patch_i.difference({}) patch_i_overlap = set([]) for patch_jdx,patch_j in enumerate(patch_sets): if patch_idx == patch_jdx: continue else: patch_i_diff = patch_i_diff.difference(patch_j) patch_i_overlap.update(patch_i.intersection(patch_j)) print(len(unique_points)) unique_points.extend(list(patch_i_diff)) overlap_points.extend(list(patch_i_overlap)) unique_points = np.array(unique_points) overlap_points = np.array(overlap_points) fig = plt.figure() ax = fig.add_subplot(111,projection='3d') ax.scatter3D(unique_points[:,0],unique_points[:,1],unique_points[:,2],color='r') ax.scatter3D(overlap_points[:,0],overlap_points[:,1],overlap_points[:,2],color='b') plt.show()
#get area of contourf for L1 error estimate as a function of "tissue depth" which will basically argue #that for our area of interest we can ignore the problematic areas of unstable far-field growth #for gradient error take the angle and magnitude differences and also show them as a function of tissue # layer position