def finalize(self):
""" Saves results from current model update iteration
"""
system.checkpoint()
# save new model to working dir
src = join(PATH.OPTIMIZE, 'm_new')
dst = PATH.MODEL
solver.split(src, dst, '.bin')
if divides(optimize.iter, PAR.SAVEMODEL):
self.save_model()
if divides(optimize.iter, PAR.SAVEGRADIENT):
self.save_gradient()
if divides(optimize.iter, PAR.SAVEKERNELS):
self.save_kernels()
if divides(optimize.iter, PAR.SAVETRACES):
self.save_traces()
self.save_traces(type='syn')
if divides(optimize.iter, PAR.SAVERESIDUALS):
self.save_residuals()
def write_model(self, path='', suffix=''):
""" Writes model in format used by solver
"""
unix.mkdir(path)
src = PATH.OPTIMIZE +'/'+ 'm_' + suffix
dst = path +'/'+ 'model'
unix.mkdir(dst)
unix.cp(glob(join(PATH.MODEL, '*.bin')), dst)
solver.split(src, dst, '.bin')
def write_model(self, path='', suffix=''):
""" Writes model in format used by solver
"""
unix.mkdir(path)
src = PATH.OPTIMIZE + '/' + 'm_' + suffix
dst = path + '/' + 'model'
parts = solver.split(loadnpy(src))
solver.save(dst, parts)
def write_model(self, path='', suffix=''):
""" Writes model in format used by solver
"""
unix.mkdir(path)
src = PATH.OPTIMIZE +'/'+ 'm_' + suffix
dst = path +'/'+ 'model'
parts = solver.split(loadnpy(src))
solver.save(dst, parts)
def save(self, path, v, backup=None):
if backup:
src = path +'/'+ 'gradient'
dst = path +'/'+ 'gradient_'+backup
unix.mv(src, dst)
solver.save(path +'/'+ 'gradient',
solver.split(v),
suffix='_kernel')
def solve(self):
mat = []
consts = []
for eqns in self.eqns:
mat.append(solver.split(eqns)[:-1])
consts.append(solver.split(eqns)[-1])
if type(solver.split(eqns)) == str:
self.eqns.clear()
return solver.split(eqns)
results = solver.EqnSolver(mat, consts).solve()
try:
var = "".join(sorted(i for i in self.eqns[0] if i.isalpha()))
s = zip(var, results)
l = ""
for i in s:
l += "{} = {}\n".format(i[0], i[1])
self.eqns.clear()
return l
except:
return "Error. No output"
def save_model(self):
src = PATH.OPTIMIZE +'/'+ 'm_new'
dst = join(PATH.OUTPUT, 'model_%04d' % optimize.iter)
parts = solver.split(loadnpy(src))
vp_min, vp_max = 300,3750
vs_min, vs_max = 50,2800
#for key in ['vp', 'vs']:
# for iproc in range(PAR.NPROC):
# if key == 'vp':
# np.clip(parts[key][iproc], vp_min, vp_max)
# if key == 'vs':
# np.clip(parts[key][iproc], vs_min, vs_max)
solver.save(dst, parts)
def save_model(self):
src = PATH.OPTIMIZE + '/' + 'm_new'
dst = join(PATH.OUTPUT, 'model_%04d' % optimize.iter)
solver.save(dst, solver.split(loadnpy(src)))
def save_model(self):
src = PATH.OPTIMIZE +'/'+ 'm_new'
dst = join(PATH.OUTPUT, 'model_%04d' % optimize.iter)
solver.save(dst, solver.split(loadnpy(src)))
def save_model(self):
src = join(PATH.OPTIMIZE, 'm_new')
dst = join(PATH.MODELS, 'm{:02d}'.format(optimize.iter))
unix.mkdir(dst)
solver.split(src, dst, '.bin')
def fix_near_field(self, path=''):
"""
"""
import preprocess
preprocess.setup()
name = solver.check_source_names()[solver.getnode]
fullpath = path + '/' + name
#print 'DB: name=', name
#print 'DB: fullpath=', fullpath
g = solver.load(fullpath, suffix='_kernel')
g_vec = solver.merge(g)
nproc = solver.mesh.nproc
#print 'DB: len(g_vec)=', len(g_vec)
if not PAR.FIXRADIUS:
return
x, y, z = self.getcoords()
#print 'DB: len(g)=', len(g)
#print 'DB: len(g[vp][0])=', len(g['vp'][0])
#print 'DB: x.shape=', x.shape
#print 'DB: len(x)=', len(x)
##sys.exit("DB: stop from postporcess-regularize")
lx = x.max() - x.min()
ly = y.max() - y.min()
lz = z.max() - z.min()
nn = x.size
nx = np.around(np.sqrt(nn * lx / (lz * ly)))
ny = np.around(np.sqrt(nn * ly / (lx * lz)))
nz = np.around(np.sqrt(nn * lz / (lx * ly)))
dx = lx / nx * 1.25
dy = ly / ny * 1.25
dz = lz / nz * 1.25
#print 'DB: lx=', lx
#print 'DB: ly=', ly
#print 'DB: lz=', lz
#print 'DB: nn=', nn
#print 'DB: nx=', nx
#print 'DB: ny=', ny
#print 'DB: nz=', nz
#print 'DB: dx=', dx
#print 'DB: dy=', dy
#print 'DB: dz=', dz
sigma = PAR.FIXRADIUS * (dx + dz + dy) / 3.0
_, h = preprocess.load(solver.getpath + '/' + 'traces/obs')
# mask sources
mask = np.exp(-0.5 * ((x - h.sx[0])**2. + (y - h.sy[0])**2. +
(z - h.sz[0])**2.) / sigma**2.)
# mask top
# for matlab
# z_sqrt=(abs(z).^(0.25)); depth_scale=1-z_sqrt/max(z_sqrt); figure; plot(depth_scale,z);
z_factor = np.power(abs(z), 0.5)
#max_z_factor = np.amax(z_factor)
#scale_depth = 1.0 - z_factor/max_z_factor
#print 'DB: max(z_factor)=',max_z_factor
#print 'DB: max(scale_depth)=',np.amax(scale_depth)
#print 'DB: min(scale_depth)=',np.amin(scale_depth)
#mask *= scale_depth
#mask_depth = solver.split(z)
mask_depth = solver.split(z_factor)
mask_d = solver.split(mask)
##print 'DB: sigma=',sigma
##print 'DB: mask=',mask
#print 'DB: len(mask)=', len(mask)
#print 'DB: len(mask_d)=', len(mask_d)
##print 'DB: len(g)=', len(g)
##print 'DB: len(g)[vp][0]=', len(g['vp'][0])
for key in solver.parameters:
for iproc in range(nproc):
#print 'DB: key, iproc=', key, iproc
#print 'DB: len(g[key][iproc])=', len(g[key][iproc])
#print 'DB: len(mask_d[key][iproc])=', len(mask_d[key][iproc])
weight = np.sum(mask_d['vp'][iproc] * g[key][iproc]) / np.sum(
mask_d['vp'][iproc])
#print 'DB: key, iproc, weigth= ', key, iproc, weight
g[key][iproc] *= 1. - mask_d['vp'][iproc]
g[key][iproc] *= mask_depth['vp'][iproc]
#g[key][iproc] += mask_d['vp'][iproc]*weight
#weight = np.sum(mask_d['vp'][iproc]*g[key][iproc])/np.sum(mask_d['vp'][iproc])
##print 'DB: key, iproc, weigth= ', key, iproc, weight
#g[key][iproc] *= 1.-mask_d['vp'][iproc]
#g[key][iproc] += mask_d['vp'][iproc]*weight
# mask receivers
#for ir in range(h.nr):
# mask = np.exp(-0.5*((x-h.rx[ir])**2.+(z-h.ry[ir])**2.)/sigma**2.)
# for key in solver.parameters:
# weight = np.sum(mask*g[key][0])/np.sum(mask)
# g[key][0] *= 1.-mask
# g[key][0] += mask*weight
solver.save(fullpath, g, suffix='_kernel')
def fix_near_field(self, path=''):
"""
"""
import preprocess
preprocess.setup()
name = solver.check_source_names()[solver.getnode]
fullpath = path + '/' + name
g = solver.load(fullpath, suffix='_kernel')
g_vec = solver.merge(g)
nproc = solver.mesh.nproc
if not PAR.FIXRADIUS:
return
x, y, z = self.getcoords()
lx = x.max() - x.min()
ly = y.max() - y.min()
lz = z.max() - z.min()
nn = x.size
nx = np.around(np.sqrt(nn * lx / (lz * ly)))
ny = np.around(np.sqrt(nn * ly / (lx * lz)))
nz = np.around(np.sqrt(nn * lz / (lx * ly)))
dx = lx / nx * 1.25
dy = ly / ny * 1.25
dz = lz / nz * 1.25
sigma = PAR.FIXRADIUS * (dx + dz + dy) / 3.0
_, h = preprocess.load(solver.getpath + '/' + 'traces/obs')
mask = np.exp(-0.5 * ((x - h.sx[0])**2. + (y - h.sy[0])**2. +
(z - h.sz[0])**2.) / sigma**2.)
scale_z = np.power(abs(z), 0.5)
power_win = 10
win_x = np.power(x, power_win)
win_y = np.power(y, power_win)
win_z = np.power(z, power_win)
win_x = win_x / win_x.max()
win_y = win_y / win_y.max()
win_z = win_z / win_z.max()
win_x = 1.0 - win_x[::-1]
win_y = 1.0 - win_y[::-1]
win_z = 1.0 - win_z[::-1]
win_x_rev = win_x[::-1]
win_y_rev = win_y[::-1]
win_z_rev = win_z[::-1]
taper_x = x * 0.0 + 1.0
taper_y = y * 0.0 + 1.0
taper_z = z * 0.0 + 1.0
taper_x *= win_x
taper_y *= win_y
taper_z *= win_z
taper_x *= win_x_rev
taper_y *= win_y_rev
taper_z *= win_z_rev
scale_z = scale_z * taper_z + 0.1
mask_x = solver.split(taper_x)
mask_y = solver.split(taper_y)
mask_z = solver.split(scale_z)
mask_d = solver.split(mask)
for key in solver.parameters:
for iproc in range(nproc):
weight = np.sum(mask_d['vp'][iproc] * g[key][iproc]) / np.sum(
mask_d['vp'][iproc])
g[key][iproc] *= 1. - mask_d['vp'][iproc]
g[key][iproc] *= mask_z['vp'][iproc]
g[key][iproc] *= mask_x['vp'][iproc]
g[key][iproc] *= mask_y['vp'][iproc]
#sigma = 1.0
## mask receivers
#for ir in range(h.nr):
# mask = np.exp(-0.5*((x-h.rx[ir])**2.+(y-h.ry[ir])**2.+(z-h.rz[ir])**2.)/sigma**2.)
# mask_d = solver.split(mask)
# #mask = np.exp(-0.5*((x-h.rx[ir])**2.+(z-h.ry[ir])**2.)/sigma**2.)
# for key in solver.parameters:
# for iproc in range(nproc):
# #weight = np.sum(mask*g[key][0])/np.sum(mask)
# g[key][iproc] *= 1.-mask_d['vp'][iproc]
# #g[key][0] += mask*weight
solver.save(fullpath, g, suffix='_kernel')
