Пример #1
0
def thrsou(ss,wav,par):

    par['xsou0']=par['xsou']-0.25
    par['zsou0']=par['zsou']-0.25

    par['xsou1']=par['xsou']
    par['zsou1']=par['zsou']
    
    par['xsou2']=par['xsou']+0.25
    par['zsou2']=par['zsou']+0.25
    
    for j in range(3):
        fdmod.point(ss+str(j),par['xsou'+str(j)],par['zsou'+str(j)],par)
        Flow(ss,[ss+'0',ss+'1',ss+'2'],'cat axis=2 space=n ${SOURCES[1:3]}')

    fdmod.wavelet(wav+'0_',50,par)
    Flow(wav+'0',
         wav+'0_',
         'scale rscale=1.0 | window f1=100 | pad end1=100 | put o1=%(ot)g n2=1' %par)
        
    fdmod.wavelet(wav+'1_',50,par) 
    Flow(wav+'1',
         wav+'1_',
         'window' %par)
    
    fdmod.wavelet(wav+'2_',50,par)
    Flow(wav+'2',
         wav+'2_',
         'scale rscale=1.0 | pad beg1=100 | window n1=%(nt)d | put o1=%(ot)g n2=1' %par)
    
    Flow(wav,[wav+'0',wav+'1',wav+'2'],
         '''
         cat axis=2 space=n ${SOURCES[1:3]} |
         transp
         ''')
Пример #2
0
def shotcoord(ss,par):

    for iexp in range(par['ns']):
        etag = "-e%03d" % iexp
    
        xsou = par['os'] + (par['fs'] + iexp * par['js']) * par['ds']
        fdmod.point('ss'+etag,xsou,par['ozimg'],par)
        Plot(ss+etag,fdmod.ssplot('plotcol=5',par))
        
    Plot(ss,map(lambda x: ss+'-e%03d'%x,range(par['ns'])),
         'cat axis=3 space=n ${SOURCES[1:%d]} |' % par['ns']
         + fdmod.ssplot('plotcol=5',par))
Пример #3
0
def shotcoord(ss, par):

    for iexp in range(par['ns']):
        etag = "-e%03d" % iexp

        xsou = par['os'] + (par['fs'] + iexp * par['js']) * par['ds']
        fdmod.point('ss' + etag, xsou, par['ozimg'], par)
        Plot(ss + etag, fdmod.ssplot('plotcol=5', par))

    Plot(
        ss, map(lambda x: ss + '-e%03d' % x, range(par['ns'])),
        'cat axis=3 space=n ${SOURCES[1:%d]} |' % par['ns'] +
        fdmod.ssplot('plotcol=5', par))
Пример #4
0
def points(sp,sa,wp,xm,qq,par):
    
    # ------------------------------------------------------------
    ls = 2*par['lo']    

    par['zs' ] = par['oz'] + par['lo']
    par['zs0'] = par['zt']+ls
    par['zs1'] = par['zt']
    par['zs2'] = par['zt']-ls

    par['xs' ] = par['xt']
    par['xs0'] = par['xt']
    par['xs1'] = par['xt']-ls
    par['xs2'] = par['xt']+ls

    par['jzs0'] = par['zs0'] / par['dz']
    par['jzs1'] = par['zs1'] / par['dz']
    par['jzs2'] = par['zs2'] / par['dz']
    
    par['jxs0'] = par['xs0'] / par['dx']
    par['jxs1'] = par['xs1'] / par['dx']
    par['jxs2'] = par['xs2'] / par['dx']
    
    # ------------------------------------------------------------
    # source positions
    fdmod.point('ss0',par['xs0'],par['zs0'],par)
    fdmod.point('ss1',par['xs1'],par['zs1'],par)
    fdmod.point('ss2',par['xs2'],par['zs2'],par)
    Flow(sp,'ss0 ss1 ss2','cat axis=2 space=n ${SOURCES[1:3]} | window n1=2')
    Plot(sp,'window |' + fdmod.ssplot('plotcol=2',par))

    fdmod.point(sa,par['xs'],par['zs'],par)    
    Plot(sa,'window |' + fdmod.ssplot('',par))

    # ------------------------------------------------------------
    # source wavelet
    fdmod.wavelet(wp+'_',par['fo'],par)
    Flow(wp,wp+'_','spray axis=2 n=3 o=0 d=1 | transp')

    # ------------------------------------------------------------
    # scatterrers
    Flow(xm,None,
         '''
         spike nsp=3 mag=1,1,1
         n1=%(nz)d o1=%(oz)g d1=%(dz)g k1=%(jzs0)d,%(jzs1)d,%(jzs2)d l1=%(jzs0)d,%(jzs1)d,%(jzs2)d
         n2=%(nx)d o2=%(ox)g d2=%(dx)g k2=%(jxs0)d,%(jxs1)d,%(jxs2)d l2=%(jxs0)d,%(jxs1)d,%(jxs2)d
         ''' % par)

    Plot(  xm,'smooth rect1=3 rect2=3 repeat=3 |'
           +fdmod.cgrey('pclip=100',par))
    Result(xm,[xm,qq],'Overlay')
Пример #5
0
def points(sp, sa, wp, xm, qq, par):

    # ------------------------------------------------------------
    ls = 2 * par['lo']

    par['zs'] = par['oz'] + par['lo']
    par['zs0'] = par['zt'] + ls
    par['zs1'] = par['zt']
    par['zs2'] = par['zt'] - ls

    par['xs'] = par['xt']
    par['xs0'] = par['xt']
    par['xs1'] = par['xt'] - ls
    par['xs2'] = par['xt'] + ls

    par['jzs0'] = par['zs0'] / par['dz']
    par['jzs1'] = par['zs1'] / par['dz']
    par['jzs2'] = par['zs2'] / par['dz']

    par['jxs0'] = par['xs0'] / par['dx']
    par['jxs1'] = par['xs1'] / par['dx']
    par['jxs2'] = par['xs2'] / par['dx']

    # ------------------------------------------------------------
    # source positions
    fdmod.point('ss0', par['xs0'], par['zs0'], par)
    fdmod.point('ss1', par['xs1'], par['zs1'], par)
    fdmod.point('ss2', par['xs2'], par['zs2'], par)
    Flow(sp, 'ss0 ss1 ss2', 'cat axis=2 space=n ${SOURCES[1:3]} | window n1=2')
    Plot(sp, 'window |' + fdmod.ssplot('plotcol=2', par))

    fdmod.point(sa, par['xs'], par['zs'], par)
    Plot(sa, 'window |' + fdmod.ssplot('', par))

    # ------------------------------------------------------------
    # source wavelet
    fdmod.wavelet(wp + '_', par['fo'], par)
    Flow(wp, wp + '_', 'spray axis=2 n=3 o=0 d=1 | transp')

    # ------------------------------------------------------------
    # scatterrers
    Flow(
        xm, None, '''
         spike nsp=3 mag=1,1,1
         n1=%(nz)d o1=%(oz)g d1=%(dz)g k1=%(jzs0)d,%(jzs1)d,%(jzs2)d l1=%(jzs0)d,%(jzs1)d,%(jzs2)d
         n2=%(nx)d o2=%(ox)g d2=%(dx)g k2=%(jxs0)d,%(jxs1)d,%(jxs2)d l2=%(jxs0)d,%(jxs1)d,%(jxs2)d
         ''' % par)

    Plot(xm,
         'smooth rect1=3 rect2=3 repeat=3 |' + fdmod.cgrey('pclip=100', par))
    Result(xm, [xm, qq], 'Overlay')
Пример #6
0
def new(par):

    fdmod.point3('ssold0', par['ox'] + 3 * par['nx'] / 10 * par['dx'],
                 par['oz'], 1, par)
    fdmod.point3('ssold1', par['ox'] + 5 * par['nx'] / 10 * par['dx'],
                 par['oz'], 1, par)
    fdmod.point3('ssold2', par['ox'] + 6 * par['nx'] / 10 * par['dx'],
                 par['oz'], 1, par)
    Flow('ssold', ['ssold0', 'ssold1', 'ssold2'],
         'cat axis=2 space=n ${SOURCES[0:3]}',
         stdin=0)
    Flow('wavold', 'wav', 'window')
    fdmod.lmodel('doold', 'woold', 'ddold', 'wdold', 'wavold', 'velo', 'refl',
                 'ssold', 'rr', 'jsnap=100 nbz=100 nbx=100 ', par)

    Result('woold', fdmod.wgrey('', par))
    Result('wdold', fdmod.wgrey('', par))

    fdmod.point('ssnew0', par['ox'] + 3 * par['nx'] / 10 * par['dx'],
                par['oz'], par)
    fdmod.point('ssnew1', par['ox'] + 5 * par['nx'] / 10 * par['dx'],
                par['oz'], par)
    fdmod.point('ssnew2', par['ox'] + 6 * par['nx'] / 10 * par['dx'],
                par['oz'], par)
    Flow('ssnew', ['ssnew0', 'ssnew1', 'ssnew2'],
         'cat axis=2 space=n ${SOURCES[0:3]}',
         stdin=0)
    Flow('wavnew', 'wav', 'window squeeze=n')
    fdmod.lwefd1('donew', 'wonew', 'ddnew', 'wdnew', 'wavnew', 'velo', 'dens',
                 'refl', 'ssnew', 'rr', 'jsnap=100 nb=100 ', par)

    Result('wonew', fdmod.wgrey('', par))
    Result('wdnew', fdmod.wgrey('', par))
Пример #7
0
def thrsou(ss, par):
    fdmod.point(ss + '0', par['ox'] + 3 * par['nx'] / 10 * par['dx'], 0, par)
    fdmod.point(ss + '1', par['ox'] + 5 * par['nx'] / 10 * par['dx'], 0, par)
    fdmod.point(ss + '2', par['ox'] + 6 * par['nx'] / 10 * par['dx'], 0, par)
    Flow(ss, [ss + '0', ss + '1', ss + '2'],
         'cat axis=2 space=n ${SOURCES[0:3]}',
         stdin=0)
Пример #8
0
def new(par):

    fdmod.point3('ssold0',par['ox']+3*par['nx']/10*par['dx'],par['oz'],1,par)
    fdmod.point3('ssold1',par['ox']+5*par['nx']/10*par['dx'],par['oz'],1,par)
    fdmod.point3('ssold2',par['ox']+6*par['nx']/10*par['dx'],par['oz'],1,par)
    Flow('ssold',['ssold0','ssold1','ssold2'],'cat axis=2 space=n ${SOURCES[0:3]}', stdin=0)    
    Flow('wavold','wav','window')
    fdmod.lmodel(
        'doold','woold',
        'ddold','wdold',
        'wavold','velo','refl',
        'ssold','rr','jsnap=100 nbz=100 nbx=100 ',par)
    
    Result('woold',fdmod.wgrey('',par))
    Result('wdold',fdmod.wgrey('',par))

    fdmod.point('ssnew0',par['ox']+3*par['nx']/10*par['dx'],par['oz'],par)
    fdmod.point('ssnew1',par['ox']+5*par['nx']/10*par['dx'],par['oz'],par)
    fdmod.point('ssnew2',par['ox']+6*par['nx']/10*par['dx'],par['oz'],par)
    Flow('ssnew',['ssnew0','ssnew1','ssnew2'],'cat axis=2 space=n ${SOURCES[0:3]}', stdin=0)    
    Flow('wavnew','wav','window squeeze=n')
    fdmod.lwefd1(
        'donew','wonew',
        'ddnew','wdnew',
        'wavnew','velo','dens','refl',
        'ssnew','rr','jsnap=100 nb=100 ',par)
    
    Result('wonew',fdmod.wgrey('',par))
    Result('wdnew',fdmod.wgrey('',par))
Пример #9
0
def point(sp,sa,wp,xm,qq,par):

    # ------------------------------------------------------------
    ls = 2*par['lo']    

    par['zs' ] = par['oz'] + par['lo']
    par['zs0'] = par['zt']

    par['xs' ] = par['xt']
    par['xs0'] = par['xt']

    par['jzs0'] = (par['zs0']-par['oz']) / par['dz']
    par['jxs0'] = (par['xs0']-par['ox']) / par['dx']
    
    # ------------------------------------------------------------
    # source positions
    fdmod.point(sp,par['xs0'],par['zs0'],par)
    Plot(sp,'window |' + fdmod.ssplot('',par))

    fdmod.point(sa,par['xs'],par['zs'],par)    
    Plot(sa,'window |' + fdmod.ssplot('',par))

    # ------------------------------------------------------------
    # source wavelet
    fdmod.wavelet(wp+'_',par['fo'],par)
    Flow(wp,wp+'_','transp')

    # ------------------------------------------------------------
    # scatterrers
    Flow(xm,None,
         '''
         spike nsp=3 mag=1,1,1
         n1=%(nz)d o1=%(oz)g d1=%(dz)g k1=%(jzs0)d l1=%(jzs0)d
         n2=%(nx)d o2=%(ox)g d2=%(dx)g k2=%(jxs0)d l2=%(jxs0)d
         ''' % par)

    Plot(  xm,'smooth rect1=3 rect2=3 repeat=3 |'
           +fdmod.cgrey('pclip=100',par))
    Result(xm,[xm,qq],'Overlay')
Пример #10
0
def point(sp, sa, wp, xm, qq, par):

    # ------------------------------------------------------------
    ls = 2 * par['lo']

    par['zs'] = par['oz'] + par['lo']
    par['zs0'] = par['zt']

    par['xs'] = par['xt']
    par['xs0'] = par['xt']

    par['jzs0'] = (par['zs0'] - par['oz']) / par['dz']
    par['jxs0'] = (par['xs0'] - par['ox']) / par['dx']

    # ------------------------------------------------------------
    # source positions
    fdmod.point(sp, par['xs0'], par['zs0'], par)
    Plot(sp, 'window |' + fdmod.ssplot('', par))

    fdmod.point(sa, par['xs'], par['zs'], par)
    Plot(sa, 'window |' + fdmod.ssplot('', par))

    # ------------------------------------------------------------
    # source wavelet
    fdmod.wavelet(wp + '_', par['fo'], par)
    Flow(wp, wp + '_', 'transp')

    # ------------------------------------------------------------
    # scatterrers
    Flow(
        xm, None, '''
         spike nsp=3 mag=1,1,1
         n1=%(nz)d o1=%(oz)g d1=%(dz)g k1=%(jzs0)d l1=%(jzs0)d
         n2=%(nx)d o2=%(ox)g d2=%(dx)g k2=%(jxs0)d l2=%(jxs0)d
         ''' % par)

    Plot(xm,
         'smooth rect1=3 rect2=3 repeat=3 |' + fdmod.cgrey('pclip=100', par))
    Result(xm, [xm, qq], 'Overlay')
Пример #11
0
def makemicroseisms(ns,wav,sou,par):
    sources = []
    wavelets = []

    r = random.Random()
    r.seed(1234)

    locations = []
    for i in range(ns):
        tag = '-%03d' % i
        xi = r.randrange(100,150)
        zi = r.randrange(50,60)
        ti = r.randrange(par['nt']/4,3*par['nt']/4)

        print 'Microseism %d %d %d %d' % (i,xi,zi,ti)
        locations.append((xi,zi,ti))
        xsou = par['ox']+par['dx']*xi
        zsou = par['oz']+par['dz']*zi
        fdmod.point(sou+tag,xsou,zsou,par)
        wavelet(wav+tag,par['frq'],ti,par)
        sources.append(sou+tag)
        wavelets.append(wav+tag)
        
    Flow(wav+'_',wavelets,'cat axis=2 ${SOURCES[1:%d]}' % ns)
    Flow(sou,sources,'cat axis=2 ${SOURCES[1:%d]}' % ns)

    Plot('ss-2d',fdmod.ssplot('symbol=+ symbolsz=7 plotfat=5',par))
    Plot('ss-2d-box','ss-2d',
        fdmod.ssplot('min1=0.4 max1=0.9 min2=0.2 max2=0.4 plotfat=5 symbol=+ symbolsz=9',par))
    Flow(  'wava','wav_','add scale=10000000 | transp')
    Result('wava','transp |' + fdmod.waveplot('',par))

    # These are bad locations, no microseisms here.
    locations.append((50,25,100))
    locations.append((75,80,100))

    return locations 
Пример #12
0
def thrsou(ss, wav, par):

    par['xsou0'] = par['xsou'] - 0.25
    par['zsou0'] = par['zsou'] - 0.25

    par['xsou1'] = par['xsou']
    par['zsou1'] = par['zsou']

    par['xsou2'] = par['xsou'] + 0.25
    par['zsou2'] = par['zsou'] + 0.25

    for j in range(3):
        fdmod.point(ss + str(j), par['xsou' + str(j)], par['zsou' + str(j)],
                    par)
        Flow(ss, [ss + '0', ss + '1', ss + '2'],
             'cat axis=2 space=n ${SOURCES[1:3]}')

    fdmod.wavelet(wav + '0_', 50, par)
    Flow(
        wav + '0', wav + '0_',
        'scale rscale=1.0 | window f1=100 | pad end1=100 | put o1=%(ot)g n2=1'
        % par)

    fdmod.wavelet(wav + '1_', 50, par)
    Flow(wav + '1', wav + '1_', 'window' % par)

    fdmod.wavelet(wav + '2_', 50, par)
    Flow(
        wav + '2', wav + '2_',
        'scale rscale=1.0 | pad beg1=100 | window n1=%(nt)d | put o1=%(ot)g n2=1'
        % par)

    Flow(
        wav, [wav + '0', wav + '1', wav + '2'], '''
         cat axis=2 space=n ${SOURCES[1:3]} |
         transp
         ''')
Пример #13
0
def reflectivity(refl, sp, sa, wp, xm, qq, par):

    par['zs'] = par['lo']
    par['zs0'] = par['zt']

    par['xs'] = par['ox'] + 0.50 * par['nx'] * par['dx']
    par['xs0'] = par['xt']

    par['jzs0'] = 0.85 * par['nz']
    par['jxs0'] = 0.50 * par['nx']

    Flow(
        refl + '_mask', refl, '''
         window f1=300 |
         mask min=-0.01 max=0.01 |
         dd type=float |
         scale rscale=-1 |
         add add=1 |
         dd type=integer |
         pad beg1=300
         ''')
    Result(refl + '_mask', 'sfdd type=float |' + fdmod.cgrey('pclip=100', par))

    par['nspk'] = par['nz'] * par['nx']
    for x in ('x1', 'x2'):
        if (x == 'x1'): o = sp + '_z'
        if (x == 'x2'): o = sp + '_x'

        Flow(
            o, [refl, refl + '_mask'], '''
             math output=%s |
             put n1=1 n2=%d |
             headerwindow mask=${SOURCES[1]} |
             window
             ''' % (x, par['nspk']))
    Flow(sp, [sp + '_x', sp + '_z'],
         '''
         cat axis=2 space=n
         ${SOURCES[0:2]} | transp
         ''',
         stdin=0)
    Plot(sp, 'window |' + fdmod.ssplot('', par))

    fdmod.point(sa, par['xs'], par['zs'], par)
    Plot(sa, 'window |' + fdmod.ssplot('', par))

    # ------------------------------------------------------------
    # source wavelet
    Flow(
        sp + '_r', [refl, refl + '_mask'], '''
         put n1=1 n2=%d |
         headerwindow mask=${SOURCES[1]} |
         window
         ''' % (par['nspk']))
    Flow(
        sp + '_mask', sp + '_r', '''
         spray axis=2 n=%(nt)d o=%(ot)g d=%(dt)g
         ''' % par)

    fdmod.wavelet(wp + '_', par['fo'], par)
    Flow(
        wp, [wp + '_', sp + '_mask'], '''
         spray axis=2 n=32914 o=0 d=1 |
         transp |
         math m=${SOURCES[1]} output="input*m"
         ''' % par)

    # ------------------------------------------------------------
    # scatterers
    Flow(xm, refl, 'window')
    Plot(xm,
         'smooth rect1=3 rect2=3 repeat=3 |' + fdmod.cgrey('pclip=98', par))
    Result(xm, [xm, qq], 'Overlay')
Пример #14
0
def segments(sp, sa, wp, xm, qq, par):

    par['ff'] = 30

    par['zs'] = par['oz'] + par['lo']
    par['zs0'] = par['zt']

    par['xs'] = par['ox'] + 0.35 * par['nx'] * par['dx']
    par['xs0'] = par['xt']

    par['jzs0'] = 0.85 * par['nz']
    par['jxs0'] = 0.50 * par['nx']

    n = 200
    m = 26
    par['nspk'] = n * m

    par['allx'] = ''
    par['allz'] = ''
    par['allr'] = ''
    par['alli'] = ''

    ind = 0
    for j in range(m):
        for i in range(n):
            xc = par['jxs0'] + (
                i - n / 2) - (j - m / 2 + 0.5) * 7 * par['lo'] / par['dx']
            zc = par['jzs0'] + (i - n / 2) * math.tan(math.radians(par['ff']))
            par['allx'] += '%d,' % xc
            par['allz'] += '%d,' % zc
            par['allr'] += '1,'

            ind += 1
            par['alli'] += '%d,' % ind

    # ------------------------------------------------------------
    # source positions
    Flow(sp + '_x', None,
         'spike nsp=%(nspk)s mag=%(allx)s n1=%(nspk)s k1=%(alli)s' % par)
    Flow(sp + '_z', None,
         'spike nsp=%(nspk)s mag=%(allz)s n1=%(nspk)s k1=%(alli)s' % par)
    Flow(sp + '_r', None,
         'spike nsp=%(nspk)s mag=%(allr)s n1=%(nspk)s k1=%(alli)s' % par)
    Flow(sp, [sp + '_x', sp + '_z'],
         '''
         cat axis=2 space=n
         ${SOURCES[0:2]} | transp
         ''',
         stdin=0)
    Plot(sp, 'window |' + fdmod.ssplot('', par))

    fdmod.point(sa, par['xs'], par['zs'], par)
    Plot(sa, 'window |' + fdmod.ssplot('', par))

    # ------------------------------------------------------------
    # source wavelet
    fdmod.wavelet(wp + '_', par['fo'], par)
    Flow(wp, wp + '_', 'transp' % par)
    #    Flow(wp,wp+'_','spray axis=2 n=%(nspk)d o=0 d=1 | transp' % par)

    # ------------------------------------------------------------
    # scatterers
    Flow(
        xm, None, '''
         spike nsp=%(nspk)s mag=%(allr)s
         n1=%(nz)d o1=%(oz)g d1=%(dz)g k1=%(allz)s
         n2=%(nx)d o2=%(ox)g d2=%(dx)g k2=%(allx)s
         ''' % par)
    Plot(xm,
         'smooth rect1=5 rect2=5 repeat=1 |' + fdmod.cgrey('pclip=98', par))
    Result(xm, [xm, qq], 'Overlay')
Пример #15
0
def test(par):
    # ------------------------------------------------------------
    # source coordinate
    fdmod.point('ss',par['xsou'],par['zsou'],par)
    Plot('ss',fdmod.ssplot('',par))
    Result('vel',['vel','ss'],'Overlay')
    Result('ref',['ref','ss'],'Overlay')
    Result('img',['img','ss'],'Overlay')

    # slowness
    Flow('slo','vel',
         '''
         transp |
         math "output=1/input" |
         spray axis=2 n=1 |
         put label2=y
         ''' % par )
    Result('slo','window | transp |' + fdmod.cgrey('allpos=y bias=0.065',par))

    # migration wavelet
    Flow('wvl',None,
         '''
         spike nsp=1 mag=1
         n1=%(nt)d d1=%(dt)g o1=0        k1=1
         n2=1      d2=%(dx)g o2=%(xsou)g |
         scale axis=123 |
         put label1=t label2=x label3=y
         ''' % par)

    # modeling wavelet (time domain)
    Flow('wav',None,
         '''
         spike nsp=1 mag=1
         n1=%(nt)d d1=%(dt)g o1=0   k1=%(kt)d
         n2=1      d2=%(dx)g o2=%(xsou)g |
         ricker1 frequency=%(frq)g |
         scale axis=123 |
         put label1=t label2=x label3=y
         ''' % par)
    Result('wav','window n1=200 |' + fdmod.waveplot('',par))

    # modeling wavelet (frequency domain)
    Flow('sou','wav',
         '''
         fft1 |
         window squeeze=n n1=%(nw)d min1=%(ow)g |
         pad beg2=%(xpad)d n2out=%(nx)d |
         put label1=w label2=x label3=y |
         transp memsize=250 plane=12 |
         transp memsize=250 plane=23 
         ''' % par)

    # global slowness perturnation
    Flow('ds',None,
         '''
         spike nsp=1 mag=0.00005
         n1=%(nz)d d1=%(dz)g o1=%(oz)g
         n2=%(nx)d d2=%(dx)g o2=%(ox)g |
         put label1=z label2=x label3=y |
         smooth rect1=1 rect2=1 |
         transp plane=12 |
         transp plane=23 |
         rtoc
         ''' % par)
    Plot('ds','window | real | transp |'+ fdmod.cgrey('pclip=99.9',par))

    # ------------------------------------------------------------
    # zero-offset
    # ------------------------------------------------------------
    # data
    zomig.model3('Zmod','slo','img',par)
    Flow('Zdat','Zmod',
         '''
         transp plane=23 |
         transp plane=12 |
         pad beg1=%(begw)d n1out=%(padw)d |
         fft1 inv=y |
         put o1=0 label1=t label2=x
         ''' % par)
    Result('Zdat',fdmod.dgrey('screenratio=0.5 screenht=7',par))
    
    # wavefield
    zomig.Awftwo3('woz','Zmod','slo',par)

    # migration
    zomig.image3('Zimg','slo','Zmod',par)
    Plot(  'Zimg','window | transp |' + fdmod.cgrey('',par))
    Result('Zimg','Zimg','Overlay')

    # WEMVA zero-offset
    zomig.s2i(  'ds' ,'ZFds','woz','slo',par) # forward   F(ds)
    zomig.i2s('ZFds','ZAFds','woz','slo',par) # adjoint A(F(ds))
    Result( 'ZFds','window | real | transp |'+ fdmod.cgrey('',par))
    Result('ZAFds','window | real | transp |'+ fdmod.cgrey('pclip=98',par))

    # ------------------------------------------------------------
    # shot-record 
    # ------------------------------------------------------------
    # data
    spmig.modelPW3('Smod','slo','sou','ref',par)
    Flow('Sdat','Smod',
         '''
         transp plane=23 |
         transp plane=12 |
         pad beg1=%(begw)d n1out=%(padw)d |
         fft1 inv=y |
         window f1=%(kt)d |
         pad n1out=%(nt)d |
         put o1=0 o2=%(xoff)g o3=%(xsou)g
         ''' % par)
    Result('Sdat',
           fdmod.dgrey('min2=%g max2=%g label2="Offset" screenratio=0.5 screenht=7'
                       %(par['xoff'],-par['xoff']),par))
    
    # wavefields
    spmig.wflds  ('dos','dor','wvl','Sdat',par)
    zomig.Cwfone3('wos','dos','slo',par) #   source
    zomig.Awfone3('wor','dor','slo',par) # receiver
    
    # migration
    spmig.imagePW3('Simg','cig','slo','dos','dor',par)
    Plot(  'Simg','window | transp |'+ fdmod.cgrey('',par))
    Result('Simg','Simg ss','Overlay')

    # WEMVA shot-record
    spmig.s2i(  'ds', 'SFds','wos','wor','slo',par) # forward   F(ds)
    spmig.i2s('SFds','SAFds','wos','wor','slo',par) # adjoint A(F(ds))
    Result( 'SFds','window | real | transp |'+ fdmod.cgrey('',par))
    Result('SAFds','window | real | transp |'+ fdmod.cgrey('pclip=98',par))

    # ------------------------------------------------------------
    for ispk in range(par['nspk']):
        i = par['ospk'] + ispk
        tag = str(i)

        par['xx']=par['nx']/2+i*par['jspk']
        par['xs']=par['xx']    # x start
        par['xe']=par['xx']    # x end
        par['zs']=par['nz']/2  # z start
        par['ze']=par['nz']/2  # z end

        # slowness perturbation
        Flow('ds'+tag,None,
             '''
             spike nsp=1 mag=1
             n1=%(nz)d d1=%(dz)g o1=%(oz)g k1=%(zs)d l1=%(ze)d
             n2=%(nx)d d2=%(dx)g o2=%(ox)g k2=%(xs)d l2=%(xe)d |
             put label1=z label2=x label3=y |
             smooth rect1=6 rect2=2 repeat=3 |
             scale axis=123 |
             scale rscale=0.00005 |
             transp plane=12 |
             transp plane=23 |
             rtoc
             ''' % par)
        Result('ds'+tag,'window | real | transp |'+ fdmod.cgrey('',par))

        # image perturbation
        Flow('di'+tag,'ZFds msk',
             '''
             window squeeze=n n1=1 f1=%(xx)d |
             pad beg1=%(xx)d n1out=%(nx)d |
             put o1=%(ox)g |
             math m=${SOURCES[1]} output="input*m"
             ''' %par)
        Result('di'+tag,'window | real | transp | smooth rect2=3 repeat=3 |'+ fdmod.cgrey('',par))

        # WEMVA zero-offset
        zomig.s2i(  'ds'+tag, 'ZFds'+tag,'woz','slo',par) # forward   F(ds)
        zomig.i2s('ZFds'+tag,'ZAFds'+tag,'woz','slo',par) # adjoint A(F(ds))
        zomig.i2s(  'di'+tag, 'ZAdi'+tag,'woz','slo',par) # adjoint   A(di)
        zomig.s2i('ZAdi'+tag,'ZFAdi'+tag,'woz','slo',par) # forward F(A(di))

        Result(   'ZFds'+tag,'window | real | transp |'+ fdmod.cgrey('',par))
        Result(  'ZAFds'+tag,'window | real | transp |'+ fdmod.cgrey('pclip=99.9',par))
        Result(   'ZAdi'+tag,'window | real | transp |'+ fdmod.cgrey('pclip=99.9',par))
        Result(  'ZFAdi'+tag,'window | real | transp |'+ fdmod.cgrey('',par))

        # WEMVA shot-record
        spmig.s2i(  'ds'+tag, 'SFds'+tag,'wos','wor','slo',par) # forward   F(ds)
        spmig.i2s('SFds'+tag,'SAFds'+tag,'wos','wor','slo',par) # adjoint A(F(ds))
        spmig.i2s(  'di'+tag, 'SAdi'+tag,'wos','wor','slo',par) # adjoint   A(di)
        spmig.s2i('SAdi'+tag,'SFAdi'+tag,'wos','wor','slo',par) # forward F(A(di))

        Result(   'SFds'+tag,'window | real | transp |'+ fdmod.cgrey('',par))
        Result(  'SAFds'+tag,'window | real | transp |'+ fdmod.cgrey('pclip=99.9',par))
        Result(   'SAdi'+tag,'window | real | transp |'+ fdmod.cgrey('pclip=99.9',par))
        Result(  'SFAdi'+tag,'window | real | transp |'+ fdmod.cgrey('',par))
Пример #16
0
def run(par):
    # ------------------------------------------------------------
    fdmod.point('ss1',par['xsou1'],par['oz'],par)
    fdmod.point('ss2',par['xsou2'],par['oz'],par)
    Plot('ss1','window      |' + fdmod.ssplot('plotcol=5',par))
    Plot('ss2','window      |' + fdmod.ssplot('plotcol=5',par))

    # ------------------------------------------------------------
    # velocity
    Plot(  'vel',fdmod.cgrey('bias=4.8 allpos=y pclip=99 color=j',par))
    Result('vel','vel ss1 ss2','Overlay')

    # slowness
    Flow('slo','vel',
         '''
         math output=1/input |
         transp |
         transp plane=23 |
         put o2=0 d2=1 label2=y
         ''')
    Result('slo','window | transp |'
           + fdmod.cgrey('allpos=y pclip=95 bias=0.125',par))

    # reflectivity
    Flow('ref','del',
         '''
         transp |
         transp plane=23 |
         put o2=0 d2=1 label2=y
         ''')
    Result('ref','window | transp |' + fdmod.cgrey('pclip=99',par))
    
    # ------------------------------------------------------------
    # wavelet
    fdmod.wavelet('wav',8,par)
    Result('wav','window n1=500 |' + fdmod.waveplot('',par))

    # ------------------------------------------------------------
    for i in ('1','2'):
        Flow('spk'+i,'wav',
             '''
             pad beg2=%d n2out=%d |
             put o2=%g d2=%g
             ''' % ( (par['xsou'+i]-par['ox'])/par['dx'],par['nx'],par['ox'],par['dx']) )
        Result('spk'+i,fdmod.dgrey('pclip=100',par))
        
    # ------------------------------------------------------------
    for i in ('1','2'):
        # source wavefield (from time to frequency)
        zomig.wflds('dds'+i,'spk'+i,par)
        
        # wavefield extrapolation MODELING
        spmig.modelPW3('ddr'+i,'slo','dds'+i,'ref',par)
        
    # ------------------------------------------------------------
    # shots 1 and 2
    Flow('dds0','dds1 dds2','add ${SOURCES[1]}')
    Flow('ddr0','ddr1 ddr2','add ${SOURCES[1]}') # both shots

    for i in ('1','2','0'):
        Result('dds'+i,'window | real | smooth rect1=5 | sfgrey pclip=100')
        Result('ddr'+i,'window | real | smooth rect1=5 | sfgrey pclip=100')

    # ------------------------------------------------------------
    # available dds[0,1,2], ddr[0,1,2], slo
    # ------------------------------------------------------------
    for i in ('1','2','0'):
        # recorded data (from frequency to time) 
        Flow('ttr'+i,'ddr'+i,
             '''
             window |
             transp |
             pad beg1=%(fw)d n1out=%(kw)d |
             fft1 inv=y opt=n
             ''' % par)
        Result('ttr'+i,fdmod.dgrey('pclip=100 min1=1 max1=6 screenratio=0.5 screenht=7',par))
    
        # wavefield extrapolation MIGRATION
        spmig.imagePW3('ii'+i,'cc'+i,'slo','dds'+i,'ddr'+i,par)
        Plot(  'ii'+i,'window min1=%(lox)d max1=%(hix)d | transp |' %par
               + fdmod.cgrey('pclip=99',par))
        Result('ii'+i,['ii'+i,'ss1','ss2'],'Overlay')

    Flow('ii','ii1 ii2','add ${SOURCES[1]}')
    Plot('ii','window min1=%(lox)d max1=%(hix)d | transp |' %par
         + fdmod.cgrey('pclip=100',par))
    Result('ii',['ii','ss1','ss2'],'Overlay')
    
    # ------------------------------------------------------------
    # datuming
    zomig.Cwfone3('wfs','dds0','slo',par) # source wavefield for one shot
    zomig.Awfone3('wfr','ddr0','slo',par) # receiver wavefield for two shots

    # ------------------------------------------------------------
    # data in the time domain
    for k in ('s','r'):    
        Flow('q'+k,'wf'+k,
             '''
             window min1=%(lox)d max1=%(hix)d j1=2 j3=2 |
             transp plane=23 memsize=500 |
             transp plane=12 memsize=500 |
             pad beg1=%(fw)d n1out=%(kw)d |
             fft1 inv=y opt=n |
             window max1=%(tcut)g
             ''' % par)
        
        Plot('q'+k,'window j3=10 |' +
             fdmod.dgrey('gainpanel=a pclip=99',par),view=1)

    Flow(  'qi','qs qr','add mode=p ${SOURCES[1]}')
    Plot('qi','window j3=10 |'
           + fdmod.dgrey('gainpanel=a pclip=100',par),view=1)
        
    # SIC
    Flow('kk',['qs','qr'],
         '''
         sic3d ur=${SOURCES[1]} nbuf=500 verb=y stack=n
         oanga=%(oanga)g nanga=%(nanga)d danga=%(danga)g
         oangb=%(oangb)g nangb=%(nangb)d dangb=%(dangb)g
         nl=%(nl)d dl=%(dl)g
         sig=%(sig)g
         ''' % par)
    
    Plot('kk','transp plane=23 | stack | transp |'
           + fdmod.cgrey('pclip=100',par))
    Result('kk',['kk','ss1','ss2'],'Overlay')
Пример #17
0
def onesou(ss, qq, wav, par):

    fdmod.point(ss, par['xsou'], par['zsou'], par)

    fdmod.wavelet(wav + '_', 50, par)
    Flow(wav, wav + '_', 'transp')
Пример #18
0
def twosou(ss,par):
    fdmod.point(ss+'0',par['ox']+3.5*par['nx']/10*par['dx'],0,par)
    fdmod.point(ss+'1',par['ox']+5.0*par['nx']/10*par['dx'],0,par)    
    Flow(ss,[ss+'0',ss+'1'],'cat axis=2 space=n ${SOURCES[0:2]}', stdin=0)
Пример #19
0
def twosou(ss, par):
    fdmod.point(ss + '0', par['ox'] + 3.5 * par['nx'] / 10 * par['dx'], 0, par)
    fdmod.point(ss + '1', par['ox'] + 5.0 * par['nx'] / 10 * par['dx'], 0, par)
    Flow(ss, [ss + '0', ss + '1'],
         'cat axis=2 space=n ${SOURCES[0:2]}',
         stdin=0)
Пример #20
0
def onesou(ss, par):
    fdmod.point(ss + '1', par['ox'] + 5 * par['nx'] / 10 * par['dx'], 0, par)
    Flow(ss, ss + '1', 'window')
Пример #21
0
def run(par):
    # ------------------------------------------------------------
    fdmod.point('ss1', par['xsou1'], par['oz'], par)
    fdmod.point('ss2', par['xsou2'], par['oz'], par)
    Plot('ss1', 'window      |' + fdmod.ssplot('plotcol=5', par))
    Plot('ss2', 'window      |' + fdmod.ssplot('plotcol=5', par))

    # ------------------------------------------------------------
    # velocity
    Plot('vel', fdmod.cgrey('bias=4.8 allpos=y pclip=99 color=j', par))
    Result('vel', 'vel ss1 ss2', 'Overlay')

    # slowness
    Flow(
        'slo', 'vel', '''
         math output=1/input |
         transp |
         transp plane=23 |
         put o2=0 d2=1 label2=y
         ''')
    Result(
        'slo',
        'window | transp |' + fdmod.cgrey('allpos=y pclip=95 bias=0.125', par))

    # reflectivity
    Flow(
        'ref', 'del', '''
         transp |
         transp plane=23 |
         put o2=0 d2=1 label2=y
         ''')
    Result('ref', 'window | transp |' + fdmod.cgrey('pclip=99', par))

    # ------------------------------------------------------------
    # wavelet
    fdmod.wavelet('wav', 8, par)
    Result('wav', 'window n1=500 |' + fdmod.waveplot('', par))

    # ------------------------------------------------------------
    for i in ('1', '2'):
        Flow(
            'spk' + i, 'wav', '''
             pad beg2=%d n2out=%d |
             put o2=%g d2=%g
             ''' % ((par['xsou' + i] - par['ox']) / par['dx'], par['nx'],
                    par['ox'], par['dx']))
        Result('spk' + i, fdmod.dgrey('pclip=100', par))

    # ------------------------------------------------------------
    for i in ('1', '2'):
        # source wavefield (from time to frequency)
        zomig.wflds('dds' + i, 'spk' + i, par)

        # wavefield extrapolation MODELING
        spmig.modelPW3('ddr' + i, 'slo', 'dds' + i, 'ref', par)

    # ------------------------------------------------------------
    # shots 1 and 2
    Flow('dds0', 'dds1 dds2', 'add ${SOURCES[1]}')
    Flow('ddr0', 'ddr1 ddr2', 'add ${SOURCES[1]}')  # both shots

    for i in ('1', '2', '0'):
        Result('dds' + i, 'window | real | smooth rect1=5 | sfgrey pclip=100')
        Result('ddr' + i, 'window | real | smooth rect1=5 | sfgrey pclip=100')

    # ------------------------------------------------------------
    # available dds[0,1,2], ddr[0,1,2], slo
    # ------------------------------------------------------------
    for i in ('1', '2', '0'):
        # recorded data (from frequency to time)
        Flow(
            'ttr' + i, 'ddr' + i, '''
             window |
             transp |
             pad beg1=%(fw)d n1out=%(kw)d |
             fft1 inv=y opt=n
             ''' % par)
        Result(
            'ttr' + i,
            fdmod.dgrey('pclip=100 min1=1 max1=6 screenratio=0.5 screenht=7',
                        par))

        # wavefield extrapolation MIGRATION
        spmig.imagePW3('ii' + i, 'cc' + i, 'slo', 'dds' + i, 'ddr' + i, par)
        Plot(
            'ii' + i, 'window min1=%(lox)d max1=%(hix)d | transp |' % par +
            fdmod.cgrey('pclip=99', par))
        Result('ii' + i, ['ii' + i, 'ss1', 'ss2'], 'Overlay')

    Flow('ii', 'ii1 ii2', 'add ${SOURCES[1]}')
    Plot(
        'ii', 'window min1=%(lox)d max1=%(hix)d | transp |' % par +
        fdmod.cgrey('pclip=100', par))
    Result('ii', ['ii', 'ss1', 'ss2'], 'Overlay')

    # ------------------------------------------------------------
    # datuming
    zomig.Cwfone3('wfs', 'dds0', 'slo', par)  # source wavefield for one shot
    zomig.Awfone3('wfr', 'ddr0', 'slo',
                  par)  # receiver wavefield for two shots

    # ------------------------------------------------------------
    # data in the time domain
    for k in ('s', 'r'):
        Flow(
            'q' + k, 'wf' + k, '''
             window min1=%(lox)d max1=%(hix)d j1=2 j3=2 |
             transp plane=23 memsize=500 |
             transp plane=12 memsize=500 |
             pad beg1=%(fw)d n1out=%(kw)d |
             fft1 inv=y opt=n |
             window max1=%(tcut)g
             ''' % par)

        Plot('q' + k,
             'window j3=10 |' + fdmod.dgrey('gainpanel=a pclip=99', par),
             view=1)

    Flow('qi', 'qs qr', 'add mode=p ${SOURCES[1]}')
    Plot('qi',
         'window j3=10 |' + fdmod.dgrey('gainpanel=a pclip=100', par),
         view=1)

    # SIC
    Flow(
        'kk', ['qs', 'qr'], '''
         sic3d ur=${SOURCES[1]} nbuf=500 verb=y stack=n
         oanga=%(oanga)g nanga=%(nanga)d danga=%(danga)g
         oangb=%(oangb)g nangb=%(nangb)d dangb=%(dangb)g
         nl=%(nl)d dl=%(dl)g
         sig=%(sig)g
         ''' % par)

    Plot('kk',
         'transp plane=23 | stack | transp |' + fdmod.cgrey('pclip=100', par))
    Result('kk', ['kk', 'ss1', 'ss2'], 'Overlay')
Пример #22
0
def segments(sp,sa,wp,xm,qq,par):

    par['ff']=30

    par['zs' ] = par['oz'] + par['lo']
    par['zs0'] = par['zt']

    par['xs' ] = par['ox']+0.35*par['nx']*par['dx']
    par['xs0'] = par['xt']

    par['jzs0'] = 0.85*par['nz']
    par['jxs0'] = 0.50*par['nx']
    
    n = 200
    m = 26
    par['nspk'] = n*m

    par['allx'] = ''
    par['allz'] = ''
    par['allr'] = ''
    par['alli'] = ''
    
    ind = 0
    for j in range(m):
        for i in range(n):
            xc = par['jxs0'] + (i-n/2) - (j-m/2+0.5) * 7*par['lo']/ par['dx']
            zc = par['jzs0'] + (i-n/2) * math.tan(math.radians(par['ff']))
            par['allx'] += '%d,'%xc
            par['allz'] += '%d,'%zc
            par['allr'] += '1,'

            ind +=1
            par['alli'] += '%d,'%ind

    # ------------------------------------------------------------
    # source positions
    Flow(sp+'_x',None,'spike nsp=%(nspk)s mag=%(allx)s n1=%(nspk)s k1=%(alli)s' %par)
    Flow(sp+'_z',None,'spike nsp=%(nspk)s mag=%(allz)s n1=%(nspk)s k1=%(alli)s' %par)
    Flow(sp+'_r',None,'spike nsp=%(nspk)s mag=%(allr)s n1=%(nspk)s k1=%(alli)s' %par)
    Flow(sp,[sp+'_x',sp+'_z'],
         '''
         cat axis=2 space=n
         ${SOURCES[0:2]} | transp
         ''', stdin=0)
    Plot(sp,'window |' + fdmod.ssplot('',par))
    
    fdmod.point(sa,par['xs'],par['zs'],par)
    Plot(sa,'window |' + fdmod.ssplot('',par))

    # ------------------------------------------------------------
    # source wavelet
    fdmod.wavelet(wp+'_',par['fo'],par)
    Flow(wp,wp+'_','transp' % par)
    #    Flow(wp,wp+'_','spray axis=2 n=%(nspk)d o=0 d=1 | transp' % par)

    # ------------------------------------------------------------
    # scatterers
    Flow(xm,None,
         '''
         spike nsp=%(nspk)s mag=%(allr)s
         n1=%(nz)d o1=%(oz)g d1=%(dz)g k1=%(allz)s
         n2=%(nx)d o2=%(ox)g d2=%(dx)g k2=%(allx)s
         ''' % par)
    Plot(  xm,'smooth rect1=5 rect2=5 repeat=1 |'
           +fdmod.cgrey('pclip=98',par))
    Result(xm,[xm,qq],'Overlay')
Пример #23
0
def onesou(ss,par):
    fdmod.point(ss+'1',par['ox']+5*par['nx']/10*par['dx'],0,par)
    Flow(ss,ss+'1','window')
Пример #24
0
def test(par):
    # ------------------------------------------------------------
    # source coordinate
    fdmod.point('ss', par['xsou'], par['zsou'], par)
    Plot('ss', fdmod.ssplot('', par))
    Result('vel', ['vel', 'ss'], 'Overlay')
    Result('ref', ['ref', 'ss'], 'Overlay')
    Result('img', ['img', 'ss'], 'Overlay')

    # slowness
    Flow(
        'slo', 'vel', '''
         transp |
         math "output=1/input" |
         spray axis=2 n=1 |
         put label2=y
         ''' % par)
    Result('slo',
           'window | transp |' + fdmod.cgrey('allpos=y bias=0.065', par))

    # migration wavelet
    Flow(
        'wvl', None, '''
         spike nsp=1 mag=1
         n1=%(nt)d d1=%(dt)g o1=0        k1=1
         n2=1      d2=%(dx)g o2=%(xsou)g |
         scale axis=123 |
         put label1=t label2=x label3=y
         ''' % par)

    # modeling wavelet (time domain)
    Flow(
        'wav', None, '''
         spike nsp=1 mag=1
         n1=%(nt)d d1=%(dt)g o1=0   k1=%(kt)d
         n2=1      d2=%(dx)g o2=%(xsou)g |
         ricker1 frequency=%(frq)g |
         scale axis=123 |
         put label1=t label2=x label3=y
         ''' % par)
    Result('wav', 'window n1=200 |' + fdmod.waveplot('', par))

    # modeling wavelet (frequency domain)
    Flow(
        'sou', 'wav', '''
         fft1 |
         window squeeze=n n1=%(nw)d min1=%(ow)g |
         pad beg2=%(xpad)d n2out=%(nx)d |
         put label1=w label2=x label3=y |
         transp memsize=250 plane=12 |
         transp memsize=250 plane=23 
         ''' % par)

    # global slowness perturnation
    Flow(
        'ds', None, '''
         spike nsp=1 mag=0.00005
         n1=%(nz)d d1=%(dz)g o1=%(oz)g
         n2=%(nx)d d2=%(dx)g o2=%(ox)g |
         put label1=z label2=x label3=y |
         smooth rect1=1 rect2=1 |
         transp plane=12 |
         transp plane=23 |
         rtoc
         ''' % par)
    Plot('ds', 'window | real | transp |' + fdmod.cgrey('pclip=99.9', par))

    # ------------------------------------------------------------
    # zero-offset
    # ------------------------------------------------------------
    # data
    zomig.model3('Zmod', 'slo', 'img', par)
    Flow(
        'Zdat', 'Zmod', '''
         transp plane=23 |
         transp plane=12 |
         pad beg1=%(begw)d n1out=%(padw)d |
         fft1 inv=y |
         put o1=0 label1=t label2=x
         ''' % par)
    Result('Zdat', fdmod.dgrey('screenratio=0.5 screenht=7', par))

    # wavefield
    zomig.Awftwo3('woz', 'Zmod', 'slo', par)

    # migration
    zomig.image3('Zimg', 'slo', 'Zmod', par)
    Plot('Zimg', 'window | transp |' + fdmod.cgrey('', par))
    Result('Zimg', 'Zimg', 'Overlay')

    # WEMVA zero-offset
    zomig.s2i('ds', 'ZFds', 'woz', 'slo', par)  # forward   F(ds)
    zomig.i2s('ZFds', 'ZAFds', 'woz', 'slo', par)  # adjoint A(F(ds))
    Result('ZFds', 'window | real | transp |' + fdmod.cgrey('', par))
    Result('ZAFds', 'window | real | transp |' + fdmod.cgrey('pclip=98', par))

    # ------------------------------------------------------------
    # shot-record
    # ------------------------------------------------------------
    # data
    spmig.modelPW3('Smod', 'slo', 'sou', 'ref', par)
    Flow(
        'Sdat', 'Smod', '''
         transp plane=23 |
         transp plane=12 |
         pad beg1=%(begw)d n1out=%(padw)d |
         fft1 inv=y |
         window f1=%(kt)d |
         pad n1out=%(nt)d |
         put o1=0 o2=%(xoff)g o3=%(xsou)g
         ''' % par)
    Result(
        'Sdat',
        fdmod.dgrey(
            'min2=%g max2=%g label2="Offset" screenratio=0.5 screenht=7' %
            (par['xoff'], -par['xoff']), par))

    # wavefields
    spmig.wflds('dos', 'dor', 'wvl', 'Sdat', par)
    zomig.Cwfone3('wos', 'dos', 'slo', par)  #   source
    zomig.Awfone3('wor', 'dor', 'slo', par)  # receiver

    # migration
    spmig.imagePW3('Simg', 'cig', 'slo', 'dos', 'dor', par)
    Plot('Simg', 'window | transp |' + fdmod.cgrey('', par))
    Result('Simg', 'Simg ss', 'Overlay')

    # WEMVA shot-record
    spmig.s2i('ds', 'SFds', 'wos', 'wor', 'slo', par)  # forward   F(ds)
    spmig.i2s('SFds', 'SAFds', 'wos', 'wor', 'slo', par)  # adjoint A(F(ds))
    Result('SFds', 'window | real | transp |' + fdmod.cgrey('', par))
    Result('SAFds', 'window | real | transp |' + fdmod.cgrey('pclip=98', par))

    # ------------------------------------------------------------
    for ispk in range(par['nspk']):
        i = par['ospk'] + ispk
        tag = str(i)

        par['xx'] = par['nx'] / 2 + i * par['jspk']
        par['xs'] = par['xx']  # x start
        par['xe'] = par['xx']  # x end
        par['zs'] = par['nz'] / 2  # z start
        par['ze'] = par['nz'] / 2  # z end

        # slowness perturbation
        Flow(
            'ds' + tag, None, '''
             spike nsp=1 mag=1
             n1=%(nz)d d1=%(dz)g o1=%(oz)g k1=%(zs)d l1=%(ze)d
             n2=%(nx)d d2=%(dx)g o2=%(ox)g k2=%(xs)d l2=%(xe)d |
             put label1=z label2=x label3=y |
             smooth rect1=6 rect2=2 repeat=3 |
             scale axis=123 |
             scale rscale=0.00005 |
             transp plane=12 |
             transp plane=23 |
             rtoc
             ''' % par)
        Result('ds' + tag, 'window | real | transp |' + fdmod.cgrey('', par))

        # image perturbation
        Flow(
            'di' + tag, 'ZFds msk', '''
             window squeeze=n n1=1 f1=%(xx)d |
             pad beg1=%(xx)d n1out=%(nx)d |
             put o1=%(ox)g |
             math m=${SOURCES[1]} output="input*m"
             ''' % par)
        Result(
            'di' + tag, 'window | real | transp | smooth rect2=3 repeat=3 |' +
            fdmod.cgrey('', par))

        # WEMVA zero-offset
        zomig.s2i('ds' + tag, 'ZFds' + tag, 'woz', 'slo',
                  par)  # forward   F(ds)
        zomig.i2s('ZFds' + tag, 'ZAFds' + tag, 'woz', 'slo',
                  par)  # adjoint A(F(ds))
        zomig.i2s('di' + tag, 'ZAdi' + tag, 'woz', 'slo',
                  par)  # adjoint   A(di)
        zomig.s2i('ZAdi' + tag, 'ZFAdi' + tag, 'woz', 'slo',
                  par)  # forward F(A(di))

        Result('ZFds' + tag, 'window | real | transp |' + fdmod.cgrey('', par))
        Result('ZAFds' + tag,
               'window | real | transp |' + fdmod.cgrey('pclip=99.9', par))
        Result('ZAdi' + tag,
               'window | real | transp |' + fdmod.cgrey('pclip=99.9', par))
        Result('ZFAdi' + tag,
               'window | real | transp |' + fdmod.cgrey('', par))

        # WEMVA shot-record
        spmig.s2i('ds' + tag, 'SFds' + tag, 'wos', 'wor', 'slo',
                  par)  # forward   F(ds)
        spmig.i2s('SFds' + tag, 'SAFds' + tag, 'wos', 'wor', 'slo',
                  par)  # adjoint A(F(ds))
        spmig.i2s('di' + tag, 'SAdi' + tag, 'wos', 'wor', 'slo',
                  par)  # adjoint   A(di)
        spmig.s2i('SAdi' + tag, 'SFAdi' + tag, 'wos', 'wor', 'slo',
                  par)  # forward F(A(di))

        Result('SFds' + tag, 'window | real | transp |' + fdmod.cgrey('', par))
        Result('SAFds' + tag,
               'window | real | transp |' + fdmod.cgrey('pclip=99.9', par))
        Result('SAdi' + tag,
               'window | real | transp |' + fdmod.cgrey('pclip=99.9', par))
        Result('SFAdi' + tag,
               'window | real | transp |' + fdmod.cgrey('', par))
Пример #25
0
def reflectivity(refl,sp,sa,wp,xm,qq,par):

    par['zs' ] = par['lo']
    par['zs0'] = par['zt']
    
    par['xs' ] = par['ox']+0.50*par['nx']*par['dx']
    par['xs0'] = par['xt']
    
    par['jzs0'] = 0.85*par['nz']
    par['jxs0'] = 0.50*par['nx']

    Flow(refl+'_mask',refl,
         '''
         window f1=300 |
         mask min=-0.01 max=0.01 |
         dd type=float |
         scale rscale=-1 |
         add add=1 |
         dd type=integer |
         pad beg1=300
         ''')
    Result(refl+'_mask',
           'sfdd type=float |' + fdmod.cgrey('pclip=100',par))

    par['nspk']=par['nz']*par['nx']
    for x in ('x1','x2'):
        if(x=='x1'): o=sp+'_z'
        if(x=='x2'): o=sp+'_x'
        
        Flow(o,[refl,refl+'_mask'],
             '''
             math output=%s |
             put n1=1 n2=%d |
             headerwindow mask=${SOURCES[1]} |
             window
             ''' % (x,par['nspk']))
    Flow(sp,[sp+'_x',sp+'_z'],
         '''
         cat axis=2 space=n
         ${SOURCES[0:2]} | transp
         ''', stdin=0)
    Plot(sp,'window |' + fdmod.ssplot('',par))

    fdmod.point(sa,par['xs'],par['zs'],par)
    Plot(sa,'window |' + fdmod.ssplot('',par))

    # ------------------------------------------------------------
    # source wavelet
    Flow(sp+'_r',[refl,refl+'_mask'],
         '''
         put n1=1 n2=%d |
         headerwindow mask=${SOURCES[1]} |
         window
         '''  % (par['nspk']) )
    Flow(sp+'_mask',sp+'_r',
         '''
         spray axis=2 n=%(nt)d o=%(ot)g d=%(dt)g
         ''' % par)
    
    fdmod.wavelet(wp+'_',par['fo'],par)
    Flow(wp,[wp+'_',sp+'_mask'],
         '''
         spray axis=2 n=32914 o=0 d=1 |
         transp |
         math m=${SOURCES[1]} output="input*m"
         ''' % par)

    # ------------------------------------------------------------
    # scatterers
    Flow(xm,refl,'window')
    Plot(  xm,'smooth rect1=3 rect2=3 repeat=3 |'
           +fdmod.cgrey('pclip=98',par))
    Result(xm,[xm,qq],'Overlay')
Пример #26
0
def onesou(ss,qq,wav,par):
    
    fdmod.point(ss,par['xsou'],par['zsou'],par)

    fdmod.wavelet(wav+'_',50,par) 
    Flow(wav,wav+'_','transp')
Пример #27
0
def thrsou(ss,par):
    fdmod.point(ss+'0',par['ox']+3*par['nx']/10*par['dx'],0,par)
    fdmod.point(ss+'1',par['ox']+5*par['nx']/10*par['dx'],0,par)
    fdmod.point(ss+'2',par['ox']+6*par['nx']/10*par['dx'],0,par)
    Flow(ss,[ss+'0',ss+'1',ss+'2'],'cat axis=2 space=n ${SOURCES[0:3]}', stdin=0)