def get_datasets(filename1, filename2):
rsf_format = '.rsf' in filename1 and '.rsf' in filename2
bin_format = '.bin' in filename1 and '.bin' in filename2
if rsf_format:
file1 = rsf.Input(filename1)
file2 = rsf.Input(filename2)
data1 = file1.getalldata()
data2 = file2.getalldata()
elif bin_format:
top_dir = filename1.split('/')[0]
json_filename = os.path.join(top_dir, 'in_and_out', 'asofi3D.json')
params = read_asofi3d_json(json_filename)
TSNAP1, TSNAP2 = params['TSNAP1'], params['TSNAP2']
TSNAPINC = params['TSNAPINC']
nsnap = int(1 + np.floor((TSNAP2 - TSNAP1) / TSNAPINC))
NX, NY, NZ = params['NX'], params['NY'], params['NZ']
IDX, IDY, IDZ = params['IDX'], params['IDY'], params['IDZ']
data1 = np.fromfile(filename1, dtype=np.float32)
data2 = np.fromfile(filename2, dtype=np.float32)
data1.reshape((NY / IDY, NX / IDX, NZ / IDZ, nsnap))
data2.reshape((NY / IDY, NX / IDX, NZ / IDZ, nsnap))
else:
raise Exception('Cannot determine dataset format!')
return data1, data2
def read(self,
fre,
fim,
gather='all',
fsrc='src.txt',
frcv='rcv.txt',
ffreq='freq.txt',
inum=1):
#sfile='src.dat', rfile='rcv.dat', ffile='freq.dat'):
input_re = rsf.Input(fre)
input_im = rsf.Input(fim)
self.read_header(fre, fim, fsrc, frcv, ffreq)
tmp_re = np.zeros((self.srcs.n, self.rcvs.n), 'f')
tmp_im = np.zeros((self.srcs.n, self.rcvs.n), 'f')
if gather == 's':
isrc = inum
tmpd_real = np.zeros((self.freqs.n, self.rcvs.n), 'f')
tmpd_imag = np.zeros((self.freqs.n, self.rcvs.n), 'f')
for ifreq in range(self.freqs.n):
input_re.read(tmp_re)
input_im.read(tmp_im)
tmpd_real[ifreq, :] = tmp_re[isrc - 1, :]
tmpd_imag[ifreq, :] = tmp_im[isrc - 1, :]
elif gather == 'r':
ircv = inum
tmpd_real = np.zeros((self.freqs.n, self.srcs.n), 'f')
tmpd_imag = np.zeros((self.freqs.n, self.srcs.n), 'f')
for ifreq in range(self.freqs.n):
input_re.read(tmp_re)
input_im.read(tmp_im)
tmpd_real[ifreq, :] = tmp_re[:, ircv - 1]
tmpd_imag[ifreq, :] = tmp_im[:, ircv - 1]
elif gather == 'f':
ifreq = inum
tmpd_real = np.zeros((self.srcs.n, self.rcvs.n), 'f')
tmpd_imag = np.zeros((self.srcs.n, self.rcvs.n), 'f')
for i in range(ifreq):
input_re.read(tmpd_real)
input_im.read(tmpd_imag)
else:
tmpd_real = np.zeros((self.freqs.n, self.srcs.n, self.rcvs.n), 'f')
tmpd_imag = np.zeros((self.freqs.n, self.srcs.n, self.rcvs.n), 'f')
input_re.read(tmpd_real)
input_im.read(tmpd_imag)
self.d = tmpd_real + 1.0j * tmpd_imag
def read(self, input=None, f=None, fsrc=None, frcv=None):
if input is None:
input = rsf.Input(f)
self.read_header(input, fsrc=fsrc, frcv=frcv)
self.d = np.zeros((self.nsrc, self.nt, self.nrcv), 'f')
input.read(self.d)
input.close()
def read_header(self, input=None, f=None, fsrc=None, frcv=None):
if input is None:
input = rsf.Input(f)
self.nrcv = input.int('n1')
self.nc = input.int('n2')
self.nt = input.int('n3')
self.drcv = input.float('d1')
self.dc = input.float('d2')
self.dt = input.float('d3')
self.orcv = input.float('o1')
self.oc = input.float('o2')
self.ot = input.float('o3')
if get_dim(input) >= 4:
self.osrc = input.float('o4')
self.nsrc = input.int('n4')
self.dsrc = input.float('d4')
else:
self.nsrc = 1
self.osrc = 0.
self.dsrc = 1.
self.set_t()
# setup srcs and rcvs
if fsrc:
self.srcs = rsf_loc(fsrc)
else:
self.srcs = rn_loc(self.nsrc)
if frcv:
self.rcvs = rsf_loc(fsrc)
else:
self.rcvs = rn_loc(self.nrcv)
def read_rsf(self, finput):
try:
input = rsf.Input(finput)
except:
input = finput
self.get_header(input)
self.initialise(0.)
input.read(self.d)
def read(self, input=None, f=None):
if input is None:
input = rsf.Input(f)
self.read_header(input=input)
self.initiali1e(0.0)
input.read(self.d)
self.set_axis()
def read(self, input=None, f=None):
if input is None:
try:
input = rsf.Input(f)
except:
print("File %s doesn't exist" % f)
self.read_header(input=input)
self.d = np.zeros((self.nsrc, self.nt, self.nc, self.nrcv), 'f')
input.read(self.d)
def read_header(self, input=None, f=None):
if input is None:
input = rsf.Input(f)
self.nrcv = input.int('n1')
self.nsrc = input.int('n2')
self.drcv = input.float('d1')
self.dsrc = input.float('d2')
self.orcv = input.float('o1')
self.osrc = input.float('o2')
def read(self, input=None, f=None):
if input is None:
try:
input = rsf.Input(f)
except:
print("file %s does not exist" % f)
self.read_header(input=input)
input.read(self.d)
def read(self, input=None, f=None):
if input is None:
input = rsf.Input(f)
self.read_header(input=input)
print(self.nsrc, self.nt, self.nc, self.nrcv)
self.d = np.zeros((self.nsrc, self.nt, self.nc, self.nrcv), 'f')
input.read(self.d)
def rsf_loc(floc):
input = rsf.Input(floc)
n1 = input.int('n1')
n2 = input.int('n2')
loc = rn_loc(n=n2)
tmp = np.zeros((loc.n, 2), dtype=np.float32)
input.read(tmp)
loc.x = tmp[:, 0]
loc.z = tmp[:, 1]
return loc
def read_rsf(self,
input=None,
finput=None,
sfile='src.dat',
rfile='rcv.dat'):
if input is None:
input = rsf.Input(finput)
self.read_header(input=input, sfile=sfile, rfile=rfile)
self.data = np.zeros((self.nsrc, self.nrcv, self.nt), 'f')
input.read(self.data)
def read(self, input=None, f=None):
if input is None:
input = rsf.Input(f)
self.read_header(input)
self.d = np.zeros((self.nsrc, self.nrcv), 'f')
input.read(self.d)
self.d = np.ma.masked_equal(self.d, 0.)
if type(self.d.mask) is not np.ndarray:
if self.d.mask is False:
self.d.mask = np.zeros(0, dtype=np.bool)
else:
self.d.mask = np.zeros(1, dtype=np.bool)
def read_header(self,
fre,
fim,
fsrc='src.txt',
frcv='rcv.txt',
ffreq='freq.txt'):
# sfile='src.dat', rfile='rcv.dat', ffile='freq.dat'):
input_re = rsf.Input(fre)
input_im = rsf.Input(fim)
self.rcvs.n = input_re.int('n1')
self.srcs.n = input_re.int('n2')
self.rcvs.d = input_re.float('d1')
self.srcs.d = input_re.float('d2')
self.rcvs.o = input_re.float('o1')
self.srcs.o = input_re.float('o2')
if (get_dim(input_re) == 3):
self.freqs.n = input_re.int('n3')
self.freqs.d = input_re.float('d3')
self.freqs.o = input_re.float('o3')
else:
self.freqs.n = 1
self.freqs.d = 1.
self.freqs.o = 1.
if os.path.exists(fsrc):
self.srcs.read(fsrc)
else:
self.srcs.d = np.arange(self.srcs.n)
if os.path.exists(frcv):
self.rcvs.read(frcv)
else:
self.rcvs.d = np.arange(self.rcvs.n)
if os.path.exists(ffreq):
self.freqs.read(ffreq)
else:
self.freqs.d = np.arange(self.freqs.n)
def read(self, input=None, f=None):
if input is None:
input = rsf.Input(f)
self.niter = input.int('n1')
self.diter = input.float('d1')
self.oiter = input.float('o1')
if (input.int('n2')):
self.nblock = input.int('n2')
self.dblock = input.float('d2')
self.oblock = input.float('o2')
self.data = np.zeros((self.nblock, self.niter), 'f')
input.read(self.data)
self.set_axis()
def read_header(self, input=None, f=None):
if input is None:
input = rsf.Input(f)
self.nrcv = input.int('n1')
self.nc = input.int('n2')
self.nt = input.int('n3')
self.nsrc = input.int('n4')
self.drcv = input.float('d1')
self.dc = input.float('d2')
self.dt = input.float('d3')
self.dsrc = input.float('d4')
self.orcv = input.float('o1')
self.oc = input.float('o2')
self.ot = input.float('o3')
self.osrc = input.float('o4')
self.set_t()
def read_header(self, input=None, f=None):
if input is None:
input = rsf.Input(f)
self.n1 = input.int('n1')
self.n2 = input.int('n2')
self.n3 = input.int('n3')
self.d1 = input.float('d1')
self.d2 = input.float('d2')
self.d3 = input.float('d3')
self.o1 = input.float('o1')
self.o2 = input.float('o2')
self.o3 = input.float('o3')
self.nc = self.n3
self.dc = self.d3
self.oc = self.o3
self.nx = self.n2
self.dx = self.d2
self.ox = self.o2
self.nz = self.n1
self.dz = self.d1
self.oz = self.o1
self.set_t()
def read_header(self, input=None, f=None, fsrc=None, frcv=None):
if input is None:
input = rsf.Input(f)
self.nrcv = input.int('n1')
self.nt = input.int('n2')
self.nsrc = input.int('n3')
self.drcv = input.float('d1')
self.dt = input.float('d2')
self.dsrc = input.float('d3')
self.orcv = input.float('o1')
self.ot = input.float('o2')
self.osrc = input.float('o3')
self.t = set_t(self.ot, self.dt, self.nt)
# setup srcs and rcvs
if fsrc:
self.srcs = rsf_loc(fsrc)
else:
self.srcs = rn_loc(self.nsrc)
if frcv:
self.rcvs = rsf_loc(fsrc)
else:
self.rcvs = rn_loc(self.nrcv)
def read_header(self, input=None, f=None):
if input is None:
try:
input = rsf.Input(f)
except:
print("file %s does not exist" % f)
self.nz = input.int('n1')
self.nx = input.int('n2')
self.nc = input.int('n3')
self.nt = input.int('n4')
self.dz = input.float('d1')
self.dx = input.float('d2')
self.dc = input.float('d3')
self.dt = input.float('d4')
self.oz = input.float('o1')
self.ox = input.float('o2')
self.oc = input.float('o3')
self.ot = input.float('o4')
self.ntrace = self.nx * self.nz
self.x = np.arange(0, self.nx, dtype=np.float) * self.dx + self.ox
self.z = np.arange(0, self.nz, dtype=np.float) * self.dz + self.oz
self.initialize()
from __future__ import print_function
import rsf.api as rsf
import numpy as np
import scipy as sp
import matplotlib.pyplot as plt
fin = rsf.Input('/home/karl/m8r/madagascar-1.3/user/karl/model.rsf')
print("fin.shape()=", fin.shape())
print("list(fin.shape())=", list(fin.shape()))
print("(list(fin.shape())).reverse()=", (list(fin.shape())).reverse())
mylist = list(fin.shape())
mylist.reverse()
data = np.zeros(mylist, 'f')
print("data array shape=", data.shape)
print("\n")
fin.read(data)
print("data array shape=", data.shape)
print("data[0,:,:].shape=", data[0, :, :].shape)
# in python and c you index data[i3,i2,i1]. Shape need to be (n3,n2,n1),
# reverse from that it in fin.shape()
fin1 = rsf.Input('/home/karl/m8r/madagascar-1.3/user/karl/model.rsf')
data1 = np.zeros(fin1.shape(), 'f')
fin1.read(data1)
plt.subplot(121)
plt.imshow(data[0, :, :].T) # good left plot has shape reversed
#!/usr/bin/env python
'C-Wave Backus Averaging (See Marion et al., 1994)'
import sys
import numpy as np
import rsf.api as rsf
import string
import math as mt
# Inputs
par = rsf.Par()
slowness_name = par.string('slowness') # Slowness from Logs
rhob_name = par.string('density') # Density from Logs
depth = rsf.Input() # Depth from Logs
slow = rsf.Input(slowness_name)
rhob = rsf.Input(rhob_name)
ratio = par.float("ratio") # Percent of dom wavelength
peak_f = par.float("peak_f") # Dom wavelength
depthsample = par.float("depthsample") # Depth Sampling
depth_bkn = rsf.Output() # Output depth sampling
vel_bkn = rsf.Output('vel_bk') # Backus Avg. velocity
slow_bkn = rsf.Output('slow_bk') # Backus Avg. slowness
rhob_bkn = rsf.Output('rhob_bk') # Averaged density
assert 'float' == depth.type
assert 'float' == slow.type
assert 'float' == rhob.type
for i in range(1, 4):
nkey = 'n%d' % i
dkey = 'd%d' % i
okey = 'o%d' % i
self.dims[nkey] = RSFFile.int(nkey)
self.dims[dkey] = RSFFile.float(dkey)
self.dims[okey] = RSFFile.float(okey)
self.shape.append(RSFFile.int(nkey))
self.shape.reverse()
# end class def
par = rsf.Par()
fin = rsf.Input()
header = Header(fin)
data = numpy.zeros(header.shape, 'f')
fin.read(data)
mlab.pipeline.image_plane_widget(mlab.pipeline.scalar_field(data),
plane_orientation='x_axes',
slice_index=10)
mlab.pipeline.image_plane_widget(mlab.pipeline.scalar_field(data),
plane_orientation='y_axes',
slice_index=10)
mlab.pipeline.image_plane_widget(mlab.pipeline.scalar_field(data),
#!/usr/bin/env python
'''
1D dataset padding
Built for time-depth relationship manipulation. LSIM scan/pick is smooth intoducing non-real updates at top of pick.
'''
import sys
import numpy as np
import rsf.api as rsf
import string
import math as mt
par = rsf.Par()
loga = rsf.Input() # Input 1D dataset
assert 'float' == loga.type
sdepth = loga.int("n1")
log = np.zeros(sdepth, 'f')
loga.read(log)
loc = par.int("loc") # Location of value used to replace
assert loc
num = par.int("num") # Number of values to replace at beginning of dataset
assert num
log_eo = rsf.Output() # Output 1D dataset
log_e = np.empty(sdepth)
import rsf.api as rsf
try:
import numpy as np
except Exception, e:
print 'ERROR : need numpy'
sys.exit(1)
try:
from pylab import *
from matplotlib.colors import LogNorm
except Exception, e:
print 'ERROR : need numpy'
sys.exit(1)
pi = rsf.Input()
po = rsf.Output()
par = rsf.Par()
dim = pi.shape()
n1 = pi.int("n1")
o1 = pi.float("o1")
d1 = pi.float("d1")
n2 = pi.int("n2")
o2 = pi.float("o2")
d2 = pi.float("d2")
# x label
label1 = par.string("label1")
if label1 == None:
elif pDir == 'x':
zStart = 190
zStop = zStart
xStart = 469
xStop = 529
folder = project + part + freq + '/'
modelFolder = project + 'model/'
if not os.path.exists(save + part + freq + '/'):
os.makedirs(save + part + freq + '/')
dz = 10
dx = dz
fin = rsf.Input(modelFolder + 'rh.rsf')
[n, m] = fin.shape()
data = np.zeros([n, m], 'f')
fin.read(data)
rho = np.array(data.transpose())
rhoNorm = normalize(rho)
fin = rsf.Input(modelFolder + 'vp.rsf')
fin.read(data)
vp = np.array(data.transpose())
vpNorm = normalize(vp)
fin = rsf.Input(modelFolder + 'vs.rsf')
fin.read(data)
vs = np.array(data.transpose())
vsNorm = normalize(vs)
def read_header(self, fre,
sfile = 'src.dat', rfile = 'rcv.dat', ffile = 'freq.dat'):
self.input = rsf.Input(fre)
self.nrcv = self.input.int('n1')
self.nsrc = self.input.int('n2')
self.drcv = self.input.float('d1')
self.dsrc = self.input.float('d2')
self.orcv = self.input.float('o1')
self.osrc = self.input.float('o2')
if (get_dim(self.input) >= 3):
self.nfreq = self.input.int('n3')
self.dfreq = self.input.float('d3')
self.ofreq = self.input.float('o3')
else:
self.nfreq = 1
self.dfreq = 1.
self.ofreq = 1.
if (get_dim(self.input) >= 4):
self.niter = self.input.int('n4')
self.diter = self.input.float('d4')
self.oiter = self.input.float('o4')
else:
self.niter = 1
self.diter = 1.
self.oiter = 1.
# define axis
if os.path.isfile(sfile):
self.srcx = np.fromfile( sfile, sep = ' ', count = self.nsrc * 2
).reshape( [self.nsrc, 2] )[:, 0]
self.srcz = np.fromfile( sfile, sep = ' ', count = self.nsrc * 2
).reshape( [self.nsrc, 2] )[:, 1]
else:
self.srcx = np.arange( 0, self.nsrc, dtype = 'f' )
self.srcz = np.arange( 0, self.nsrc, dtype = 'f' )
if os.path.isfile(rfile):
self.rcvx = np.fromfile( rfile, sep = ' ', count = self.nrcv * 2
).reshape( [self.nrcv, 2] )[:, 0]
self.rcvz = np.fromfile( rfile, sep = ' ', count = self.nrcv * 2
).reshape( [self.nrcv, 2] )[:, 1]
else:
self.rcvx=np.arange(0., self.nrcv, dtype = 'f')
self.rcvz=np.arange(0., self.nrcv, dtype = 'f')
if os.path.isfile(ffile):
self.freq = np.fromfile( ffile, sep=' ', count = self.nfreq + 1
)[ 1 : ( self.nfreq + 1)]
else :
self.freq = ( np.arange(0, self.nfreq, dtype = 'f' ) * self.dfreq
+ self.ofreq )
self.iter = np.arange(0, self.niter, dtype = 'f')
try :
self.srcx = self.srcx * self.scale
self.srcz = self.srcz * self.scale
self.rcvx = self.rcvx * self.scale
self.rcvz = self.rcvz * self.scale
except:
print 'no scaling for axis'
import rsf.api as rsf
import string
import math as mt
par = rsf.Par()
depth_name = par.string('depth')
par = rsf.Par()
log1_name = par.string('log1')
par = rsf.Par()
log2_name = par.string('log2')
par = rsf.Par()
log3_name = par.string('log3')
par = rsf.Par()
log4_name = par.string('log4')
logrefa = rsf.Input() # Reference well log
deptha = rsf.Input(depth_name) # Depth information
log1a = rsf.Input(log1_name) # Well log 1
log2a = rsf.Input(log2_name) # Well log 2
log3a = rsf.Input(log3_name) # Well log 3
log4a = rsf.Input(log4_name) # Well log 4
assert 'float' == logrefa.type
assert 'float' == deptha.type
assert 'float' == log1a.type
assert 'float' == log2a.type
assert 'float' == log3a.type
assert 'float' == log4a.type
sdepth = deptha.int("n1")
'''
Hard constraint 2D map
For use with LSIM if a specific alignment location is desired.
Use with reference and real datasets and scale LSIM scan by output
'''
import sys
import numpy as np
import rsf.api as rsf
import string
import math as mt
# Inputs
par = rsf.Par()
logrefa = rsf.Input() # Input 1D data
assert 'float' == logrefa.type
sdepth = logrefa.int("n1")
sd = logrefa.float("d1")
so = logrefa.float("o1")
logref = np.zeros(sdepth, 'f')
logrefa.read(logref)
num = par.float("value") # Location of hard constraint
window = par.int("wind") # Number of samples of hard constraint
assert window
#!/usr/bin/env python
'''
find max value in a file
'''
from __future__ import print_function
import rsf.api as rsf
import numpy as np
import sys
par = rsf.Par()
verb = par.bool('verb', False) # verbosity flag
Fin = rsf.Input() # input file
n1 = Fin.int("n1")
nn = Fin.size(1)
# number of traces
din = np.zeros(n1, 'f')
Fou = rsf.Output() # output file
Fou.put("n1", 1)
Fou.put("o1", 0)
Fou.put('d1', 1)
Fou.put("n2", 1)
Fou.put("n3", 1)
Fou.put("n4", 1)
dou = np.zeros(1, 'f')
mymax = 0
for i in range(nn):
Correlation operator w/ adjoint
wfl [file] : is taken from stdin
opr [file] : is taken from "opr"
Requires both files to have the same dimensions
'''
import rsf.api as rsf
import numpy as np
import sys
par = rsf.Par()
verb = par.bool('verb',False) # verbosity flag
adj = par.bool( 'adj',False) # adjoint flag
# Operator
Fopr = rsf.Input("opr")
nt = Fopr.int ("n1")
ot = Fopr.float("o1")
dt = Fopr.float("d1")
lt = Fopr.string("label1")
ut = Fopr.string("unit1")
nn = Fopr.size(1)*Fopr.size(2)*Fopr.size(3) # number of traces
opr = np.zeros(nt,'f') # allocate opr array
# ------------------------------------------------------------
# setup output
if adj==1:
Fcor = rsf.Input() # input cor
