# BOUNCE

#

BOUNCE computes the reflection coefficient for a stack of acoustic media optionally overlying elastic media. The reflection coefficient is written to both a '.IRC' file (internal reflection coefficient) and to a '.BRC' file (bottom reflection coefficient). These files can be used by KRAKEN, SCOOTER, and BELLHOP to provide a boundary condition, or plotted using PLOTRTH.

The input structure is identical to that used by KRAKENC although the input lines for source and receiver depth are not read and can be omitted. Furthermore, the surface boundary condition is ignored and, in effect, replaced by a homogeneous halfspace where the incident wave propagates.

If you are interested in getting a reflection coefficient for a bottom which is being used in a KRAKENC, SCOOTER, or BELLHOP run, you will need to delete the layers corresponding to the water column. Otherwise you will get a reflection coefficient corresponding to a wave incident from above the ocean surface.

The angles used for calculating the reflection coefficient are calculated based on the phase-velocity interval [ CMin, CMax ]. For a full 90 degree calculation set CMin to the lowest speed in the problem (say 1400.0) CMax to 1.0E9. The actual number of tabulated points is then determined by RMax.

If you are using the reflection coefficient for a coherent TL calculation then RMax should be the maximum range to which you are propagating. The further you go, the finer the sampling that is needed in the reflection coefficient. Run time is usually not an issue; however, if you pick an RMax that is insanely large then it could be.

The reflection coefficient depends on the impedance contrast between the halfspace from which the field is incident and the reflecting medium. Therefore BOUNCE must know the sound speed and other properties of the upper halfspace. If you're using the reflection coefficient to replace the sub-bottom in the ocean then you must set the speed of that upper halfspace to match the sound speed at the bottom of the ocean.

If you set the number of finite-difference grid points (NPTS) to zero, then BOUNCE automatically calculates a value to have 20 points per wavelength. If there is shear in a certain layer, then the shear wave will have a shorter wavelength than the P-wave speed. Then the smaller shear wavelength will be used to calculate the default. In some cases, 20 points per wavelength does not provide sufficient accuracy and you may need to increase that to as much as 100 points per wavelength.

If you only have a halfspace, you can set NMedia to 0. (The other models in the acoustics toolbox always require at least one acoustic medium, normally the ocean.)

Files:

Name Description

Input

*.ENV ENVironmental data

*.BRC Bottom Refl. Coef. (optl)

Output

*.PRT PRinT file

*.BRC Bottom Refl. Coef.

*.IRC Internal Refl. Coef.

## EXAMPLE OF ENV FILE:

'Refl. coef. test problem'

50.0

1

'NAW'
0.0 1500.0 0.0 1.0 0.0 0.0/ ! Z(m) CP CS (m/s) RHO (g/cm3) AP AS
100 0.0 20.0

0.0 1600.0 400.0 1.8 0.2 0.5

20.0 /

'A' 0.0

20.0 1800.0 600.0 2.0 0.1 0.2

1400.0 19000.0

10.0 ! RMax (km)

1 ! NSz

50.0 / ! Sz( 1 : NSz )

501 ! NRz

0.0 150.0 / ! Rz( 1 : NRz )

The above example (taken from the SAFARI reference manual) involves two elastic layers.

## `The Algorithm`

`All the models in the Acoustics Toolbox treat boundaries and interfaces with a Robin boundary condition:`

`
` `Z_Top p' + p = 0`

`Z_Bot p' + p = 0`

`
` `where p is the acoustic pressure. Thus Z = -p/p' represents something akin to an impedance (but which is not precisely the impedance because of some scale factors). That impedance is represented by a ratio, Z = g/( \rho f ), where f and g are functions of the horizontal wavenumber that have no singularities. In this fashion, we can find eigenvalues by shooting from the bottom towards the top, or vice versa, adjusting the wavenumber to satisfy the boundary condition:`

`
` `\delta(k ) = g(k) p' + \rho f(k) p = 0.`

`
` `Working with the non-singular \delta( k ) makes it easier to do the root finding. This Z is related to the reflection coefficient by:`

`
` `Z = ( 1 / (i k_z ) ) * ( 1 + R ) / ( 1 - R ) Eq. ( 1 )`

`
` `where k_z = sqrt( omega^2/c^2 - k_x^2 ) is the vertical wavenumber. This implies:`

`
` `R = - ( 1 - i k_z Z ) / ( 1 + i k_z Z ) Eq. ( 2 )`

`
` `which you can easily check by substituting (1) into (2) or vice versa. The propagation angle associated with a given wavenumber is atan( k_z, k_x ).
`

`To summarize, a bottom reflection coefficient is calculated by propagating the f(k), g(k) functions up from the bottom and then using the above formula to convert that to a reflection coefficient. If the deepest layer is a halfspace, then we use the analytic formula for the reflection coefficient from a halfspace and convert that to f(k), g(k). Centered-finite difference formulas then are used to shoot up through the layers. The layers can be elastic-- see the formulas in the KRAKEN manual.
`

`BOUNCE writes f(k), g(k) to the output Internal Reflection Coefficient file (IRCFile) and R( theta ) to the Bottom Reflection Coefficient file (BRCFile). Both of these files can be used with most of the models in the Acoustics Toolbox. However, the IRCFIL represents an entire function that works better with the KRAKEN root finder.
`

`The Matlab function PLOTBRC.m plots that. As mentioned above, the reflection coefficient refers to a planewave propagating in a halfspace, reflecting off the stack of layers being treated by BOUNCE. Therefore, it depends on the soundspeed of the halfspace in which that planewave is propagating. In other words, the reflection coefficient, R( theta ) depends not just on the impedance of the stack of layers, but the impedance contrast. Thus, it is important to specify the upper halfspace parameters. (Otherwise you get the default of c0= 1500 m/s.)
`

`The functions f(k) and g(k) can become *very* large or very small when there is tunneling. To deal with that, all the models in the Acoustics Toolbox carry a separate variable, iPower, which keeps track of powers of 10. Thus we have f(k) = F(k) * 10^iPower and g(k) = G(k) * 10^iPower. The removal of these extra factors is done whenever f and g become badly scaled. This does not have to be done in any precise way. The important thing is just to avoid over/underflows.``These quantities, f(k), g(k), and iPower(k), are the key values output as the Internal Reflection Coefficient.
`

``

`Usually something like 10 points/wavelength in the numerical grid is sufficient. However, one should keep in mind that the shortest wavelength (often related to shear speed) is the important one for the sampling. Also, since BOUNCE is very fast, there's no reason to skimp. The finer the grid, the more accurate the result. I'll suggest perhaps 100 points/wavelength as a good balance between run time and accuracy. I have seen cases where 10 points/wavelength gave very poor accuracy in R( theta ).
`