pdf - Madagascar

Homework 5
Thomas Bayes
This homework has two parts.
ABSTRACT
1. Theoretical questions related to covariance estimation.
2. Missing data interpolation for ocean floor topography using covariance estimation.
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
To do the assignment on your personal computer, you need to install the required
environments. Please ask for help if you don’t know where to start.
The homework code is available from the Madagascar repository by running
svn co http://svn.code.sf.net/p/rsf/code/trunk/book/geo391/hw5
THEORY
1. The following equality for the posterior model covariance was given in lecture
notes without a proof:
Ĉ m = ( F T C −1
n
Prove it.
)
F + C −1 −1
m = Cm − C m F ( ) T F C m F T −1
+ C n F Cm . (1)

2
2. Suppose that we use the gradient operator for data interpolation:
min |∇m| 2 . (2)
This approach roughly corresponds to minimizing the surface area and represents
the behavior of a soap film or a thin rubber sheet.
The corresponding inverse model covariance operator is the negative Laplacian
C −1
m = ∇ T ∇ = −∇ 2 . The corresponding covariance operator corresponds to
the Green’s function G(x) that solves
In 2-D, the Green’s function has the form
with some constant A.
−∇ 2 G = δ(x − x 0 ) . (3)
G(x) = A − ln |x − x 0|
2π
To derive equation (4), we can introduce polar coordinates around x 0 with the
radius r = |x−x 0 | and note that the Laplacian operator for a radially-symmetric
function φ(r) in polar coordinates takes the form
Away from the point x 0 , solving
∇ 2 φ = 1 r
1
r
d
dr
d
dr
(
r dφ )
dr
(4)
(5)
(
r dG )
= 0 (6)
dr
leads to G(r) = A + B ln r. To find the constant B, we can integrate ∇ 2 G
over a circle with some small radius ɛ around the origin and apply the Green’s
theorem
∫∫
−1 =
∮
∇ 2 Gdx dy =
∇G · ⃗ds =
∫ 2π
0
∂G
∂r
∣ ɛ dθ = 2π B . (7)
r=ɛ
Derive the model covariance function G(x) which corresponds to replacing equation
(2) with equation
min ∣ ∣ ∇ 2 m ∣ ∣ 2 (8)
and approximates the behavior of a thin elastic plate.

3
Figure 1: (a) Water depth measurements from one day of SeaBeam acquisition. (b)
Mask for locations of known data.
MISSING OCEAN-FLOOR DATA INTERPOLATION
SeaBeam is an apparatus for measuring water depth both directly under a boat and
somewhat off to the sides of the boat’s track. In this part of the assignment, we will
use a benchmark dataset from Claerbout (2008): SeaBeam data from a single day of
acquisition. The original data are shown in Figure 1a.
Program interpolate.c implements two alternative methods: regularized inversion
using convolution with a multi-dimensional filter and preconditioning, which uses
the inverse operation (recursive deconvolution or polynomial division on a helix) for
model reparameterization.
Our first attempt is to use the Laplacian-factor filter from the previous homework.
The results from the two methods are shown in Figure 2. They are not very successful
in hiding the “acquisition footprint”.
Next, we will try to estimate the model covariance from the available data. The
covariance can be estimated using two alternative methods: the fast Fourier transform
(FFT) method (Marcotte, 1996) and the prediction-error filter (PEF) method
(Claerbout and Brown, 1999). Random realizations of model patterns from the two
methods and the corresponding 2-D Fourier spectra are shown in Figures 3 and 4.
Our new attempt to interpolate missing data using the helical prediction-error
filter is shown in Figure 5.

4
Figure 2: Left: missing data interpolation using regularization by convolution with a
Laplacian factor. Right: missing data interpolation using model reparameterization
by deconvolution (polynomial division) with a Laplacian factor.
Figure 3: Left: data pattern generated using FFT method for covariance estimation.
Right: its Fourier spectrum.

5
Figure 4: Left: data pattern generated using PEF method for inverse covariance
estimation. Right: its Fourier spectrum.
Figure 5: Left: missing data interpolation using regularization by convolution with
a prediction-error filter. Right: missing data interpolation using model reparameterization
by deconvolution (polynomial division) with a prediction-error filter.

6
seabeam/interpolate.c
1 /∗ Multi−dimensional missing data i n t e r p o l a t i o n . ∗/
2
3 #include
4
5 int main ( int argc , char∗ argv [ ] )
6 {
7 int na , ia , n i t e r , n , i ;
8 float a0 , ∗mm, ∗ zero ;
9 bool prec , ∗known ;
10 char ∗ l a g f i l e ;
11 s f f i l t e r aa ;
12 s f f i l e in , out , f i l t , lag , mask ;
13
14 s f i n i t ( argc , argv ) ;
15 in = s f i n p u t ( ” in ” ) ;
16 f i l t = s f i n p u t ( ” f i l t ” ) ;
17 /∗ f i l t e r f o r i n v e r s e model covariance ∗/
18 out = s f o u t p u t ( ” out ” ) ;
19
20 n = s f f i l e s i z e ( in ) ;
21
22 i f ( ! s f g e t b o o l ( ” prec ”,& prec ) ) prec=true ;
23 /∗ I f y , use p r e c o n d i t i o n i n g ∗/
24 i f ( ! s f g e t i n t ( ” n i t e r ”,& n i t e r ) ) n i t e r =100;
25 /∗ Number o f i t e r a t i o n s ∗/
26
27 i f ( ! s f h i s t i n t ( f i l t , ”n1”,&na ) ) s f e r r o r ( ”No n1=” ) ;
28 aa = s f a l l o c a t e h e l i x ( na ) ;
29
30 i f ( ! s f h i s t f l o a t ( f i l t , ”a0”,&a0 ) ) a0 =1.;
31
32 /∗ Get f i l t e r l a g s ∗/
33 i f (NULL == ( l a g f i l e = s f h i s t s t r i n g ( f i l t , ” l a g ” ) ) ) {
34 for ( i a =0; i a < na ; i a++) {
35 aa−>l a g [ i a ]= i a +1;
36 }
37 } else {
38 l a g = s f i n p u t ( l a g f i l e ) ;
39 s f i n t r e a d ( aa−>lag , na , l a g ) ;
40 s f f i l e c l o s e ( l a g ) ;
41 }
42
43 /∗ Get f i l t e r v a l u e s ∗/

7
44 s f f l o a t r e a d ( aa−>f l t , na , f i l t ) ;
45 s f f i l e c l o s e ( f i l t ) ;
46
47 /∗ Normalize ∗/
48 for ( i a =0; i a < na ; i a++) {
49 aa−>f l t [ i a ] /= a0 ;
50 }
51
52 mm = s f f l o a t a l l o c (n ) ;
53 zero = s f f l o a t a l l o c (n ) ;
54 known = s f b o o l a l l o c (n ) ;
55
56 /∗ s p e c i f y known l o c a t i o n s ∗/
57 mask = s f i n p u t ( ”mask” ) ;
58 s f f l o a t r e a d (mm, n , mask ) ;
59 s f f i l e c l o s e ( mask ) ;
60
61 for ( i =0; i < n ; i++) {
62 known [ i ] = ( bool ) (mm[ i ] != 0 . 0 f ) ;
63 zero [ i ] = 0 . 0 f ;
64 }
65
66 /∗ Read input data ∗/
67 s f f l o a t r e a d (mm, n , in ) ;
68
69 i f ( prec ) {
70 s f m a s k i n i t ( known ) ;
71 s f p o l y d i v i n i t (n , aa ) ;
72 s f s o l v e r p r e c ( sf mask lop , s f c g s t e p , s f p o l y d i v l o p ,
73 n , n , n , mm, mm, n i t e r , 0 . , ”end” ) ;
74 } else {
75 s f h e l i c o n i n i t ( aa ) ;
76 s f s o l v e r ( s f h e l i c o n l o p , s f c g s t e p , n , n , mm, zero ,
77 n i t e r , ”known” , known , ”x0” , mm, ”end” ) ;
78 }
79
80 s f f l o a t w r i t e (mm, n , out ) ;
81
82 e x i t ( 0 ) ;
83 }

8
1 from r s f . p r o j import ∗
seabeam/SConstruct
2
3 # Download data
4 Fetch ( ’ apr18 . h ’ , ’ seab ’ )
5 Flow ( ’ data ’ , ’ apr18 . h ’ , ’ dd form=n a t i v e ’ )
6
7 def grey ( t i t l e ) :
8 return ’ ’ ’
9 grey p c l i p =100 l a b e l s z =10 t i t l e s z =12
10 transp=n y r e v e r s e=n
11 l a b e l 1=l o n g i t u d e l a b e l 2=l a t i t u d e t i t l e =”%s ”
12 ’ ’ ’ % t i t l e
13
14 def sgrey ( t i t l e ) :
15 return ’ ’ ’
16 grey l a b e l s z =10 t i t l e s z =12 a l l p o s=y
17 transp=n y r e v e r s e=n t i t l e =”%s ”
18 l a b e l 1 =1/ l o n g i t u d e l a b e l 2 =1/ l a t i t u d e
19 ’ ’ ’ % t i t l e
20
21 # Bin to r e g u l a r g r i d
22 Flow ( ’ bin ’ , ’ data ’ ,
23 ’ ’ ’
24 window n1=1 f1=2 | math output =’(2978− input )/387 ’ |
25 bin head=$SOURCE n i t e r =150 nx=160 ny=160 xkey=0 ykey=1
26 ’ ’ ’ )
27
28 # Mask f o r known data
29 Flow ( ’msk ’ , ’ bin ’ ,
30 ’ ’ ’
31 math output=”abs ( input )” |
32 mask min=0.001 | dd type=f l o a t
33 ’ ’ ’ )
34
35 Plot ( ’ bin ’ , grey ( ’ Binned ’ ) )
36 Plot ( ’msk ’ , grey ( ’Mask ’ ) + ’ a l l p o s=y ’ )
37
38 Result ( ’ data ’ , ’ bin msk ’ , ’ SideBySideAniso ’ )
39
40 # Laplacian f a c t o r i z a t i o n
41
42 Flow ( ’ lag0 . asc ’ , None ,
43 ’ ’ ’

9
44 echo 1 160 n1=2 n=160 ,160
45 data format=a s c i i i n t in=$TARGET
46 ’ ’ ’ )
47 Flow ( ’ lag0 ’ , ’ lag0 . asc ’ , ’ dd form=n a t i v e ’ )
48
49 Flow ( ’ f l t 0 . asc ’ , ’ lag0 ’ ,
50 ’ ’ ’
51 echo −1 −1 a0=2 n1=2 l a g=$SOURCE
52 data format=a s c i i f l o a t in=$TARGET
53 ’ ’ ’ , s t d i n =0)
54 Flow ( ’ f l t 0 ’ , ’ f l t 0 . asc ’ , ’ dd form=n a t i v e ’ )
55
56 Flow ( ’ l a p f l t l a p l a g ’ , ’ f l t 0 ’ ,
57 ’ wilson eps=1e−3 lagout=${TARGETS[ 1 ] } ’ )
58
59 # Missing data i n t e r p o l a t i o n with Laplacian
60
61 n i t e r =100
62
63 program = Program ( ’ i n t e r p o l a t e . c ’ )
64
65 for prec in ( 0 , 1 ) :
66 i n t e r p=’ l i n t e r p%d ’ % prec
67 Flow ( interp , ’ bin msk l a p f l t %s ’ % program [ 0 ] ,
68 ’ ’ ’
69 . / ${SOURCES[ 3 ] } prec=%d n i t e r=%d
70 mask=${SOURCES[ 1 ] } f i l t =${SOURCES[ 2 ] }
71 ’ ’ ’ % ( prec , n i t e r ) )
72 Plot ( interp , grey ( ’%s p r e c o n d i t i o n i n g ’ %
73 ( ’ Without ’ , ’ With ’ ) [ prec ] ) )
74 Result ( ’ lseabeam ’ , ’ l i n t e r p 0 l i n t e r p 1 ’ , ’ SideBySideAniso ’ )
75
76 # Random r e a l i z a t i o n o f white noise
77 seed = 102012 # CHANGE ME! ! !
78
79 Flow ( ’ white ’ , ’ bin ’ ,
80 ’ ’ ’
81 noise rep=y seed=%d var =0.02
82 ’ ’ ’ % seed )
83
84 # Covariance e s t i m a t i o n by FFT
85
86 import r s f . r e c i p e s . s p a t i a l s t a t s as s t a t s
87
88 par = d i c t ( val=’ bin ’ , ind=’msk ’ ,

10
89 nx=160,ny=160,nz=1,
90 dx =0.00337373 ,
91 dy =0.00338847 ,
92 dz=1)
93
94 r u l e s = {}
95 s t a t s . c o v a r i a n c e ( par , r u l e s )
96 for case in r u l e s . keys ( ) :
97 Flow ( case , r u l e s [ case ] [ 0 ] , r u l e s [ case ] [ 1 ] )
98
99 Flow ( ’ fcov ’ , ’ bin cov ’ ,
100 ’ ’ ’
101 window n1=160 n2=160 |
102 f f t 1 | f f t 3 a x i s=2 |
103 math output=”abs ( input )”
104 ’ ’ ’ )
105 Flow ( ’ rand2 ’ , ’ white fcov ’ ,
106 ’ ’ ’
107 f f t 1 | f f t 3 a x i s=2 |
108 math f c o v=${SOURCES[ 1 ] } output=”input ∗ f c o v ” |
109 f f t 3 a x i s=2 inv=y | f f t 1 inv=y
110 ’ ’ ’ )
111 Plot ( ’ rand2 ’ , grey ( ’FFT Pattern ’ ) )
112
113 Flow ( ’ frand2 ’ , ’ rand2 ’ , ’ s p e c t r a 2 ’ )
114 Plot ( ’ frand2 ’ , sgrey ( ’FFT Spectrum ’ ) )
115
116 Result ( ’ rand2 ’ , ’ rand2 frand2 ’ , ’ SideBySideAniso ’ )
117
118 # Covariance e s t i m a t i o n by PEF
119
120 # Estimate PEF
121 Flow ( ’ pef l a g ’ , ’ bin msk ’ ,
122 ’ ’ ’
123 p e f maskin=${SOURCES[ 1 ] } l a g=${TARGETS[ 1 ] }
124 a=5,3 n i t e r =50
125 ’ ’ ’ )
126
127 Flow ( ’ rand ’ , ’ white pef ’ ,
128 ’ h e l i c o n f i l t =${SOURCES[ 1 ] } div=y ’ )
129 Plot ( ’ rand ’ , grey ( ’REF Pattern ’ ) )
130
131 Flow ( ’ frand ’ , ’ rand ’ , ’ s p e c t r a 2 ’ )
132 Plot ( ’ frand ’ , sgrey ( ’PEF Spectrum ’ ) )
133

11
134 Result ( ’ rand ’ , ’ rand frand ’ , ’ SideBySideAniso ’ )
135
136 # Missing data i n t e r p o l a t i o n with PEF
137
138 n i t e r =20 # CHANGE ME! ! !
139
140 for prec in ( 0 , 1 ) :
141 i n t e r p=’ i n t e r p%d ’ % prec
142 Flow ( interp , ’ bin msk pef %s ’ % program [ 0 ] ,
143 ’ ’ ’
144 . / ${SOURCES[ 3 ] } prec=%d n i t e r=%d
145 mask=${SOURCES[ 1 ] } f i l t =${SOURCES[ 2 ] }
146 ’ ’ ’ % ( prec , n i t e r ) )
147 Plot ( interp , grey ( ’%s p r e c o n d i t i o n i n g ’ %
148 ( ’ Without ’ , ’ With ’ ) [ prec ] ) )
149 Result ( ’ seabeam ’ , ’ i n t e r p 0 i n t e r p 1 ’ , ’ SideBySideAniso ’ )
150
151 End ( )
Your task:
1. Change directory to hw5/seabeam
2. Run
scons view
to reproduce the figures on your screen.
3. Modify the SConstruct file to implement the following tasks:
(a) Find the number of iterations required for both methods shown in Figure 5
to achieve similar results.
(b) To provide a more quantitative comparison, modify the interpolate.c
program to output a measure of convergence (such as the least-squares
misfit) as a function of the number of iterations 1 . Generate figures comparing
convergence with and without preconditioning.
4. A method for generating multiple realizations of missing data interpolation is:
(a) Start with a random realization m 0 such as the one shown in 4 or 3.
(b) Instead of estimating m such that K m = d, estimate x such that
K x = d − K m 0 .
1 You can study the interfaces to the sf solver and sf solver prec programs. See https:
//sourceforge.net/p/rsf/code/HEAD/tree/trunk/api/c/bigsolver.c

12
(c) The estimate for m is then ̂m = ̂x + m 0 .
Implement several realizations of missing data interpolation using several realizations
of m 0 . You can do it by modifying either SConstruct or interpolate.c.
5. Include your results in the paper.
6. EXTRA CREDIT for implementing missing data interpolation using the FFT
method for model covariance.
COMPLETING THE ASSIGNMENT
1. Change directory to hw5.
2. Edit the file paper.tex in your favorite editor and change the first line to have
your name instead of Bayes’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
Claerbout, J., 2008, Image estimation by example: Environmental soundings image
enhancement: Stanford Exploration Project.
Claerbout, J., and M. Brown, 1999, Two-dimensional textures and prediction-error
filters: 61st Mtg., Eur. Assn. Geosci. Eng., Session:1009.
Marcotte, D., 1996, Fast variogram computation with FFT: Computers and Geosciences,
22, 11751186.