def getmesh(self): model_path = PATH.OUTPUT + '/' + 'model_init' try: m = solver.load(model_path) x = m['x'][0] z = m['z'][0] mesh = stack(x, z) except: from seisflows.seistools.io import loadbin x = loadbin(model_path, 0, 'x') z = loadbin(model_path, 0, 'z') mesh = stack(x, z) return mesh
def getmesh(self): model_path = PATH.OUTPUT +'/'+ 'model_init' try: m = solver.load(model_path) x = m['x'][0] z = m['z'][0] mesh = stack(x, z) except: from seisflows.plugins.io.sem import read x = read(model_path, 'x', 0) z = read(model_path, 'z', 0) mesh = stack(x, z) return mesh
def getmesh(self): model_path = PATH.OUTPUT +'/'+ 'model_init' try: m = solver.load(model_path) x = m['x'][0] z = m['z'][0] mesh = stack(x, z) except: from seisflows.seistools.io import loadbin x = loadbin(model_path, 0, 'x') z = loadbin(model_path, 0, 'z') mesh = stack(x, z) return mesh
def smooth(self, path='', parameters=None, span=0.): """ Smooths SPECFEM2D kernels by convolving them with a Gaussian """ from seisflows.tools.array import meshsmooth, stack #assert parameters == self.parameters # implementing nproc > 1 would be straightforward, but a bit tedious #assert self.mesh.nproc == 1 kernels = self.load(path, suffix='_kernel') if not span: return kernels # set up grid x = sem.read(PATH.MODEL_INIT, 'x', 0) z = sem.read(PATH.MODEL_INIT, 'z', 0) mesh = stack(x, z) for key in parameters or self.parameters: kernels[key] = [meshsmooth(kernels[key][0], mesh, span)] unix.rm(path + '_nosmooth') unix.mv(path, path + '_nosmooth') self.save(path, kernels, suffix='_kernel')
def smooth(self, path='', parameters='dummy', span=0. ): """ Smooths SPECFEM2D kernels by convolving them with a Gaussian """ from seisflows.tools.array import meshsmooth, stack #assert parameters == self.parameters # implementing nproc > 1 would be straightforward, but a bit tedious #assert self.mesh.nproc == 1 kernels = self.load(path, suffix='_kernel') if not span: return kernels # set up grid _,x = loadbypar(PATH.MODEL_INIT, ['x'], 0) _,z = loadbypar(PATH.MODEL_INIT, ['z'], 0) mesh = stack(x[0], z[0]) for key in self.parameters: kernels[key] = [meshsmooth(kernels[key][0], mesh, span)] unix.rm(path + '_nosmooth') unix.mv(path, path + '_nosmooth') self.save(path, kernels, suffix='_kernel')
def smooth(self, path='', span=0., parameters=[]): """ Smooths SPECFEM2D kernels by convolving them with a Gaussian """ from seisflows.tools.array import meshsmooth, stack kernels = self.load(path, suffix='_kernel') if not span: return kernels x = kernels['x'][0] z = kernels['z'][0] mesh = stack(x, z) for key in parameters: kernels[key] = [meshsmooth(kernels[key][0], mesh, span)] unix.mv(path, path + '_nosmooth') self.save(path, kernels)
def apply_smoothing(self, parameter): from seisflows.tools.array import meshsmooth, stack coords = [] for key in ['x', 'z']: coords += [sem.read(PATH.MODEL_INIT, key, 0)] mesh = stack(*coords) for suffix in ['_nu']: path = PATH.MUMFORD_SHAH_OUTPUT if PAR.SMOOTH_EDGES > 0.: # backup original kernel = sem.read(path, parameter+suffix, 0) sem.write(kernel, path, parameter+suffix+'_nosmooth', 0) # apply smoothing operator kernel = meshsmooth(kernel, mesh, PAR.SMOOTH_EDGES) sem.write(kernel, path, parameter+suffix, 0)
def smooth_legacy(input_path='', output_path='', parameters=[], span=0.): solver = sys.modules['seisflows_solver'] PATH = sys.modules['seisflows_paths'] if not exists(input_path): raise Exception if not exists(output_path): unix.mkdir(output_path) if solver.mesh_properties.nproc!=1: raise NotImplementedError # intialize arrays kernels = {} for key in parameters or solver.parameters: kernels[key] = [] coords = {} for key in ['x', 'z']: coords[key] = [] # read kernels for key in parameters or solver.parameters: kernels[key] += solver.io.read_slice(input_path, key+'_kernel', 0) if not span: return kernels # read coordinates for key in ['x', 'z']: coords[key] += solver.io.read_slice(PATH.MODEL_INIT, key, 0) mesh = array.stack(coords['x'][0], coords['z'][0]) # apply smoother for key in parameters or solver.parameters: kernels[key] = [array.meshsmooth(kernels[key][0], mesh, span)] # write smooth kernels for key in parameters or solver.parameters: solver.io.write_slice(kernels[key][0], output_path, key+'_kernel', 0)
def smooth_legacy(input_path='', output_path='', parameters=[], span=0.): solver = sys.modules['seisflows_solver'] PATH = sys.modules['seisflows_paths'] if not exists(input_path): raise Exception if not exists(output_path): unix.mkdir(output_path) if solver.mesh_properties.nproc != 1: raise NotImplementedError # intialize arrays kernels = {} for key in parameters or solver.parameters: kernels[key] = [] coords = {} for key in ['x', 'z']: coords[key] = [] # read kernels for key in parameters or solver.parameters: kernels[key] += solver.io.read_slice(input_path, key + '_kernel', 0) if not span: return kernels # read coordinates for key in ['x', 'z']: coords[key] += solver.io.read_slice(PATH.MODEL_INIT, key, 0) mesh = array.stack(coords['x'][0], coords['z'][0]) # apply smoother for key in parameters or solver.parameters: kernels[key] = [array.meshsmooth(kernels[key][0], mesh, span)] # write smooth kernels for key in parameters or solver.parameters: solver.io.write_slice(kernels[key][0], output_path, key + '_kernel', 0)
def write_damping_term(self, parameter): path_coords = PATH.OUTPUT+'/'+'model_init' path_input = PATH.GRAD+'/'+'model' path_output = PATH.MUMFORD_SHAH_OUTPUT path_run = PATH.SUBMIT x = sem.read(path_coords, 'x', 0) z = sem.read(path_coords, 'z', 0) mesh = stack(x,z) m, grid = mesh2grid(sem.read(path_input, parameter, 0), mesh) nu, _ = mesh2grid(sem.read(path_output, parameter+'_nu', 0), mesh) grad_m = grad(m) grad_nu = grad(nu) V = -2.*(grad_m[0]*grad_nu[0] + grad_m[1]*grad_nu[1]) +\ -nu**2 * nabla2(m) v = grid2mesh(V, grid, mesh) sem.write(v, path_output, parameter+'_dm', 0)
def smooth_legacy(path='', parameters=[], span=0.): solver = sys.modules['seisflows_solver'] PATH = sys.modules['seisflows_paths'] # intialize arrays kernels = {} for key in parameters or solver.parameters: kernels[key] = [] coords = {} for key in ['x', 'z']: coords[key] = [] # read kernels for key in parameters or solver.parameters: kernels[key] += solver.io.read_slice(path, key + '_kernel', 0) if not span: return kernels # read coordinates for key in ['x', 'z']: coords[key] += solver.io.read_slice(PATH.MODEL_INIT, key, 0) mesh = array.stack(coords['x'][0], coords['z'][0]) #mesh = array.stack(solver.mesh_properties.coords['x'][0], # solver.mesh_properties.coords['z'][0]) for key in parameters or solver.parameters: kernels[key] = [array.meshsmooth(kernels[key][0], mesh, span)] unix.rm(path + '_nosmooth') unix.mv(path, path + '_nosmooth') unix.mkdir(path) for key in parameters or solver.parameters: solver.io.write_slice(kernels[key][0], path, key + '_kernel', 0)
def smooth(self, path='', parameters=None, span=0.): """ For a long time SPECFEM2D lacked its own smoothing utility; this method was intended only as a crude workaround """ from seisflows.tools import array assert self.mesh_properties.nproc == 1,\ msg.SmoothingError_SPECFEM2D kernels = self.load(path, suffix='_kernel') if not span: return kernels # set up grid x = sem.read(PATH.MODEL_INIT, 'x', 0) z = sem.read(PATH.MODEL_INIT, 'z', 0) mesh = array.stack(x, z) for key in parameters or self.parameters: kernels[key] = [array.meshsmooth(kernels[key][0], mesh, span)] unix.rm(path + '_nosmooth') unix.mv(path, path + '_nosmooth') self.save(path, kernels, suffix='_kernel')
from seisflows.seistools import io from seisflows.tools.array import mesh2grid, stack import numpy as np #from seisflows.postprocess.regularize import getmesh x = io.read_fortran('../model_init/proc000000_x.bin') z = io.read_fortran('../model_init/proc000000_z.bin') mesh = stack(x, z) #from seisflows.seistools.io import loadbin vs = io.read_fortran('proc000000_vs.bin') vs, grid = mesh2grid(vs, mesh) print vs.shape dd = vs[:, 328] np.savetxt('extrue.dat', dd, fmt='%7.4f') #ext = vs[] #io.write_fortran(x,'proc000000_x.bin') #io.write_fortran(z,'proc000000_z.bin')