Documentation:system/seismic
Jump to navigation
Jump to search
Contents
- 1 sfaastack
- 2 sfagmig
- 3 sfai2refl
- 4 sfavo
- 5 sfbeamspray
- 6 sfc2r
- 7 sfcascade
- 8 sfcell2
- 9 sfcell3
- 10 sfcgscan
- 11 sfcmp2shot
- 12 sfconstfdmig2
- 13 sfcos2ang
- 14 sfdepth2time
- 15 sfdiffoc
- 16 sfdiffraction
- 17 sfdimag
- 18 sfdmo
- 19 sfdsr
- 20 sfdsr2
- 21 sfenvelope
- 22 sffincon
- 23 sffindmo
- 24 sffinstack
- 25 sffkamo
- 26 sffkdmo
- 27 sffold
- 28 sffourvc
- 29 sffourvc0
- 30 sffourvc2
- 31 sffreqint
- 32 sffreqlet
- 33 sfgazdag
- 34 sfhalfint
- 35 sfheaderattr
- 36 sfheadermath
- 37 sfhwt2d
- 38 sfhwtex
- 39 sfinfill
- 40 sfinmo
- 41 sfinmo3
- 42 sfintbin
- 43 sfintbin3
- 44 sfisin2ang
- 45 sfitaupmo
- 46 sfitaupmo2
- 47 sfitaupmo3
- 48 sfitxmo
- 49 sfiwarp
- 50 sfiwarp2
- 51 sfiwarp3
- 52 sfkirchinv
- 53 sfkirchnew
- 54 sfkirmod
- 55 sfkirmod3
- 56 sflinsincos
- 57 sfmap2coh
- 58 sfmigsteep3
- 59 sfmodrefl
- 60 sfmodrefl2
- 61 sfmodrefl3
- 62 sfmoveout
- 63 sfnmo
- 64 sfnmo3
- 65 sfnmov
- 66 sfnmow
- 67 sfnmow_adj
- 68 sfovc
- 69 sfoway1
- 70 sfpmig
- 71 sfpnmo
- 72 sfpnmo3d
- 73 sfpp2psang
- 74 sfpp2psang2
- 75 sfpp2pstsic
- 76 sfpreconstkirch
- 77 sfprestolt
- 78 sfptaupmo
- 79 sfptaupmo3
- 80 sfptaupmoVTI
- 81 sfpveltran
- 82 sfpveltran3
- 83 sfpveltranVTI
- 84 sfpyramid
- 85 sfradial
- 86 sfradial2
- 87 sfradon
- 88 sfrandrefl
- 89 sfrays2
- 90 sfrays2a
- 91 sfrays3
- 92 sfrefer
- 93 sfricker
- 94 sfricker1
- 95 sfricker2
- 96 sfrweab
- 97 sfrwesrmig
- 98 sfrwezomig
- 99 sfs2ofz
- 100 sfs2ofz2
- 101 sfsegyheader
- 102 sfsegyread
- 103 sfsegywrite
- 104 sfshifts
- 105 sfshoot2
- 106 sfshot2cmp
- 107 sfshotconstkirch
- 108 sfshotholes
- 109 sfshotprop
- 110 sfsin
- 111 sfslant
- 112 sfsrmva
- 113 sfsrsyn
- 114 sfsstep2
- 115 sfstolt
- 116 sfstolt2
- 117 sfstoltstretch
- 118 sfstretch
- 119 sftan2ang
- 120 sftaupmo
- 121 sftime2depth
- 122 sftlagtoang2d
- 123 sftshift
- 124 sftxpnmo
- 125 sftxpscan
- 126 sfvelmod
- 127 sfveltran
- 128 sfvoft
- 129 sfvofz
- 130 sfvscan
- 131 sfxlagtoang2d
- 132 sfzoeppritz
- 133 sfzomig
- 134 sfzomva
sfaastack
Stack with antialiasing | |||
---|---|---|---|
sfaastack < inp.rsf > out.rsf adj=n inv=n n2=15 n2=1 vel=1.5 antialias=1. box=n | |||
bool | adj=n | [y/n] | adjoint flag |
float | antialias=1. | antialiasing | |
bool | box=n | [y/n] | box antialiasing |
bool | inv=n | [y/n] | inverse flag |
int | n2=1 | ||
float | vel=1.5 | velocity |
sfagmig
Angle-gather constant-velocity time migration. | |||
---|---|---|---|
sfagmig < in.rsf > out.rsf vel= ng= dg= g0= na=nx a=80. | |||
float | a=80. | maximum dip angle | |
float | dg= | reflection angle sampling | |
float | g0= | reflection angle origin | |
int | na=nx | number of dip angles | |
int | ng= | number of reflection angles | |
float | vel= | velocity |
sfai2refl
1-D convolution modeling. | |||
---|---|---|---|
sfai2refl < ai.rsf > mod.rsf |
sfavo
Compute intercept and gradient by least squares. | |||
---|---|---|---|
sfavo < cmp.rsf > avo.rsf offset=offset.rsf half=y | |||
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
string | offset= | auxiliary input file name |
sfbeamspray
2-D beam spraying. | |||
---|---|---|---|
sfbeamspray < in.rsf dip=dip.rsf cur=cur.rsf > out.rsf rect=3 type= | |||
file | cur= | auxiliary input file name | |
file | dip= | auxiliary input file name | |
int | rect=3 | smoothing radius | |
string | type= | beam type |
sfc2r
Cartesian-Coordinates to Riemannian-Coordinates interpolation | |||
---|---|---|---|
sfc2r < Fi.rsf rays=Fr.rsf > Fo.rsf verb=n adj=n linear=y a2n=1 a2o=0. a2d=1. a1n=1 a1o=0. a1d=1. | |||
float | a1d=1. | ||
int | a1n=1 | ||
float | a1o=0. | ||
float | a2d=1. | ||
int | a2n=1 | ||
float | a2o=0. | ||
bool | adj=n | [y/n] | |
bool | linear=y | [y/n] | |
file | rays= | auxiliary input file name | |
bool | verb=n | [y/n] |
sfcascade
Velocity partitioning for cascaded migrations. | |||
---|---|---|---|
sfcascade < in.rsf > out.rsf ntcut= tcut= ncut=1 | |||
int | ncut=1 | number of cuts | |
ints | ntcut= | [ncut] | |
floats | tcut= | time cuts [ncut] |
sfcell2
Second-order cell ray tracing with locally parabolic rays. | |||
---|---|---|---|
sfcell2 < vel.rsf > time.rsf shotfile=shots.rsf anglefile=angles.rsf vel=y order=4 nt=nx*nz nr= a0=0. amax=360. traj= > rays.rsf | |||
Rays and wavefronts can be displayed with sfplotrays. | |||
float | a0=0. | First angle in degrees (if anglefile is not specified) | |
float | amax=360. | Maximum angle in degrees (if anglefile is not specified) | |
string | anglefile= | file with initial angles (auxiliary input file name) | |
int | nr= | Number of angles (if anglefile is not specified) | |
int | nt=nx*nz | number of time steps | |
int | order=4 | Interpolation accuracy | |
string | shotfile= | file with shot locations (auxiliary input file name) | |
string | traj= | ||
bool | vel=y | [y/n] | If y, the input is velocity; if n, slowness |
sfcell3
Second-order cell ray tracing with locally parabolic rays in 3-D. | |||
---|---|---|---|
sfcell3 < vel.rsf > time.rsf shotfile=shots.rsf anglefile=angles.rsf vel=y order=4 nt=nx*nz na= nb= a0=0. amax=360. b0=0. bmax=180. traj= > rays.rsf | |||
Rays and wavefronts can be displayed with sfplotrays. | |||
float | a0=0. | First azimuth angle in degrees (if anglefile is not specified) | |
float | amax=360. | Maximum azimuth angle in degrees (if anglefile is not specified) | |
string | anglefile= | file with initial angles (auxiliary input file name) | |
float | b0=0. | First inclination angle in degrees (if anglefile is not specified) | |
float | bmax=180. | Maximum inclination angle in degrees (if anglefile is not specified) | |
int | na= | Number of azimuths (if anglefile is not specified) | |
int | nb= | Number of inclinations (if anglefile is not specified) | |
int | nt=nx*nz | number of time steps | |
int | order=4 | Interpolation accuracy | |
string | shotfile= | file with shot locations (auxiliary input file name) | |
string | traj= | ||
bool | vel=y | [y/n] | If y, the input is velocity; if n, slowness |
sfcgscan
Hyperbolic Radon transform with conjugate-directions inversion | |||
---|---|---|---|
sfcgscan < in.rsf > out.rsf error=err.rsf mask=msk.rsf adj=n niter=0 miter=2 psun1=1 psun2=1 anti=1. s02=0. ncycle=0 perc=50.0 | |||
bool | adj=n | [y/n] | adjoint flag |
float | anti=1. | antialiasing | |
string | error= | auxiliary output file name | |
string | mask= | auxiliary input file name | |
int | miter=2 | conjugate-direction memory | |
int | ncycle=0 | number of sharpening cycles | |
int | niter=0 | number of iterations | |
float | perc=50.0 | percentage for sharpening | |
int | psun1=1 | amplitude type for adjoint | |
int | psun2=1 | amplitude type for forward | |
float | s02=0. | reference slowness squared (for antialiasing) |
sfcmp2shot
Convert CMPs to shots for regular 2-D geometry. | |||
---|---|---|---|
sfcmp2shot < in.rsf > out.rsf positive=y | |||
bool | positive=y | [y/n] | initial offset orientation |
sfconstfdmig2
2-D implicit finite-difference migration in constant velocity. | |||
---|---|---|---|
sfconstfdmig2 < data.rsf > imag.rsf movie=movie.rsf nz=2*(nw-1) dz=1./(nz*dw) vel= hi=y sixth=1./12 | |||
float | dz=1./(nz*dw) | vertical time sampling | |
bool | hi=y | [y/n] | if y, use 45-degree; n, 15-degree |
string | movie= | auxiliary output file name | |
int | nz=2*(nw-1) | vertical time samples | |
float | sixth=1./12 | one-sixth trick | |
float | vel= | constant velocity |
sfcos2ang
Inverse cos to angle transformation | |||
---|---|---|---|
sfcos2ang < Fstk.rsf > Fang.rsf velocity=velocity.rsf na=nt da=90/(nt-1) a0=0. extend=4 top=n | |||
float | a0=0. | angle origin | |
float | da=90/(nt-1) | angle sampling | |
int | extend=4 | tmp extension | |
int | na=nt | number of angles | |
bool | top=n | [y/n] | velocity scaling option |
file | velocity= | auxiliary input file name |
sfdepth2time
Conversion from depth to time in a V(z) medium. | |||
---|---|---|---|
sfdepth2time < in.rsf velocity=velocity.rsf > out.rsf nt= dt= t0= slow=n eps=0.01 | |||
Transforms function of z to function of tau = Integral[2/v[x,n],{n,0,z}] | |||
float | dt= | Time sampling (default is d1) | |
float | eps=0.01 | smoothness parameter | |
int | nt= | Number of points in time (default is n1) | |
bool | slow=n | [y/n] | y: slowness, n: velocity |
float | t0= | Time origin (default is 0) | |
file | velocity= | auxiliary input file name |
sfdiffoc
Diffraction focusing test. | |||
---|---|---|---|
sfdiffoc < inp.rsf > out.rsf v0=SF_EPS v= pad=nt pad2=2*kiss_fft_next_fast_size((n2+1)/2) extend=4 | |||
int | extend=4 | trace extension | |
int | pad=nt | padding for stretch | |
int | pad2=2*kiss_fft_next_fast_size((n2+1)/2) | padding for FFT | |
float | v= | final velocity | |
float | v0=SF_EPS | initial velocity |
sfdiffraction
Generate diffractions in zero-offset data. | |||
---|---|---|---|
sfdiffraction < w1.rsf w2=w2.rsf w12=w12.rsf spikes=spikes.rsf > data.rsf freq=0.2/dt | |||
float | freq=0.2/dt | peak frequency for Ricker wavelet | |
file | spikes= | auxiliary input file name | |
file | w12= | auxiliary input file name | |
file | w2= | auxiliary input file name |
sfdimag
Diffraction imaging in the plane-wave domain. | |||
---|---|---|---|
sfdimag < cmp.rsf > scan.rsf semblance=n nb=2 v0= dv= nv= extend=4 mute=12 str=0. x0= | |||
float | dv= | ||
int | extend=4 | trace extension | |
int | mute=12 | mute zone | |
int | nb=2 | semblance averaging | |
int | nv= | ||
bool | semblance=n | [y/n] | if y, compute semblance; if n, stack |
float | str=0. | maximum stretch allowed | |
float | v0= | ||
float | x0= |
sfdmo
Kirchhoff DMO with antialiasing by reparameterization. | |||
---|---|---|---|
sfdmo < in.rsf > out.rsf mint=2 n=32 adj=y inv=n type=1 h= half=y velhalf=0.75 | |||
bool | adj=y | [y/n] | adjoint flag |
float | h= | ||
bool | half=y | [y/n] | if y, the third axis is half-offset instead of full offset |
bool | inv=n | [y/n] | inversion flag |
int | mint=2 | starting time sample | |
int | n=32 | number of offset samples | |
int | type=1 | type of amplitude (0,1,2,3) | |
float | velhalf=0.75 | half-velocity |
sfdsr
Prestack 2-D VTI v(z) modeling/migration by DSR with angle gathers. | |||
---|---|---|---|
sfdsr < in.rsf > out.rsf velocity=vel.rsf velz=velz.rsf eta=eta.rsf inv=n eps=0.01 depth=n na=1 da=90. nt= dt= t0=0. nh= dh= nz=nt dz=dt vel= vz=v0 n=0.0 nw=nt2/2+1 rule= arule= | |||
string | arule= | angle gather rule | |
float | da=90. | angle sampling (in degrees) | |
bool | depth=n | [y/n] | if true, depth migration |
float | dh= | Offset sampling (for modeling) | |
float | dt= | Sampling of time axis (for modeling) | |
float | dz=dt | Sampling of depth axis (for migration, if no velocity file) | |
float | eps=0.01 | Stabilization parameter | |
string | eta= | auxiliary input file name | |
bool | inv=n | [y/n] | If y, modeling; If n, migration |
float | n=0.0 | Constant eta (if no velocity file) | |
int | na=1 | number of angles | |
int | nh= | Number of offsets (for modeling) | |
int | nt= | Length of time axis (for modeling) | |
int | nw=nt2/2+1 | Maximum number of frequencies | |
int | nz=nt | Length of depth axis (for migration, if no velocity file) | |
string | rule= | phase-shift interpolation rule (simple, midpoint, linear, anisotropic, dti) | |
float | t0=0. | ||
float | vel= | Constant velocity (if no velocity file) | |
string | velocity= | file with velocity (file with velocity (auxiliary input file name)) | |
string | velz= | auxiliary input file name | |
float | vz=v0 | Constant vertical velocity (if no velocity file) |
sfdsr2
2-D prestack modeling/migration with split-step DSR. | |||
---|---|---|---|
sfdsr2 < in.rsf > out.rsf slowness=vel.rsf inv=n verb=n eps=0.01 nt=1 nr=1 dt=0.004 npad=0 nw= dw= w0=0. | |||
float | dt=0.004 | time error | |
float | dw= | Frequency sampling (for modeling) | |
float | eps=0.01 | stability parameter | |
bool | inv=n | [y/n] | If y, modeling; if n, migration |
int | npad=0 | padding on offset wavenumber | |
int | nr=1 | maximum number of references | |
int | nt=1 | taper size | |
int | nw= | Length of frequency axis (for modeling) | |
file | slowness= | auxiliary input file name | |
bool | verb=n | [y/n] | verbosity flag |
float | w0=0. | Frequency origin (for modeling) |
sfenvelope
Compute data envelope or phase rotation. | |||
---|---|---|---|
sfenvelope < in.rsf > out.rsf order=100 ref=1. hilb=n phase=90. | |||
November 2011 program of the month: http://ahay.org/rsflog/index.php?/archives/274-Program-of-the-month-sfenvelope.html | |||
bool | hilb=n | [y/n] | if y, compute Hilbert transform |
int | order=100 | Hilbert transformer order | |
float | phase=90. | phase shift (in degrees) to use with hilb=y | |
float | ref=1. | Hilbert transformer reference (0.5 < ref <= 1) |
sffincon
Offset continuation by finite differences | |||
---|---|---|---|
sffincon < input.rsf > output.rsf nh= dh= h0= all=n | |||
bool | all=n | [y/n] | if y, output all offsets |
float | dh= | Offset step size | |
float | h0= | Initial offset | |
int | nh= | Number of steps in offset |
sffindmo
DMO without stacking by finite-difference offset continuation. | |||
---|---|---|---|
sffindmo < cmp.rsf > stk.rsf |
sffinstack
DMO and stack by finite-difference offset continuation. | |||
---|---|---|---|
sffinstack < cmp.rsf > stk.rsf |
sffkamo
Computes Azimuth Move-Out (AMO) operator in the f-k log-stretch domain | |||
---|---|---|---|
sffkamo < in.rsf > out.rsf h1= h2= f1= f2= maxe=10. | |||
float | f1= | input azimuth in degrees | |
float | f2= | output azimuth in degrees | |
float | h1= | input offset | |
float | h2= | output offset | |
float | maxe=10. | stability constraint |
sffkdmo
Offset continuation by log-stretch F-K operator. | |||
---|---|---|---|
sffkdmo < in.rsf > out.rsf h= nh=1 h0=0. | |||
float | h= | final offset | |
float | h0=0. | initial offset | |
int | nh=1 | number of offset steps |
sffold
Make a seismic foldplot/stacking chart. | |||
---|---|---|---|
sffold < in.rsf > out.rsf verbose=1 o1= o2= o3= n1= n2= n3= d1= d2= d3= label1= label2= label3= | |||
This is a general 3D histogram program implemented to create foldplot or stacking charts on a 3d project from trace headers. Axis1, 2 and 3 define the bins for the output fold map. These are usually (offset,xline,iline), but you might want to compute some other histogram. This can be done by selecting other segy headers using label1, 2 and 3. See also fold= option in sfbin for creating 2D histograms. EXAMPLES: To make a stacking chart movie showing fold(xline,offset) for each inline from a 3d segyfile: sfsegyread tfile=tteapot.rsf hfile=teapot.asc bfile=teapot.bin \ tape=npr3_field.sgy > teapot.rsf # read the tfile, which contains the segy trace headers < tteapot.rsf sfdd type=float \ | sffold verbose=1 \ o1=0 n1=96 d1=200 label1=offset \ o2=1 n2=188 d2=1 label2=xline \ o3=1 n3=345 d3=1 label3=iline \ >foldplot.rsf <foldplot.rsf sfgrey title=foldplot pclip=100 \ | sfpen # transpose this data to plot foldmaps for each offset window: < foldplot.rsf sftransp plane=13 \ | sftransp plane=12 \ | sfgrey title=foldplot_off gainpanel=all \ | sfpen | |||
float | d1= | Delta label1 - usually delta offset | |
float | d2= | Delta label2 - usually delta xline | |
float | d3= | Delta label3 - usually delta iline | |
string | label1= | header for axis1 - usually offset | |
string | label2= | header for axis2 - usually xline or cdp | |
string | label3= | header for axis3 - usually iline | |
int | n1= | Number label1 - usually number offset | |
int | n2= | Number label2 - usually number xline | |
int | n3= | Number label3 - usually number iline | |
float | o1= | Minimum label1 - usually min offset | |
float | o2= | Minimum label2 - usually min xline | |
float | o3= | Minimum label3 - usually min iline | |
int | verbose=1 | 0 terse, 1 informative, 2 chatty, 3 debug |
sffourvc
Prestack velocity continuation. | |||
---|---|---|---|
sffourvc < in.rsf > out.rsf eps=0.01 pad=n1 pad2=2*kiss_fft_next_fast_size((n2+1)/2) verb=n nv= dv= extend=4 v0= | |||
float | dv= | velocity step size | |
float | eps=0.01 | regularization | |
int | extend=4 | trace extension | |
int | nv= | velocity steps | |
int | pad=n1 | padding for stretch | |
int | pad2=2*kiss_fft_next_fast_size((n2+1)/2) | padding for FFT | |
float | v0= | starting velocity | |
bool | verb=n | [y/n] | verbosity flag |
sffourvc0
Velocity continuation after NMO. | |||
---|---|---|---|
sffourvc0 < in.rsf > out.rsf eps=0.01 pad=n1 pad2=2*kiss_fft_next_fast_size((n2+1)/2) verb=n nv= dv= extend=4 | |||
float | dv= | ||
float | eps=0.01 | ||
int | extend=4 | trace extension | |
int | nv= | ||
int | pad=n1 | ||
int | pad2=2*kiss_fft_next_fast_size((n2+1)/2) | ||
bool | verb=n | [y/n] | verbosity flag |
sffourvc2
Velocity continuation with semblance computation. | |||
---|---|---|---|
sffourvc2 < in.rsf > out.rsf nb=2 eps=0.01 pad=n1 pad2=2*kiss_fft_next_fast_size((n2+1)/2) nv= dv= semblance=y extend=4 | |||
float | dv= | ||
float | eps=0.01 | ||
int | extend=4 | trace extension | |
int | nb=2 | ||
int | nv= | ||
int | pad=n1 | ||
int | pad2=2*kiss_fft_next_fast_size((n2+1)/2) | ||
bool | semblance=y | [y/n] | if y, compute semblance; if n, stack |
sffreqint
1-D data regularization using freqlet transform | |||
---|---|---|---|
sffreqint < in.rsf > out.rsf freq=w.rsf coord=coord.rsf n1= d1= o1= niter=10 ncycle=1 eps=1.0 inv=n perc=50.0 type= | |||
file | coord= | auxiliary input file name | |
float | d1= | output sampling | |
float | eps=1.0 | regularization parameter | |
file | freq= | auxiliary input file name | |
bool | inv=n | [y/n] | inversion flag |
int | n1= | output samples | |
int | ncycle=1 | number of IRLS iterations | |
int | niter=10 | number of iterations for inversion | |
float | o1= | output origin | |
float | perc=50.0 | percentage for sharpening | |
string | type= | [haar,linear,biorthogonal] wavelet type, the default is linear |
sffreqlet
1-D seislet frame | |||
---|---|---|---|
sffreqlet < in.rsf > out.rsf freq=w.rsf inv=n verb=y decomp=n ncycle=0 niter=1 perc=50.0 type= | |||
bool | decomp=n | [y/n] | do decomposition |
file | freq= | auxiliary input file name | |
bool | inv=n | [y/n] | if y, do inverse transform |
int | ncycle=0 | number of iterations | |
int | niter=1 | number of Bregman iterations | |
float | perc=50.0 | percentage for sharpening | |
string | type= | [haar,linear,biorthogonal] wavelet type, the default is linear | |
bool | verb=y | [y/n] | verbosity flag |
sfgazdag
Post-stack 2-D v(z) time modeling/migration with Gazdag phase-shift. | |||
---|---|---|---|
sfgazdag < in.rsf > out.rsf velocity=vel.rsf velz=velz.rsf eta=eta.rsf inv=n eps=0.01 verb=n depth=n nt= dt= nz= dz= vel= vz=v0 n=0.0 pad=2*kiss_fft_next_fast_size((nt+1)/2) rule= | |||
bool | depth=n | [y/n] | if true, depth migration |
float | dt= | Sampling of time axis (for modeling) | |
float | dz= | Sampling of depth axis (for migration, if no velocity file) | |
float | eps=0.01 | stabilization parameter | |
string | eta= | auxiliary input file name | |
bool | inv=n | [y/n] | if y, modeling; if n, migration |
float | n=0.0 | Constant eta (if no velocity file) | |
int | nt= | Length of time axis (for modeling) | |
int | nz= | Length of depth axis (for migration, if no velocity file) | |
int | pad=2*kiss_fft_next_fast_size((nt+1)/2) | ||
string | rule= | phase-shift interpolation rule (simple, midpoint, linear) | |
float | vel= | Constant velocity (if no velocity file) | |
string | velocity= | auxiliary input file name | |
string | velz= | auxiliary input file name | |
bool | verb=n | [y/n] | verbosity flag |
float | vz=v0 | Constant vertical velocity (if no velocity file) |
sfhalfint
Half-order integration or differentiation. | |||
---|---|---|---|
sfhalfint < in.rsf > out.rsf adj=n inv=n rho=1.-1./n1 | |||
December 2012 program of the month: http://ahay.org/rsflog/index.php?/archives/317-Program-of-the-month-sfhalfint.html | |||
bool | adj=n | [y/n] | If y, apply adjoint |
bool | inv=n | [y/n] | If y, do differentiation instead of integration |
float | rho=1.-1./n1 | Leaky integration constant |
sfheaderattr
Integer header attributes. | |||
---|---|---|---|
sfheaderattr < head.rsf | |||
Only nonzero values are reported. |
sfheadermath
Mathematical operations, possibly on header keys. | |||
---|---|---|---|
sfheadermath < in.rsf > out.rsf memsize=sf_memsize() output= | |||
Known functions: cos, sin, tan, acos, asin, atan, cosh, sinh, tanh, acosh, asinh, atanh, exp, log, sqrt, abs See also sfmath. An addition operation can be performed by sfstack. | |||
int | memsize=sf_memsize() | Max amount of RAM (in Mb) to be used | |
string | output= | Describes the output in a mathematical notation. |
sfhwt2d
2-D Huygens wavefront tracing traveltimes | |||
---|---|---|---|
sfhwt2d < Fv.rsf > Fw.rsf verb=n rays=n xsou=sf_o(ax) + nx*sf_d(ax)/2 zsou=sf_o(az) + nz*sf_d(az)/2 nt=100 ot=0 dt=0.001 ng=360 og=-180 dg=1 | |||
float | dg=1 | ||
float | dt=0.001 | ||
int | ng=360 | ||
int | nt=100 | ||
float | og=-180 | ||
float | ot=0 | ||
bool | rays=n | [y/n] | velocity file |
bool | verb=n | [y/n] | |
float | xsou=sf_o(ax) + nx*sf_d(ax)/2 | ||
float | zsou=sf_o(az) + nz*sf_d(az)/2 |
sfhwtex
Huygens wavefront tracing traveltimes | |||
---|---|---|---|
sfhwtex < Fv.rsf sou=Fs.rsf > Fw.rsf verb=n nt=100 ot=0 dt=0.001 | |||
float | dt=0.001 | ||
int | nt=100 | ||
float | ot=0 | ||
file | sou= | auxiliary input file name | |
bool | verb=n | [y/n] | velocity file |
sfinfill
Shot interpolation. | |||
---|---|---|---|
sfinfill < in.rsf > out.rsf eps=0.1 positive=y | |||
float | eps=0.1 | regularization parameter | |
bool | positive=y | [y/n] | initial offset orientation |
sfinmo
Inverse normal moveout. | |||
---|---|---|---|
sfinmo < cmp.rsf velocity=velocity.rsf > nmod.rsf offset=offset.rsf half=y slowness=n h0=0. eps=0.01 | |||
float | eps=0.01 | stretch regularization | |
float | h0=0. | reference offset | |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
string | offset= | auxiliary input file name | |
bool | slowness=n | [y/n] | if y, use slowness instead of velocity |
file | velocity= | auxiliary input file name |
sfinmo3
3-D Inverse normal moveout. | |||
---|---|---|---|
sfinmo3 < cmp.rsf > nmod.rsf velocity=vel.rsf half=y eps=0.01 extend=8 | |||
velocity file contains slowness squared with n2=3 (wx,wy,wxy) | |||
float | eps=0.01 | stretch regularization | |
int | extend=8 | trace extension | |
bool | half=y | [y/n] | if y, the second and third axes are half-offset instead of full offset |
file | velocity= | auxiliary input file name |
sfintbin
Data binning by trace sorting. | |||
---|---|---|---|
sfintbin < in.rsf > out.rsf xkey= ykey= xmin= xmax= ymin= ymax= head= xk= yk= mask= | |||
The input is 2-D (n1 x ntr). The output is 3-D (n1 x n2 x n3), n2 and n3 correspond to two selected keys from the header file. | |||
string | head= | header file | |
string | mask= | output mask file | |
string | xk= | x key name | |
int | xkey= | x key number (if no xk), default is fldr | |
int | xmax= | x maximum | |
int | xmin= | x minimum | |
string | yk= | y key name | |
int | ykey= | y key number (if no yk), default is tracf | |
int | ymax= | y maximum | |
int | ymin= | y minimum |
sfintbin3
4-D data binning. | |||
---|---|---|---|
sfintbin3 < in.rsf > out.rsf xkey= ykey= zkey= xmin= xmax= ymin= ymax= zmin= zmax= head= xk= yk= zk= mask= | |||
string | head= | header file | |
string | mask= | output mask file | |
string | xk= | x key name | |
int | xkey= | x key number (if no xk), default is fldr | |
int | xmax= | x maximum | |
int | xmin= | x minimum | |
string | yk= | y key name | |
int | ykey= | y key number (if no yk), default is tracf | |
int | ymax= | y maximum | |
int | ymin= | y minimum | |
string | zk= | z key name | |
int | zkey= | z key number (if no zk), default is tracf | |
int | zmax= | z maximum | |
int | zmin= | z minimum |
sfisin2ang
inverse sin to angle transformation | |||
---|---|---|---|
sfisin2ang < Fstk.rsf > Fang.rsf velocity=velocity.rsf na=nt da=90/(nt-1) a0=0. extend=4 top=n | |||
float | a0=0. | angle origin | |
float | da=90/(nt-1) | angle sampling | |
int | extend=4 | tmp extension | |
int | na=nt | number of angles | |
bool | top=n | [y/n] | velocity scaling option |
file | velocity= | auxiliary input file name |
sfitaupmo
Inverse normal moveout in tau-p domain. | |||
---|---|---|---|
sfitaupmo < cmp.rsf velocity=velocity.rsf > nmod.rsf eta=eta.rsf interval=y eps=0.01 | |||
float | eps=0.01 | stretch regularization | |
string | eta= | auxiliary input file name | |
bool | interval=y | [y/n] | use interval velocity |
file | velocity= | auxiliary input file name |
sfitaupmo2
Inverse normal moveout in tau-p-x domain. | |||
---|---|---|---|
sfitaupmo2 < cmp.rsf velocity=velocity.rsf > nmod.rsf nx= dx= x0=0.0 nw=4 | |||
float | dx= | offset sampling | |
int | nw=4 | interpolator size (2,3,4,6,8) | |
int | nx= | number of offsets | |
file | velocity= | auxiliary input file name | |
float | x0=0.0 | first offset |
sfitaupmo3
3-D Inverse taup normal moveout. | |||
---|---|---|---|
sfitaupmo3 < cmp.rsf > nmod.rsf velocity=vel.rsf eps=0.01 slow=n interval=y extend=8 | |||
velocity file contains velocity squared with n2=3 (vx,vy,vxy) | |||
float | eps=0.01 | stretch regularization | |
int | extend=8 | trace extension | |
bool | interval=y | [y/n] | use interval velocity |
bool | slow=n | [y/n] | slowness [y] or velocity [n] squared |
file | velocity= | auxiliary input file name |
sfitxmo
Forward and inverse normal moveout with interval velocity. | |||
---|---|---|---|
sfitxmo < inp.rsf > out.rsf velocity=velocity.rsf inv=n nx= dx= x0=0. np= dp= eps=0.01 | |||
float | dp= | slope sampling | |
float | dx= | offset sampling | |
float | eps=0.01 | stretch regularization | |
bool | inv=n | [y/n] | |
int | np= | slope samples | |
int | nx= | offset samples | |
file | velocity= | auxiliary input file name | |
float | x0=0. | first offset |
sfiwarp
Inverse 1-D warping. | |||
---|---|---|---|
sfiwarp < in.rsf > out.rsf warp=warp.rsf inv=y n1=nt eps=0.01 d1=1 o1=0 | |||
September 2012 program of the month: http://ahay.org/rsflog/index.php?/archives/304-Program-of-the-month-sfiwarp.html | |||
float | d1=1 | output sampling - for inv=y | |
float | eps=0.01 | stretch regularization | |
bool | inv=y | [y/n] | inversion flag |
int | n1=nt | output samples - for inv=y | |
float | o1=0 | output origin - for inv=y | |
file | warp= | auxiliary input file name |
sfiwarp2
Inverse 2-D warping | |||
---|---|---|---|
sfiwarp2 < in.rsf > out.rsf warp=warp.rsf inv=y n1=nt n2=nx eps=0.01 d1=1 o1=0 | |||
float | d1=1 | output sampling - for inv=y | |
float | eps=0.01 | stretch regularization | |
bool | inv=y | [y/n] | inversion flag |
int | n1=nt | ||
int | n2=nx | output samples - for inv=y | |
float | o1=0 | output origin - for inv=y | |
file | warp= | auxiliary input file name |
sfiwarp3
Inverse 3-D warping | |||
---|---|---|---|
sfiwarp3 < in.rsf > out.rsf warp=warp.rsf inv=y n1=nt n2=ny n3=nx eps=0.01 d1=1 o1=0 | |||
float | d1=1 | output sampling - for inv=y | |
float | eps=0.01 | stretch regularization | |
bool | inv=y | [y/n] | inversion flag |
int | n1=nt | ||
int | n2=ny | ||
int | n3=nx | output samples - for inv=y | |
float | o1=0 | output origin - for inv=y | |
file | warp= | auxiliary input file name |
sfkirchinv
Kirchhoff 2-D post-stack least-squares time migration with antialiasing. | |||
---|---|---|---|
sfkirchinv < in.rsf > out.rsf velocity=vel.rsf hd=y ps=y sw=0 niter=10 err= | |||
Antialiasing by reparameterization. | |||
string | err= | output file for error | |
bool | hd=y | [y/n] | if y, apply half-derivative filter |
int | niter=10 | number of iterations | |
bool | ps=y | [y/n] | if y, apply pseudo-unitary weighting |
int | sw=0 | if > 0, select a branch of the antialiasing operation | |
file | velocity= | auxiliary input file name |
sfkirchnew
Kirchhoff 2-D post-stack time migration and modeling with antialiasing. | |||
---|---|---|---|
sfkirchnew < in.rsf > out.rsf velocity=vel.rsf adj=y hd=y sw=0 v0= | |||
Antialiasing by reparameterization. | |||
bool | adj=y | [y/n] | yes: migration, no: modeling |
bool | hd=y | [y/n] | if y, apply half-derivative filter |
int | sw=0 | if > 0, select a branch of the antialiasing operation | |
float | v0= | constant velocity (if no velocity=) | |
string | velocity= | velocity file (auxiliary input file name) |
sfkirmod
Kirchhoff 2-D/2.5-D modeling with analytical Green's functions. | |||
---|---|---|---|
sfkirmod < modl.rsf > data.rsf curv=curv.rsf refl=refl.rsf picks=picks.rsf slopes=slopes.rsf lin=n adj=n absoff=n nt= dt=0.004 t0=0. ns=nx s0=x0 ds=dx nh=nx h0=0. dh=dx verb=n r0=1. r0=1. twod=n cmp=n freq=0.2/dt vel= gradx= gradz= velz= eta= refx= refz= vel2= gradx2= gradz2= rgrad= dip= type= type2= | |||
October 2012 program of the month: http://ahay.org/rsflog/index.php?/archives/308-Program-of-the-month-sfkirmod.html | |||
bool | absoff=n | [y/n] | y - h0 is not in shot coordinate system |
bool | adj=n | [y/n] | adjoint flag |
bool | cmp=n | [y/n] | compute CMP instead of shot gathers |
file | curv= | auxiliary input file name | |
float | dh=dx | offset increment | |
string | dip= | reflector dip file | |
float | ds=dx | shot/midpoint increment | |
float | dt=0.004 | time sampling | |
float | eta= | parameter for VTI anisotropy | |
float | freq=0.2/dt | peak frequency for Ricker wavelet | |
float | gradx= | horizontal velocity gradient | |
float | gradx2= | converted velocity, horizontal gradient | |
float | gradz= | vertical velocity gradient | |
float | gradz2= | converted velocity, vertical gradient | |
float | h0=0. | first offset | |
bool | lin=n | [y/n] | if linear operator |
int | nh=nx | number of offsets | |
int | ns=nx | number of shots (midpoints if cmp=y) | |
int | nt= | time samples | |
string | picks= | auxiliary output file name | |
float | r0=1. | normal reflectivity (if constant) | |
string | refl= | auxiliary input file name | |
float | refx= | reference x-coordinate for velocity | |
float | refz= | reference z-coordinate for velocity | |
string | rgrad= | AVO gradient file (B/A) | |
float | s0=x0 | first shot (midpoint if cmp=y) | |
string | slopes= | auxiliary output file name | |
float | t0=0. | time origin | |
bool | twod=n | [y/n] | 2-D or 2.5-D |
string | type= | type of velocity, 'c': constant, 's': linear sloth, 'v': linear velocity, 'a': VTI anisotropy | |
string | type2= | type of velocity for the converted (receiver side) branch | |
float | vel= | velocity | |
float | vel2= | converted velocity | |
float | velz= | vertical velocity for VTI anisotropy | |
bool | verb=n | [y/n] | verbosity flag |
sfkirmod3
Kirchhoff 3-D modeling with analytical Green's functions. | |||
---|---|---|---|
sfkirmod3 < curv.rsf > modl.rsf head=head.rsf refl=refl.rsf nt= dt=0.004 t0=0. absoff=n nsx=nx s0x=x0 dsx=dx nsy=ny s0y=y0 dsy=dy nhx=nx h0x=0. dhx=dx nhy=ny h0y=0. dhy=dy r0=1. aper=hypotf(nx*dx,ny*dy) freq=0.2/dt rgrad= dipx= dipy= type= | |||
bool | absoff=n | [y/n] | y - h0x, h0y - are not in shot coordinate system |
float | aper=hypotf(nx*dx,ny*dy) | aperture | |
float | dhx=dx | inline offset increment | |
float | dhy=dy | crossline offset increment | |
string | dipx= | ||
string | dipy= | ||
float | dsx=dx | inline shot increment | |
float | dsy=dy | crossline shot increment | |
float | dt=0.004 | time sampling | |
float | freq=0.2/dt | peak frequency for Ricker wavelet | |
float | h0x=0. | first inline offset | |
float | h0y=0. | first crossline offset | |
string | head= | source-receiver geometry (optional) (auxiliary input file name) | |
int | nhx=nx | number of inline offsets | |
int | nhy=ny | number of crossline offsets | |
int | nsx=nx | number of inline shots | |
int | nsy=ny | number of crossline shots | |
int | nt= | time samples | |
float | r0=1. | constant reflectivity | |
string | refl= | auxiliary input file name | |
string | rgrad= | ||
float | s0x=x0 | first inline shot | |
float | s0y=y0 | first crossline shot | |
float | t0=0. | time origin | |
string | type= | type of velocity ('c': constant, 's': linear sloth, 'v': linear velocity) |
sflinsincos
Solve for angle in equation vx*sin(d) + vy*cos(d) = 1/s0. | |||
---|---|---|---|
sflinsincos < in.rsf > out.rsf s0= na= da= oa= nt=180 dt=2. ot=0. nr=nvx/2 dr=dvx extend=4 | |||
float | da= | angle sampling. | |
float | dr=dvx | radius sampling. | |
float | dt=2. | polar angle sampling. | |
int | extend=4 | tmp extension | |
int | na= | number of angle values. | |
int | nr=nvx/2 | number of radius on radial lines | |
int | nt=180 | number of polar angle for integration. | |
float | oa= | angle origin | |
float | ot=0. | polar angle origin | |
float | s0= | reference slowness |
sfmap2coh
From parameter's attribute map (veltran) to coherency-like plots. | |||
---|---|---|---|
sfmap2coh < cmp.rsf map=map.rsf > coh.rsf nv= v0= dv= min2=o2 max2=o2+d2*(n2-1) nw=4 | |||
(eventually masked) | |||
float | dv= | velocity sampling | |
string | map= | parameters map (auxiliary input file name) | |
float | max2=o2+d2*(n2-1) | max2 | |
float | min2=o2 | min2 | |
int | nv= | number of velocities | |
int | nw=4 | interpolator size (2,3,4,6,8) | |
float | v0= | velocity origin |
sfmigsteep3
3-D Kirchhoff time migration for antialiased steep dips. | |||
---|---|---|---|
sfmigsteep3 < in.rsf hdr=head.rsf > mig.rsf n2= d2= o2= n3= d3= o3= n1= vel= | |||
Combine with sfmig3 antialias=flat for the complete response. | |||
float | d2= | ||
float | d3= | ||
file | hdr= | auxiliary input file name | |
int | n1= | ||
int | n2= | ||
int | n3= | ||
float | o2= | ||
float | o3= | ||
float | vel= | migration velocity |
sfmodrefl
Normal reflectivity modeling. | |||
---|---|---|---|
sfmodrefl < depth.rsf vp=vp.rsf vs=vs.rsf rho=rho.rsf > dat.rsf nt= dt= nw=4 | |||
float | dt= | time sampling | |
int | nt= | time samples | |
int | nw=4 | interpolation length | |
file | rho= | auxiliary input file name | |
file | vp= | auxiliary input file name | |
file | vs= | auxiliary input file name |
sfmodrefl2
Normal reflectivity modeling. | |||
---|---|---|---|
sfmodrefl2 < in.rsf > out.rsf nt= dt= nw=4 | |||
In this version, the input contains Vp, Vs, and density into one file. The output contains PP intercept, PP gradient, and PS gradient. | |||
float | dt= | time sampling | |
int | nt= | time samples | |
int | nw=4 | interpolation length |
sfmodrefl3
Normal reflectivity modeling. | |||
---|---|---|---|
sfmodrefl3 < in.rsf > out.rsf sparse=10 moveout=y nt= dt= np= dp= p0= eps=0.01 | |||
In this version, the input contains Vp, Vs, and density into one file. The output contains PP and PS tau-p seismograms. | |||
float | dp= | slope sampling | |
float | dt= | time sampling | |
float | eps=0.01 | stretch regularization | |
bool | moveout=y | [y/n] | if apply moveout |
int | np= | slope samples | |
int | nt= | time samples | |
float | p0= | slope origin | |
int | sparse=10 | sparseness of reflectivity |
sfmoveout
Put spikes at an arbitrary moveout | |||
---|---|---|---|
sfmoveout < warp.rsf > out.rsf n1= d1=1. o1=0. eps=0.1 nw=10 | |||
float | d1=1. | time sampling | |
float | eps=0.1 | stretch regularization | |
int | n1= | time samples | |
int | nw=10 | wavelet length | |
float | o1=0. | time origin |
sfnmo
Normal moveout. | |||
---|---|---|---|
sfnmo < cmp.rsf velocity=velocity.rsf > nmod.rsf s=het.rsf offset=offset.rsf mask=msk.rsf half=y str=0.5 mute=12 CDPtype= slowness=n squared=n h0=0. extend=4 a= | |||
Compatible with sfvscan. | |||
int | CDPtype= | ||
string | a= | ||
int | extend=4 | trace extension | |
float | h0=0. | reference offset | |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
string | mask= | auxiliary input file name | |
int | mute=12 | mute zone | |
string | offset= | auxiliary input file name | |
string | s= | auxiliary input file name | |
bool | slowness=n | [y/n] | if y, use slowness instead of velocity |
bool | squared=n | [y/n] | if y, the slowness or velocity is squared |
float | str=0.5 | maximum stretch allowed | |
file | velocity= | auxiliary input file name |
sfnmo3
3-D Normal moveout. | |||
---|---|---|---|
sfnmo3 < cmp.rsf > nmod.rsf velocity=vel.rsf offset=offset.rsf half=y eps=0.01 mute=12 extend=8 | |||
input data has gathers along *4th* axis; velocity file contains slowness squared with n2=3 (wx,wy,wxy); offset file contains x,y offset pairs for input data | |||
float | eps=0.01 | stretch regularization | |
int | extend=8 | trace extension | |
bool | half=y | [y/n] | if y, the second and third axes are half-offset instead of full offset |
int | mute=12 | mute zone | |
string | offset= | auxiliary input file name | |
file | velocity= | auxiliary input file name |
sfnmov
Least-squares fitting of t^2-t_0^2 surfaces for isotropic V_{nmo}. | |||
---|---|---|---|
sfnmov < inp.rsf > out.rsf |
sfnmow
Least-squares fitting of t^2-t_0^2 surfaces for elliptical slowness matrix, W. | |||
---|---|---|---|
sfnmow < inp.rsf > out.rsf offset=offset.rsf half=y nw=3 | |||
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
int | nw=3 | ||
string | offset= | If offset file is provided, it must be of the form:(auxiliary input file name) |
sfnmow_adj
None | |||
---|---|---|---|
sfnmow_adj < inp.rsf > out.rsf gather=gather.rsf adj=n nw=3 | |||
bool | adj=n | [y/n] | |
file | gather= | auxiliary input file name | |
int | nw=3 |
sfovc
Oriented velocity continuation. | |||
---|---|---|---|
sfovc < in.rsf > out.rsf eps=0.1 nv=1 lagrange=n v0=0. vmax= | |||
Axis order: t, p, x | |||
float | eps=0.1 | stretch regularization | |
bool | lagrange=n | [y/n] | Use Lagrangian method |
int | nv=1 | number of velocity steps | |
float | v0=0. | starting velocity | |
float | vmax= | end velocity |
sfoway1
Oriented one-way wave equation. | |||
---|---|---|---|
sfoway1 < in.rsf > out.rsf velocity=vel.rsf vgrad=vgrad.rsf eps=0.1 lagrange=n | |||
Axis order: x, p, t | |||
float | eps=0.1 | stretch regularization | |
bool | lagrange=n | [y/n] | Use Lagrangian method |
file | velocity= | auxiliary input file name | |
file | vgrad= | auxiliary input file name |
sfpmig
Slope-based prestack time migration. | |||
---|---|---|---|
sfpmig < cmp.rsf xdip=xdip.rsf hdip=hdip.rsf > mig.rsf half=y mzo=n eps=1.0 | |||
float | eps=1.0 | stretch regularization | |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
file | hdip= | auxiliary input file name | |
bool | mzo=n | [y/n] | do migration to zero offset |
file | xdip= | auxiliary input file name |
sfpnmo
Slope-based normal moveout. | |||
---|---|---|---|
sfpnmo < cmp.rsf dip=dip.rsf > nmod.rsf vel=vel.rsf offset=offset.rsf crv=crv.rsf eta=eta.rsf half=y eps=0.01 | |||
string | crv= | auxiliary input file name | |
file | dip= | auxiliary input file name | |
float | eps=0.01 | stretch regularization | |
file | eta= | auxiliary output file name | |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
string | offset= | auxiliary input file name | |
file | vel= | auxiliary output file name |
sfpnmo3d
Slope-based normal moveout for 3-D CMP geometry. | |||
---|---|---|---|
sfpnmo3d < cmp.rsf dipx=dipx.rsf dipy=dipy.rsf > nmod.rsf vel=vel.rsf half=y eps=0.01 extend=8 | |||
file | dipx= | auxiliary input file name | |
file | dipy= | auxiliary input file name | |
float | eps=0.01 | stretch regularization | |
int | extend=8 | trace extension | |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
file | vel= | auxiliary output file name |
sfpp2psang
Transform PP angle gathers to PS angle gathers. | |||
---|---|---|---|
sfpp2psang < in.rsf > out.rsf vpvs=vpvs.rsf nw=4 inv=n | |||
* (designed for absolute offsets) | |||
bool | inv=n | [y/n] | if y, do inverse transform |
int | nw=4 | accuracy level | |
file | vpvs= | auxiliary input file name |
sfpp2psang2
Transform PP angle gathers to PS angle gathers. | |||
---|---|---|---|
sfpp2psang2 < in.rsf > out.rsf vpvs=vpvs.rsf dip=dip.rsf verb=n nw=4 inv=n | |||
* (designed for horizontal offsets) | |||
file | dip= | auxiliary input file name | |
bool | inv=n | [y/n] | if y, do inverse transform |
int | nw=4 | accuracy level | |
bool | verb=n | [y/n] | |
file | vpvs= | auxiliary input file name |
sfpp2pstsic
Compute angle gathers for time-shift imaging condition | |||
---|---|---|---|
sfpp2pstsic < Fstk.rsf velocity=Fvel.rsf vpvs=Fgam.rsf dip=Fdip.rsf > Fang.rsf na=nv da=1./(nv-1) a0=0. extend=4 | |||
float | a0=0. | ||
float | da=1./(nv-1) | ||
file | dip= | auxiliary input file name | |
int | extend=4 | tmp extension | |
int | na=nv | ||
file | velocity= | auxiliary input file name | |
file | vpvs= | auxiliary input file name |
sfpreconstkirch
Prestack Kirchhoff modeling/migration in constant velocity. | |||
---|---|---|---|
sfpreconstkirch < in.rsf > out.rsf inv=n zero=n aal=y nh= dh= h0= vel= | |||
Requires the input to be in (time,cmp x,cmp y,offset) | |||
bool | aal=y | [y/n] | if y, apply antialiasing |
float | dh= | offset sampling | |
float | h0= | offset origin | |
bool | inv=n | [y/n] | if y, modeling; if n, migration |
int | nh= | number of offsets | |
float | vel= | velocity | |
bool | zero=n | [y/n] | if y, stack in migration |
sfprestolt
Prestack Stolt modeling/migration. | |||
---|---|---|---|
sfprestolt < in.rsf > out.rsf inv=n depth=n nh= dh= stack=y vel= pad=nt extend=4 | |||
bool | depth=n | [y/n] | y: depth migration, n: time migration |
float | dh= | offset sampling | |
int | extend=4 | trace extension | |
bool | inv=n | [y/n] | y: modeling, n: migration |
int | nh= | number of offsets | |
int | pad=nt | padding on the time axis | |
bool | stack=y | [y/n] | if y: stack migrated image |
float | vel= | constant velocity |
sfptaupmo
Slope-based tau-p moveout. | |||
---|---|---|---|
sfptaupmo < inp.rsf dip=dip.rsf dipt=dipt.rsf > nmod.rsf vel2=vel2.rsf eps=0.01 v0=0. type= | |||
file | dip= | auxiliary input file name | |
file | dipt= | auxiliary input file name | |
float | eps=0.01 | stretch regularization | |
string | type= | transform type | |
float | v0=0. | initial velocity | |
file | vel2= | auxiliary output file name |
sfptaupmo3
Slope-based tau-p 3D moveout. | |||
---|---|---|---|
sfptaupmo3 < inp.rsf dip1=dip1.rsf dip2=dip2.rsf > nmod.rsf tau0=tau0.rsf eps=0.01 | |||
string | dip1= | slope field mesaure along dimension 2(auxiliary input file name) | |
string | dip2= | slope field mesaure along dimension 3(auxiliary input file name) | |
float | eps=0.01 | stretch regularization | |
string | tau0= | tau0(tau,p) (auxiliary output file name) |
sfptaupmoVTI
Slope-based tau-p moveout in VTI. | |||
---|---|---|---|
sfptaupmoVTI < inp.rsf dip=dip.rsf ddip=ddip.rsf > nmod.rsf tau0=tau0.rsf cos2=cos2.rsf eps=0.01 | |||
file | cos2= | auxiliary output file name | |
string | ddip= | curvature field (auxiliary input file name) | |
string | dip= | slope field (auxiliary input file name) | |
float | eps=0.01 | stretch regularization | |
string | tau0= | tau0(tau,p) (auxiliary output file name) |
sfpveltran
Slope-based velocity transform. | |||
---|---|---|---|
sfpveltran < cmp.rsf dip=dip.rsf > vel.rsf dipt=dipt.rsf half=y nv= v0= dv= interval=n eps=0.1 | |||
file | dip= | auxiliary input file name | |
file | dipt= | auxiliary input file name | |
float | dv= | velocity sampling | |
float | eps=0.1 | stretch regularization | |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
bool | interval=n | [y/n] | if y, compute interval velocity |
int | nv= | number of velocities | |
float | v0= | velocity origin |
sfpveltran3
Slope-based tau-p 3D velocity transform for elliptical anisotropy. | |||
---|---|---|---|
sfpveltran3 < input.rsf > velx.rsf vely=vely.rsf velxy=velxy.rsf cmp=cmp.rsf dipx=dipx.rsf dipy=dipy.rsf dipxy=dipxy.rsf map=n interval=n nvx= vx0= dvx= nvy=nvx vy0=vx0 dvy=dvx nvxy=101 vxy0=-0.1 dvxy=0.1 nw=4 | |||
* The program returns the squared velocity vx,vy,vxy spectra or maps | |||
string | cmp= | auxiliary input file name | |
string | dipx= | auxiliary input file name | |
string | dipxy= | auxiliary input file name | |
string | dipy= | auxiliary input file name | |
float | dvx= | vx squared velocity sampling | |
float | dvxy=0.1 | vxy velocity sampling | |
float | dvy=dvx | vy squared velocity sampling | |
bool | interval=n | [y/n] | interval values by 3D stripping equations |
bool | map=n | [y/n] | output maps instead of coherency panels |
int | nvx= | number of vx squared velocities | |
int | nvxy=101 | number of vxy velocities | |
int | nvy=nvx | number of vy squared velocities | |
int | nw=4 | interpolator size (2,3,4,6,8) | |
file | velxy= | auxiliary output file name | |
file | vely= | auxiliary output file name | |
float | vx0= | vx squared velocity origin | |
float | vxy0=-0.1 | vxy velocity origin | |
float | vy0=vx0 | vy squared velocity origin |
sfpveltranVTI
Slope-based tau-p velocity transform for VTI media. | |||
---|---|---|---|
sfpveltranVTI < tau0.rsf > velN.rsf velH=velH.rsf eta=eta.rsf cmp=cmp.rsf dip=dip.rsf curv=curv.rsf dipt=dipt.rsf tau0t=tau0t.rsf curvt=curvt.rsf map=n nv= v0= dv= nvh=nv vh0=v0 dvh=dv ne=101 e0=-0.5 de=0.01 nw=4 method= | |||
file | cmp= | auxiliary input file name | |
string | curv= | curvature field (required for method=e and method=d) (auxiliary input file name) | |
string | curvt= | time derivative of curvature field (required for method=d and method=s) (auxiliary input file name) | |
float | de=0.01 | eta sampling | |
string | dip= | slope field (required for method=e and method=d) (auxiliary input file name) | |
string | dipt= | time derivative of slope field(auxiliary input file name) | |
float | dv= | velocity sampling | |
float | dvh=dv | HOR velocity sampling | |
float | e0=-0.5 | eta origin | |
file | eta= | auxiliary output file name | |
bool | map=n | [y/n] | output maps instead of coherency panels |
string | method= | method to use (stripping,dix,fowler,effective) | |
int | ne=101 | number of etas | |
int | nv= | number of velocities | |
int | nvh=nv | number of HOR velocities | |
int | nw=4 | interpolator size (2,3,4,6,8) | |
string | tau0t= | tau0 tau derivative field (required for method=f) (auxiliary input file name) | |
float | v0= | velocity origin | |
file | velH= | auxiliary output file name | |
float | vh0=v0 | HOR velocity origin |
sfpyramid
Pyramid transform | |||
---|---|---|---|
sfpyramid < in.rsf > out.rsf inv=n nu= du=dx u0=x0 eps=0.01 | |||
float | du=dx | ||
float | eps=0.01 | stretch regularization | |
bool | inv=n | [y/n] | inversion flag |
int | nu= | ||
float | u0=x0 |
sfradial
Radial transform. | |||
---|---|---|---|
sfradial < in.rsf > out.rsf inv=n nw=2 tp=t0 nv= vmin= vmax= | |||
bool | inv=n | [y/n] | if y, do inverse transform |
int | nv= | number of velocities (if inv=n) | |
int | nw=2 | accuracy level | |
float | tp=t0 | ||
float | vmax= | maximum velocity (if inv=n) | |
float | vmin= | minimum velocity (if inv=n) |
sfradial2
Another version of radial transform. | |||
---|---|---|---|
sfradial2 < in.rsf > out.rsf inv=n eps=0.01 tp=t0 nv= vmin= vmax= | |||
float | eps=0.01 | stretch regularization | |
bool | inv=n | [y/n] | if y, do inverse transform |
int | nv= | number of velocities (if inv=n) | |
float | tp=t0 | ||
float | vmax= | maximum velocity (if inv=n) | |
float | vmin= | minimum velocity (if inv=n) |
sfradon
High-resolution Radon transform. | |||
---|---|---|---|
sfradon < in.rsf > out.rsf offset=offset.rsf adj=y inv=adj spk=inv verb=n np= dp= p0= nx= eps=1. ns=1 tol=1.e-6 perc=50.0 ox= dx= parab=n x0=1. niter=100 | |||
bool | adj=y | [y/n] | if y, perform adjoint operation |
float | dp= | p sampling (if adj=y) | |
float | dx= | ||
float | eps=1. | ||
bool | inv=adj | [y/n] | if y, perform inverse operation |
int | niter=100 | ||
int | np= | number of p values (if adj=y) | |
int | ns=1 | number of sharpening cycles | |
int | nx= | number of offsets (if adj=n) | |
string | offset= | auxiliary input file name | |
float | ox= | ||
float | p0= | p origin (if adj=y) | |
bool | parab=n | [y/n] | if y, parabolic Radon transform |
float | perc=50.0 | percentage for sharpening | |
bool | spk=inv | [y/n] | if y, use spiking (hi-res) inversion |
float | tol=1.e-6 | inversion tolerance | |
bool | verb=n | [y/n] | verbosity flag |
float | x0=1. | reference offset |
sfrandrefl
Simple synthetics with random reflectivity. | |||
---|---|---|---|
sfrandrefl > mod.rsf vpvs=vpvs.rsf fo= nr= n1=3501 d1=0.001 o1=0.0 tscale=1. func= | |||
float | d1=0.001 | time sampling | |
floats | fo= | [3] | |
string | func= | type of vpvs function | |
int | n1=3501 | time length | |
int | nr= | number of reflectors | |
float | o1=0.0 | time origin | |
float | tscale=1. | maximum time | |
file | vpvs= | auxiliary output file name |
sfrays2
Ray tracing by a Runge-Kutta integrator. | |||
---|---|---|---|
sfrays2 < vel.rsf > rays.rsf shotfile=shots.rsf anglefile=angles.rsf vel=y order=4 nt= dt= sym=y verb=y escvar=n zshot=0. yshot=o[1] + 0.5*(n[1]-1)*d[1] nr= a0=0. amax=360. > rays.rsf | |||
Rays can be plotted with sfplotrays. | |||
float | a0=0. | minimum angle (if no anglefile) | |
float | amax=360. | maximum angle (if no anglefile) | |
string | anglefile= | file with initial angles (auxiliary input file name) | |
float | dt= | Sampling in time | |
bool | escvar=n | [y/n] | If y - output escape values, n - trajectories |
int | nr= | number of angles (if no anglefile) | |
int | nt= | Number of time steps | |
int | order=4 | Interpolation order | |
string | shotfile= | file with shot locations (auxiliary input file name) | |
bool | sym=y | [y/n] | if y, use symplectic integrator |
bool | vel=y | [y/n] | If y, input is velocity; if n, slowness |
bool | verb=y | [y/n] | Verbosity flag |
float | yshot=o[1] + 0.5*(n[1]-1)*d[1] | ||
float | zshot=0. | shot coordinates (if no shotfile) |
sfrays2a
Ray tracing in VTI media by a Runge-Kutta integrator. | |||
---|---|---|---|
sfrays2a < vz.rsf > rays.rsf shotfile=shots.rsf anglefile=angles.rsf vel=y order=4 nt= dt= verb=y escvar=n zshot=0. yshot=o[1] + 0.5*(n[1]-1)*d[1] nr= a0=0. amax=360. vx= eta= > rays.rsf | |||
Rays can be plotted with sfplotrays. | |||
float | a0=0. | minimum angle (if no anglefile) | |
float | amax=360. | maximum angle (if no anglefile) | |
string | anglefile= | file with initial angles (auxiliary input file name) | |
float | dt= | Sampling in time | |
bool | escvar=n | [y/n] | If y - output escape values, n - trajectories |
string | eta= | eta parameter | |
int | nr= | number of angles (if no anglefile) | |
int | nt= | Number of time steps | |
int | order=4 | Interpolation order | |
string | shotfile= | file with shot locations (auxiliary input file name) | |
bool | vel=y | [y/n] | If y, input is velocity; if n, slowness |
bool | verb=y | [y/n] | Verbosity flag |
string | vx= | horizontal velocity or slowness | |
float | yshot=o[1] + 0.5*(n[1]-1)*d[1] | ||
float | zshot=0. | shot coordinates (if no shotfile) |
sfrays3
Ray tracing by a Runge-Kutta integrator in 3-D. | |||
---|---|---|---|
sfrays3 < vel.rsf > rays.rsf shotfile=shots.rsf anglefile=angles.rsf vel=y order=4 nt= dt= sym=y escvar=n zshot=o[0] yshot=o[1] + 0.5*(n[1]-1)*d[1] xshot=o[2] + 0.5*(n[2]-1)*d[2] na= nb= a0=0. amax=360. b0=0. bmax=180. > rays.rsf | |||
Rays can be plotted with sfplotrays. | |||
float | a0=0. | First azimuth angle in degrees (if anglefile is not specified) | |
float | amax=360. | Maximum azimuth angle in degrees (if anglefile is not specified) | |
string | anglefile= | file with initial angles (auxiliary input file name) | |
float | b0=0. | First inclination angle in degrees (if anglefile is not specified) | |
float | bmax=180. | Maximum inclination angle in degrees (if anglefile is not specified) | |
float | dt= | Sampling in time | |
bool | escvar=n | [y/n] | If y - output escape values, n - trajectories |
int | na= | Number of azimuths (if anglefile is not specified) | |
int | nb= | Number of inclinations (if anglefile is not specified) | |
int | nt= | Number of time steps | |
int | order=4 | Interpolation order | |
string | shotfile= | file with shot locations (auxiliary input file name) | |
bool | sym=y | [y/n] | if y, use symplectic integrator |
bool | vel=y | [y/n] | If y, input is velocity; if n, slowness |
float | xshot=o[2] + 0.5*(n[2]-1)*d[2] | shot location crossline (if shotfile is not specified) | |
float | yshot=o[1] + 0.5*(n[1]-1)*d[1] | shot location inline (if shotfile is not specified) | |
float | zshot=o[0] | shot location in depth (if shotfile is not specified) |
sfrefer
Subtract a reference from a grid. | |||
---|---|---|---|
sfrefer < in.rsf > out.rsf ref=ref.rsf | |||
file | ref= | auxiliary input file name |
sfricker
Ricker wavelet estimation. | |||
---|---|---|---|
sfricker < in.rsf > out.rsf ma=ma.rsf m=f0+0.25*(na-1)*df niter=100 verb=n | |||
float | m=f0+0.25*(na-1)*df | initial frequency | |
file | ma= | auxiliary output file name | |
int | niter=100 | number of iterations | |
bool | verb=n | [y/n] | verbosity flag |
sfricker1
Convolution with a Ricker wavelet. | |||
---|---|---|---|
sfricker1 < in.rsf > out.rsf frequency= freq=0.2 deriv=n | |||
January 2013 program of the month: http://ahay.org/rsflog/index.php?/archives/318-Program-of-the-month-sfricker1.html | |||
bool | deriv=n | [y/n] | apply a half-order derivative filter |
float | freq=0.2 | peak frequency for Ricker wavelet (as fraction of Nyquist) | |
float | frequency= | peak frequency for Ricker wavelet (in Hz) |
sfricker2
Nonstationary convolution with a Ricker wavelet. Phase and Frequency can be time-varying. | |||
---|---|---|---|
sfricker2 < in.rsf > out.rsf tfreq=tfre.rsf tphase=tpha.rsf frequency= freq=0.2 esp=0. norm=n hiborder=6 hibref=1. | |||
float | esp=0. | if norm=y, stable parameter | |
float | freq=0.2 | peak frequency for Ricker wavelet (as fraction of Nyquist) | |
float | frequency= | peak frequency for Ricker wavelet (in Hz) | |
int | hiborder=6 | Hilbert transformer order | |
float | hibref=1. | ||
bool | norm=n | [y/n] | |
file | tfreq= | auxiliary input file name | |
string | tphase= | auxiliary input file name |
sfrweab
Riemannian Wavefield Extrapolation: a,b coefficients | |||
---|---|---|---|
sfrweab < Fi.rsf slo=Fs.rsf > Fo.rsf abr=Fr.rsf verb=n naref=1 nbref=1 peps=0.01 | |||
file | abr= | auxiliary output file name | |
int | naref=1 | ||
int | nbref=1 | ||
float | peps=0.01 | ||
file | slo= | auxiliary input file name | |
bool | verb=n | [y/n] |
sfrwesrmig
Riemannian Wavefield Extrapolation: shot-record migration. | |||
---|---|---|---|
sfrwesrmig abm=Fm.rsf abr=Fr.rsf < Fw_s.rsf > Fw_r.rsf img=Fi.rsf verb=n method=0 adj=n | |||
file | abm= | auxiliary input file name | |
file | abr= | auxiliary input file name | |
bool | adj=n | [y/n] | y=modeling; n=migration |
file | img= | auxiliary input file name | |
int | method=0 | extrapolation method | |
bool | verb=n | [y/n] |
sfrwezomig
Riemannian Wavefield Extrapolation: zero-offset modeling/migration | |||
---|---|---|---|
sfrwezomig abm=Fm.rsf abr=Fr.rsf < Fi.rsf > Fd.rsf verb=n method=0 adj=n nw= dw= ow=0. | |||
file | abm= | auxiliary input file name | |
file | abr= | auxiliary input file name | |
bool | adj=n | [y/n] | y=modeling; n=migration |
float | dw= | ||
int | method=0 | extrapolation method | |
int | nw= | ||
float | ow=0. | ||
bool | verb=n | [y/n] |
sfs2ofz
Analytical point-source traveltime in a linear slowness squared model. | |||
---|---|---|---|
sfs2ofz > out.rsf n= g=-6. v0=4 s=0.5 | |||
float | g=-6. | slowness squared gradient | |
int | n= | number of samples | |
float | s=0.5 | shot location at the surface | |
float | v0=4 | initial slowness squared |
sfs2ofz2
Analytical plane-wave traveltime in a linear slowness squared model. | |||
---|---|---|---|
sfs2ofz2 > out.rsf n= gz=-6. gx=2. v0=4 | |||
float | gx=2. | slowness squared gradient | |
float | gz=-6. | ||
int | n= | number of samples | |
float | v0=4 | initial slowness squared |
sfsegyheader
Make a trace header file for segywrite. | |||
---|---|---|---|
sfsegyheader < in.rsf > out.rsf n1= d1= o1=0 | |||
Use the output for tfile= argument in segywrite. | |||
float | d1= | trace sampling | |
int | n1= | number of samples in a trace | |
float | o1=0 | trace origin |
sfsegyread
Convert a SEG-Y or SU dataset to RSF. | |||
---|---|---|---|
sfsegyread mask=msk.rsf > out.rsf tfile=hdr.rsf verb=n su= suxdr=n endian=y n2=0 format=segyformat (bhead) ns=segyns (bhead) key#= tape= hfile= bfile= read= | |||
Data headers and trace headers are separated from the data. "suread" is equivalent to "segyread su=y" SEGY key names: tracl: trace sequence number within line 0 tracr: trace sequence number within reel 4 fldr: field record number 8 tracf: trace number within field record 12 ep: energy source point number 16 cdp: CDP ensemble number 20 cdpt: trace number within CDP ensemble 24 trid: trace identification code: 1 = seismic data 2 = dead 3 = dummy 4 = time break 5 = uphole 6 = sweep 7 = timing 8 = water break 9---, N = optional use (N = 32,767) 28 nvs: number of vertically summed traces 30 nhs: number of horizontally summed traces 32 duse: data use: 1 = production 2 = test 34 offset: distance from source point to receiver group (negative if opposite to direction in which the line was shot) 36 gelev: receiver group elevation from sea level (above sea level is positive) 40 selev: source elevation from sea level (above sea level is positive) 44 sdepth: source depth (positive) 48 gdel: datum elevation at receiver group 52 sdel: datum elevation at source 56 swdep: water depth at source 60 gwdep: water depth at receiver group 64 scalel: scale factor for previous 7 entries with value plus or minus 10 to the power 0, 1, 2, 3, or 4 (if positive, multiply, if negative divide) 68 scalco: scale factor for next 4 entries with value plus or minus 10 to the power 0, 1, 2, 3, or 4 (if positive, multiply, if negative divide) 70 sx: X source coordinate 72 sy: Y source coordinate 76 gx: X group coordinate 80 gy: Y group coordinate 84 counit: coordinate units code: for previous four entries 1 = length (meters or feet) 2 = seconds of arc (in this case, the X values are unsigned longitude and the Y values are latitude, a positive value designates the number of seconds east of Greenwich or north of the equator 88 wevel: weathering velocity 90 swevel: subweathering velocity 92 sut: uphole time at source 94 gut: uphole time at receiver group 96 sstat: source static correction 98 gstat: group static correction 100 tstat: total static applied 102 laga: lag time A, time in ms between end of 240- byte trace identification header and time break, positive if time break occurs after end of header, time break is defined as the initiation pulse which maybe recorded on an auxiliary trace or as otherwise specified by the recording system 104 lagb: lag time B, time in ms between the time break and the initiation time of the energy source, may be positive or negative 106 delrt: delay recording time, time in ms between initiation time of energy source and time when recording of data samples begins (for deep water work if recording does not start at zero time) 108 muts: mute time--start 110 mute: mute time--end 112 ns: number of samples in this trace 114 dt: sample interval, in micro-seconds 116 gain: gain type of field instruments code: 1 = fixed 2 = binary 3 = floating point 4 ---- N = optional use 118 igc: instrument gain constant 120 igi: instrument early or initial gain 122 corr: correlated: 1 = no 2 = yes 124 sfs: sweep frequency at start 126 sfe: sweep frequency at end 128 slen: sweep length in ms 130 styp: sweep type code: 1 = linear 2 = cos-squared 3 = other 132 stas: sweep trace length at start in ms 134 stae: sweep trace length at end in ms 136 tatyp: taper type: 1=linear, 2=cos^2, 3=other 138 afilf: alias filter frequency if used 140 afils: alias filter slope 142 nofilf: notch filter frequency if used 144 nofils: notch filter slope 146 lcf: low cut frequency if used 148 hcf: high cut frequncy if used 150 lcs: low cut slope 152 hcs: high cut slope 154 year: year data recorded 156 day: day of year 158 hour: hour of day (24 hour clock) 160 minute: minute of hour 162 sec: second of minute 164 timbas: time basis code: 1 = local 2 = GMT 3 = other 166 trwf: trace weighting factor, defined as 1/2^N volts for the least sigificant bit 168 grnors: geophone group number of roll switch position one 170 grnofr: geophone group number of trace one within original field record 172 grnlof: geophone group number of last trace within original field record 174 gaps: gap size (total number of groups dropped) 176 otrav: overtravel taper code: 1 = down (or behind) 2 = up (or ahead) 178 cdpx: X coordinate of CDP 180 cdpy: Y coordinate of CDP 184 iline: in-line number 188 xline: cross-line number 192 shnum: shotpoint number 196 shsca: shotpoint scalar 200 tval: trace value meas. 202 tconst4: transduction const 204 tconst2: transduction const 208 tunits: transduction units 210 device: device identifier 212 tscalar: time scalar 214 stype: source type 216 sendir: source energy dir. 218 unknown: unknown 222 smeas4: source measurement 224 smeas2: source measurement 228 smeasu: source measurement unit 230 unass1: unassigned 232 unass2: unassigned 236 | |||
string | bfile= | output binary data header file | |
bool | endian=y | [y/n] | Whether to automatically estimate endianness or not |
int | format=segyformat (bhead) | [1,2,3,5] | Data format. The default is taken from binary header.
|
string | hfile= | output text data header file | |
string | key#= | extra key for trace headers | |
string | mask= | optional header mask for reading only selected traces (auxiliary input file name) | |
int | n2=0 | number of traces to read (if 0, read all traces) | |
int | ns=segyns (bhead) | Number of samples. The default is taken from binary header | |
string | read= | what to read: h - header, d - data, b - both (default) | |
bool | su= | [y/n] | y if input is SU, n if input is SEGY |
bool | suxdr=n | [y/n] | y, SU has XDR support |
string | tape= | input data | |
string | tfile= | output trace header file (auxiliary output file name) | |
bool | verb=n | [y/n] | Verbosity flag |
sfsegywrite
Convert an RSF dataset to SEGY or SU. | |||
---|---|---|---|
sfsegywrite < in.rsf tfile=hdr.rsf verb=n endian=y su= suxdr=n suxdr=n tape= hfile= bfile= | |||
Merges trace headers with data. "suwrite" is equivalent to "segywrite su=y" | |||
string | bfile= | input binary data header file | |
bool | endian=y | [y/n] | Whether to automatically estimate endianness or not |
string | hfile= | input text data header file | |
bool | su= | [y/n] | y if input is SU, n if input is SEGY |
bool | suxdr=n | [y/n] | y, SU has XDR support |
string | tape= | output data | |
file | tfile= | auxiliary input file name | |
bool | verb=n | [y/n] | Verbosity flag |
sfshifts
Multiple shifts. | |||
---|---|---|---|
sfshifts < inp.rsf > out.rsf np= dp= p0= | |||
float | dp= | slope sampling | |
int | np= | number of slopes | |
float | p0= | first slope |
sfshoot2
2-D ray shooting. | |||
---|---|---|---|
sfshoot2 < vel.rsf > out.rsf shotfile=shots.rsf vel=y order=4 nt=nx*nz nr=1 r0=x0 dr=dx tol=0.01 | |||
float | dr=dx | receiver increment | |
int | nr=1 | number of recievers | |
int | nt=nx*nz | Maximum number of time steps | |
int | order=4 | Interpolation order | |
float | r0=x0 | first receiver | |
string | shotfile= | file with shot locations (auxiliary input file name) | |
float | tol=0.01 | Shooting tolerance (in degrees) | |
bool | vel=y | [y/n] | If y, the input is velocity; if n, slowness |
sfshot2cmp
Convert shots to CMPs for regular 2-D geometry. | |||
---|---|---|---|
sfshot2cmp < in.rsf > out.rsf mask=msk.rsf positive=y half=y | |||
The axes in the input are {time,offset,shot} The axes in the output are {time,offset,midpoint} | |||
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
string | mask= | auxiliary output file name | |
bool | positive=y | [y/n] | initial offset orientation |
sfshotconstkirch
Prestack shot-profile Kirchhoff migration in constant velocity. | |||
---|---|---|---|
sfshotconstkirch < inp.rsf > out.rsf aal=y nx=ns dx=ds x0=s0 offset=n vel= | |||
Requires the input to be in (time,offset,shot) | |||
bool | aal=y | [y/n] | if y, apply antialiasing |
float | dx=ds | ||
int | nx=ns | ||
bool | offset=n | [y/n] | if y, the output is in offset |
float | vel= | velocity | |
float | x0=s0 |
sfshotholes
Remove random shot gathers from a 2-D dataset. | |||
---|---|---|---|
sfshotholes < in.rsf > mask.rsf perc=0.75 | |||
float | perc=0.75 | how many shots to remove |
sfshotprop
Shot propagation. | |||
---|---|---|---|
sfshotprop < in.rsf > out.rsf ns= ds= eps=0.1 positive=y | |||
float | ds= | shot sampling | |
float | eps=0.1 | regularization parameter | |
int | ns= | number of shots | |
bool | positive=y | [y/n] | initial offset orientation |
sfsin
Simple operations with complex sinusoids | |||
---|---|---|---|
sfsin < in.rsf > out.rsf root=root.rsf mask=mask.rsf adj=n verb=n niter=0 rect=1 perc=50. eps=1./n1 oper= type= | |||
bool | adj=n | [y/n] | adjoint flag |
float | eps=1./n1 | scaling for shaping inversion | |
string | mask= | missing data interpolation (auxiliary input file name) | |
int | niter=0 | number of iterations | |
string | oper= | operation to perform | |
float | perc=50. | percentage for thresholding (used when oper=t and niter > 0) | |
int | rect=1 | ||
file | root= | auxiliary input file name | |
string | type= | [haar,linear,biortho] type of the seislet transform | |
bool | verb=n | [y/n] | verbosity flag |
sfslant
Time-space-domain Radon transform (slant stack) | |||
---|---|---|---|
sfslant < in.rsf > out.rsf verb=n adj=n rho=y anti=1. np= dp= p0= x0= dx= nx= p1=0. | |||
bool | adj=n | [y/n] | adjoint flag |
float | anti=1. | antialiasing | |
float | dp= | p sampling (if adj=y) | |
float | dx= | offset sampling | |
int | np= | number of p values (if adj=y) | |
int | nx= | number of offsets | |
float | p0= | p origin (if adj=y) | |
float | p1=0. | reference slope | |
bool | rho=y | [y/n] | rho filtering |
bool | verb=n | [y/n] | verbosity flag |
float | x0= | offset origin |
sfsrmva
3-D S/R WEMVA with extended split-step | |||
---|---|---|---|
sfsrmva slo=Bs.rsf swf=Bw_s.rsf rwf=Bw_r.rsf < Pi.rsf > Ps.rsf verb=y eps=0.01 adj=n twoway=y nrmax=1 dtmax=0.004 pmx=0 pmy=0 tmx=0 tmy=0 | |||
bool | adj=n | [y/n] | y=ADJ scat; n=FWD scat |
float | dtmax=0.004 | max time error | |
float | eps=0.01 | stability parameter | |
int | nrmax=1 | max number of refs | |
int | pmx=0 | padding on x | |
int | pmy=0 | padding on y | |
file | rwf= | auxiliary input file name | |
file | slo= | auxiliary input file name | |
file | swf= | auxiliary input file name | |
int | tmx=0 | taper on x | |
int | tmy=0 | taper on y | |
bool | twoway=y | [y/n] | two-way traveltime |
bool | verb=y | [y/n] | verbosity flag |
sfsrsyn
Synthesize shot/receiver wavefields for 3-D SR migration | |||
---|---|---|---|
sfsrsyn < Fr.rsf wav=Fs.rsf swf=Fsw.rsf > Frw.rsf nx= dx= ox= ny=1 dy=1 oy=0 | |||
float | dx= | x sampling | |
float | dy=1 | y sampling | |
int | nx= | x samples | |
int | ny=1 | y samples | |
float | ox= | x origin | |
float | oy=0 | y origin | |
file | swf= | auxiliary output file name | |
file | wav= | auxiliary input file name |
sfsstep2
3-D post-stack modeling/migration with extended split step. | |||
---|---|---|---|
sfsstep2 < in.rsf > out.rsf slowness=vel.rsf inv=n verb=n eps=0.01 nt=1 nr=1 padx=0 pady=0 dt=0.004 nw= dw= w0=0. | |||
float | dt=0.004 | time error | |
float | dw= | Frequency sampling (for modeling) | |
float | eps=0.01 | stability parameter | |
bool | inv=n | [y/n] | If y, modeling; if n, migration |
int | nr=1 | maximum number of references | |
int | nt=1 | taper size | |
int | nw= | Length of frequency axis (for modeling) | |
int | padx=0 | cross-line padding | |
int | pady=0 | in-line padding | |
file | slowness= | auxiliary input file name | |
bool | verb=n | [y/n] | verbosity flag |
float | w0=0. | Frequency origin (for modeling) |
sfstolt
Post-stack Stolt modeling/migration. | |||
---|---|---|---|
sfstolt < in.rsf > out.rsf vel= pad=nt extend=4 mute=12 minstr=0.0 | |||
Requires the input to be cosine-transformed over the lateral axes. | |||
int | extend=4 | trace extension | |
float | minstr=0.0 | minimum stretch allowed | |
int | mute=12 | mute zone | |
int | pad=nt | padding on the time axis | |
float | vel= | Constant velocity (use negative velocity for modeling) |
sfstolt2
Post-stack Stolt modeling/migration. | |||
---|---|---|---|
sfstolt2 < in.rsf > out.rsf vel= pad=nt nf=2 | |||
Requires the input to be cosine-transformed over the lateral axes. | |||
int | nf=2 | Interpolation accuracy | |
int | pad=nt | padding on the time axis | |
float | vel= | Constant velocity (use negative velocity for modeling) |
sfstoltstretch
Stolt stretch. | |||
---|---|---|---|
sfstoltstretch < in.rsf > st.rsf velocity=vel.rsf inv=n nstretch=1 pad=nt eps=0.01 vel= | |||
float | eps=0.01 | stretch regularization | |
bool | inv=n | [y/n] | if y, inverse stretch |
int | nstretch=1 | number of steps | |
int | pad=nt | time axis padding | |
float | vel= | reference velocity | |
file | velocity= | auxiliary input file name |
sfstretch
Stretch of the time axis. | |||
---|---|---|---|
sfstretch < in.rsf > out.rsf datum=dat.rsf inv=n dens=1 verb=y v0= half=y CDPtype= delay= tdelay= hdelay= scale= nout=dens*n1 extend=4 mute=0 maxstr=0 rule= | |||
int | CDPtype= | ||
file | datum= | auxiliary input file name | |
float | delay= | time delay for rule=lmo | |
int | dens=1 | axis stretching factor | |
int | extend=4 | trace extension | |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
float | hdelay= | offset delay for rule=rad | |
bool | inv=n | [y/n] | if y, do inverse stretching |
float | maxstr=0 | maximum stretch | |
int | mute=0 | tapering size | |
int | nout=dens*n1 | output axis length (if inv=n) | |
string | rule= | Stretch rule:
| |
float | scale= | scaling factor for rule=scale | |
float | tdelay= | time delay for rule=rad | |
float | v0= | moveout velocity | |
bool | verb=y | [y/n] | verbosity flag |
sftan2ang
tangent to angle transformation | |||
---|---|---|---|
sftan2ang < Fstk.rsf > Fang.rsf velocity=velocity.rsf na=nt da=90/(nt-1) a0=0. extend=4 top=n | |||
float | a0=0. | ||
float | da=90/(nt-1) | ||
int | extend=4 | tmp extension | |
int | na=nt | ||
bool | top=n | [y/n] | |
file | velocity= | auxiliary input file name |
sftaupmo
Normal moveout in tau-p domain. | |||
---|---|---|---|
sftaupmo < taup.rsf velocity=velocity.rsf > nmod.rsf slope=slope.rsf velx=velocityx.rsf mute=12 str=0.5 extend=4 interval=y | |||
int | extend=4 | interpolation accuracy | |
bool | interval=y | [y/n] | use interval velocity |
int | mute=12 | mute zone | |
string | slope= | auxiliary input file name | |
float | str=0.5 | maximum stretch | |
file | velocity= | auxiliary input file name | |
string | velx= | auxiliary input file name |
sftime2depth
Time-to-depth conversion in V(z). | |||
---|---|---|---|
sftime2depth < in.rsf velocity=velocity.rsf > out.rsf intime=n nz= dz= z0=0. extend=4 slow=n twoway=y eps=0.01 | |||
float | dz= | Depth sampling (default: d1) | |
float | eps=0.01 | stretch regularization | |
int | extend=4 | Interpolation accuracy | |
bool | intime=n | [y/n] | y if velocity is in time rather than depth |
int | nz= | Number of depth samples (default: n1) | |
bool | slow=n | [y/n] | If y, input slowness; if n, velocity |
bool | twoway=y | [y/n] | if y, two-way traveltime |
file | velocity= | auxiliary input file name | |
float | z0=0. | Depth origin |
sftlagtoang2d
SS(t-lag) to angle transformation (PP or PS waves) | |||
---|---|---|---|
sftlagtoang2d < Fstk.rsf > Fang.rsf vpvs=Fgam.rsf dip=Fdip.rsf vel=Fvel.rsf verb=n inv=n na=sf_n(as) da=1./(sf_n(as)-1) oa=0. extend=4 | |||
float | da=1./(sf_n(as)-1) | ||
file | dip= | auxiliary input file name | |
int | extend=4 | tmp extension | |
bool | inv=n | [y/n] | inverse transformation flag |
int | na=sf_n(as) | ||
float | oa=0. | ||
file | vel= | auxiliary input file name | |
bool | verb=n | [y/n] | verbosity flag |
file | vpvs= | auxiliary input file name |
sftshift
Compute angle gathers for time-shift imaging condition | |||
---|---|---|---|
sftshift < Fstk.rsf velocity=Fvel.rsf dip=Fdip.rsf > Fang.rsf na=nv da=1./(nv-1) a0=0. extend=4 cos=n | |||
float | a0=0. | ||
bool | cos=n | [y/n] | if n, convert pseudo-v to pseudo-tan(theta);
|
float | da=1./(nv-1) | ||
file | dip= | auxiliary input file name | |
int | extend=4 | tmp extension | |
int | na=nv | ||
file | velocity= | auxiliary input file name |
sftxpnmo
Normal moveout in TXP domain. | |||
---|---|---|---|
sftxpnmo < cmp.rsf velocity=velocity.rsf > nmod.rsf str=0.5 mute=12 extend=4 | |||
int | extend=4 | trace extension | |
int | mute=12 | mute zone | |
float | str=0.5 | maximum stretch allowed | |
file | velocity= | auxiliary input file name |
sftxpscan
Velocity analysis using T-X-P domain. | |||
---|---|---|---|
sftxpscan < cmp.rsf > scan.rsf v0= dv= nv= extend=4 mute=12 str=0.5 smin=1.0 smax=2.0 | |||
float | dv= | step in velocity | |
int | extend=4 | trace extension | |
int | mute=12 | mute zone | |
int | nv= | number of scanned velocities | |
float | smax=2.0 | maximum heterogeneity | |
float | smin=1.0 | minimum heterogeneity | |
float | str=0.5 | maximum stretch allowed | |
float | v0= | first scanned velocity |
sfvelmod
Velocity transform. | |||
---|---|---|---|
sfvelmod < scan.rsf > cmp.rsf half=y extend=4 slowness=n | |||
Inverse of sfvscan. | |||
int | extend=4 | trace extension | |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
bool | slowness=n | [y/n] | if y, use slowness instead of velocity |
sfveltran
Hyperbolic Radon transform | |||
---|---|---|---|
sfveltran < in.rsf > out.rsf adj=n anti=1. s02=0. pull=y | |||
bool | adj=n | [y/n] | adjoint flag |
float | anti=1. | antialiasing | |
bool | pull=y | [y/n] | pull or push operator |
float | s02=0. | reference slowness squared (for antialiasing) |
sfvoft
V(t) function for a linear V(Z) profile. | |||
---|---|---|---|
sfvoft < in.rsf > out.rsf v0=1.5 alpha=0.5 | |||
float | alpha=0.5 | velocity gradient | |
float | v0=1.5 | initial velocity |
sfvofz
Analytical traveltime in a linear V(z) model. | |||
---|---|---|---|
sfvofz > out.rsf n1= n= n2= n= g=1. v0=0.5 s=0.5 d1=0.5/(n1-1) d2=1./(n2-1) o1=0. o2=0. intime=n | |||
float | d1=0.5/(n1-1) | vertical sampling | |
float | d2=1./(n2-1) | horizontal sampling | |
float | g=1. | velocity gradient | |
bool | intime=n | [y/n] | if in vertical time coordinates |
int | n= | number of samples | |
int | n1= | vertical samples | |
int | n2= | horizontal samples | |
float | o1=0. | vertical origin | |
float | o2=0. | horizontal origin | |
float | s=0.5 | shot location at the surface | |
float | v0=0.5 | initial velocity |
sfvscan
Velocity analysis. | |||
---|---|---|---|
sfvscan < cmp.rsf > scan.rsf offset=offset.rsf mask=msk.rsf grad=grd.rsf semblance=n diffsemblance=n avosemblance=n nb=2 weight=y half=y smax=2.0 ns=1 slowness=n squared=n v1= extend=4 mute=12 str=0.5 v0= dv= nv= v1= type= | |||
Inverse of sfvelmod | |||
bool | avosemblance=n | [y/n] | if y, compute AVO-friendly semblance |
bool | diffsemblance=n | [y/n] | if y, compute differential semblance |
float | dv= | step in velocity | |
int | extend=4 | trace extension | |
string | grad= | auxiliary input file name | |
bool | half=y | [y/n] | if y, the second axis is half-offset instead of full offset |
string | mask= | optional mask file (auxiliary input file name) | |
int | mute=12 | mute zone | |
int | nb=2 | semblance averaging | |
int | ns=1 | number of heterogeneity scans | |
int | nv= | number of scanned velocities | |
string | offset= | auxiliary input file name | |
bool | semblance=n | [y/n] | if y, compute semblance; if n, stack |
bool | slowness=n | [y/n] | if y, use slowness instead of velocity |
float | smax=2.0 | maximum heterogeneity | |
bool | squared=n | [y/n] | if y, the slowness or velocity is squared |
float | str=0.5 | maximum stretch allowed | |
string | type= | type of semblance (avo,diff,sembl,power,weighted) | |
float | v0= | first scanned velocity | |
float | v1= | reference velocity | |
bool | weight=y | [y/n] | if y, apply pseudo-unitary weighting |
sfxlagtoang2d
SS(x-lag) to angle transformation (PP or PS waves) | |||
---|---|---|---|
sfxlagtoang2d < Fstk.rsf > Fang.rsf vpvs=Fgam.rsf dip=Fdip.rsf verb=n inv=n na=sf_n(axs) da=1./(sf_n(axs)-1) oa=0. extend=4 | |||
float | da=1./(sf_n(axs)-1) | ||
file | dip= | auxiliary input file name | |
int | extend=4 | tmp extension | |
bool | inv=n | [y/n] | inverse transformation flag |
int | na=sf_n(axs) | ||
float | oa=0. | ||
bool | verb=n | [y/n] | verbosity flag |
file | vpvs= | auxiliary input file name |
sfzoeppritz
Testing Zoeppritz equation | |||
---|---|---|---|
sfzoeppritz > out.rsf na=90 a0=0. da=90./na icoef=1 vp1= vp2= vs1= vs2= rho1=1. rho2=1. incp=y outp=y refl=y | |||
float | a0=0. | first angle | |
float | da=90./na | angle increment | |
int | icoef=1 | [1,2,3] | particle displacement, displacement potential, or energy |
bool | incp=y | [y/n] | incident P (or S) |
int | na=90 | number of angles | |
bool | outp=y | [y/n] | rellected/transmitted P (or S) |
bool | refl=y | [y/n] | reflection or transmission |
float | rho1=1. | ||
float | rho2=1. | ||
float | vp1= | ||
float | vp2= | ||
float | vs1= | ||
float | vs2= |
sfzomig
3-D zero-offset modeling/migration with extended split-step | |||
---|---|---|---|
sfzomig slo=Fs.rsf < Fd.rsf > Fw.rsf < Fi.rsf verb=n incore=y eps=0.01 inv=n causal=n twoway=y nrmax=1 dtmax=0.004 pmx=0 pmy=0 tmx=0 tmy=0 nw= dw= ow=0. mode= | |||
To be deprecated in favor of zomig3 | |||
bool | causal=n | [y/n] | y=causal; n=anti-causal |
float | dtmax=0.004 | time error | |
float | dw= | ||
float | eps=0.01 | stability parameter | |
bool | incore=y | [y/n] | in core execution |
bool | inv=n | [y/n] | y=modeling; n=migration |
string | mode= | ||
int | nrmax=1 | maximum references | |
int | nw= | ||
float | ow=0. | ||
int | pmx=0 | padding on x | |
int | pmy=0 | padding on y | |
file | slo= | auxiliary input file name | |
int | tmx=0 | taper on x | |
int | tmy=0 | taper on y | |
bool | twoway=y | [y/n] | two-way traveltime |
bool | verb=n | [y/n] | verbosity flag |
sfzomva
3-D zero-offset WEMVA | |||
---|---|---|---|
sfzomva slo=Bs.rsf wfl=Bw.rsf < Pi.rsf > Ps.rsf verb=n eps=0.01 inv=n twoway=y nrmax=1 dtmax=0.004 pmx=0 pmy=0 tmx=0 tmy=0 | |||
float | dtmax=0.004 | time error | |
float | eps=0.01 | stability parameter | |
bool | inv=n | [y/n] | y=modeling; n=migration |
int | nrmax=1 | maximum number of references | |
int | pmx=0 | padding on x | |
int | pmy=0 | padding on y | |
file | slo= | auxiliary input file name | |
int | tmx=0 | taper on x | |
int | tmy=0 | taper on y | |
bool | twoway=y | [y/n] | two-way traveltime |
bool | verb=n | [y/n] | verbosity flag |
file | wfl= | auxiliary input file name |