def get_all_voltages(self, anomaly): mesh_new = set_perm(self.all_meas.mesh_obj, anomaly=anomaly, background=None) voltage_readings, measurements, new_ind = self.fwd.solveAnomaly( ex_mat=self.ex_mat_all, step=1, perm=mesh_new['perm'], parser=None) ind = np.lexsort((measurements[:, 3], measurements[:, 2], measurements[:, 1], measurements[:, 0])) return voltage_readings[ind], measurements[ind]
def demo(): """demo shows how to interpolate on regular/irregular grids""" # 1. create mesh mesh_obj, _ = layer_circle(n_layer=8, n_fan=6) pts = mesh_obj['node'] tri = mesh_obj['element'] # set anomaly anomaly = [{'x': 0.5, 'y': 0.5, 'd': 0.2, 'perm': 100.0}] mesh_new = set_perm(mesh_obj, anomaly=anomaly) # 2. interpolate using averaged neighbor triangle area perm_node = sim2pts(pts, tri, mesh_new['perm']) # plot mesh and interpolated mesh (tri2pts) fig_size = (6, 4) fig = plt.figure(figsize=fig_size) ax = fig.add_subplot(111) ax.set_aspect('equal') ax.triplot(pts[:, 0], pts[:, 1], tri) im1 = ax.tripcolor(pts[:, 0], pts[:, 1], tri, mesh_new['perm']) fig.colorbar(im1, orientation='vertical') fig = plt.figure(figsize=fig_size) ax2 = fig.add_subplot(111) ax2.set_aspect('equal') ax2.triplot(pts[:, 0], pts[:, 1], tri) im2 = ax2.tripcolor(pts[:, 0], pts[:, 1], tri, perm_node, shading='flat') fig.colorbar(im2, orientation='vertical') # 3. interpolate on grids (irregular or regular) using IDW, sigmod xg, yg, mask = meshgrid(pts) im = np.ones_like(mask) # mapping from values on xy to values on xyi xy = np.mean(pts[tri], axis=1) xyi = np.vstack((xg.flatten(), yg.flatten())).T # w_mat = weight_idw(xy, xyi) w_mat = weight_sigmod(xy, xyi) im = np.dot(w_mat.T, mesh_new['perm']) # im = weight_linear_rbf(xy, xyi, mesh_new['perm']) im[mask] = 0. # reshape to grid size im = im.reshape(xg.shape) # plot interpolated values fig, ax = plt.subplots(figsize=fig_size) ax.set_aspect('equal') ax.triplot(pts[:, 0], pts[:, 1], tri, alpha=0.5) im3 = ax.pcolor(xg, yg, im, edgecolors=None, linewidth=0, alpha=0.8) fig.colorbar(im3, orientation='vertical') plt.show()
def demo(): """demo shows how to interpolate on regular/irregular grids""" # 1. create mesh mesh_obj, _ = layer_circle(n_layer=8, n_fan=6) pts = mesh_obj["node"] tri = mesh_obj["element"] # set anomaly anomaly = [{"x": 0.5, "y": 0.5, "d": 0.2, "perm": 100.0}] mesh_new = set_perm(mesh_obj, anomaly=anomaly) # 2. interpolate using averaged neighbor triangle area perm_node = sim2pts(pts, tri, mesh_new["perm"]) # 3. interpolate on grids (irregular or regular) using IDW, sigmod xg, yg, mask = meshgrid(pts) im = np.ones_like(mask) # mapping from values on xy to values on xyi xy = np.mean(pts[tri], axis=1) xyi = np.vstack((xg.flatten(), yg.flatten())).T # w_mat = weight_idw(xy, xyi) w_mat = weight_sigmod(xy, xyi) im = np.dot(w_mat.T, mesh_new["perm"]) # im = weight_linear_rbf(xy, xyi, mesh_new['perm']) im[mask] = 0.0 # reshape to grid size im = im.reshape(xg.shape) # Inverse mapping # w_mat_T_inv = np.linalg.pinv(w_mat.T) w_mat_T_inv = w_mat mesh_new_r = np.dot(w_mat_T_inv, im) # plot mesh and interpolated mesh (tri2pts) fig, axs = plt.subplots(1, 3) ax1, ax2, ax3 = axs[0], axs[1], axs[2] ax1.set_aspect('equal') ax1.triplot(pts[:, 0], pts[:, 1], tri) im1 = ax1.tripcolor(pts[:, 0], pts[:, 1], tri, mesh_new['perm']) ax2.set_aspect('equal') ax2.triplot(pts[:, 0], pts[:, 1], tri) im2 = ax2.tripcolor(pts[:, 0], pts[:, 1], tri, perm_node, shading='flat') # plot interpolated values fig, ax = plt.subplots(figsize=fig_size) ax.set_aspect("equal") ax.triplot(pts[:, 0], pts[:, 1], tri, alpha=0.5) im3 = ax.pcolor(xg, yg, im, edgecolors=None, linewidth=0, alpha=0.8) fig.colorbar(im3, orientation="vertical") plt.show()
def get_obs(self,**kwargs): folder=kwargs.pop('folder','./result') fname=str(self.gdim)+'d_EIT_dim'+str(self.dim) try: with open(os.path.join(folder,fname+'.pckl'),'rb') as f: [self.true_perm,obs]=pickle.load(f)[:2] print('Data '+fname+' loaded!') except: print('No data found. Generate new data...') mesh_new=mesh.set_perm(self.mesh_obj, anomaly=self.anomaly, background=1.0) self.true_perm=mesh_new['perm'] fs=self.solve(self.true_perm,skip_jac=True,**kwargs) obs=fs.v # if np.size(self.nz_var)<np.size(obs): self.nz_var=np.resize(self.nz_var,np.size(obs)) # obs+=np.sqrt(self.nz_var)*np.random.randn(np.size(obs)) # voltage must be positive! if not os.path.exists(folder): os.makedirs(folder) with open(os.path.join(folder,fname+'.pckl'),'wb') as f: pickle.dump([self.true_perm,obs,self.n_el,self.bbox,self.meshsz,self.el_dist,self.step,self.anomaly,self.lamb],f) return obs
import numpy as np import matplotlib.pyplot as plt import pyeit.mesh as mesh from pyeit.eit.fem import Forward from pyeit.eit.utils import eit_scan_lines import pyeit.eit.bp as bp """ 0. build mesh """ mesh_obj, el_pos = mesh.create(16, h0=0.1) # extract node, element, alpha pts = mesh_obj['node'] tri = mesh_obj['element'] """ 1. problem setup """ anomaly = [{'x': 0.5, 'y': 0.5, 'd': 0.1, 'perm': 10.0}] mesh_new = mesh.set_perm(mesh_obj, anomaly=anomaly, background=1.0) # draw delta_perm = np.real(mesh_new['perm'] - mesh_obj['perm']) fig, ax = plt.subplots() im = ax.tripcolor(pts[:, 0], pts[:, 1], tri, delta_perm, shading='flat', cmap=plt.cm.viridis) ax.set_title(r'$\Delta$ Conductivities') fig.colorbar(im) ax.axis('equal') fig.set_size_inches(6, 4) # fig.savefig('demo_bp_0.png', dpi=96)
anomaly = [ { "x": 0.4, "y": 0.4, "d": 0.2, "perm": 10 }, { "x": -0.4, "y": -0.4, "d": 0.2, "perm": 0.1 }, ] # background changed to values other than 1.0 requires more iterations mesh_new = set_perm(mesh_obj, anomaly=anomaly, background=2.0) # extract node, element, perm pts = mesh_obj["node"] tri = mesh_obj["element"] perm = mesh_new["perm"] # show fig, ax = plt.subplots(figsize=(6, 4)) im = ax.tripcolor(pts[:, 0], pts[:, 1], tri, np.real(perm), shading="flat", cmap=plt.cm.viridis) fig.colorbar(im)
from pyeit.eit.interp2d import sim2pts import pyeit.eit.jac_reg as jac_reg """ 0. construct mesh """ mesh_obj, el_pos = mesh.create(16, h0=0.1) # mesh_obj, el_pos = mesh.layer_circle() # extract node, element, alpha pts = mesh_obj["node"] tri = mesh_obj["element"] x, y = pts[:, 0], pts[:, 1] """ 1. problem setup """ mesh_obj["alpha"] = np.random.rand(tri.shape[0]) * 200 + 100 anomaly = [{"x": 0.5, "y": 0.5, "d": 0.1, "perm": 1000.0}] mesh_new = mesh.set_perm(mesh_obj, anomaly=anomaly) """ 2. FEM simulation """ el_dist, step = 1, 1 ex_mat = eit_scan_lines(16, el_dist) # calculate simulated data fwd = Forward(mesh_obj, el_pos) f0 = fwd.solve_eit(ex_mat, step=step, perm=mesh_obj["perm"]) f1 = fwd.solve_eit(ex_mat, step=step, perm=mesh_new["perm"]) """ 3. JAC solver """ # Note: if the jac and the real-problem are generated using the same mesh, # then, data normalization in solve are not needed. # However, when you generate jac from a known mesh, but in real-problem # (mostly) the shape and the electrode positions are not exactly the same
def greit_rec(p, t, el_pos, anomaly, fwd, continuous=False, step='random', n_pix=64, n_el=20, length=None, el_dist=None, num_per_el=3, continuousPerm=None): ''' function that generates forward solution and a GREIT reconstruction for a given conductivity distribution Takes: p - array of point coordinates created by meshing algorithm [number of points, 2] array[float] t - array of a triangles included in meshing [number of triangles , 3] array[int] el_pos - array of electrode positions [number of electrodes , 2] array[float] anomaly - list of all the anomalies for which reconstruction should be made array[dict] step - array storing the distance (in number of electrodes) for each source/sink pair [number of source/sink pairs , 1] array[int] (Default is 'random' == generates random step for each measurement) n_pix - number of pixels to be created in each dimension for GREIT algorithm [int] n_el - number of electrodes of the system that participate in reconstruction [int] Returns: ds - recreated conductivity map by GREIT algorithm [number of pixels,number of pixels] array[float] ''' #check order of points for each triangle and rearrange to ensure counter-clockwise arrangement (from pyEIT) t = checkOrder(p, t) #generate electrode indices el_pos = np.arange(n_el * num_per_el) #initialise unit uniform permitivity for the triangular mesh to be used perm = np.ones(t.shape[0], dtype=np.float) #build mesh structure given the input elements mesh_obj = {'element': t, 'node': p, 'perm': perm} # extract x, y coordinate of mesh vertices x, y = p[:, 0], p[:, 1] #check to see the state of the generated mesh (optional) #quality.stats(p, t) ex_mat = orderedExMat(n_el, length, el_dist) #if random step is invoked a random step is generated for each source/sink pair if step == 'random': step = np.array(rand.randint(1, n_el, size=ex_mat.shape[0])) #if the step is not an integer in the needed range, just randomize the same step for a source/sink pairs elif (step < 0 or step > n_el).any(): step = rand.randint(1, n_el) start_t = time() # calculate simulated data using FEM (for uniform conductivity) f = fwd.solve_eit(ex_mat=ex_mat, step=step, perm=mesh_obj['perm']) # creating forward dictionary with solution of forward problem pde_result = namedtuple("pde_result", ['jac', 'v', 'b_matrix']) f0 = pde_result(jac=f.jac, v=f.v, b_matrix=f.b_matrix) # adding anomalies with a overwritten anomaly function originally in pyEIT (pyEIT.mesh.wrapper) (heavily changed) unp_t = time() print("Unperturbed forward solution t", unp_t - start_t) if continuous == False: mesh_new = set_perm(mesh_obj, anomaly=anomaly, background=None) permUsed = mesh_new['perm'] elif continuous == True: permUsed = continuousPerm else: print('kurec') start_anom = time() # solving with anomalies f1 = fwd.solve_eit(ex_mat=ex_mat, step=step, perm=permUsed) # generate array for variance, 3% standard deviation for the voltage measurement variance = 0.0009 * np.power(f1.v, 2) # apply noise to voltage measurements v # here white Gaussian noise is assumed (since we don't have significant sources of systematic error like in medical applications, e.g. moving electrodes...) v = sk.random_noise(f1.v, mode='gaussian', clip=False, mean=0.0, var=variance) # create the Forward object used by GREIT the voltage map with the Gaussian noise f1 = pde_result(jac=np.vstack(f1.jac), v=np.hstack(v), b_matrix=np.vstack(f1.b_matrix)) end_anom = time() print("Anomaly forward t: ", end_anom - start_anom ) # (optional) draw anomalies only delta_perm = np.real(mesh_new['perm'] - mesh_obj['perm']) fig, ax = plt.subplots() im = ax.tripcolor(p[:, 0], p[:, 1], t, delta_perm, shading='flat', cmap=plt.cm.viridis) ax.set_title(r'$\Delta$ Conductivities') fig.colorbar(im) ax.axis('equal') fig.set_size_inches(6, 4) # fig.savefig('demo_bp_0.png', dpi=96) #plt.show() start_greit = time() # constructing GREIT object (from pyEIT) (classes changed singificantly for optimisation) eit = greit.GREIT(mesh_obj, el_pos, f=f, ex_mat=ex_mat, step=step, parser='std') # solving inverse problem with GREIT algorithm eit.setup(p=0.1, lamb=0.01, n=n_pix, s=15., ratio=0.1) ds = eit.solve(f1.v, f0.v) #reshaping output to the desired dimensions ds = ds.reshape((n_pix, n_pix)) print("Greit solution time ", time() - start_greit) # (optional) plot to check whether generated sensibly fig, ax = plt.subplots(figsize=(6, 4)) im = ax.imshow(np.real(ds), interpolation='none', cmap=plt.cm.viridis, origin='lower', extent=[-1,1,-1,1]) fig.colorbar(im) ax.axis('equal') plt.show() ''' gradConductivity = np.linalg.norm(np.gradient(ds), axis=0) figGrad, axGrad = plt.subplots(figsize=(6, 4)) imGrad = axGrad.imshow(np.real(gradConductivity), interpolation='none', cmap=plt.cm.viridis, origin='lower', extent=[-1,1,-1,1]) figGrad.colorbar(imGrad) axGrad.axis('equal') figGrad2, axGrad2 = plt.subplots(figsize=(6, 4)) imGrad2 = axGrad2.imshow(np.real(gradConductivity * ds), interpolation='none', cmap=plt.cm.viridis, origin='lower', extent=[-1,1,-1,1]) figGrad2.colorbar(imGrad2) axGrad2.axis('equal') v_pert = np.empty(shape=(len(f1.v), len(f1.v))) perturbing_mat = np.ones((len(f1.v), len(f1.v))) + 0.05 * np.identity(len(f1.v)) v_pert[:] = np.dot(perturbing_mat, np.diag(f1.v)) influence_mat = -np.dot(eit.H, v_pert).reshape(n_pix, n_pix, len(f1.v)) - ds[:, :, None] influence_mat = np.absolute(influence_mat) influence_mat = np.sum(influence_mat, axis=2) #mask = circleMask(npix, a) #influence_mat[~mask] = np.amax(influence_mat) figInfl, axInfl = plt.subplots(figsize=(6, 4)) imInfl = axInfl.imshow(np.real(influence_mat), interpolation='none', cmap=plt.cm.viridis, origin='lower', extent=[-1,1,-1,1]) figInfl.colorbar(imInfl) axInfl.axis('equal') totalMap = gradConductivity * ds * influence_mat figTotal, axTotal = plt.subplots(figsize=(6, 4)) imTotal = axTotal.imshow(np.real(totalMap), interpolation='none', cmap=plt.cm.viridis, origin='lower', extent=[-1,1,-1,1]) figTotal.colorbar(imTotal) axTotal.axis('equal') plt.show() ''' return ds