Changeset 7558


Ignore:
Timestamp:
08/10/18 15:21:54 (2 months ago)
Author:
paulf
Message:

cleaned up travel times in grid.c to be in seconds, not integer values converted back and forth

Location:
trunk/src/seismic_processing/binder_ew
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/seismic_processing/binder_ew/binder_ew.c

    r7556 r7558  
    134134   paulf - v1.0.35 - fixed potential bug in v1.0.32 for pick differential time, which could 
    135135                        be negative 
     136   paulf - v1.0.36 - changed from integer travel time (1000th of secs) used during nucleation 
     137                to actual double value of the travel time in seconds 
    136138*/ 
    137139 
    138 #define BINDER_VERSION "1.0.35 2018.08.10" 
     140#define BINDER_VERSION "1.0.36 2018.08.10" 
    139141 
    140142#include <stdio.h> 
  • trunk/src/seismic_processing/binder_ew/grid.c

    r7556 r7558  
    33 */ 
    44#include <math.h> 
     5#include <limits.h> 
    56#include <inttypes.h> 
    67#include <string.h> 
     
    7576long   mStack          = 20;    /* Maximum number of picks to stack     */ 
    7677unsigned int maskGrid  = 0;     /* Initialization mask                  */ 
    77 int    tStack          = 5;     /* Stack width (0.1 s)                  */ 
    78 int    stack_horizontals = 0;  /* set to 1 to allow horizontal components in stack - paulf */ 
     78double  tStack          = 0.1;   /* Stack width (0.1 s)                  */ 
     79int    stack_horizontals = 0;   /* set to 1 to allow horizontal components in stack - paulf */ 
    7980int    mPix; 
    8081int    nPix; 
     
    102103                Stack[ix][iy][iz]. Index is calculated as 
    103104                iz + nZ*iy + nYS*nZ*ix (times are in .1 secs)           */ 
    104 uint32_t *lpTrav; 
    105 int lpTravMax; 
     105double *lpTrav; 
     106int lpTravMax; /* the maximum index in lpTrav[]  */ 
    106107 
    107108/* Stacking Grid 
     
    176177                           "nXS, nYS = %d %d\n", nXS, nYS); 
    177178                lpTravMax = nXS * nYS * nZ; 
    178                 lpTrav = (uint32_t *)malloc( nXS*nYS*nZ*sizeof(uint32_t) ); 
     179                lpTrav = (double *)malloc( nXS*nYS*nZ*sizeof(double) ); 
    179180                for(ix=0; ix<nXS; ix++) { 
    180181                        x = dSpace * (double)ix; 
     
    187188                                        ixyz = iz + nZ*iy + nYS*nZ*ix; 
    188189                                        if ((ixyz<0) || (ixyz>=lpTravMax)) Panic( 11 ); 
    189                                         lpTrav[ixyz] = (int)(1000.0 * t); 
     190                                        lpTrav[ixyz] = t; 
    190191                                } 
    191192                        } 
     
    284285 
    285286        if(k_its("tstack")) { 
    286            tStack = (int)(1000.0 * k_val());  /* truncate to nearest thousandth sec */ 
     287           tStack = k_val();   
    287288           return 1; 
    288289        } 
     
    472473        struct {                /* List of picks to stack, 0 is master  */ 
    473474                long  id;       /* Pick id                              */ 
    474                 int32_t kt;     /* Offset in thousandth of seconds          */ 
     475                double kt;      /* Offset in seconds                    */ 
    475476                short x;        /* Station location (grid coord)        */ 
    476477                short y;        /* Station location (grid coord)        */ 
     
    485486        int     it;             /* Travel time iterator                 */ 
    486487        int     ix, iy, iz;     /* Spatial iterators                    */ 
    487         int     kt;             /* Time accumator during stacking       */ 
     488        double     kt;             /* Time accumator during stacking       */ 
    488489        int     i, i2;          /* Common iterator                      */ 
    489490        int     j;              /* Common iterator                      */ 
    490491        int     is;             /* Stack index                          */ 
    491492        int     inc;            /* Stack increment (wt dependent)       */ 
    492         int     kt1, kt2, kt3; 
     493        double     kt1, kt2, kt3; 
    493494        int     idifx, idify; 
    494495        int     reject;         /* used to reject a pick if higher weight one exists */ 
     
    527528        grid_cart(&geo, &xyz); 
    528529        list[0].id  = lpick; 
    529         list[0].kt  = 0; 
     530        list[0].kt  = 0.0; 
    530531        list[0].x   = (int)(xyz.x/dSpace); 
    531532        list[0].y   = (int)(xyz.y/dSpace); 
     
    551552        it = IXTRAV(0, nYS-1, nZ-1); 
    552553        if ((it<0) || (it>=lpTravMax))  Panic( 12 ); 
    553         tmax = 0.001 * lpTrav[it]; 
     554        tmax = lpTrav[it]; 
    554555        ts = pPick[ipick].t; 
    555556        t1 = ts - tmax; 
     
    628629                grid_cart(&geo, &xyz); 
    629630                list[nlist].id   = l; 
    630                 list[nlist].kt   = (int)(1000.0*(pPick[i].t - ts)); 
     631                list[nlist].kt   = pPick[i].t - ts; 
    631632                list[nlist].x    = (int)(xyz.x/dSpace); 
    632633                list[nlist].y    = (int)(xyz.y/dSpace); 
     
    760761                                              Site[s].name,Site[s].comp,                    
    761762                                              Site[s].net,Site[s].loc,                      
    762                                               ix,iy,iz, lpGrid[is],(float)kt/1000. );  
     763                                              ix,iy,iz, lpGrid[is],(float)kt );  
    763764#endif /* DEBUG */ 
    764765                                        if(lpGrid[is] < mhit) 
    765766                                                continue; 
    766767                                        if(lpGrid[is] > mhit) { 
    767                                                 kdmin = 10000; 
     768                                                kdmin = INT_MAX; 
    768769                                                mhit = lpGrid[is]; 
    769770                                                nhit = 0; 
     
    777778                                                nhit = 0; 
    778779                                        } 
    779                                         kdy = list[0]. y - iy; 
     780                                        kdy = list[0].y - iy; 
    780781                                        if(kdy < 0) kdy = - kdy; 
    781782                                        if(kdy < kdmin) { 
     
    797798                                      Site[s].name,Site[s].comp,                    
    798799                                      Site[s].net,Site[s].loc,                     
    799                                       ix,iy,iz, lpGrid[is],(float)kt/1000. );        
     800                                      ix,iy,iz, lpGrid[is], kt );        
    800801                                }  
    801802#endif  /* END DEBUG loop */ 
     
    841842                        kt = kt1 - kt2 + kt3; 
    842843                        if(kt > -tStack && kt < tStack) { 
    843                                 ipix[npix++] = i; 
     844                                ipix[npix++] = i; /* add the pick to the list that is used */ 
    844845                                break; 
    845846                        } 
     
    862863                        hit[i].y - list[0].y, hit[i].z); 
    863864                if ((it<0) || (it>=lpTravMax)) Panic( 16 ); 
    864                 tsum += ts - 0.001 * lpTrav[it]; 
     865                tsum += ts - lpTrav[it]; 
    865866                xsum += hit[i].x; 
    866867                ysum += hit[i].y; 
Note: See TracChangeset for help on using the changeset viewer.