pdf 260K - Madagascar

Homework 1
Isaac Newton
ABSTRACT
This homework has three parts. In the theoretical part, you will derive some new
forms of ray tracing equations and their solutions. In the computational part,
you will experiment with wave propagation in a simple synthetic model. In the
programming part, you will modify a finite-difference wave modeling program.
PREREQUISITES
Completing the computational part of this homework assignment requires
• Madagascar software environment available from
http://www.ahay.org
• L A TEX environment with SEGTeX available from
http://www.ahay.org/wiki/SEGTeX
You are welcome to do the assignment on your personal computer by installing
the required environments. In this case, you can obtain all homework assignments
from the Madagascar repository by running
svn co http://svn.code.sf.net/p/rsf/code/trunk/book/geo384w/hw1
You can also do this assignment in the computer lab at the Department of Geological
Sciences (JGB 3.216B).
THEORETICAL PART
You can either write your answers on paper or edit them in the file hw1/paper.tex.
Please show all the mathematical derivations that you perform.
1. In class, we used a mysterious parameter σ to represent a variable continuously
increasing along a ray. There are other variables that can play a similar role.

2
(a) Transform the isotropic ray tracing system
dp
dσ
= S(x) ∇S (1)
dx
dσ = p (2)
dT
dσ = S2 (x) (3)
into an equivalent system that uses ξ instead of σ, where ξ is constrained
by equation (4):
dp
dξ
dx
dξ
dT
dξ
What are the physical units of ξ?
= ∇S
S 2 (x)
(4)
= (5)
= (6)
(b) Suppose you are given T (x) – the traveltime from the source to all points
x in the domain of interest. Your task is to find ξ(x) for all x. Derive a
first-order partial differential equation that connects ∇ξ and ∇T .
2. The so-called “parabolic” or 15 ◦ eikonal equation (Tappert, 1977; Claerbout,
1985; Bamberger et al., 1988) has the form
∂T
+ 1
∂x 1 2 S(x)
( ∂T
∂x 2
) 2
= S(x) (7)
where x = {x 1 , x 2 } is a point in space, T (x) is the traveltime, and S(x) is
slowness.
(a) Derive the ray tracing system for equation (7)
dx 2
dx 1
= (8)
dp 1
dx 1
= (9)
dp 2
dx 1
= (10)
dT
dx 1
= (11)
where p 1 represents ∂T/∂x 1 and p 2 represents ∂T/∂x 2 .
(b) Assuming constant slowness S(x) ≡ S 0 , solve the ray tracing system for a
point source at the origin {x 1 , x 2 } = {0, 0}.

3
(c) Using the ray tracing solution, find the shape of the wavefronts defined by
equation (7 in the case of a constant slowness.
(d) The isotropic eikonal equation
describes wavefronts of the wave equation
( ) 2 ( ) 2
∂T ∂T
+ = S 2 (x) (12)
∂x 1 ∂x 2
S 2 (x) ∂2 P
∂t 2 = ∇2 P + · · · (13)
with omitted possible first- and zero-order terms.
corresponds to equation (7)?
What wave equation
S(x) ∂2 P
∂t 2 = (14)
COMPUTATIONAL PART
In this part, we will simulate and observe acoustic wave propagation in a simple
velocity model shown in Figure 1a. A wave snapshot is shown in Figure 1b.
1. Change directory to geo384w/hw1/wave
2. Run
scons model.view
to generate and view the velocity model from Figure 1a.
3. Run
scons wave.vpl
to generate and observe a propagating wave on your screen.
4. Run
scons fronts.vpl
to generate and observe a propagating first-arrival wavefront on your screen.
5. Run
scons snap.view

4
a
b
Figure 1: (a) Velocity model for simple wave propagation experiments. (b) Wave
snapshot with overlaid first-arrival wavefront.

5
to generate and view a wave snapshot selected at 1 s as shown in Figure 1b.
6. Open the file SConstruct in your favorite editor. Your task is to make the
following modifications in it:
• Find a parameter responsible for selecting the time frame for the snapshot
in Figure 1b. Modify it to increase the time from 1 s to your favorite point
in the movie. Run scons snap.view again to verify your change.
• Can you observe a geometrical part of the wave that is not captured by
the first-arrival wavefront? What is its physical meaning?
• Find a parameter in the SConstruct file responsible for the vertical smoothness
of the model in Figure 1a. Modify it to increase the smoothness of
the model in such a way that the first-arrival wavefront follows the wave
geometry exactly. Run scons snap.view again to verify your change.
• (EXTRA CREDIT) For extra credit, modify SConstruct to generate a
movie of pictures like Figure 1b for a gradually increasing smoothness.
1 from r s f . p r o j import ∗
2
3 # Make a v e l o c i t y model with a h y p e r b o l i c r e f l e c t o r
4 Flow ( ’ model ’ , None ,
5 ’ ’ ’
6 math n1=301 o1=−1 d1=0.01 output=” s q r t (1+x1∗x1 )” |
7 u n i f 2 n1=201 d1=0.01 v00 =1,2 |
8 put l a b e l 1=Depth unit1=km l a b e l 2=L a t e r a l unit2=km
9 l a b e l=V e l o c i t y u n i t=km/ s |
10 smooth r e c t 1=3
11 ’ ’ ’ )
12
13 # Plot model
14 Result ( ’ model ’ ,
15 ’ ’ ’
16 grey a l l p o s=y t i t l e =Model b i a s=1
17 s c a l e b a r=y b a r r e v e r s e=y
18 ’ ’ ’ )
19
20 # Source w a v e l e t
21 Flow ( ’ wavelet ’ , None ,
22 ’ ’ ’
23 s p i k e nsp=1 n1=2000 d1 =0.001 k1=201 |
24 r i c k e r 1 frequency=10
25 ’ ’ ’ )
26
27 # Extended model ( f o r a b s o r b i n g boundaries )

6
28 Flow ( ’ l e f t ’ , ’ model ’ ,
29 ’ ’ ’
30 window n2=1 | spray a x i s=2 n=50 o=−1.5 d=0.01 |
31 math output=”input ∗ exp(−4∗(−1−x2 )ˆ2)”
32 ’ ’ ’ )
33 Flow ( ’ r i g h t ’ , ’ model ’ ,
34 ’ ’ ’
35 window n2=1 f2 =300 | spray a x i s=2 n=50 o=3.01 d=0.01 |
36 math output=”input ∗ exp(−4∗(3−x2 )ˆ2)”
37 ’ ’ ’ )
38 Flow ( ’ emodel2 ’ , ’ l e f t model r i g h t ’ ,
39 ’ cat a x i s=2 ${SOURCES[ 1 : 3 ] } ’ )
40
41 Flow ( ’ top ’ , ’ emodel2 ’ ,
42 ’ ’ ’
43 window n1=1 | spray a x i s=1 n=50 o=−0.5 d=0.01 |
44 math output=”input ∗ exp(−4∗x1 ˆ2)”
45 ’ ’ ’ )
46 Flow ( ’ bottom ’ , ’ emodel2 ’ ,
47 ’ ’ ’
48 window n1=1 f1 =200 | spray a x i s=1 n=50 o=2.01 d=0.01 |
49 math output=”input ∗ exp(−4∗(2−x1 )ˆ2)”
50 ’ ’ ’ )
51 Flow ( ’ emodel ’ , ’ top emodel2 bottom ’ ,
52 ’ cat a x i s=1 ${SOURCES[ 1 : 3 ] } ’ )
53
54 # Source l o c a t i o n
55 Flow ( ’ source ’ , None ,
56 ’ ’ ’
57 s p i k e k1=101 k2=251
58 n2=401 o2=−1.5 d2=0.01 l a b e l 1=Depth unit1=km
59 n1=301 o1=−0.5 d1=0.01 l a b e l 2=L a t e r a l unit2=km
60 ’ ’ ’ )
61
62 # Modeling
63 exe = Program ( ’ wave . c ’ )
64 Flow ( ’ wave ’ , ’ source %s wavelet emodel ’ % exe [ 0 ] ,
65 ’ ’ ’
66 . / ${SOURCES[ 1 ] } wav=${SOURCES[ 2 ] } v=${SOURCES[ 3 ] }
67 j t =5 f t =200
68 ’ ’ ’ )
69
70 # Movie o f wave snapshots
71 Plot ( ’ wave ’ ,
72 ’ ’ ’

7
73 window f 1 =50 f2=50 n1=201 n2=301 |
74 grey gainpanel=a l l t i t l e =Wave
75 ’ ’ ’ , view=1)
76
77 # Your f a v o r i t e time moment
78 ###########################
79 time = 1 . 0 # ! ! ! MODIFY ME
80 ###########################
81
82 # Wavefield snapshot
83 Plot ( ’ snap ’ , ’ wave ’ ,
84 ’ ’ ’
85 window f 1 =50 f2=50 n1=201 n2=301 n3=1 min3=%g |
86 grey t i t l e =”Wave Snapshot at %g s ”
87 l a b e l 1=Depth unit1=km l a b e l 2=L a t e r a l unit2=km
88 ’ ’ ’ % ( time , time ) )
89
90 # First −a r r i v a l t r a v e l t i m e
91 Flow ( ’ f i r s t ’ , ’ model ’ ,
92 ’ e i k o n a l yshot=1 zshot =0.5 | add add=0.2 ’ )
93
94 # Movie o f f i r s t −a r r i v a l wavefronts
95 f r o n t s = [ ]
96 for snap in range ( 1 8 0 ) :
97 f r o n t = ’ f r o n t%d ’ % snap
98 f r o n t s . append ( f r o n t )
99 tsnap = 0.2+ snap ∗0.01
100 Plot ( front , ’ f i r s t ’ ,
101 ’ contour nc=1 c0=%g t i t l e=”%g s ” ’ % ( tsnap , tsnap ) )
102 Plot ( ’ f r o n t s ’ , f r o n t s , ’ Movie ’ , view=1)
103
104 # First −a r r i v a l wavefront
105 Plot ( ’ f r o n t ’ , ’ f i r s t ’ ,
106 ’ ’ ’
107 contour nc=1 c0=%g w a n t t i t l e=n wantaxis=n
108 p l o t c o l =3 p l o t f a t =5
109 ’ ’ ’ % time )
110
111 # Overlay wavefront and t r a v e l t i m e
112 Result ( ’ snap ’ , ’ snap f r o n t ’ , ’ Overlay ’ )
113
114 End ( )

8
PROGRAMMING PART (EXTRA CREDIT)
For extra credit, you can modify the wave modeling program to include anisotropic
wave propagation effects. The program below (slightly modified from the original
version by Paul Sava) implements wave modeling with equation
∂ 2 P
∂t 2
= V 2 (x) ∇ 2 P + F (x, t) = V 2 (x)
( ∂ 2 P
∂x 2 1
+ ∂2 P
∂x 2 2
)
+ F (x, t) , (15)
where F (x, t) is the source term. The implementation uses finite-difference discretization
(second-order in time and fourth-order in space). Stepping in time involves the
following computations:
P t+∆t = [ V 2 (x) ∇ 2 P t + F (x, t) ] ∆t 2 + 2P t − P t−∆t , (16)
where P represents the propagating wavefield discretized at different time steps.
1 /∗ 2−D f i n i t e −d i f f e r e n c e a c o u s t i c wave propagation ∗/
2 #include
3
4 #i f d e f OPENMP
5 #include
6 #endif
7
10
8 static int n1 , n2 ;
9 static float c0 , c11 , c21 , c12 , c22 ;
11 static void l a p l a c i a n ( float ∗∗ uin /∗ [ n2 ] [ n1 ] ∗/ ,
12 float ∗∗ uout /∗ [ n2 ] [ n1 ] ∗/ )
13 /∗ Laplacian operator , 4 th−order f i n i t e −d i f f e r e n c e ∗/
14 {
15 int i1 , i 2 ;
16
17 #i f d e f OPENMP
18 #pragma omp p a r a l l e l for \
19 p r i v a t e ( i2 , i 1 ) \
20 shared ( n2 , n1 , uout , uin , c11 , c12 , c21 , c22 , c0 )
21 #endif
22 for ( i 2 =2; i 2 < n2 −2; i 2++) {
23 for ( i 1 =2; i 1 < n1 −2; i 1++) {
24 uout [ i 2 ] [ i 1 ] =
25 c11 ∗( uin [ i 2 ] [ i1 −1]+uin [ i 2 ] [ i 1 +1]) +
26 c12 ∗( uin [ i 2 ] [ i1 −2]+uin [ i 2 ] [ i 1 +2]) +
27 c21 ∗( uin [ i2 −1][ i 1 ]+ uin [ i 2 +1][ i 1 ] ) +
28 c22 ∗( uin [ i2 −2][ i 1 ]+ uin [ i 2 +2][ i 1 ] ) +
29 c0 ∗ uin [ i 2 ] [ i 1 ] ;
30 }

9
31 }
32 }
33
34 int main ( int argc , char∗ argv [ ] )
35 {
36 int i t , i1 , i 2 ; /∗ index v a r i a b l e s ∗/
37 int nt , n12 , ft , j t ;
38 float dt , d1 , d2 , dt2 ;
39
40 float ∗ww,∗∗ vv ,∗∗ r r ;
41 float ∗∗u0 ,∗∗ u1 ,∗∗ u2 ,∗∗ ud ;
42
43 s f f i l e Fw, Fv , Fr , Fo ; /∗ I /O f i l e s ∗/
44
45 /∗ i n i t i a l i z e Madagascar ∗/
46 s f i n i t ( argc , argv ) ;
47
48 /∗ i n i t i a l i z e OpenMP support ∗/
49 omp init ( ) ;
50
51 /∗ setup I /O f i l e s ∗/
52 Fr = s f i n p u t ( ” in ” ) ; /∗ source p o s i t i o n ∗/
53 Fo = s f o u t p u t ( ” out ” ) ; /∗ output w a v e f i e l d ∗/
54
55 Fw = s f i n p u t ( ”wav” ) ; /∗ source w a v e l e t ∗/
56 Fv = s f i n p u t ( ”v” ) ; /∗ v e l o c i t y ∗/
57
58 /∗ Read/Write axes ∗/
59 i f ( ! s f h i s t i n t ( Fr , ”n1”,&n1 ) ) s f e r r o r ( ”No n1= in inp ” ) ;
60 i f ( ! s f h i s t i n t ( Fr , ”n2”,&n2 ) ) s f e r r o r ( ”No n2= in inp ” ) ;
61 i f ( ! s f h i s t f l o a t ( Fr , ”d1”,&d1 ) ) s f e r r o r ( ”No d1= in inp ” ) ;
62 i f ( ! s f h i s t f l o a t ( Fr , ”d2”,&d2 ) ) s f e r r o r ( ”No d2= in inp ” ) ;
63
64 i f ( ! s f h i s t i n t (Fw, ”n1”,&nt ) ) s f e r r o r ( ”No n1= in wav” ) ;
65 i f ( ! s f h i s t f l o a t (Fw, ”d1”,&dt ) ) s f e r r o r ( ”No d1= in wav” ) ;
66
67 n12 = n1∗n2 ;
68
69 i f ( ! s f g e t i n t ( ” f t ”,& f t ) ) f t =0;
70 /∗ f i r s t recorded time ∗/
71 i f ( ! s f g e t i n t ( ” j t ”,& j t ) ) j t =1;
72 /∗ time i n t e r v a l ∗/
73
74 s f p u t i n t (Fo , ”n3” , ( nt−f t )/ j t ) ;
75 s f p u t f l o a t (Fo , ”d3” , j t ∗ dt ) ;

10
76 s f p u t f l o a t (Fo , ”o3” , f t ∗ dt ) ;
77
78 dt2 = dt ∗ dt ;
79
80 /∗ s e t Laplacian c o e f f i c i e n t s ∗/
81 d1 = 1 . 0 / ( d1∗d1 ) ;
82 d2 = 1 . 0 / ( d2∗d2 ) ;
83
84 c11 = 4.0∗ d1 / 3 . 0 ;
85 c12= −d1 / 1 2 . 0 ;
86 c21 = 4.0∗ d2 / 3 . 0 ;
87 c22= −d2 / 1 2 . 0 ;
88 c0 = −2.0 ∗ ( c11+c12+c21+c22 ) ;
89
90 /∗ read wavelet , v e l o c i t y & source p o s i t i o n ∗/
91 ww=s f f l o a t a l l o c ( nt ) ; s f f l o a t r e a d (ww , nt ,Fw) ;
92 vv=s f f l o a t a l l o c 2 ( n1 , n2 ) ; s f f l o a t r e a d ( vv [ 0 ] , n12 , Fv ) ;
93 r r=s f f l o a t a l l o c 2 ( n1 , n2 ) ; s f f l o a t r e a d ( r r [ 0 ] , n12 , Fr ) ;
94
95 /∗ a l l o c a t e temporary arrays ∗/
96 u0=s f f l o a t a l l o c 2 ( n1 , n2 ) ;
97 u1=s f f l o a t a l l o c 2 ( n1 , n2 ) ;
98 u2=s f f l o a t a l l o c 2 ( n1 , n2 ) ;
99 ud=s f f l o a t a l l o c 2 ( n1 , n2 ) ;
100
101 for ( i 2 =0; i2

11
121 for ( i 1 =0; i1= f t && 0 == ( i t −f t )% j t ) {
138 s f w a r n i n g ( ”%d ; ” , i t +1);
139 s f f l o a t w r i t e ( u1 [ 0 ] , n12 , Fo ) ;
140 }
141 }
142 s f w a r n i n g ( ” . ” ) ;
143
144 e x i t ( 0 ) ;
145 }
1 ! 2−D f i n i t e −d i f f e r e n c e a c o u s t i c wave propagation
2 module l a p l a c e
3 ! Laplacian operator , 4 th−order f i n i t e −d i f f e r e n c e
4 implicit none
5 real : : c0 , c11 , c21 , c12 , c22
6 contains
7 subroutine l a p l a c i a n s e t ( d1 , d2 )
8 real , intent ( in ) : : d1 , d2
9
10 c11 = 4.0∗ d1 /3.0
11 c12= −d1 /12.0
12 c21 = 4.0∗ d2 /3.0
13 c22= −d2 /12.0
14 c0 = −2.0 ∗ ( c11+c12+c21+c22 )
15 end subroutine l a p l a c i a n s e t
16
17 subroutine l a p l a c i a n ( uin , uout )
18 real , dimension ( : , : ) , intent ( in ) : : uin
19 real , dimension ( : , : ) , intent ( out ) : : uout

12
20 integer n1 , n2
21
22 n1 = size ( uin , 1 )
23 n2 = size ( uin , 2 )
24
25 uout ( 3 : n1 −2 ,3: n2−2) = &
26 c11 ∗( uin ( 2 : n1 −3 ,3: n2−2) + uin ( 4 : n1 −1 ,3: n2 −2)) + &
27 c12 ∗( uin ( 1 : n1 −4 ,3: n2−2) + uin ( 5 : n1 , 3 : n2 −2)) + &
28 c21 ∗( uin ( 3 : n1 −2 ,2: n2−3) + uin ( 3 : n1 −2 ,4: n2 −1)) + &
29 c22 ∗( uin ( 3 : n1 −2 ,1: n2−4) + uin ( 3 : n1 −2 ,5: n2 ) ) + &
30 c0 ∗ uin ( 3 : n1 −2 ,3: n2−2)
31 end subroutine l a p l a c i a n
32 end module l a p l a c e
33
34 program Wave
35 use r s f
36 use l a p l a c e
37 implicit none
38
39 integer : : i t , nt , ft , jt , n1 , n2
40 real : : dt , d1 , d2 , dt2
41
42 real , dimension ( : ) , allocatable : : ww
43 real , dimension ( : , : ) , allocatable : : vv , r r
44 real , dimension ( : , : ) , allocatable : : u0 , u1 , u2 , ud
45
46 type ( f i l e ) : : Fw, Fv , Fr , Fo ! I /O f i l e s
47
48 c a l l s f i n i t ( ) ! i n i t i a l i z e Madagascar
49
50 ! setup I /O f i l e s
51 Fr = r s f i n p u t ( ” in ” ) ! source p o s i t i o n
52 Fo = r s f o u t p u t ( ” out ” ) ! output w a v e f i e l d
53
54 Fw = r s f i n p u t ( ”wav” ) ! source w a v e l e t
55 Fv = r s f i n p u t ( ”v” ) ! v e l o c i t y
56
57 ! Read/Write axes
58 c a l l from par ( Fr , ”n1” , n1 )
59 c a l l from par ( Fr , ”n2” , n2 )
60 c a l l from par ( Fr , ”d1” , d1 )
61 c a l l from par ( Fr , ”d2” , d2 )
62
63 c a l l from par (Fw, ”n1” , nt )
64 c a l l from par (Fw, ”d1” , dt )

13
65
66 c a l l from par ( ” f t ” , ft , 0 ) ! f i r s t recorded time
67 c a l l from par ( ” j t ” , jt , 0 ) ! time i n t e r v a l
68
69 c a l l t o p a r (Fo , ”n3” , ( nt−f t )/ j t )
70 c a l l t o p a r (Fo , ”d3” , j t ∗ dt )
71 c a l l t o p a r (Fo , ”o3” , f t ∗ dt )
72
73 dt2 = dt ∗ dt
74 f t = f t +1
75
76 ! s e t Laplacian c o e f f i c i e n t s
77 c a l l l a p l a c i a n s e t ( 1 . 0 / ( d1∗d1 ) , 1 . 0 / ( d2∗d2 ) )
78
79 ! read wavelet , v e l o c i t y & source p o s i t i o n
80 allocate (ww( nt ) , vv ( n1 , n2 ) , r r ( n1 , n2 ) )
81 c a l l r s f r e a d (Fw,ww)
82 c a l l r s f r e a d (Fv , vv )
83 c a l l r s f r e a d ( Fr , r r )
84
85 ! a l l o c a t e temporary arrays ∗/
86 allocate ( u0 ( n1 , n2 ) , u1 ( n1 , n2 ) , u2 ( n1 , n2 ) , ud ( n1 , n2 ) )
87
88 u0=0.0
89 u1=0.0
90 u2=0.0
91 ud=0.0
92 vv = vv∗vv∗ dt2
93
94 ! Time loop
95 do i t =1, nt
96 c a l l l a p l a c i a n ( u1 , ud )
97
98 ! s c a l e by v e l o c i t y
99 ud = ud∗vv
100 ! i n j e c t w a v e l e t
101 ud = ud + ww( i t ) ∗ r r
102 ! time s t e p
103 u2 = 2∗u1 − u0 + ud
104 u0 = u1
105 u1 = u2
106
107 ! w r i t e w a v e f i e l d to output
108 i f ( i t >= f t . and . 0 == mod( i t −ft , j t ) ) then
109 write (0 , ’ ( a , i 4 ) ’ ,advance=’ no ’ ) achar ( 1 3 ) , i t

14
110 c a l l r s f w r i t e (Fo , u1 )
111 end i f
112 end do
113 write ( 0 , ∗ )
114
115 c a l l exit ( 0 )
116 end program Wave
Your task is to modify the code to implement elliptically-anisotropic wave propagation
according to equation
∂ 2 P
∂t 2 = V 2
1 (x) ∂2 P
∂x 2 1
+ V 2
2 (x) ∂2 P
∂x 2 2
+ F (x, t) (17)
You can test your implementation using a constant velocity example shown in Figure
2.
Figure 2: Wavefield snapshot for
propagation from a point-source
in a homogeneous medium. Modify
the code to make wave propagation
anisotropic.
1. Change directory to geo384w/hw1/code
2. Run
scons wave.vpl
to compile and run the program and to observe a propagating wave on your
screen.
3. Open the file wave.c in your favorite editor and modify it to implement the
wave operator from equation (17).
4. Run

15
scons wave.vpl
again to compile and test your program.
5. (EXTRA EXTRA CREDIT) For an additional test, modify the file SConstruct
and run appropriate commands to output a snapshot of wave propagation in
the Hess VTI model, shown in Figure 3 1 . Modify the file paper.tex to include
your figure.
a
b
Figure 3: Vertical velocity (a) and horizontal velocity (b) in the Hess VTI model.
1 from r s f . p r o j import ∗
2 from r s f . prog import RSFROOT
3
4 # Program compilation
5 #####################
6
7 p r o j = P r o j e c t ( )
8
9 # To do the coding assignment in Fortran ,
10 # comment the next l i n e and uncomment the l i n e s below
11 #exe = p r o j . Program ( ’ wave . c ’)
12
13 exe = p r o j . Program ( ’ wave . f90 ’ ,
14 F90PATH=os . path . j o i n (RSFROOT, ’ i n c l u d e ’ ) ,
15 LIBS=[ ’ r s f f 9 0 ’ ]+ p r o j . get ( ’ LIBS ’ ) )
16
17 # Constant v e l o c i t y t e s t
18 ########################
19
20 # Source w a v e l e t
21 Flow ( ’ wavelet ’ , None ,
22 ’ ’ ’
23 s p i k e n1=1000 d1 =0.001 k1=201 |
1 The Hess VTI model was generated at Hess Corporation and released at http://software.
seg.org. For this exercise, we are going to approximate it with an elliptically anisotropic model

16
24 r i c k e r 1 frequency=10
25 ’ ’ ’ )
26
27 # Source l o c a t i o n
28 Flow ( ’ source ’ , None ,
29 ’ ’ ’
30 s p i k e n1=201 n2=301 d1=0.01 d2=0.01
31 l a b e l 1=x1 unit1=km l a b e l 2=x2 unit2=km
32 k1=101 k2=151
33 ’ ’ ’ )
34
35 # V e l o c i t y model
36 Flow ( ’ v1 ’ , ’ source ’ , ’ math output=1 ’ )
37 Flow ( ’ v2 ’ , ’ source ’ , ’ math output =1.5 ’ )
38
39 # Modeling
40 Flow ( ’ wave ’ , ’ source %s wavelet v1 v2 ’ % exe [ 0 ] ,
41 ’ ’ ’
42 . / ${SOURCES[ 1 ] } wav=${SOURCES[ 2 ] }
43 v=${SOURCES[ 3 ] } vx=${SOURCES[ 4 ] }
44 f t =200 j t =5
45 ’ ’ ’ )
46
47 Plot ( ’ wave ’ , ’ grey gainpanel=a l l t i t l e=Wave ’ , view=1)
48
49 Result ( ’ wave ’ ,
50 ’ ’ ’
51 window n3=1 min3=0.9 |
52 grey t i t l e =Wave s c r e e n h t=8 screenwd=12
53 ’ ’ ’ )
54
55 # Download Hess VTI model
56 #########################
57 zcat = WhereIs ( ’ gzcat ’ ) or WhereIs ( ’ zcat ’ )
58 for case in ( ’ vp ’ , ’ e p s i l o n ’ ) :
59 sgy = ’ t i m o d e l %s . segy ’ % case
60 sgyz = sgy + ’ . gz ’
61 Fetch ( sgyz , d i r=’ Hess VTI ’ ,
62 s e r v e r=’ f t p : / / s o f tware . seg . org ’ ,
63 top=’ pub/ d a t a s e t s /2D ’ )
64 # Uncompress
65 Flow ( sgy , sgyz , zcat + ’ $SOURCE ’ , s t d i n =0)
66 # Convert to RSF format
67 Flow ( case , sgy ,
68 ’ ’ ’

17
69 segyread read=data |
70 window j 1=2 j2=2 | put d1=40 d2=40
71 unit1=f t l a b e l 1=Depth unit2=f t l a b e l 2=Distance
72 ’ ’ ’ )
73
74 # H o r i z o n t a l v e l o c i t y
75 Flow ( ’ vx ’ , ’ vp e p s i l o n ’ ,
76 ’ math e=${SOURCES[ 1 ] } output=”input ∗ s q r t (1+2∗ e )” ’ )
77
78 for case in ( ’ vp ’ , ’ vx ’ ) :
79 Result ( case ,
80 ’ ’ ’
81 grey c o l o r=j p c l i p =100 a l l p o s=y b i a s =5000
82 s c a l e b a r=y b a r r e v e r s e=y w a n t t i t l e=n
83 b a r l a b e l=V e l o c i t y b a r u n i t=f t / s
84 s c r e e n h t=5 screenwd=12 l a b e l s z =6
85 ’ ’ ’ )
86
87 Flow ( ’ hsource ’ , ’ vp ’ , ’ s p i k e k1=300 k2=900 ’ )
88 Flow ( ’ hess ’ , ’ hsource %s wavelet vp vx ’ % exe [ 0 ] ,
89 ’ ’ ’
90 . / ${SOURCES[ 1 ] } wav=${SOURCES[ 2 ] }
91 v=${SOURCES[ 3 ] } vx=${SOURCES[ 4 ] }
92 f t =200 j t =5
93 ’ ’ ’ )
94
95 End ( )

18
COMPLETING THE ASSIGNMENT
1. Change directory to geo384w/hw1.
2. Edit the file paper.tex in your favorite editor and change the first line to have
your name instead of Newton’s.
3. Run
sftour scons lock
to update all figures.
4. Run
sftour scons -c
to remove intermediate files.
5. Run
scons pdf
to create the final document.
6. Submit your result (file paper.pdf) on paper or by e-mail.
REFERENCES
Bamberger, A., B. Engquist, L. Halpern, and P. Joly, 1988, Parabolic wave equation
approximation in heterogenous media: SIAM Journal on Appl. Math., 48, 99–128.
Claerbout, J. F., 1985, Imaging the Earth’s interior: Blackwell Scientific Publications.
Tappert, F. D., 1977, The parabolic approximation method, in Wave Propagation
and Underwater Acoustics: Springer, 70, 224–287.