A tutorial for processing a 2D land line using Seismic Unix

Karl Schleicher

ABSTRACT
This paper described how to process a public 2D land line data set though a very basic processing sequence using Seismic Unix. The data from the north slopes of Alaska has good signal, although it may be suitable for testing ground roll attenuation programs. The detailed steps download the data from the internet and process it are described. You should be able to follow these steps and recreate my results. I hope this will accelerate the testing and validation of programs developed in research groups. The tutorial starts with background information like data downloading, region overview, data aquisition, and previous processing. The scripts and custom programs to translate to seismic unix, load headers, qc, apply preprocessing (including velocity ltering and decon), cdp gather, velocity analysis, and stack are listed and described. Header loading is not described in other Seismic Unix documentation. One approach to header loading is described here. The velocity analysis script is better than I found in previous papers. My eort to process these data is ongoing. I have not computed and applied residual statics. I have not migrated the data. My current results are not as good as obtained when the data was originally processed by GSI in 1981. I would like to provide my most current results to anyone who wants to use publicly available software to process seismic data. This paper is the beginning of an eort to build a library of open-access seismic datasets and processing scripts using open-source geophysical software.

INTRODUCTION
Seismic Unix (SU) is one of the best known open software packages for seismic processing. The distribution includes some example processing scripts and there are two books that teach how to use the software, Geophysical Image Processing with Seismic Unix (?) and Seismic Processing with Seismic Un*x (Forel et al., 2005) books cover broad subjects including basic Unix commands, setting up a user environment, basic seismic processing, and more advanced scripting for seismic processing. You can follow the text and recreate some seismic processing. These books to not provide much information about creating trace headers or preprocessing.

This paper assumes you are familiar with Seismic Unix. I concentrate on providing example scripts and programs to process a 2D land line using the processing system. I describe the data acquisition and previous data processing. I provide the custom programs I used to load the trace headers. The scripts for preprocessing, velocity analysis, and stacking are provided and explained. These scripts provide the detailed parameters used by the Seismic Unix programs. The parameters for deconvolution, velocity lter, mute, moveout velocity, and scaling can adapted for use by other seismic processing systems. Currently I have not applied residual statics or migration. The results in the deep section are similar to the results obtained in 1981. The shallow section is not as good as previously obtained. This paper provides detailed steps that describe how to download the data from the internet and process it using seismic unix. You should be able to follow these steps and recreate my results. The scripts, data, and programs can be modied to allow you to validate your own ideas about seismic processing. This should accelerate the testing and validation of new seismic research.

BACKGROUND INFORMATION ABOUT THE DATASET

President Warren Harding created the Naval Petroleum Reserve Number 4 in 1923. It was renamed the National Petroleum Reserve, Alaska (NPRA) in 1976. Figure 1 is a map of the region and Figure 2 maps the lines collected and processed between 1974 and 1981. I selected and processed line 31-81 because it was a short line from the most recent acquisition season. The les I found for line 31-81 are: L23535.SGY unprocessed seismic data in segy format L23536.SGY L23537.SGY 3181O.PDF the Observers log 3181.SGY segy of the 1981 nal stack 3181S.PDF the surveyors log 3181.SPT the textle of shotpoint, latitude, longitude. S609.JPG A 1981 nal stack in jpeg format. S609.TIF A higher resolution stack in tif format I downloaded these les into my directory, /home/karl/data/alaska/31-81/clientles. I was able to view the large JPG and TIF les in OpenOce.org draw (other programs

had problems). I zoomed the display of S609.TIF to look at the side label that describes the acquisition and processing parameters. The data was acquired 96 trace, 12 fold with a dynamite source. The shotpoint interval is 440 ft and the receiver interval is 110 ft. The average shot depth is 75 ft. The elevation plot on the section header shows the elevation is about 200 ft and there is little variation. The processing applied by GSI in 1981 was: 1. Edit and true amplitude recovery 2. spherical divergence and exponentiation (alpha - 4.5 db/s, initial time - 0 s, nal time - 4.5 s) 3. Velocity ltering dip range -12 to 4 ms/trace 4. Designature deconvolution 5. Time-variant scaling (unity) 6. Apply datum statics 7. Velocity estimation 8. Normal moveout correction 9. Automatic Residual Statics application 10. First Break Suppression 100 ms at 55 ft 380 ms at 2970 ft 700 ms at 5225 ft 11. Common depth point stack 12. Time Variant ltering 16-50 Hz at 700 ms 14-45 Hz at 1400 ms 12-40 Hz at 2000 ms 8-40 Hz at 400 ms 13. Time variant scaling

DATA LOADING AND INITIAL DATA QC

I found little documentation about loading data and creating trace headers in precious publications. This section provides a detailed description.

I created a script le to load the rst segy le, /home/karl/jobs/alaska/31-81/load/view1.job. This le is listed in Appendix 1. The way I developed this script is by pasting a command or two into a terminal window and picking information from the print of displays to write the next few commands. The segyread command translates data to SU format. The surange command prints: 3030 traces: tracl 1 3030 (1 - 3030) tracr 1 3030 (1 - 3030) dr 101 130 (101 - 130) tracf 1 101 (1 101) trid 1 ns 3000 dt 2000 f1 0.000000 0.000000 (0.000000 - 0.000000) The print indicates there is little information in the input headers. There are 31 shot records (dr 101 - 130) and each record has 101 traces (tracf 1 - 101). The suximage produces Figure 1 and the zoom plot Figure 2. The rst 10 records in the le are test records. These tests records are the unuisual traces in the left third of Figure 1. The Observer Log indicates the rst shotpoint is eld le identier (d) 110. There are also 5 auxiliary traces in each shot record. These auxiliary traces can be seen o ngures 4 and 5. The suxmovie command allows all the shots record on the line to be displayed. The parameter n2 is set to the number of traces in each shot record, which was based on the tracf range printed in surange (1 - 101). The movie loops continuously and can be stopped by pressing s. Once stopped, you can move forward or backward using the f and b. An example screen is shown in Figure 5. This plot allowed me to see that traces 1-96 were the data channels and 97-101 were the auxiliary traces. The nal command in the view1.job le is the sugethw. This prints the dr and tracf header keys. These are the keys I used to map the data to the shotpoint and receiver locations. I wrote a custom java program to load the trace headers. The code is not elegant, but it is straightforward to write and it works. It is listed in Appendix 2. This program require les to dene the shotpoint elevation and the FFID/EP relationship. The surveyor log, downloaded as: /home/karl/data/alaska/31-81/clientles/3181O.PDF denes the shotpoint elevations. The observers log, downloaded as: /home/karl/data/alaska/3181/clientles/3181O.PDF describes the relationship between the su header keys d and ep (these are called REC. and SHOTPOINT by in the observers log). This information was typed into two les listed in appendices 3 and 4. The program to load the headers was run by the script: /home/karl/jobs/alaska/3181/load/hdrload1.job This le is listed in appendix 5. The other two segy les were loaded by scripts view2.job, view3.job, hdrload2.job,

1000

2000

3000

Figure 1: First 300 traces on the rst tape.

1000 0

1050

1100

1150

1200

1250

0.5

1.0

1.5

2.0

2.5

3.0

Figure 2: Zoom of gure 1.First look at the data. Notice the ground roll and good signal. There are 101 traces in each shotpoint, 5 auxiliary traces and 96 data traces.

and hdrload3.job in the same directory, /home/karl/jobs/alaska/31-81/load. These scripts dier from the previous scripts only by the names of the input and output le. The stack le from the previous process was translated to SU format and displayed using the viewqcstack.job script listed in appendix 6. This is a straight forward execution of segyread and suximage. Display of the checkstack is in Figure 6.

SHOT RECORD VELOCITY FILTER

I applied Velocity ltering (sudiplt) to remove the groundroll. The receivers leading the shotpoint were processed separately from the trailing receivers. This allowed an asymmetrical dip lter to be applied (-15,5 ms/trace). These parameters are loosely based on the 1981 processing that used (-12,4). Sudiplter was intended for post stack processing, so a loop is required in the script to divide the data into individual shotrecords and seperate the positive and negative osets. The script also includes suxmovie of the velocity ltered data. It is listed in appendix 7. Figure 7 is an example shot record after velocity ltering,

SHOT RECORD EDIT, MUTE, AND CDP SORT

There is a bad shotpoint I removed. I also applied a mute and sorted the data to CDP order in the same script. The script is listed in Appendix 8. Figure 8 is a display of two cdp gathers.

VELOCITY INTERPRETATION
I used a long script that combined several su program for velocity interpretation. This script is listed in Appendix 9. I combined the scripts from Forel et. al. 2005 (iva.sh section 7.6.7.3 and velanQC.sh section 8.2.2.2). The script is more practical, because you can start from no velocity function, or review and update and existing velocity eld. The script hos more capabilities, but it is tidier and a little shorter than Forels script. Figure 9 is an example velocity analysis plot. There are four components of the plot, semblance plot, constant velocity stack (CVS) plot, cmp gather without NMO and cmp gather after NMO. The semblance plots and CVS plot have the velocity function overplotted. The velocities I picked are listed on Appendix 10.

STACK
The script that stacks the data is in Appendix 11. This script also applied decon using the command supef. The script also applied AGC. I wanted to start the decon design gate start time to increase with oset so the shallow data near the mute was not included. The only way I knew how to do this us SU was to apply linear moveout to move the design gate start time to a constant time. This was accomplished by removing the sign from the oset header and computing a time static from the oset. Supef was bracketed with sustatic to apply and remove the oset dependent static. I compared the stack created in SU to the original processing results created in 1981 (gures 10 and 11).

COMPARISON OF THE SU AND THE 1981 RESULTS

Figures 10 and 11 are the results created using SU and the results obtained in 1981. Some of the dierences in the processing sequences are: 1. The 1981 processing used GSIs designature process. This source signature removal applies the same operator to all traces in a shotrecord. The lter is designed dierently from conventional deconvolution and the two types of deconvolution will not produce data with the same wavelet. 2. There are many dierences in the application of AGC. For example the GSI used to apply AGC before velocity ltering inverse AGC after velocity lter. 3. GSI used diversity stack to control the high amplitude noise bursts. 4. The original processing includes residual statics. Considering all these dierences, I think the results are surprisingly similar, especially below 400 ms. I think residual statics account for most of the dierences. The shallow result on the SU processing is worse than the 1981 processing. In general, I found the SU software hard to use. Sudiplter was not intended for shotrecord velocity ltering, so a collection of program were required. Many of my input errors were not trapped by the code. I was disappointed that the processing applied 30 years ago produced better results than I obtained using SU. SU is a useful prototyping environment, but it falls short of the commercial packages I have used.

PLANS
Some of the ideas I have to continue this work include: 1. Adding more processes, especially residual statics and migration.

2. Process using other software (Open source of proprietary. 3. Working on dierent datasets (marine, 3D, ...). 4. Make scripts and intermediate results available on the internet. 5. Improve open source software.

CONCLUSIONS
I have provided a set of scripts the process a land line using SU. These scripts include the processing stages: 1. data load 2. trace header creation 3. velocity ltering 4. cdp gather 5. velocity analysis 6. stack Although this sequence omits important processes like residual statics and migration, it illustrates processing stages not presented by Forel or Stockwell. My processing results can be recreated by others since the processing scripts are included in appendixes of this paper and the data can be downloaded from the internet. The task of loading trace headers is no addressed in other publications. The custom java program included in this paper is one way to complete this processing stage. The velocity analysis script (iva.sh in Appendix 9) improves the scripts in Forels book. I was able to pick the velocities on this line using the script. Some of the ideas I have to continue this work include: 1. Adding more processes, especially residual statics and migration 2. Process using other software (Open source of proprietary. 3. Working on more data (Marine, 3D, ...) 4. Make scripts and intermediate results available on the internet 5. Improve open source

10

REFERENCES
Forel, D., T. Benz, and W. D. Pennington, 2005, Seismic data processing with seismic un*x: Society of Exploration Geophysicists.

APPENDIX A SCONSTRUCT FILE

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

from r s f . s u p r o j import import r s f . p r o j # need t o add t h e v e l o c i t y a n a l y s i s s c r i p t # need t o add m i g r a t i o n # need t o t r y s u d i v s t a c k ## # # # # # # # # ########## # Fetch t h e d a t a s e t and c o n v e r t t o m u l t i p l e r s f f i l e s ## # # # # # # # # ########## segyread = s e g y r e a d b f i l e=${TARGETS[ 1 ] } h f i l e=${TARGETS[ 2 ] } t a p e=$SOURCE endian=%d % (1 l i t t l e e n d i a n ( ) ) rawsegy =[ L23535 , L23536 , L23537 ] for f i l e in rawsegy : r s f . p r o j . Fetch ( f i l e + .SGY , s e r v e r= http : / / certmapper . c r . u s g s . gov , top= n e r s l /NPRA/SEISMIC/1981/31 8 1 , d i r= DMUX ) Flow ( [ f i l e , f i l e + . bi n , f i l e + . a s c ] , f i l e + .SGY , s e g y r e a d , s t d i n =0)

r s f . p r o j . Fetch ( 31 81 PR .SGY , s e r v e r= http : / / certmapper . c r . u s g s . gov , top= n e r s l /NPRA/SEISMIC/1981/31 8 1 , d i r= PROCESSED )

# concatinate the input f i l e s Flow ( l i n e , rawsegy , c a t L23535 . su L23536 . su L23537 . su , s t d i n =0)

11

36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80

# d i s p l a y t h e f i r s t 3000 t r a c e s Result ( f i r s t , l i n e , suwind count =3000 | suximage p e r c =90 ) Result ( zoomfirst , l i n e , suwind key=t r a c l min=1000 max=1250 tmin=0 tmax=3 | suximage p e r c =90 ) #R e s u l t ( f i r s t m o v i e , l i n e , # # suxmovie n2=101 l o o p=1 f f r a m e=1 dframe=1 # t i t l e =r e c o r d %g p e r c =20 # ) Result ( f i r s t r e c 2 4 , l i n e , suwind key=t r a c l min=2324 max=2424 tmin=0 tmax=6 | suximage p e r c =90 ) Flow ( h d r f i l e . t x t , l i n e , sugethw output=geom key=t r a c l , f l d r , t r a c f ) #Flow # # # #Flow # # # ( InterpText . c l a s s , InterpText . java , j a v a c ${SOURCE} , s t d i n =0) ( h d r f i l e 1 . t x t ,[ h d r f i l e . t x t , InterpText . class ] , java InterpText , s t d i n =0)

Flow ( h d r f i l e 1 . t x t , [ h d r f i l e . t x t , I n t e r p T e x t . py ] , . / I n t e r p T e x t . py , s t d i n =0) Flow ( b i n a r y h d r f i l e 1 . dat , h d r f i l e 1 . t x t , a2b n1=13 )

12

81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125

keys= ep , sx , sy , gx , gy , cdp , t r a c f , o f f s e t , \ selev , gelev , sstat , gstat , t s t a t Flow ( a l l s h o t s , [ l i n e , b i n a r y h d r f i l e 1 . dat ] , sushw i n f i l e =b i n a r y h d r f i l e 1 . dat key=%s | sushw key=f 1 a=0 | suwind key=cdp min=999998 max=999999 | suwind key=ep min=999998 max=999999 | suwind key=ep r e j e c t =149 % keys ) #R e s u l t ( t e s t , a l l s h o t s , # # suxmovie n2=96 l o o p=1 f f r a m e=1 dframe=1 # t i t l e = a l l s h o t s r e c o r d %g p e r c =20 # )

# d i s p l a y t r a c e s 10101250 f i r s t 3100 ms ( or 1550 s a m p l e s ) #R e s u l t ( second , l i n e , # # window f 2 =1010 n2=240 n1=1550 | # agc r e c t 1 =250 r e c t 2 =100 | # g r e y t i t l e = F i r s t 3000 t r a c e s p c l i p =70 # ) #Fetch ( 3 1 81 PR .SGY , # s e r v e r = h t t p : / / certmapper . c r . u s g s . gov , # t o p = n e r s l /NPRA/SEISMIC/1981/31 8 1 , # d i r =PROCESSED )

13

126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170

# c o n v e r t s t a c k and view i t : f i l e= checkstack Flow ( [ f i l e , f i l e + . bi n , f i l e + . a s c ] , 31 81 PR .SGY , s e g y r e a d + | sushw key=n t r a=534 | sushw key=d1 a=0 , s t d i n =0) Result ( checkstack , checkstack , suximage t i t l e =c h e c k s t a c k p e r c =90 ) R e s u l t ( zoomcheckstack , c h e c k s t a c k , suwind tmin=0 tmax=3 | suximage t i t l e =zoom c h e c k s t a c k p e r c =90 ) Flow ( a l l v e l f i l t s h o t , a l l s h o t s a l a s k a v e l f i l t . sh , . / ${SOURCES[ 1 ] } 100 155 ) #R e s u l t ( m o v i e v e l f i l t , a l l v e l f i l t s h o t , # # suxmovie n2=96 l o o p=1 f f r a m e=1 dframe=1 # t i t l e =r e c o r d %g p e r c =20 # ) Result ( v e l f i l t r e c 2 4 , a l l v e l f i l t s h o t , suwind key=t r a c l min=2324 max=2424 tmin=0 tmax=6 | suximage p e r c =90 ) # s e r g e y d i d t h i s , b u t i t d i d not work . I j u s t used a s t r i n g #tnmo = [ 0 0 0 0 , . 3 3 9 , . 6 0 7 , . 7 0 7 , . 8 7 2 , 1 . 1 2 5 , # 1.358 ,1.652 ,2.091 ,2.349 ,2.859 ,6.000] #vnmo = [ 7 75 2 , 8 0 7 4 , 7 9 6 4 , 7 7 8 1 , 8 1 2 4 , 0 8 75 4 , # 08931 ,09721 ,10425 ,10742 ,12518 ,16552] # #tnmo = , . j o i n (map( s t r , tnmo ) ) #vnmo = , . j o i n (map( s t r , vnmo ) ) tnmo= 0 0 0 0 , . 3 3 9 , . 6 0 7 , . 7 0 7 , . 8 7 2 , 1 . 1 2 5 , 1 . 3 5 8 , 1 . 6 5 2 , 2 . 0 9 1 , 2 . 3 4 9 , 2 . 8 5 9 , 6 . 0 0 0 vnmo= 7 7 5 2 , 8 0 7 4 , 7 9 6 4 , 7 7 8 1 , 8 1 2 4 , 8 7 5 4 , 8 9 3 1 , 9 7 2 1 , 1 0 4 2 5 , 1 0 7 4 2 , 1 2 5 1 8 , 1 6 5 5 2 Flow ( v e l f i l t c d p s m u t e , a l l v e l f i l t s h o t , s u s o r t cdp |

14

171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215

sunmo tnmo=%s vnmo=%s | sumute \ xmute = 5225 , 2970 , 55 ,55 ,2970 ,5225 \ tmute = . 7 0 0 , . 2 8 0 , . 1 0 0 , . 1 0 0 , . 2 8 0 , . 7 0 0 \ mode=0 \ key=o f f s e t | sunmo tnmo=%s vnmo=%s i n v e r t =1 % ( tnmo , vnmo , tnmo , vnmo ) ) #R e s u l t ( m o v i e c d p s , v e l f i l t c d p s m u t e , # # suxmovie n2=96 l o o p=1 f f r a m e=1 dframe=1 # t i t l e =r e c o r d %g p e r c =20 # ) R e s u l t ( cdp250 251 , v e l f i l t c d p s m u t e , suwind key=cdp min=250 max=251 tmin=0 tmax=3 | suwigb p e r c =90 ) Flow ( v e l f i l t c d p s n m o , [ v e l f i l t c d p s m u t e , v p i c k . t x t ] , suchw key1=t s t a t key2=o f f s e t a=200 b=.0861 | sustatic hdrs=1 s i g n =1 | supef maxlag =.2 p n o i s e =.01 mincor =.25 maxcor=5 | sustatic hdrs=1 s i g n=1 | sunmo

15

216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251

par=v p i c k . t x t | sugain agc=1 wagc =.1 | sumute xmute =55 ,2970 ,5225 tmute = . 1 0 0 , . 2 8 0 , . 7 0 0 mode=0 key=o f f s e t ) #R e s u l t ( m o v i e v e l f i l t c d p s n m o , v e l f i l t c d p s n m o , # # suxmovie n2=96 l o o p=1 f f r a m e=1 dframe=1 # t i t l e = v e l f i l t c d p s n m o r e c o r d %g p e r c =20 # ) Flow ( b r u t e s t a c k , v e l f i l t c d p s n m o , sustack key=cdp normpow=1 ) Result ( brutestack , brutestack , suximage t i t l e =b r u t e s t a c k p e r c =90 ) R e s u l t ( zoomb rutestack , b r u t e s t a c k , suwind tmin=0 tmax=3.0 | suximage t i t l e =b r u t e s t a c k p e r c =90 ) # do i n v e r s e nmo , 1 f u n c t i o n nmo and compare r e s i d u a l s t a t i c s . compare # velanalysis after residual statics . Flow ( s t a t i c s i n , v e l f i l t c d p s n m o , suwind tmin =1.0 tmax=3.0 | suresamp r f =2 )

252 253 254 255 256 257 258 259

16

260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304

Flow ( s o u r c e s t a t i c . dat r e c s t a t i c . dat , statics in , suresstat \ s s o l=s o u r c e s t a t i c . dat r s o l=r e c s t a t i c . dat n i t e r =5 n t r a c e s =5280 n t p i c k =100 samples nshot =167 nr =668 nc=636 s f o l d =96 r f o l d =96 c f o l d =48 v e r b o s e=1 , s t d o u t =0) R e s u l t ( s o u r c e s t a t i c , s o u r c e s t a t i c . dat , xwigb n1=167 t i t l e =s o u r c e s t a t i c ) R e s u l t ( r e c s t a t i c , r e c s t a t i c . dat , xwigb n1=668 t i t l e = r e c e i v e r s t a t i c ) Flow ( r s t a c k , v e l f i l t c d p s n m o s o u r c e s t a t i c . dat r e c s t a t i c . dat , sushw key=t s t a t a=0 | sushw key=s s t a t a=0 | sushw key=g s t a t a=0 | sustatic hdrs=3 s o u f i l e=${SOURCES[ 1 ] } r e c f i l e =${SOURCES[ 2 ] } ns =167 nr =668 no=96 | sustack key=cdp normpow=1 ) Result ( rstack , rstack , suximage t i t l e = r s t a c k p e r c =90 ) R e s u l t ( zoomrstack , r s t a c k ,

17

305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349

suwind tmin=0 tmax=3.0 | suximage t i t l e = r s t a c k p e r c =90 ) Flow ( s t k v e l 1 . i n t p 2 . bi n , 010 V e l o c i t y I n t e r p I V A . sh , . / 0 1 0 V e l o c i t y I n t e r p I V A . sh ) R e s u l t ( v f i l e , s t k v e l 1 . i n t p 2 . bi n , ximage n1=3000 d1 =.002 f 2 =101 d2=1 cmap=rdb11 ) Flow ( mig , [ r s t a c k , s t k v e l 1 . i n t p 2 . bi n ] , s u f r a c power =.5 s i g n =1 | suktmig2d v f i l e =s t k v e l 1 . i n t p 2 . b in dx=55 h o f f s e t =0 ) R e s u l t ( mig , mig , suximage t i t l e =mig p e r c =90 ) R e s u l t ( zoommig , mig , suwind tmin=0 tmax=3.0 | suximage t i t l e =mig p e r c =90 ) # i t l o o k s l i k e one o f f s e t i s used f o r t h e whole o f f s e t g a t h e r # documentation s a y s use s u f r a c b e f o r e m i g r a t i o n Flow ( premig , [ v e l f i l t c d p s n m o , v p i c k . t x t , s t k v e l 1 . i n t p 2 . b i n ] , . / mig . sh ) Flow ( p r e m i g s t a c k , premig , susort | sustack key=cdp normpow=1 ) Result ( premigstack , premigstack ,

18

350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367

s u f i l t e r f =4 ,8 ,200 ,240 | suximage t i t l e =p r e m i g s t a c k p e r c =90 ) R e s u l t ( zoompremigstack , p r e m i g s t a c k , s u f i l t e r f =4 ,8 ,200 ,240 | suwind tmin=0 tmax=3.0 | suximage t i t l e =p r e m i g s t a c k p e r c =90 ) P l o t ( premigmovie , premig , suxmovie n2=536 l o o p=1 f f r a m e=1 dframe=1 t i t l e =r e c o r d %g p e r c =20 ) End ( )