def loadrsf(file_name):
mat = m8r.Input('%s.rsf' % file_name)
n1 = mat.int("n1")
n2 = mat.int("n2")
D = mat.read(shape=(n2, n1))
shot = int(file_name[9:])
return D, shot
def m8rInput(self):
#model=m8r.Input('model.rsf')
model=m8r.Input('foldplot1.rsf')
self.vals = model[:,:,:]
npts_x, npts_y, npts_z = self.vals.shape
print("vals.shape=",self.vals.shape)
self.min_x=model.float("o1")
self.min_y=model.float("o2")
self.min_z=model.float("o3")
print("min x,y,z=",self.min_x,self.min_y,self.min_z)
dx=model.float("d1")
dy=model.float("d2")
dz=model.float("d3")
print("dx,dy,dz=",dx,dy,dz)
self.max_x=self.min_x+dx*(npts_x-1)
self.max_y=self.min_y+dy*(npts_y-1)
self.max_z=self.min_z+dz*(npts_z-1)
self.xs = linspace(self.min_x, self.max_x, self.npts_x)
self.ys = linspace(self.min_y, self.max_y, self.npts_y)
self.zs = linspace(self.min_z, self.max_z, self.npts_z)
self.minval = nanmin(self.vals)
self.maxval = nanmax(self.vals)
self.model_changed = True
def loadrsf(file_name):
mat = m8r.Input('/quanta1/home/ruan/OceanTurb_share_Jan2019/%s.rsf' % file_name)
n1 = mat.int("n1")
n2 = mat.int("n2")
D = mat.read(shape=(n2,n1))
shot = int(file_name[9:])
return D, shot
def generate_rsf_data(model_name="marm.rsf", central_freq=central_freq, dt=dt, dx=const.dx,
nt=nt, sxbeg=sxbeg, gxbeg=gxbeg, szbeg=szbeg,
jsx=jsx, jgx=jgx, jdt=jdt,
logs_out="logs.rsf", shots_out="shots_cmp.rsf",
full_shots_out=None):
#get size of the model
model_orig = sf.Input(model_name)
Nx = model_orig.int("n2")
print(Nx)
ns = (Nx - 2*sxbeg)//jgx
ng = 2*(sxbeg-gxbeg)//jgx + 1
print(f"Total number of shots = {ns}")
t_start = time.time()
cmd((f"sfgenshots < {model_name} csdgather=y fm={central_freq} amp=1 dt={dt} ns={ns} ng={ng} nt={nt} "
f"sxbeg={sxbeg} chk=n szbeg=2 jsx={jgx} jsz=0 gxbeg={gxbeg} gzbeg={szbeg} jgx={jgx} jgz=0 > shots.rsf"))
print(f"Modeling time for {ns} shots = {time.time()-t_start}")
if full_shots_out != None:
cmd(f"sfcp < shots.rsf > {full_shots_out}")
# ## Analyze and filter the data set generated
# correct header and reduce sampling in time jdt (usually 4) times
cmd(f"sfput < shots.rsf d3={jgx*dx} | sfwindow j1={jdt} | sfbandpass flo=2 fhi=4 > shots_decimated.rsf")
cmd(f"sfrm shots.rsf")
# sort into cmp gathers and discard odd cmps and not full cmps
cmd(f"sfshot2cmp < shots_decimated.rsf half=n | sfwindow j3=2 min3={(-1.5*gxbeg+1.5*sxbeg)*dx} max3={(Nx-(2.5*sxbeg-.5*gxbeg))*dx} > {shots_out}")
cmd(f"sfrm shots_decimated.rsf")
# create the logs -- training outputs
cmd(f"sfwindow < {model_name} min2={(-gxbeg+2*sxbeg)*dx} j2={jsx} max2={(Nx-(2*sxbeg-gxbeg))*dx} > {logs_out}")
cmd(f"sfin < {logs_out}")
return 0
def __init__(self, filename):
super(SeisData, self).__init__()
self.model=m8r.Input(filename)
self.vals = self.model[:,:,:]
print "vals.shape=",self.vals.shape
for i in range(0,self.vals.shape[1]):
print "max(vals[:,%d,:])="%i,max(self.vals[:,i,:])
self.dim=len(self.vals.shape)
self.axis_start=self.read_axis_float_info("o")
print "self.axis_start=",self.axis_start
self.axis_delta=self.read_axis_float_info("d")
print "self.axis_delta=",self.axis_delta
self.axis_end=[]
for i in range(0,self.dim):
self.axis_end.append(self.axis_start[i]+
(self.vals.shape[i]-1)*self.axis_delta[i])
print "self.axis_end=",self.axis_end
print "compute min"
self.minval = nanmin(self.vals)
print "compute max"
self.maxval = nanmax(self.vals)
print "set model changed"
self.model_changed = True
print "leaving m8rInput"
def read_rsf_to_np(shots_rsf='shots_cmp_full.rsf', logs_rsf='logs_full.rsf',
n_offsets=None, j_log_z=jlogz):
shots_cmp = sf.Input(shots_rsf)
X_data = shots_cmp.read()
if n_offsets==None :
X_data = X_data[:,:(np.shape(X_data)[1] + 1) // 2,:]
X_data = np.expand_dims(X_data, axis=3)
X_size = np.shape(X_data)
logs = sf.Input(logs_rsf)
T_data = logs.read()
# decimate logs in vertical direction --2 times by default
T_data = resize(T_data, (np.shape(T_data)[0], np.shape(T_data)[1] // j_log_z))
T_size = np.shape(T_data)
print(T_size)
# ensure that the number of logs is equal to the number of CMPs
assert (X_size[0] == T_size[0])
return X_data, T_data
def m8rInput(self):
#model=m8r.Input('model.rsf')
# get files names from command line
filenames=[]
for parameter in sys.argv[1:]:
print "processing parameter",parameter
if parameter.find("=")==-1 :
print "no = in parameter",parameter,"must be a file name"
filenames.append(parameter)
if len(filenames)<1:
print "just to help me test, if there are no files in the list, "
print "I will append the file foldplot1.rsf"
filenames.append('foldplot1.rsf')
model=m8r.Input(filenames[0])
self.vals = model[:,:,:]
# this makes seg fault in nanmin self.vals = model[:,:,::-1]
npts_x, npts_y, npts_z = self.vals.shape
print "vals.shape=",self.vals.shape
self.min_x=model.float("o3")
self.min_y=model.float("o2")
self.min_z=model.float("o1")
print "min x,y,z=",self.min_x,self.min_y,self.min_z
dx=model.float("d3")
dy=model.float("d2")
dz=model.float("d1")
print "dx,dy,dz=",dx,dy,dz
self.max_x=self.min_x+dx*(npts_x-1)
self.max_y=self.min_y+dy*(npts_y-1)
self.max_z=self.min_z+dz*(npts_z-1)
print "compute linspace"
print "compute min"
self.minval = nanmin(self.vals)
print "compute max"
self.maxval = nanmax(self.vals)
print "set model changed"
self.model_changed = True
print "leaving m8rInput"
def __init__(self, filename):
super(SeisData, self).__init__()
self.model = m8r.Input(filename)
self.vals = self.model[:, :, :]
print "input file shape=", self.vals.shape
self.dim = len(self.vals.shape)
self.axis_start = self.read_axis_float_info("o")
print "self.axis_start=", self.axis_start
self.axis_delta = self.read_axis_float_info("d")
print "self.axis_delta=", self.axis_delta
self.axis_end = []
for i in range(0, self.dim):
self.axis_end.append(self.axis_start[i] +
(self.vals.shape[i] - 1) * self.axis_delta[i])
print "self.axis_end=", self.axis_end
print "compute min/max"
max_n_samples = 100
inc = ones(self.dim, dtype=int)
last = ones(self.dim, dtype=int)
for i in range(0, self.dim):
inc[i] = self.vals.shape[i] / 100
#print "self.vals.shape=", self.vals.shape ,"inc=",inc
if (inc[i] < 1):
inc[i] = 1
last[i] = (self.vals.shape[i] / inc[i] - 1) * inc[i]
#print "self.vals.shape=", self.vals.shape
#print "inc=",inc,"last=",last
subsetvals = self.vals[:last[0]:inc[0], :last[1]:inc[1], :last[2]:
inc[2]]
#print "subsetvals.shape=",subsetvals.shape
mymin = min(subsetvals)
mymax = max(subsetvals)
print "min/max", mymin, mymax
self.maxval = max([abs(mymin), mymax])
self.minval = -self.maxval
print "min=", self.minval, "max=", self.maxval
print "leaving m8rInput"
def __init__(self, filename):
super(SeisData, self).__init__()
self.model = m8r.Input(filename)
self.vals = self.model[:, :, :]
self.dim = len(self.vals.shape)
self.axis_start = self.read_axis_float_info("o")
print("self.axis_start=", self.axis_start)
self.axis_delta = self.read_axis_float_info("d")
print("self.axis_delta=", self.axis_delta)
self.axis_end = []
for i in range(0, self.dim):
self.axis_end.append(self.axis_start[i] +
(self.vals.shape[i] - 1) * self.axis_delta[i])
print("self.axis_end=", self.axis_end)
print("compute min/max")
max_n_samples = 100
inc = ones(self.dim, dtype=int)
last = ones(self.dim, dtype=int)
for i in range(0, self.dim):
inc[i] = self.vals.shape[i] / 100
print("self.vals.shape=", self.vals.shape, "inc=", inc)
if (inc[i] < 1):
inc[i] = 1
last[i] = (self.vals.shape[i] / inc[i] - 1) * inc[i]
print("self.vals.shape=", self.vals.shape)
print("inc=", inc, "last=", last)
subsetvals = self.vals[:last[0]:inc[0], :last[1]:inc[1], :last[2]:
inc[2]]
print("subsetvals.shape=", subsetvals.shape)
self.minval = min(subsetvals)
print("compute max")
self.maxval = max(subsetvals)
print("min=", self.minval)
print("max=", self.maxval)
print("leaving m8rInput")
self.c0 = -2.0*(self.c11+self.c12+self.c21+self.c22)
def apply(self,uin,uout):
n1,n2 = uin.shape
uout[2:n1-2,2:n2-2] = \
self.c11*(uin[1:n1-3,2:n2-2]+uin[3:n1-1,2:n2-2]) + \
self.c12*(uin[0:n1-4,2:n2-2]+uin[4:n1 ,2:n2-2]) + \
self.c21*(uin[2:n1-2,1:n2-3]+uin[2:n1-2,3:n2-1]) + \
self.c22*(uin[2:n1-2,0:n2-4]+uin[2:n1-2,4:n2 ]) + \
self.c0*uin[2:n1-2,2:n2-2]
par = m8r.Par()
# setup I/O files
Fr=m8r.Input() # source position
Fo=m8r.Output() # output wavefield
Fv=m8r.Input ("v") # velocity
Fw=m8r.Input ("wav") # source wavefield
# Read/Write axes
a1 = Fr.axis(1); n1 = a1['n']; d1 = a1['d']
a2 = Fr.axis(2); n2 = a2['n']; d2 = a2['d']
at = Fw.axis(1); nt = at['n']; dt = at['d']
ft = par.int('ft',0)
jt = par.int('jt',0)
Fo.put('n3',(nt-ft)/jt)
if a < treshold]) # No. of elements with 0 alpha
N3 = (N - N2) / 2 # No. of elements with nonzero alpha
N4 = (N + N2) / 2
# These next commands will taper alphas, so that no abrupt transition
# between zero and nonzero elements occur
window = np.kaiser(N - N2, 2)
alphas[:N3] *= window[N3:]
alphas[N4:] *= window[:N3]
cmap._lut[:, -1] = alphas
return cmap
if __name__ == "__main__":
par = m8r.Par()
inp = m8r.Input()
shape = inp.shape()
if len(shape) != 3:
sf_error("Must have 3 axes")
if inp.type != 'float':
sf_error("Only supports float")
bgf = par.string("bg",
None) # Background for animation. Zero if not supplied
if bgf:
bg = m8r.Input(bgf)
if bg.type != 'float':
sf_error("Only supports float")
bgshape = bg.shape()
if len(bgshape) != 2 or bgshape != shape[1:]:
sf_error(
"Background must have the same two last dimensions of input")
'''
# key imports
import m8r
import numpy as np
try:
import varitools as vt
except:
import rsf.user.varitools as vt
# the actual program...
par = m8r.Par()
# files
Fvel = m8r.Input()
Fsemb = m8r.Input("semb")
assert 'float' == Fsemb.type
assert 'float' == Fvel.type
# get axis sampling
o1,d1,n1 = vt.get_axis(Fsemb,1)
o2,d2,n2 = vt.get_axis(Fsemb,2)
o3,d3,n3 = vt.get_axis(Fsemb,3)
# get number of velocities
ov,dv,nv = vt.get_axis(Fvel,3)
# put in helpful arrays
# i do not think I want to have option to input data on stdin
#if not(os.isatty(file.fileno(sys.stdin))):
# filenames.append("in")
for parameter in sys.argv[1:]:
print("processing parameter", parameter)
if parameter.find("=") == -1:
print("no = in parameter")
filenames.append(parameter)
if len(filenames) < 1:
print("just to help me test, if there are no files in the list, I will")
print("append the file:")
print("/home/karl/m8r/madagascar-1.3/user/karl/model.rsf")
filenames.append('/home/karl/m8r/madagascar-1.3/user/karl/model.rsf')
print("list of file names:", filenames)
fin = {}
for filename in filenames:
fin[filename] = m8r.Input(filename)
nsubplot = 4
(n3, n2, n1) = fin[filename].shape()
for subplot in range(nsubplot):
plt.subplot(1, nsubplot + 1, subplot + 1)
plt.imshow(fin[filenames[0]][int(n3 * float(subplot) / nsubplot), :, :].T)
plt.show()
#!/usr/bin/env python
import sys
import numpy
import m8r
c0 = -30. / 12.
c1 = +16. / 12.
c2 = -1. / 12.
par = m8r.Par()
verb = par.bool("verb", False) # verbosity
# setup I/O files
Fw = m8r.Input()
Fv = m8r.Input("vel")
Fr = m8r.Input("ref")
Fo = m8r.Output()
# Read/Write axes
at = Fw.axis(1)
nt = at['n']
dt = at['d']
az = Fv.axis(1)
nz = az['n']
dz = az['d']
ax = Fv.axis(2)
nx = ax['n']
dx = ax['d']
Fo.putaxis(az, 1)
import numpy as np
import m8r
import pylops
from pylops.utils.seismicevents import makeaxis
from pylops.optimization.sparsity import *
mat = m8r.Input('dat_full-151.rsf')
n1 = mat.int("n1")
n2 = mat.int("n2")
D = mat.read(shape=(n2, n1))
D = D.T
nr, nt = D.shape
N = nt * nr
print(nr, nt)
# model parameters
par = {'ox': 0, 'dx': 10, 'nx': nr, 'ot': 0, 'dt': 0.0025, 'nt': nt}
taxis, t2, xaxis, y = makeaxis(par)
nx_mod = 1601
nz_mod = 801
dx_mod = 2.5
dx = 10
dz_mod = 2.5
nt_mod = 6001
dt_mod = 0.0005
dt = 0.0025
interval = 6
node = np.arange(0, nr, interval)
jitter = np.random.randint(interval, size=node.size - 1)
def generate_model(model_input=c.trmodel,
model_output="marm.rsf",
dx=c.dx,
stretch_X=1,
training_flag=False,
random_state_number=c.random_state_number,
distort_flag=True,
crop_flag=True,
verbose=False,
test_flag=False,
show_flag=False):
# downscale marmousi
#def rescale_to_dx(rsf_file_in, rsf_file_out, dx)
model_orig = sf.Input(model_input)
vel = model_orig.read()
if test_flag:
n_cut = int(((const.sxbeg + const.gxbeg) * const.dx) //
(model_orig.float("d1")))
vel = np.concatenate((vel[-n_cut:, :], np.flipud(vel), vel[:n_cut, :]),
axis=0)
else:
vel = np.concatenate((vel, np.flipud(vel), vel), axis=0)
if show_flag:
np.random.RandomState(random_state_number)
random.seed(random_state_number)
np.random.seed(random_state_number)
if crop_flag:
vel_log_res = vel
#vel_log_res = resize(vel_log_res[:,:], (np.shape(vel)[0]//2, np.shape(vel)[1]//2))
if verbose:
print(f"Random state number = {random_state_number}")
#vel = resize(vel_log_res, vel.shape)
l0 = randint(np.shape(vel)[0])
#print(f"l0={l0}")
h0 = min(l0 + np.shape(vel)[0] // 4 + randint(np.shape(vel)[0] // 2),
np.shape(vel)[0])
l1 = randint(np.shape(vel)[1] // 3)
h1 = min(l1 + np.shape(vel)[1] // 3 + randint(np.shape(vel)[1] // 2),
np.shape(vel)[1])
if verbose:
print(l0, l1, h0, h1)
vel_log_res = vel_log_res[l0:h0, l1:h1]
vel = resize(vel_log_res, vel.shape)
# we downscale
scale_factor = dx / model_orig.float("d1")
vel = resize(vel[:, :], (stretch_X * np.shape(vel)[0] // scale_factor,
np.shape(vel)[1] // scale_factor))
if verbose:
print(np.shape(vel))
print(f"Model downscaled {scale_factor} times to {dx} meter sampling")
if stretch_X != 1:
print(
f"Model stretched {stretch_X} times to {dx} meter sampling \n")
# we concatenate horizontally, this is confusing because of flipped axis in madagascar
vel = np.atleast_3d(vel)
if distort_flag:
vel = elastic_transform(vel,
alpha_deform,
sigma_deform,
v_dx=dx,
random_state_number=random_state_number)
vel = np.squeeze(vel)
if distort_flag:
vel_alpha = (0.8 + 0.4 * resize(np.random.rand(5, 10), vel.shape))
#print(vel_alpha)
vel *= vel_alpha
# add water
# vel = np.concatenate((1500*np.ones((vel.shape[0], 20)), vel),
# axis=1)
#vel = ndimage.median_filter(vel, size=(7,3))
#vel = 1500 * np.ones_like(vel)
if verbose:
print(f"Writing to {model_output}")
np_to_rsf(vel, model_output)
return vel
'''
# key imports
import m8r
import numpy as np
try:
import varitools as vt
except:
import rsf.user.varitools as vt
# the actual program...
par = m8r.Par()
# files
Fsemb = m8r.Input()
# semblance volume
Fvel = m8r.Input("vo")
# starting model
Fdsemb = m8r.Input("dsemb")
# partial derivative of semblance volume with respect to v
assert 'float' == Fsemb.type
assert 'float' == Fvel.type
assert 'float' == Fdsemb.type
# get axis sampling
o1, d1, n1 = vt.get_axis(Fsemb, 1)
o2, d2, n2 = vt.get_axis(Fsemb, 2)
o3, d3, n3 = vt.get_axis(Fsemb, 3)
#!/usr/bin/env python
import m8r
import matplotlib.pyplot as plt
model = m8r.Input('model.rsf')
model.grey(color='j', gainpanel='a', title='RSF').show()
plt.imshow(model[0, :, :])
plt.show()
#!/usr/bin/env python
import numpy
import m8r
import sys
if sys.version_info[0] > 2:
xrange = range
par = m8r.Par()
input = m8r.Input()
output = m8r.Output()
n1 = input.int("n1") # trace length
n2 = input.size(1) # number of traces
clip = par.float("clip")
trace = numpy.zeros(n1,'f')
for i2 in xrange(n2): # loop over traces
input.read(trace)
trace = numpy.clip(trace,-clip,clip)
output.write(trace)
def set_size(w, h, ax=None):
""" w, h: width, height in inches """
if not ax: ax = plt.gca()
l = ax.figure.subplotpars.left
r = ax.figure.subplotpars.right
t = ax.figure.subplotpars.top
b = ax.figure.subplotpars.bottom
figw = float(w) / (r - l)
figh = float(h) / (t - b)
return figw, figh
# ax.figure.set_size_inches(figw, figh)
if __name__ == "__main__":
inp = m8r.Input()
par = m8r.Par()
# n1 = inp.int("n1")
# n2 = inp.int("n2")
(n1, d1, o1, u1, l1) = read_axis(inp, 1)
(n2, d2, o2, u2, l2) = read_axis(inp, 2)
ymax = o1 + d1 * (n1 - 1)
xmax = o2 + d2 * (n2 - 1)
data = np.zeros([n2, n1], 'f')
inp.read(data)
inp.close()
savefile = par.string("savefile")
cmap = par.string("cmap", 'gray')
figx = par.float("figx", 3.66) # Figure x size in inches, actually 8.46 cm
#!/usr/bin/env python
import sys
import numpy
import m8r
# initialize
par = m8r.Par()
inp = m8r.Input()
out = m8r.Output()
oth = m8r.Input('other')
adj = par.bool('adj',False) # adjoint flag
if adj:
# input data, output filter
n1 = inp.int('n1')
n2 = inp.int('n2')
nf = par.int('nf') # filter size
out.put('n1',nf)
out.put('n2',1)
else:
# input filter, output data
nf = inp.int('n1')
n1 = oth.int('n1')
n2 = oth.int('n2')
out.put('n1',n1)
out.put('n2',n2)
def rsf_to_np(file_name):
f = sf.Input(file_name)
vel = f.read()
return vel
#!/usr/bin/env python
import numpy
from math import sqrt
import m8r
# initialize parameters
par = m8r.Par()
# input and output
vel = m8r.Input()
tim = m8r.Output()
# time axis from input
nt = vel.int('n1')
dt = vel.float('d1')
# offset axis from command line
nh = par.int('nh', 1) # number of offsets
dh = par.float('dh', 0.01) # offset sampling
h0 = par.float('h0', 0.0) # first offset
# get reflectors
nr = par.int('nr', 1) # number of reflectors
r = par.ints('r', nr)
type = par.string('type', 'hyperbolic')
# traveltime computation type
niter = par.int('niter', 10)
# maximum number of shooting iterations
