def write_header(self, fre, fim): self.outputre = rsf.Output(fre) self.outputim = rsf.Output(fim) self.outputre.put('n1', self.rcvs.n) self.outputre.put('n2', self.srcs.n) self.outputre.put('n3', self.freqs.n) self.outputre.put('d1', self.rcvs.d) self.outputre.put('d2', self.srcs.d) if self.freqs.n > 1: self.outputre.put('d3', (self.freqs.d[1] - self.freqs.d[0])) self.outputim.put('d3', (self.freqs.d[1] - self.freqs.d[0])) else: self.outputre.put('d3', self.freqs.d[0]) self.outputim.put('d3', self.freqs.d[0]) self.outputre.put('o1', self.rcvs.o) self.outputre.put('o2', self.srcs.o) self.outputre.put('o3', self.freqs.d[0]) self.outputim.put('n1', self.rcvs.n) self.outputim.put('n2', self.srcs.n) #self.outputim.put('n3',self.freqs.n) self.outputim.put('d1', self.rcvs.d) self.outputim.put('d2', self.srcs.d) self.outputim.put('d3', self.freqs.d) self.outputim.put('o1', self.rcvs.o) self.outputim.put('o2', self.srcs.o) self.outputim.put('o3', self.freqs.d[0])
def write(self, output=None, f=None): #print('hehe') if output is None: output = rsf.Output(f) #print('hehe 2') self.write_header(output) #print('hehe 3') output.write(np.float32(self.d)) output.close()
def write(self, output=None, f=None): if output is None: output = rsf.Output(f) output.put('n1', self.nt) output.put('n2', self.nrcv) output.put('n3', self.nsrc) output.put('d1', self.dt) output.put('d2', self.drcv) output.put('d3', self.dsrc) output.put('o1', self.ot) output.put('o2', self.orcv) output.put('o3', self.osrc) output.write(np.float32(self.d)) output.close()
def write_header(self,fre): self.output=rsf.Output(fre) self.output.put('n1',self.nrcv) self.output.put('n2',self.nsrc) self.output.put('n3',self.nfreq) self.output.put('n4',self.niter) self.output.put('d1',self.drcv) self.output.put('d2',self.dsrc) self.output.put('d3',self.dfreq) self.output.put('d4',self.diter) self.output.put('o1',self.orcv) self.output.put('o2',self.osrc) self.output.put('o3',self.ofreq) self.output.put('o4',self.diter)
def write_header(self, output=None, f=None): if output is None: output = rsf.Output(f) output.put('n1', self.nrcv) output.put('n2', self.nc) output.put('n3', self.nt) output.put('n4', self.nsrc) output.put('d1', self.drcv) output.put('d2', self.dc) output.put('d3', self.dt) output.put('d4', self.dsrc) output.put('o1', self.orcv) output.put('o2', self.oc) output.put('o3', self.ot) output.put('o4', self.osrc)
def write(self, output=None, f=None): #print('w1', f) if output is None: output = rsf.Output(f) #print('w2') output.put('n1', self.n1) output.put('n2', self.n2) output.put('n3', self.n3) output.put('d1', self.d1) output.put('d2', self.d2) output.put('d3', self.d3) output.put('o1', self.o1) output.put('o2', self.o2) output.put('o3', self.o3) #print('w3') output.write(self.d.astype(np.float32)) output.close()
def write_rsf(self, foutput): try: output = rsf.Output(foutput) except: output = foutput output.put('n1', self.nt) output.put('n2', self.nc) output.put('n3', self.nrcv) output.put('n4', self.nsrc) output.put('d1', self.dt) output.put('d2', self.dc) output.put('d3', self.drcv) output.put('d4', self.dsrc) output.put('o1', self.ot) output.put('o2', self.oc) output.put('o3', self.orcv) output.put('o4', self.osrc) output.write(np.float32(self.d)) output.close()
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 nc = Fcor.int("n1") ncor = (nc-1)/2 Fwfl = rsf.Output() # output wfl Fwfl.put("n1",nt) Fwfl.put("o1",ot) Fwfl.put('d1',dt) Fwfl.put('label1',lt) Fwfl.put('unit1',ut) else: Fwfl = rsf.Input() # input wfl ncor = par.int("ncor",100) nc=2*ncor+1 # number of correlation lags Fcor = rsf.Output() # output cor Fcor.put("n1",2*ncor+1) Fcor.put("o1", -ncor*dt)
oz = par.float("oz") dz = par.float("dz") vel = par.float("vel", 1.0) cx = par.float("cx", 1.0) cy = par.float("cy", 1.0) cz = par.float("cz", 1.0) if verb: print >> sys.stderr, 't', nt, ot, dt, vel print >> sys.stderr, 'x', nx, ox, dx, cx print >> sys.stderr, 'y', ny, oy, dy, cy print >> sys.stderr, 'z', nz, oz, dz, cz # ------------------------------------------------------------ Fdat = rsf.Output() Fdat.put("n1", nt) Fdat.put("o1", ot) Fdat.put('d1', dt) Fdat.put("n2", nx) Fdat.put("o2", ox) Fdat.put('d2', dx) Fdat.put("n3", ny) Fdat.put("o3", oy) Fdat.put('d3', dy) Fdat.put("n4", nz) Fdat.put("o4", oz) Fdat.put('d4', dz) dat = np.zeros(nt, 'f')
try: import rsf.api as rsf import numpy import scipy except Exception, e: print \ '''ERROR: NEED PYTHON API, NUMPY, SCIPY ''' sys.exit(1) # Initialize RSF command line parser par = rsf.Par() # Read command line variables # Declare input and outputs fin = rsf.Input() # no argument means stdin fout = rsf.Output() # no argument means stdout # Declare optional inputs/outputs vectors = par.bool("vectors", False) # Output singular vectors? if vectors: left = par.string("left") # File to store left singular vectors if not left: sys.stderr.write('Need left=\n') sys.exit(2) right = par.string("right") # File to store right singular vectors if not right: sys.stderr.write('Need right=\n') sys.exit(2) lout = rsf.Output(left) # left singular vectors rout = rsf.Output(right) # right singular vectors
def dip_lop(n1, n2, p0, c, iter, eta): p=p0 for it in range(iter): for i2 in range(n2): for i1 in range(n1): rr=polyval(c[:,i2,i1],p[i2,i1]) dd=polyval(polyder(c[:,i2,i1]),p[i2,i1]) na=(rr*rr+dd*dd)*eta*sign(dd) # na=(abs(rr)+abs(dd))*eta*sign(dd) dp=rr/(dd+na) p[i2,i1]=p[i2,i1]-0.5*dp return p par=rsf.Par() input=rsf.Input() dip=rsf.Output() coef=rsf.Output("coef") pf=rsf.Output("pf") nf=par.int("nf",1) iter=par.int("iter",5) eta=par.float("eta",0.05) n1=input.int("n1") n2=input.int("n2") n3=2*nf+1 pf.put("n3",2*nf+1) dip.put("n3",2*nf) dip.put("n2",n2-1) coef.put("n3",n3) coef.put("n2",n2-1)
ldepth = log1a.int("n1") dlt = logrefa.float("d1") olt = logrefa.float("o1") logref = np.zeros(sdepth, 'f') log1 = np.zeros(ldepth, 'f') logrefa.read(logref) log1a.read(log1) minsamp = 0 maxs = sdepth - 1 if (logref[0] == 0): for i in range(maxs): if ((logref[i] != 0) & (logref[i + 1] != 0)): break if ((logref[i] == 0) & (logref[i + 1] != 0)): minsamp = i + 1 break log1_co = rsf.Output() if (minsamp != 0): log1_co.put('o1', minsamp * dlt + olt) log1_co.put('n1', ldepth) log1_co.write(np.array(log1))
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) for i in range(sdepth): if (i < num): log_e[i] = log[loc] else: log_e[i] = log[i] log_eo.write(np.array(log_e))
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA from __future__ import print_function import sys try: from numpy import * import rsf.api as rsf except Exception as e: print('ERROR : need numpy') sys.exit(1) par = rsf.Par() pi = rsf.Input() pi2 = rsf.Input("pi2") po = rsf.Output() po2 = rsf.Output("po2") nn = pi.shape() nd = len(nn) axis = par.int("axis", 2) if axis > nd: sys.stderr.write('axis=%d greater than nd=%d' % (axis, nd)) #n2=nn[-axis] seed = par.int("seed") #inv=par.bool("inv", False) n1 = pi.int("n1") n2 = pi.int("n2") #n3 = pi.int("n3")
logref_c = np.zeros(maxsamp - minsamp + 1) depth_c = np.zeros(maxsamp - minsamp + 1) log1_c = np.zeros(maxsamp - minsamp + 1) log2_c = np.zeros(maxsamp - minsamp + 1) log3_c = np.zeros(maxsamp - minsamp + 1) log4_c = np.zeros(maxsamp - minsamp + 1) for i in range(maxsamp - minsamp + 1): logref_c[i] = logref[minsamp + i] depth_c[i] = depth[minsamp + i] log1_c[i] = log1[minsamp + i] log2_c[i] = log2[minsamp + i] log3_c[i] = log3[minsamp + i] log4_c[i] = log4[minsamp + i] logref_co = rsf.Output() # Output reference well log depth_co = rsf.Output('depth_c') # Output depth information log1_co = rsf.Output('log1_c') # Output clipped well log 1 log2_co = rsf.Output('log2_c') # Output clipped well log 2 log3_co = rsf.Output('log3_c') # Output clipped well log 3 log4_co = rsf.Output('log4_c') # Output clipped well log 4 logref_co.put('n1', maxsamp - minsamp + 1) depth_co.put('n1', maxsamp - minsamp + 1) log1_co.put('n1', maxsamp - minsamp + 1) log2_co.put('n1', maxsamp - minsamp + 1) log3_co.put('n1', maxsamp - minsamp + 1) log4_co.put('n1', maxsamp - minsamp + 1) logref_co.write(np.array(logref_c)) depth_co.write(np.array(depth_c))
if not da == db: print('input files must have the same sampling interval', file=sys.stderr) sys.exit(1) # ------------------------------------------------------------ # command line params norm = par.bool("norm",False) # normalize output nc = par.int("nc",100) # number of correlation lags if nc > na or nc > nb: nc = min(na-1,nb-1) # ------------------------------------------------------------ # output file Fc = rsf.Output() Fc.put("n1", nc*2+1) Fc.put("o1",-nc*da) Fc.put('d1', da) # ------------------------------------------------------------ # center sample of the correlation center = (na+nb-1)/2 - (na-nb)*0.5 l1 = center-nc l2 = center+nc+1 # ------------------------------------------------------------ n2 = Fa.size(1) # number of traces of input file for i2 in range(n2):
import numpy as np import rsf.api as rsf import string import math as mt par = rsf.Par() loga = rsf.Input() # Input well log assert 'float' == loga.type sdepth = loga.int("n1") olog = loga.float("o1") log = np.zeros(sdepth, 'f') loga.read(log) log_eo = rsf.Output() # Output well log switch = par.int( "switch" ) # (0 = Two-sided axis extension by first and last non-zero sample in dataset); (2 = Two-sided axis reduction); (3 = Matches starting value and number of samples between input and reference well log); (else = pad data to dataset size by first and last nonzero sample); (4 = Testing) if ((switch == 0) | (switch == 2) | (switch == 4)): num = par.int("val") # Sample manipulation (switch=0/2) assert num if (switch == 3): reflog = par.string('reflog') # Reference log (switch=3) refa = rsf.Input(reflog) assert 'float' == refa.type oref = refa.float("o1") nref = refa.int("n1")
# You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA import rsf.api as sf import numpy as np try: # Give precedence to local version from hegilles import jitter except: # Use distributed version from rsf.user.hegilles import jitter par = sf.Par() input = sf.Input() output = sf.Output() n1 = input.int("n1") n2 = input.int("n2") ni = input.size(2) assert ni == 1, "sfjitter needs 2D input" perc = par.float("perc", .75) # percentage of traces to remove assert (perc > 0 and perc < 1), "perc should be between 0 and 1" jit = par.float("jit", 1 / (1 - perc)) # maximum gap factor seed = par.int("seed", np.random.randn()) # seed for random number generator output.put("n1", n2) output.put("n2", 1)
"W2": 0.1 * randn(units), "b2": np.zeros(shape=1) } return params # Get input parameters and 'source' files. These are RSF objects that works as # pointers to the actual data/file. par_obj = rsf.Par() x_train_obj = rsf.Input() # first input as default y_train_obj = rsf.Input('ytrain') x_val_obj = rsf.Input('xval') y_val_obj = rsf.Input('yval') # Assign output 'target' files. loss_train_obj = rsf.Output() # first output as default loss_val_obj = rsf.Output('lossval') # Parse parameter values from input object. num_epochs = par_obj.int('nepochs') learning_rate = par_obj.float('lr') hidden_units = par_obj.int('hidden') # number of hidden units # Get size of the input arrays and load them. (Initialize + Read) # Initialize numpy arrays for training data. n1 = x_train_obj.int('n1') # for x_train, n1==data sample length n2 = x_train_obj.int('n2') # for x_train, n2==number of features x_train = np.zeros((n2,n1), np.single) # shape==(nfeature x ndata) y_train = np.zeros((1,n1), np.single) # shape==(1 x ndata) # Similar for val data. n1 = x_val_obj.int('n1')
u3 = zeros((n2, n3), 'f') wt1.read(u3) u3 = numpy.transpose(u3, (1, 0)) u3.astype('float64') u4 = zeros((n3), 'f') bs1.read(u4) u4.astype('float64') u5 = zeros((n3), 'f') wt2.read(u5) u5.astype('float64') u6 = zeros((1), 'f') bs2.read(u6) u6.astype('float64') loss = rsf.Output() wt1out = rsf.Output("weight1out") wt2out = rsf.Output("weight2out") bs1out = rsf.Output("bias1out") bs2out = rsf.Output("bias2out") valloss = rsf.Output("valloss") data = list(zip(u1, u2)) data_val = list(zip(u1val, u2val)) loss_history, loss_val_history = [], [] vw1 = numpy.zeros_like(u3) vb1 = numpy.zeros_like(u4) vw2 = numpy.zeros_like(u5) vb2 = numpy.zeros_like(u6)
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): Fin.read(din) for i1 in range(n1): if abs(din[i1]) > abs(mymax):
Fwfl.read(wfl) # read wfl array # ------------------------------------------------------------ ntlag = par.int("ntlag",100) nxlag = par.int("nxlag",0) nylag = par.int("nylag",0) nzlag = par.int("nzlag",0) nct=2*ntlag+1; oct=-ntlag*dt; dct=dt ncx=2*nxlag+1; ocx=-nxlag*dx; dcx=dx ncy=2*nylag+1; ocy=-nylag*dy; dcy=dy ncz=2*nzlag+1; ocz=-nzlag*dx; dcz=dz # ------------------------------------------------------------ Fcor = rsf.Output() # output oriented cor Fcor.put("n1",nct); Fcor.put("o1",oct); Fcor.put('d1',dct) Fcor.put("n2",ncx); Fcor.put("o2",ocx); Fcor.put('d2',dcx) Fcor.put("n3",ncy); Fcor.put("o3",ocy); Fcor.put('d3',dcy) Fcor.put("n4",ncz); Fcor.put("o4",ocz); Fcor.put('d4',dcz) cor = np.zeros(2*nt-1,'f') # ------------------------------------------------------------ for icz in range(-nzlag,+nzlag+1): for icy in range(-nylag,+nylag+1): for icx in range(-nxlag,+nxlag+1): cor = np.correlate(wfl[izmid-icz,iymid-icy,izmid-icz,:],
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 out = np.zeros(sdepth) loc = (num - so) / sd if ((loc < sdepth - window) & (loc > (window - 1))): for i in range(window): out[loc - i] = 1 out[loc + i] = 1 logref_co = rsf.Output() logref_co.write(np.array(out)) # Output 1D data
logrefa = rsf.Input() # Input 1D dataset assert 'float' == logrefa.type sdepth = logrefa.int("n1") logref = np.zeros(sdepth, 'f') logrefa.read(logref) min = 0 max = 0 out = np.zeros(sdepth) for i in range(sdepth): out[i] = logref[i] for i in range(sdepth): if (out[i] == 0): min = i - 1 for j in range(sdepth - 1 - i): if (logref[i + j] != 0): max = i + j break for k in range(max - min): out[min + k] = logref[min] + (logref[max] - logref[min]) * k / (max - min) logref_co = rsf.Output() # Output 1D dataset logref_co.write(np.array(out))
## GNU General Public License for more details. ## ## You should have received a copy of the GNU General Public License ## along with this program; if not, write to the Free Software ## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA try: from numpy import * import rsf.api as rsf except Exception, e: import sys print('ERROR : need numpy') sys.exit(1) par = rsf.Par() output = rsf.Output() n1 = par.int("n1", 500) o1 = par.float("o1", -250) d1 = par.float("d1", 1) n2 = par.int("n2", 500) o2 = par.float("o2", -250) d2 = par.float("d2", 1) f = par.float("f", 0.05) # frequency (circles per sampling interval) df = par.float("df", 0.0) # chirp frequceny shift a = par.float("a", 0.0) # amplitude attenuation output.put("n1", n1)
#!/usr/bin/env python2 # coding:utf-8 """ Generate a spike file according backgroud density/velocity model """ import numpy as np import rsf.api as rsf par = rsf.Par() inp = rsf.Input() # backgroud density/velocity model spk = rsf.Input("spk") # coordinates of spikes out = rsf.Output() # Output spikes model assert inp.type == 'float', "Need float input!" n1 = inp.int("n1") n2 = inp.size(1) delta = par.float("delta") # perturbation of backgroud assert delta, "Need delta=" den = np.zeros((n2, n1), dtype=np.float32) inp.read(den) # read in backgroud density file spikes = np.zeros_like(den) spk.read(spikes)
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: label1 = pi.string("label1")
def write(self, output=None, f=None): if output is None: output = rsf.Output(f) self.write_header(output) output.write(np.float32(self.d)) output.close()
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 sdepth = depth.int("n1") sslow = slow.int("n1") srhob = rhob.int("n1") assert sdepth == sslow assert sdepth == srhob assert sslow == srhob
import numpy as np import rsf.api as rsf import string import math as mt # Inputs par = rsf.Par() cubea = rsf.Input() # Seismic Cube (Used for size of output) assert 'float' == cubea.type t_dim = cubea.int("n1") xl_dim = cubea.int("n2") il_dim = cubea.int("n3") rbf_out = rsf.Output() # Output RBF cube cube = cubea.read() xl_pos = par.int("xl") # n2 location of source il_pos = par.int("il") # n3 location of source eps = par.float("eps") # Scalar factor bound = par.int("boundary") # Scalar factor if (bound == 1): otherdata = par.string('other') # Boundary map othera = rsf.Input(otherdata) assert 'float' == othera.type other = othera.read()