GetSlowness Documentation

If you want the details, please see the write up at: http://www.billkamp.com/lws/Tetra/LSFSemblance.htm for the gory mathematical details.

The test program for this routine also provides some detail. See tst39.pro for that documentation.

This document provides the implementation details only.

The routine is called by

GetSlowness,tdMat, satLoc, toMat, slowness, rCond

Inputs

1. tdMat: A NxN matrix of the relative time delays of the event between pairs of satellites. There are N satellites, and your must have at least 4 non-co-planar satellites. You can have as many as you want.
2. satLoc: A Nx3 array of the satellite locations. Here is how to make one in IDL:

        N=4
        satLoc=make_array(N, /float)
        satLoc = [[x],[y],[z],[w]]
   

   This is a 4 satellite case, and the 3-dimensional vectors x, y, z, and w are the positions of the satellites.

OUTPUTS

1. toMat: The output predicted time delays. It should closely match tdMat.
2. slowness: The slowness vector, i.e. k/V, where k is the directional vector of the event, and V is the (scalar) phase velocity.
3. rCond: The condition number of the volumetric tensor (which is inverted) used to calculate "slowness".

Implementation

1. Make the vector origin the centroid of the array, i.e. use a coordinate system in which the sum of the location vectors is (0,0,0). That is done thusly:

    newOrigin = make_array(3,/float,value=0b)
     mySatLoc = satLoc
     FOR i=0,nSat-1 DO BEGIN
        newOrigin[0]=newOrigin[0]+satLoc[0,i]
        newOrigin[1]=newOrigin[1]+satLoc[1,i]
        newOrigin[2]=newOrigin[2]+satLoc[2,i]
     ENDFOR
     FOR i=0,nSat-1 DO BEGIN
        mySatLoc[0,i]=satLoc[0,i] -newOrigin[0]/nSat
        mySatLoc[1,i]=satLoc[1,i] -newOrigin[1]/nSat
        mySatLoc[2,i]=satLoc[2,i] -newOrigin[2]/nSat
     ENDFOR
   

2. Make the volumetric tensor:

                                   ; Make the volumetric tensor
     R = make_array(3,3,/float,VALUE=0b)
     FOR i=0,2 DO BEGIN
        FOR j=0,2 DO BEGIN
           FOR alpha=0,nSat-1 DO BEGIN
              R[i,j] = R[i,j] + mySatLoc[i,alpha]*mySatLoc[j,alpha]
           ENDFOR
        ENDFOR
     ENDFOR
   
     R = R/nSat
   

3. Find the tensor's condition number:

     rCond=cond(R)
   

4. Invert the tensor:

     rInv = invert(R)
   

5. Build the pre-slowness matrix pM that will be multiplied by rInv:

     pM = make_array(3,/float,VALUE=0b)
   ; This will be the three components of the space delay array
     spDelArr = make_array(nSat,nSat,3,/float,VALUE=0b)
                                   ; Also store the component separately, so we can multiply them by the slowness vector as a test.
     sdx = make_array(nSat, nSat,/float,value=0b)
     sdy = make_array(nSat, nSat,/float,value=0b)
     sdz = make_array(nSat, nSat,/float,value=0b)
   
     FOR alpha=0,nSat-1 DO BEGIN
        FOR beta=0,nSat-1 DO BEGIN
           sdx[alpha,beta] = mySatLoc[0,alpha]-mySatLoc[0,beta]
           sdy[alpha,beta] = mySatLoc[1,alpha]-mySatLoc[1,beta]
           sdz[alpha,beta] = mySatLoc[2,alpha]-mySatLoc[2,beta]
           FOR k=0,2 DO BEGIN
              spDelArr[alpha,beta,k] = mySatLoc[k,alpha]-mySatLoc[k,beta]
              pM[k]=pM[k]+tdMat[alpha,beta]*( mySatLoc[k,alpha]-mySatLoc[k,beta] )
           ENDFOR
        ENDFOR
     ENDFOR
     pM=pM/(2*nSat*nSat)
   

6. Calculate the slowness vector:

     slowness = transpose(pM#rInv)
   

7. And although it is not necessary, we put in toMat the predicted time delay array, which should match tdMat.

     toMat = slowness[0]*sdx
   	  toMat = slowness[1]*sdy + toMat
   		  toMat = slowness[2]*sdz + toMat
   			

SIDE EFFECTS

RESTRICTIONS

MODIFICATION HISTORY