Changeset 7525


Ignore:
Timestamp:
06/29/18 19:57:38 (3 weeks ago)
Author:
baker
Message:

fix non-conforming C90 syntax (warning: ISO C90 forbids mixed declarations and code [-Wdeclaration-after-statement])

Location:
trunk/src
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/data_exchange/pdl2ew/ark2arc.c

    r7241 r7525  
    1 /* 
    2  *   THIS FILE IS UNDER RCS - DO NOT MODIFY UNLESS YOU HAVE 
    3  *   CHECKED IT OUT USING THE COMMAND CHECKOUT. 
    4  * 
    5  * 
    6  */ 
    7  
    81/* 
    92 * pdl2ew.c: 
     
    357350} 
    358351 
    359  
    360  
    361352/* File handling stuff 
    362353**********************/ 
     
    378369   char      magStr[4]; 
    379370 
     371   sqlite3  *db; 
     372   char     *err_msg = NULL; 
     373   char     evt_sql[200], evtid[20]; 
     374   char    *sql; 
     375   double   nextPurge; 
     376   int      ins_count, upd_count, del_count, op_count; 
     377     
    380378/* Check command line arguments  
    381379 ******************************/ 
     
    470468   db_path = DBPath; 
    471469    
    472     sqlite3 *db; 
    473     char *err_msg = 0; 
    474      
    475470    rc = sqlite3_open(db_path, &db); 
    476471    if (rc != SQLITE_OK) { 
     
    480475        return -1; 
    481476    } 
    482     char evt_sql[200], evtid[20]; 
    483         char *sql = "CREATE TABLE Events(PdlID TEXT, TimeStamp TEXT);";           
     477    sql = "CREATE TABLE Events(PdlID TEXT, TimeStamp TEXT);";           
    484478    rc = sqlite3_exec(db, sql, 0, 0, &err_msg); 
    485479 
    486     double nextPurge = time(NULL) + secsInWeek; 
    487      
    488     int ins_count = 0, upd_count = 0, del_count = 0, op_count = 0; 
     480    nextPurge = time(NULL) + secsInWeek; 
     481     
     482    ins_count = 0, upd_count = 0, del_count = 0, op_count = 0; 
    489483/****************  top of working loop ********************************/ 
    490484   while(1) 
     
    510504        result = GetFileName( fname ); 
    511505        if( result == 1 ) {  /* No files found; wait for one to appear */ 
    512                 if ( time(NULL) > nextPurge ) { 
    513                     logit( "t", "Purging week-old mappings\n" ); 
    514                 char nextPurgeStr[30]; 
    515                 datestr23( nextPurge, nextPurgeStr, 30 ); 
    516                 nextPurgeStr[4] = nextPurgeStr[7] = '-'; 
    517                 //FILES THAT NEED DELETING? 
    518                 sprintf( evt_sql, "DELETE FROM Events WHERE TimeStamp < '%s';", nextPurgeStr ); 
    519                 if ( db == NULL ) { 
    520                     logit( "et", "Re-opening DB\n" ); 
    521                     rc = sqlite3_open(db_path, &db); 
    522                     if (rc != SQLITE_OK) { 
    523                         logit("et", "Cannot re-open database: %s\n", sqlite3_errmsg(db)); 
    524                         sqlite3_close(db); 
    525                         return 1; 
    526                     } 
    527                 } 
    528                 rc = sqlite3_exec(db, evt_sql, 0, 0, &err_msg);   
    529                 del_count++; 
    530                 op_count++;   
    531                 if (rc != SQLITE_OK ) { 
    532                     logit("et", "DELETE #%d failed\n", del_count);    
    533                     logit("et", "SQL DELETE error %d: %s (%s)\n", rc, err_msg, evt_sql); 
    534                 }  
    535                 nextPurge = time(NULL) + secsInWeek; 
    536                 } 
     506           if ( time(NULL) > nextPurge ) { 
     507              char nextPurgeStr[30]; 
     508              logit( "t", "Purging week-old mappings\n" ); 
     509              datestr23( nextPurge, nextPurgeStr, 30 ); 
     510              nextPurgeStr[4] = nextPurgeStr[7] = '-'; 
     511              //FILES THAT NEED DELETING? 
     512              sprintf( evt_sql, "DELETE FROM Events WHERE TimeStamp < '%s';", nextPurgeStr ); 
     513              if ( db == NULL ) { 
     514                 logit( "et", "Re-opening DB\n" ); 
     515                 rc = sqlite3_open(db_path, &db); 
     516                 if (rc != SQLITE_OK) { 
     517                    logit("et", "Cannot re-open database: %s\n", sqlite3_errmsg(db)); 
     518                    sqlite3_close(db); 
     519                    return 1; 
     520                 } 
     521              } 
     522              rc = sqlite3_exec(db, evt_sql, 0, 0, &err_msg);   
     523              del_count++; 
     524              op_count++;   
     525              if (rc != SQLITE_OK ) { 
     526                 logit("et", "DELETE #%d failed\n", del_count);    
     527                 logit("et", "SQL DELETE error %d: %s (%s)\n", rc, err_msg, evt_sql); 
     528              }  
     529              nextPurge = time(NULL) + secsInWeek; 
     530           } 
    537531           sleep_ew( CheckPeriod*1000 );  
    538532           continue; 
     
    657651  ProcessedFile: 
    658652    if ( result >= 0 ) { 
    659             logit( "t", "Saving '%s': %ld\n", evtid, eventID ); 
    660  
    661         char path[300]; 
     653        char path[300], *p2; 
     654        logit( "t", "Saving '%s': %ld\n", evtid, eventID ); 
    662655        sprintf( path, "%s/__________.arc", SaveToDir ); 
    663         char *p2 = path+strlen(SaveToDir)+1; 
     656        p2 = path+strlen(SaveToDir)+1; 
    664657        for ( i=0; i<10; i++ ) 
    665658            p2[i] = arc_msg.eventID[i]; 
  • trunk/src/data_exchange/pdl2ew/pdl2ark.c

    r7183 r7525  
     1#include <ctype.h> 
    12#include <math.h> 
    23#include <stdio.h> 
     4#include <stdlib.h> 
    35#include <string.h> 
    4 #include <stdlib.h> 
    5 #include <ctype.h> 
    66#include <unistd.h> 
     7 
    78#include "pdl2ew.h" 
    89 
     
    9192    int erArgLen = strlen(erArg); 
    9293    char erPrefix = '='; 
    93     char eventEmailFileName[250] = {0}; 
     94    char eventEmailFileName[250] = { '\0' }; 
    9495    FILE *eventEmailFile; 
    95     char htmlFileName[50] = {0}; 
     96    char htmlFileName[50] = { '\0' }; 
    9697    char *linePtr = NULL; 
     98    char sysCommand[200] = { '\0' }; 
     99 
    97100    memset( &msg, ' ', sizeof(msg) ); 
    98101    msg.term = 0; 
    99102    f = fopen( argv[2], "a" ); 
    100     char sysCommand[200] = {'\0'}; 
    101103 
    102104    //XXX XXX 
     
    142144            //fprintf( f, "%s\n", argv[i] ); 
    143145        } else if ( strncmp( myargs[LATITUDE_ARG], test_arg, strlen(myargs[LATITUDE_ARG]) ) == 0 ) { 
     146            double val, deg, min; 
     147            char *tobesaved, save; 
    144148            vals[1] = strtod( test_arg + strlen(myargs[LATITUDE_ARG]), NULL ); 
    145             double val = fabs(vals[1]); 
    146             double deg = floor(val); 
    147             double min = 60.0 * (val - deg); 
    148             char *tobesaved = ptrAfter(msg.latitude); 
    149             char save = *tobesaved; 
     149            val = fabs(vals[1]); 
     150            deg = floor(val); 
     151            min = 60.0 * (val - deg); 
     152            tobesaved = ptrAfter(msg.latitude); 
     153            save = *tobesaved; 
    150154            sprintf( msg.latitude, "%2.0lf%c%04.0lf", deg, vals[1]>=0 ? 'N' : 'S', min*100 ); 
    151155            *tobesaved = save; 
    152156            //fprintf( f, "%s\n", argv[i] ); 
    153157        } else if ( strncmp( myargs[LONGITUDE_ARG], test_arg, strlen(myargs[LONGITUDE_ARG]) ) == 0 ) { 
     158            double val, deg, min; 
     159            char *tobesaved, save; 
    154160            vals[2] = strtod( test_arg + strlen(myargs[LONGITUDE_ARG]), NULL );; 
    155             double val = fabs(vals[2]); 
    156             double deg = floor(val); 
    157             double min = 60.0 * (val - deg); 
    158             char *tobesaved = ptrAfter(msg.longitude); 
    159             char save = *tobesaved; 
     161            val = fabs(vals[2]); 
     162            deg = floor(val); 
     163            min = 60.0 * (val - deg); 
     164            tobesaved = ptrAfter(msg.longitude); 
     165            save = *tobesaved; 
    160166            sprintf( msg.longitude, "%3.0lf%c%04.0lf", deg, vals[2]>=0 ? 'E' : 'W', min*100 ); 
    161167            *tobesaved = save; 
    162168            //fprintf( f, "%s\n", argv[i] ); 
    163169       } else if ( strncmp( myargs[DEPTH_ARG], test_arg, strlen(myargs[DEPTH_ARG]) ) == 0 ) { 
    164             double val = strtod( test_arg + strlen(myargs[DEPTH_ARG]), NULL ); 
    165             char *tobesaved = ptrAfter(msg.depth); 
    166             char save = *tobesaved; 
     170            double val; 
     171            char *tobesaved, save; 
     172            val = strtod( test_arg + strlen(myargs[DEPTH_ARG]), NULL ); 
     173            tobesaved = ptrAfter(msg.depth); 
     174            save = *tobesaved; 
    167175            sprintf( msg.depth, "%5.0lf", val*100 ); 
    168176            *tobesaved = save; 
    169177            //fprintf( f, "%s\n", argv[i] ); 
    170178        } else if ( strncmp( myargs[MAGNITUDE_ARG], test_arg, strlen(myargs[MAGNITUDE_ARG]) ) == 0 ) { 
    171             double val = strtod( test_arg + strlen(myargs[MAGNITUDE_ARG]), NULL ); 
     179            double val; 
     180            val = strtod( test_arg + strlen(myargs[MAGNITUDE_ARG]), NULL ); 
    172181            vals[0] = val; 
    173182        } else if ( strncmp( myargs[NUM_PHASES_ARG], test_arg, strlen(myargs[NUM_PHASES_ARG]) ) == 0 ) { 
    174             double val = strtod( test_arg + strlen(myargs[NUM_PHASES_ARG]), NULL ); 
    175             char *tobesaved = ptrAfter(msg.numPhases); 
    176             char save = *tobesaved; 
     183            double val; 
     184            char *tobesaved, save; 
     185            val = strtod( test_arg + strlen(myargs[NUM_PHASES_ARG]), NULL ); 
     186            tobesaved = ptrAfter(msg.numPhases); 
     187            save = *tobesaved; 
    177188            sprintf( msg.numPhases, "%3.0lf", val ); 
    178189            *tobesaved = save; 
    179190            //fprintf( f, "%s\n", argv[i] ); 
    180191        } else if ( strncmp( myargs[AZIMUTH_GAP_ARG], test_arg, strlen(myargs[AZIMUTH_GAP_ARG]) ) == 0 ) { 
    181             double val = strtod( test_arg + strlen(myargs[AZIMUTH_GAP_ARG]), NULL ); 
    182             char *tobesaved = ptrAfter(msg.azimuthalGap); 
    183             char save = *tobesaved; 
     192            double val; 
     193            char *tobesaved, save; 
     194            val = strtod( test_arg + strlen(myargs[AZIMUTH_GAP_ARG]), NULL ); 
     195            tobesaved = ptrAfter(msg.azimuthalGap); 
     196            save = *tobesaved; 
    184197            sprintf( msg.azimuthalGap, "%3.0lf", val ); 
    185198            *tobesaved = save; 
    186199            //fprintf( f, "%s\n", argv[i] ); 
    187200        } else if ( strncmp( myargs[MIN_DIST_ARG], test_arg, strlen(myargs[MIN_DIST_ARG]) ) == 0 ) { 
    188             double val = strtod( test_arg + strlen(myargs[MIN_DIST_ARG]), NULL ); 
    189             char *tobesaved = ptrAfter(msg.minDist); 
    190             char save = *tobesaved; 
     201            double val; 
     202            char *tobesaved, save; 
     203            val = strtod( test_arg + strlen(myargs[MIN_DIST_ARG]), NULL ); 
     204            tobesaved = ptrAfter(msg.minDist); 
     205            save = *tobesaved; 
    191206            sprintf( msg.minDist, "%3.0lf", val ); 
    192207            *tobesaved = save; 
    193208            //fprintf( f, "%s\n", argv[i] ); 
    194209        } else if ( strncmp( myargs[HORZ_ERR_ARG], test_arg, strlen(myargs[HORZ_ERR_ARG]) ) == 0 ) { 
    195             double val = strtod( test_arg + strlen(myargs[HORZ_ERR_ARG]), NULL ); 
    196             char *tobesaved = ptrAfter(msg.horzError); 
    197             char save = *tobesaved; 
     210            double val; 
     211            char *tobesaved, save; 
     212            val = strtod( test_arg + strlen(myargs[HORZ_ERR_ARG]), NULL ); 
     213            tobesaved = ptrAfter(msg.horzError); 
     214            save = *tobesaved; 
    198215            sprintf( msg.horzError, "%4.0lf", val*100 ); 
    199216            *tobesaved = save; 
    200217            //fprintf( f, "%s\n", argv[i] ); 
    201218        } else if ( strncmp( myargs[VERT_ERR_ARG], test_arg, strlen(myargs[VERT_ERR_ARG]) ) == 0 ) { 
    202             double val = strtod( test_arg + strlen(myargs[VERT_ERR_ARG]), NULL ); 
    203             char *tobesaved = ptrAfter(msg.vertError); 
    204             char save = *tobesaved; 
     219            double val; 
     220            char *tobesaved, save; 
     221            val = strtod( test_arg + strlen(myargs[VERT_ERR_ARG]), NULL ); 
     222            tobesaved = ptrAfter(msg.vertError); 
     223            save = *tobesaved; 
    205224            sprintf( msg.vertError, "%4.0lf", val*100 ); 
    206225            *tobesaved = save; 
     
    239258        save = *tobesaved; 
    240259        sprintf( msg.Md, "%3.0lf", vals[0]*100 ); 
    241          
    242260        *tobesaved = save; 
    243261        tobesaved = ptrAfter(msg.Mpref); 
     
    247265    } 
    248266    if ( (reqd == 0) && !(isDelete) ) { 
    249         char path[300]; 
     267        char path[300], *p2; 
     268        FILE *f2; 
    250269        sprintf( path, "%s/__________.ark", argv[1] ); 
    251         char *p2 = path+strlen(argv[1])+1; 
     270        p2 = path+strlen(argv[1])+1; 
    252271        for ( i=0; i<sizeof(msg.pad_eventid); i++ ) 
    253272            if ( !isblank(msg.pad_eventid[i]) ) 
    254273                p2[i] = msg.pad_eventid[i]; 
    255274        //fprintf( f, "Path: %s\n", path ); 
    256         FILE *f2 = fopen( path, "w" ); 
     275        f2 = fopen( path, "w" ); 
    257276        puts( path ); 
    258277        puts( (char*)&msg ); 
     
    304323    return 0; 
    305324} 
    306  
    307 /* 
    308 */ 
  • trunk/src/libsrc/earlybird/geotools.c

    r7043 r7525  
    2828 char* _itoa(int value, char* result, int base)  
    2929 { 
    30  /* check that the base if valid */ 
    31     if ( base < 2 || base > 36 ) { *result = '\0'; return result; } 
    32          
    3330    char *ptr  = result;  
    3431    char *ptr1 = result; 
     
    3633    int   tmp_value; 
    3734  
     35 /* check that the base if valid */ 
     36    if ( base < 2 || base > 36 ) { *result = '\0'; return result; } 
     37         
    3838    do  
    3939    { 
     
    5858 } 
    5959#endif 
    60  
    6160 
    6261      /****************************************************************** 
     
    10761075       *                                                                * 
    10771076       ******************************************************************/ 
     1077 
    10781078int IsItDangerous (double dLat, double dLon) 
    10791079{ 
     
    12541254       *                                                                * 
    12551255       ******************************************************************/          
     1256 
    12561257int LoadTTT( char *pszFile, TSUTRAVTIME *ttt, int iNumSites, int iFormat ) 
    12571258{ 
     
    16261627       *                                                                * 
    16271628       ******************************************************************/ 
     1629 
    16281630void PadZeroesR( int iNumDigits, char *pszString ) 
    16291631{ 
  • trunk/src/reporting/ewhttpd/ewhttpd.c

    r7464 r7525  
    444444         else if (k_its("GetLogo"))  
    445445         { 
     446            int fail; 
    446447            GetLogo = ( MSG_LOGO* ) realloc( GetLogo, ( nLogo + 1 ) * sizeof( MSG_LOGO ) ); 
    447448            if( GetLogo == NULL ) 
     
    452453               exit(-1); 
    453454            } 
    454             int fail = 1; 
     455            fail = 1; 
    455456            if ( (str = k_str()) != NULL) 
    456457            { 
  • trunk/src/reporting/snwclient/snwclient.c

    r7481 r7525  
    6666                int send_failed = 0; 
    6767                int read_error  = 0; 
     68                int totalbytes; 
    6869                 
    6970                rc = GetFileName( fname ); 
     
    108109   ***************************************************************/ 
    109110                if(Verbose) log_msg( "et", "Sending file %s\n", fname ); 
    110                 int totalbytes = 0; 
     111                totalbytes = 0; 
    111112                while ( 1 ) 
    112113                { 
  • trunk/src/seismic_processing/pick_FP/picker/picker_func_test.c

    r4650 r7525  
    1212#define DEBUG 0 
    1313 
    14  
    1514void MonthDay(int year, int yearday, int* pmonth, int* pday); 
    1615 
    1716int main(int argc, char *argv[]) { 
    1817 
     18    BOOLEAN_INT useMemory = FALSE_INT; // set to TRUE_INT (=1) if function is called for packets of data in sequence, FALSE_INT (=0) otherwise 
     19    FILE *fp; 
     20    struct HDR sachdr; 
     21    float* sample; 
     22    double filterWindow, longTermWindow, threshold1, threshold2, tUpEvent; 
     23    double dt; 
     24    long iFilterWindow, ilongTermWindow, itUpEvent; 
     25    PickData **pick_list = NULL; 
     26    int num_picks = 0; 
     27    FilterPicker5_Memory* mem = NULL; 
     28    int month, day; 
     29    double sec; 
     30    char *onset, *kstnm, *kinst, *kcmpnm, *pick_str, phase[16]; 
     31    int n; 
    1932 
    2033    if (argc < 3) { 
     
    2437    } 
    2538 
    26  
    27  
    28     BOOLEAN_INT useMemory = FALSE_INT; // set to TRUE_INT (=1) if function is called for packets of data in sequence, FALSE_INT (=0) otherwise 
    29  
    30  
    31  
    3239    // open and read SAC file 
    33     FILE *fp; 
    3440    if ((fp = fopen(argv[1], "r")) == 0) { 
    3541        perror(argv[1]); 
     
    3743    } 
    3844    // read header 
    39     struct HDR sachdr; 
    4045    fread(&sachdr, sizeof (sachdr), 1, fp); 
    4146    // allocate array for data 
    4247    if (DEBUG) printf("sachdr.NPTS: %d\n", sachdr.NPTS); 
    43     float* sample = calloc(sachdr.NPTS, sizeof (float)); 
     48    sample = calloc(sachdr.NPTS, sizeof (float)); 
    4449    // read data 
    4550    fread(sample, sizeof (float), sachdr.NPTS, fp); 
    4651    fclose(fp); 
    47  
    48  
    4952 
    5053    // set picker paramters (TODO: make program arguments?) 
     
    5255    // defaults 
    5356    // filp_test filtw 4.0 ltw 10.0 thres1 8.0 thres2 8.0 tupevt 0.2 res PICKS... 
    54     double filterWindow = 4.0; // NOTE: auto set below 
    55     double longTermWindow = 10.0; // NOTE: auto set below 
    56     double threshold1 = 10.0; 
    57     double threshold2 = 10.0; 
    58     double tUpEvent = 0.5; // NOTE: auto set below 
     57    filterWindow = 4.0; // NOTE: auto set below 
     58    longTermWindow = 10.0; // NOTE: auto set below 
     59    threshold1 = 10.0; 
     60    threshold2 = 10.0; 
     61    tUpEvent = 0.5; // NOTE: auto set below 
    5962    // 
    6063    // auto set values 
    6164    // get dt 
    62     double dt = sachdr.DELTA; 
     65    dt = sachdr.DELTA; 
    6366    if (DEBUG) printf("sachdr.DELTA: %f\n", sachdr.DELTA); 
    6467    //dt = dt < 0.02 ? 0.02 : dt;     // aviod too-small values for high sample rate data 
    6568    // 
    6669    filterWindow = 300.0 * dt; 
    67     long iFilterWindow = (long) (0.5 + filterWindow * 1000.0); 
     70    iFilterWindow = (long) (0.5 + filterWindow * 1000.0); 
    6871    if (iFilterWindow > 1) 
    6972        filterWindow = (double) iFilterWindow / 1000.0; 
    7073    // 
    7174    longTermWindow = 500.0 * dt; // seconds 
    72     long ilongTermWindow = (long) (0.5 + longTermWindow * 1000.0); 
     75    ilongTermWindow = (long) (0.5 + longTermWindow * 1000.0); 
    7376    if (ilongTermWindow > 1) 
    7477        longTermWindow = (double) ilongTermWindow / 1000.0; 
    7578    // 
    7679    tUpEvent = 20.0 * dt; // time window to take integral of charFunct version 
    77     long itUpEvent = (long) (0.5 + tUpEvent * 1000.0); 
     80    itUpEvent = (long) (0.5 + tUpEvent * 1000.0); 
    7881    if (itUpEvent > 1) 
    7982        tUpEvent = (double) itUpEvent / 1000.0; 
     
    8285            filterWindow, longTermWindow, threshold1, threshold2, tUpEvent); 
    8386 
    84  
    85  
    8687    // do picker function test 
    87     PickData** pick_list = NULL; // array of num_picks ptrs to PickData structures/objects containing returned picks 
    88     int num_picks = 0; 
    89     FilterPicker5_Memory* mem = NULL; 
     88    pick_list = NULL; // array of num_picks ptrs to PickData structures/objects containing returned picks 
     89    num_picks = 0; 
     90    mem = NULL; 
    9091 
    9192    Pick( 
     
    113114    } 
    114115    // date 
    115     int month, day; 
    116116    MonthDay(sachdr.NZYEAR, sachdr.NZJDAY, &month, &day); 
    117     double sec = (double) sachdr.B + (double) sachdr.NZSEC + (double) sachdr.NZMSEC / 1000.0; 
     117    sec = (double) sachdr.B + (double) sachdr.NZSEC + (double) sachdr.NZMSEC / 1000.0; 
    118118    // id fields 
    119     char onset[] = "?"; 
    120     char* kstnm; 
     119    onset = "?"; 
    121120    kstnm = calloc(1, 16 * sizeof (char)); 
    122121    strncpy(kstnm, sachdr.KSTNM, 6); 
    123     char* kinst; 
    124122    kinst = calloc(1, 16 * sizeof (char)); 
    125123    strncpy(kinst, sachdr.KINST, 6); 
    126124    if (strstr(kinst, "(count") != NULL) 
    127125        strcpy(kinst, "(counts)"); 
    128     char* kcmpnm; 
    129126    kcmpnm = calloc(1, 16 * sizeof (char)); 
    130127    strncpy(kcmpnm, sachdr.KCMPNM, 6); 
    131     char phase[16]; 
    132128    // create NLL picks 
    133     char* pick_str; 
    134129    pick_str = calloc(1, 1024 * sizeof (char)); 
    135     int n; 
    136130    for (n = 0; n < num_picks; n++) { 
    137131        sprintf(phase, "P%d_", n); 
     
    142136        fprintf(fp, "%s\n", pick_str); 
    143137    } 
    144  
    145138 
    146139    // clean up 
     
    157150 
    158151} 
    159  
    160  
    161152 
    162153/** date functions */ 
     
    179170 
    180171} 
    181  
  • trunk/src/seismic_processing/pick_FP/picker/picker_func_test_memory.c

    r4650 r7525  
     1#include <math.h> 
    12#include <stdlib.h> 
    23#include <stdio.h> 
    34#include <string.h> 
    4 #include <math.h> 
    55 
    66#include "sachdr.h" 
     
    1515#define PACKET_SIZE 10 //simulated packet size (seconds) 
    1616 
    17  
    1817void MonthDay(int year, int yearday, int* pmonth, int* pday); 
    1918 
    2019int main(int argc, char *argv[]) { 
    2120 
     21    BOOLEAN_INT useMemory = TRUE_INT; // set to TRUE_INT (=1) if function is called for packets of data in sequence, FALSE_INT (=0) otherwise 
     22    FILE *fp; 
     23    struct HDR sachdr; 
     24    int length; 
     25    float* sample; 
     26    double filterWindow, longTermWindow, threshold1, threshold2, tUpEvent; 
     27    double dt; 
     28    long iFilterWindow, ilongTermWindow, itUpEvent; 
     29    PickData **pick_list_definitive = NULL; 
     30    int num_picks_definitive = 0; 
     31    FilterPicker5_Memory* mem = NULL; 
     32    int proc_samples, read_samples; 
     33    int month, day; 
     34    double sec; 
     35    char *onset, *kstnm, *kinst, *kcmpnm, *pick_str, phase[16]; 
    2236    int n; 
    2337 
     
    2842    } 
    2943 
    30  
    31  
    32     BOOLEAN_INT useMemory = TRUE_INT; // set to TRUE_INT (=1) if function is called for packets of data in sequence, FALSE_INT (=0) otherwise 
    33  
    34  
    35  
    3644    // open and read SAC file 
    37     FILE *fp; 
    3845    if ((fp = fopen(argv[1], "r")) == 0) { 
    3946        perror(argv[1]); 
     
    4148    } 
    4249    // read header 
    43     struct HDR sachdr; 
    4450    fread(&sachdr, sizeof (sachdr), 1, fp); 
    4551    // allocate array for data 
    4652    //if (DEBUG) printf("sachdr.NPTS: %d\n", sachdr.NPTS); 
    47     //float* sample = calloc(sachdr.NPTS, sizeof(float)); 
    48     int length = (int) rint(1.0 / sachdr.DELTA); 
     53    //sample = calloc(sachdr.NPTS, sizeof(float)); 
     54    length = (int) rint(1.0 / sachdr.DELTA); 
    4955    length *= PACKET_SIZE; 
    5056    if (DEBUG) printf("length: %d\n", length); 
    51     float* sample = calloc(length, sizeof (float)); 
     57    sample = calloc(length, sizeof (float)); 
    5258    // read data 
    5359    //fread(sample, sizeof(float), sachdr.NPTS, fp); 
    54     //fclose (fp); 
    55  
    56  
     60    //fclose(fp); 
    5761 
    5862    // set picker paramters (TODO: make program arguments?) 
     
    6064    // defaults 
    6165    // filp_N filtw 4.0 ltw 10.0 thres1 8.0 thres2 8.0 tupevt 0.2 res PICKS... 
    62     double longTermWindow = 10.0; // NOTE: auto set below 
    63     double threshold1 = 10.0; 
    64     double threshold2 = 10.0; 
    65     double tUpEvent = 0.5; // NOTE: auto set below 
    66     double filterWindow = 4.0; // NOTE: auto set below 
     66    filterWindow = 4.0; // NOTE: auto set below 
     67    longTermWindow = 10.0; // NOTE: auto set below 
     68    threshold1 = 10.0; 
     69    threshold2 = 10.0; 
     70    tUpEvent = 0.5; // NOTE: auto set below 
    6771    // 
    6872    // auto set values 
    6973    // get dt 
    70     double dt = sachdr.DELTA; 
     74    dt = sachdr.DELTA; 
    7175    if (DEBUG) printf("sachdr.DELTA: %f\n", sachdr.DELTA); 
    7276    //dt = dt < 0.02 ? 0.02 : dt;     // aviod too-small values for high sample rate data 
    7377    // 
    7478    filterWindow = 300.0 * dt; 
    75     long iFilterWindow = (long) (0.5 + filterWindow * 1000.0); 
     79    iFilterWindow = (long) (0.5 + filterWindow * 1000.0); 
    7680    if (iFilterWindow > 1) 
    7781        filterWindow = (double) iFilterWindow / 1000.0; 
    7882    // 
    7983    longTermWindow = 500.0 * dt; // seconds 
    80     long ilongTermWindow = (long) (0.5 + longTermWindow * 1000.0); 
     84    ilongTermWindow = (long) (0.5 + longTermWindow * 1000.0); 
    8185    if (ilongTermWindow > 1) 
    8286        longTermWindow = (double) ilongTermWindow / 1000.0; 
     
    8488    //tUpEvent = 10.0 * dt;   // time window to take integral of charFunct version 
    8589    tUpEvent = 20.0 * dt; // AJL20090522 
    86     long itUpEvent = (long) (0.5 + tUpEvent * 1000.0); 
     90    itUpEvent = (long) (0.5 + tUpEvent * 1000.0); 
    8791    if (itUpEvent > 1) 
    8892        tUpEvent = (double) itUpEvent / 1000.0; 
    8993    // 
    9094 
    91  
    9295    printf("picker_func_test_memory: dt %f -> filp_N filtw %f ltw %f thres1 %f thres2 %f tupevt %f res PICKS\n", 
    9396            dt, filterWindow, longTermWindow, threshold1, threshold2, tUpEvent); 
    9497 
    95  
    96  
    9798    // do picker function test 
    9899    // definitive pick data 
    99     PickData** pick_list_definative = NULL; 
    100     int num_picks_definative = 0; 
     100    pick_list_definitive = NULL; 
     101    num_picks_definitive = 0; 
    101102    // persistent memory 
    102     FilterPicker5_Memory* mem = NULL; 
     103    mem = NULL; 
    103104 
    104105    // Init TP4 Memory - claudio 
     
    116117     */ 
    117118 
    118     int proc_samples = 0; 
    119     int read_samples = 0; 
     119    proc_samples = 0; 
     120    read_samples = 0; 
    120121    while ((read_samples = fread(sample, sizeof (float), length, fp)) != 0) { //loop over trace 
    121  
    122122 
    123123        // temporary data 
     
    147147            pick->indices[0] += proc_samples; // pick indices returned are relative to start of packet 
    148148            pick->indices[1] += proc_samples; 
    149             addPickToPickList(pick, &pick_list_definative, &num_picks_definative); 
     149            addPickToPickList(pick, &pick_list_definitive, &num_picks_definitive); 
    150150        } 
    151151        // clean up temporary data 
     
    157157    } //end loop over trace 
    158158    fclose(fp); 
    159  
    160  
    161159 
    162160    // create NLLOC_OBS picks 
     
    167165    } 
    168166    // date 
    169     int month, day; 
    170167    MonthDay(sachdr.NZYEAR, sachdr.NZJDAY, &month, &day); 
    171     double sec = (double) sachdr.B + (double) sachdr.NZSEC + (double) sachdr.NZMSEC / 1000.0; 
     168    sec = (double) sachdr.B + (double) sachdr.NZSEC + (double) sachdr.NZMSEC / 1000.0; 
    172169    // id fields 
    173     char onset[] = "?"; 
    174     char* kstnm; 
     170    onset = "?"; 
    175171    kstnm = calloc(1, 16 * sizeof (char)); 
    176172    strncpy(kstnm, sachdr.KSTNM, 6); 
    177     char* kinst; 
    178173    kinst = calloc(1, 16 * sizeof (char)); 
    179174    strncpy(kinst, sachdr.KINST, 6); 
    180175    if (strstr(kinst, "(count") != NULL) 
    181176        strcpy(kinst, "(counts)"); 
    182     char* kcmpnm; 
    183177    kcmpnm = calloc(1, 16 * sizeof (char)); 
    184178    strncpy(kcmpnm, sachdr.KCMPNM, 6); 
    185     char phase[16]; 
    186179    // create NLL picks 
    187     char* pick_str; 
    188180    pick_str = calloc(1, 1024 * sizeof (char)); 
    189     for (n = 0; n < num_picks_definative; n++) { 
     181    for (n = 0; n < num_picks_definitive; n++) { 
    190182        sprintf(phase, "P%d_", n); 
    191183        pick_str = printNlloc(pick_str, 
    192                 *(pick_list_definative + n), sachdr.DELTA, kstnm, kinst, kcmpnm, onset, phase, 
     184                *(pick_list_definitive + n), sachdr.DELTA, kstnm, kinst, kcmpnm, onset, phase, 
    193185                sachdr.NZYEAR, month, day, sachdr.NZHOUR, sachdr.NZMIN, sec); 
    194186        // write pick to <pick_file> in NLLOC_OBS format 
    195187        fprintf(fp, "%s\n", pick_str); 
    196188    } 
    197  
    198189 
    199190    // clean up 
     
    203194    free(kinst); 
    204195    free(kstnm); 
    205     free_PickList(pick_list_definative, num_picks_definative); // PickData objects freed here 
     196    free_PickList(pick_list_definitive, num_picks_definitive); // PickData objects freed here 
    206197    free_FilterPicker5_Memory(&mem); 
    207198    free(sample); 
     
    210201 
    211202} 
    212  
    213  
    214203 
    215204/** date functions */ 
     
    232221 
    233222} 
    234  
Note: See TracChangeset for help on using the changeset viewer.