Changeset 7470


Ignore:
Timestamp:
06/14/18 23:23:01 (11 months ago)
Author:
baker
Message:

a demeaning window length of 0 disables data demeaning, declare local vars and functions static, general cleanup

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

Legend:

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

    r7469 r7470  
    3030#include <string.h> 
    3131 
    32 #ifdef _WINNT  
     32#ifdef _WINNT 
    3333#include <windows.h> 
    3434#endif 
     
    4545#ifdef _WINNT  
    4646#include <mmsystem.h>           /* PlaySound */ 
    47 #pragma comment(lib,"winmm.lib")  //for MSV C++   
     47#pragma comment(lib,"winmm.lib")  //for MSV C++ 
    4848    BOOL play(char *name) 
    4949    { 
     
    5656#endif 
    5757 
    58 #define THRESH_VERSION "0.3.3 2018-06-12" 
     58#define THRESH_VERSION "0.3.4 2018-06-12" 
    5959 
    6060typedef struct { 
     
    7171    int     isMagnitude;            /* Threshold is magnitude (specified as "+-thresh") */ 
    7272    double  conversion;             /* convert from counts to whatever threshold units are */ 
    73     time_t  lastSent;               /* time the last time a THRESH message was sent */     
     73    time_t  lastSent;               /* time the last time a THRESH message was sent */ 
    7474 
    7575    int     dataSize; 
     
    8989} EW_THRESHOLD_DEF; 
    9090 
    91 #define MAX_THRESH_DEFS 1000    /* maximum number of SNCL/threshold definitions */ 
    92  
    93 #define CSU_VERSION     "v2.0"  /* version of TYPE_TRIGLIST_SCNL        */ 
     91#define MAX_THRESH_DEFS 1000        /* maximum number of SNCL/threshold definitions */ 
     92 
     93#define CSU_VERSION     "v2.0"      /* version of TYPE_TRIGLIST_SCNL */ 
    9494#define TVMSG_HDR_LEN 100 
    9595#define TVMSG_SCNL_LEN 100 
     
    104104static long     NMB_delay = 0; 
    105105 
    106  
    107  
    108106EW_THRESHOLD_DEF threshDef[MAX_THRESH_DEFS];    /* threshold definitions */ 
    109107 
    110 int nThreshDefs = 0;                                                    /* and how many of them */ 
     108static int nThreshDefs = 0;                     /* and how many of them */ 
    111109 
    112110/* Functions in this source file 
    113111 *******************************/ 
    114 void  ewthresh_config  ( char * ); 
    115 void  ewthresh_lookup  ( void ); 
    116 void  ewthresh_status  ( unsigned char, short, char * ); 
    117 void  ewthresh_free    ( void ); 
     112static void  ewthresh_config  ( char * ); 
     113static void  ewthresh_lookup  ( void ); 
     114static void  ewthresh_status  ( unsigned char, short, char * ); 
     115static void  ewthresh_free    ( void ); 
    118116 
    119117 
     
    124122                                     /*   to queue */ 
    125123 
    126 #define MSGSTK_OFF    0              /* MessageStacker has not been started      */ 
    127 #define MSGSTK_ALIVE  1              /* MessageStacker alive and well            */ 
    128 #define MSGSTK_ERR   -1              /* MessageStacker encountered error quit    */ 
    129 volatile int MessageStackerStatus = MSGSTK_OFF; 
     124#define MSGSTK_OFF    0              /* MessageStacker has not been started   */ 
     125#define MSGSTK_ALIVE  1              /* MessageStacker alive and well         */ 
     126#define MSGSTK_ERR   -1              /* MessageStacker encountered error quit */ 
     127volatile static int MessageStackerStatus = MSGSTK_OFF; 
    130128 
    131129thr_ret MessageStacker( void * );    /* used to pass messages between main thread */ 
     
    137135/* Timers 
    138136   ******/ 
    139 time_t now;        /* current time, used for timing heartbeats */ 
    140 time_t MyLastBeat;         /* time of last local (into Earthworm) hearbeat */ 
     137static time_t now;                   /* current time, used for timing heartbeats */ 
     138static time_t MyLastBeat;            /* time of last local (into Earthworm) hearbeat */ 
    141139 
    142140extern int  errno; 
    143141 
    144 static  SHM_INFO  InRegion;     /* shared memory region to use for input  */ 
    145 static  SHM_INFO  OutRegion;    /* shared memory region to use for output */ 
     142static SHM_INFO  InRegion;           /* shared memory region to use for input  */ 
     143static SHM_INFO  OutRegion;          /* shared memory region to use for output */ 
    146144 
    147145#define   MAXLOGO   10 
    148 MSG_LOGO  GetLogo[MAXLOGO];     /* array for requesting module,type,instid */ 
    149 short     nLogo; 
    150  
    151 char *Argv0;            /* pointer to executable name */ 
    152 pid_t MyPid;        /* Our own pid, sent with heartbeat for restart purposes */ 
     146static MSG_LOGO  GetLogo[MAXLOGO];   /* array for requesting module,type,instid */ 
     147static short     nLogo; 
     148 
     149static char *Argv0;                  /* pointer to executable name */ 
     150static pid_t MyPid;                  /* Our own pid, sent with heartbeat for restart purposes */ 
    153151 
    154152/* Things to read or derive from configuration file 
     
    191189static time_t        tvHoldVotingUntil = 0;  /* ignore voting until this time */ 
    192190 
    193 void tvAddAlert( time_t t )  
    194 { 
     191static void tvAddAlert( time_t t ) { 
     192 
    195193    tvAlertTimes[tvIndex] = t; 
    196194    tvIndex = (tvIndex+1) % tvNumTrig; 
     
    204202        char * msgPtr; 
    205203        int i; 
    206          
     204 
    207205        /* write triglist message */ 
    208          
     206 
    209207        /*  Convert network onTime to a tm structure            */ 
    210208        gmtime_ew( &ttTimeOn, &tmTimeOn ); 
    211209 
    212         sprintf( tvMsg,  
     210        sprintf( tvMsg, 
    213211            "%s EVENT DETECTED     %4d%02d%02d %02d:%02d:%02d.00 UTC " 
    214212            "EVENT ID: %lu AUTHOR: %03u%03u%03u\n\n", 
    215213            CSU_VERSION, 
    216214            tmTimeOn.tm_year + 1900, tmTimeOn.tm_mon + 1, 
    217             tmTimeOn.tm_mday, tmTimeOn.tm_hour, tmTimeOn.tm_min,  
     215            tmTimeOn.tm_mday, tmTimeOn.tm_hour, tmTimeOn.tm_min, 
    218216            tmTimeOn.tm_sec, 0L, 
    219217            TypeTrigList, MyModId, 
     
    249247        tvHoldVotingUntil = t + (time_t)tvTimeSpanSeconds; 
    250248    }    
     249 
    251250} 
    252251 
    253252/* Error messages used by export 
    254  ***********************************/ 
     253 *******************************/ 
    255254#define  ERR_MISSMSG       0   /* message missed in transport ring        */ 
    256255#define  ERR_TOOBIG        1   /* retreived msg too large for buffer      */ 
    257256#define  ERR_NOTRACK       2   /* msg retreived; tracking limit exceeded  */ 
    258 static char  errText[256];     /* string for log/error messages           */ 
    259  
    260  
    261 int main( int argc, char **argv ) 
    262 { 
    263 /* Other variables: */ 
     257 
     258int main( int argc, char **argv ) { 
     259 
     260    /* Other variables: */ 
    264261    int           res; 
    265262    long          recsize;   /* size of retrieved message             */ 
    266263    MSG_LOGO      reclogo;   /* logo of retrieved message             */ 
    267     int idx; 
     264    int           idx; 
    268265 
    269266    /* Check command line arguments 
     
    304301    } 
    305302 
    306  
    307303    /* Allocate space for input/output messages for all threads 
    308304    ***********************************************************/ 
     
    315311        return( -1 ); 
    316312    } 
    317     
     313 
    318314    /* Allocate space for dealing w/ triglist messages if needed */ 
    319315    if ( tvNumTrig > 0 ) { 
     
    332328    } 
    333329 
    334  
    335330    /* Attach to Input/Output shared memory ring 
    336331    ********************************************/ 
     
    363358    } 
    364359    GetLogo[0].type = Type_Tracebuf2; 
    365    
     360 
    366361    if ( tvNumTrig > 0 ) 
    367362        if ( GetType( "TYPE_TRIGLIST_SCNL", &TypeTrigList ) != 0 ) { 
     
    385380    ewthresh_status( TypeHeartBeat, 0, "" ); 
    386381    time(&MyLastBeat); 
    387  
    388382 
    389383    /* Start the message stacking thread if it isn't already running. 
     
    432426 *           Move messages from transport to memory queue         * 
    433427 ******************************************************************/ 
    434 thr_ret MessageStacker( void *dummy ) 
    435 { 
     428thr_ret MessageStacker( void *dummy ) { 
     429 
    436430    long            recsize;   /* size of retrieved message             */ 
    437431    MSG_LOGO        reclogo;       /* logo of retrieved message             */ 
     
    456450    char            msg[100]; 
    457451    time_t          curTime; 
     452    char            errText[256];    /* string for log/error messages */ 
    458453 
    459454    int             posn; 
     
    468463 
    469464  /* Start main export service loop for current connection 
    470     ********************************************************/ 
     465   *******************************************************/ 
    471466    while( 1 ) { 
    472467        max = INT32_MIN; 
    473468        lastThresh = -1; 
    474            
     469 
    475470        /* Get a message from transport ring 
    476         ************************************/ 
     471         ***********************************/ 
    477472        res = tport_getmsg( &InRegion, GetLogo, nLogo, 
    478473                          &reclogo, &recsize, MSrawmsg, MaxMsgSize ); 
    479474 
    480475        /* Wait if no messages for us 
    481         ****************************/ 
     476         ****************************/ 
    482477        if( res == GET_NONE ) { 
    483             sleep_ew(100);  
     478            sleep_ew(100); 
    484479            continue; 
    485480        } 
    486481 
    487482        /* Check return code; report errors 
    488         ***********************************/ 
     483         **********************************/ 
    489484        if( res != GET_OK ) { 
    490485            if( res==GET_TOOBIG ) { 
     
    507502 
    508503        /* Process retrieved msg (res==GET_OK,GET_MISS,GET_NOTRACK) 
    509          ***********************************************************/ 
     504         **********************************************************/ 
    510505 
    511506        /* First, localize & make sure it is a TRACEBUF2X message 
    512         ***********************************************/ 
    513         if ( WaveMsg2XMakeLocal(tbh2x) != 0)  
     507         ********************************************************/ 
     508        if ( WaveMsg2XMakeLocal(tbh2x) != 0) 
    514509            continue; 
    515510 
     
    519514 
    520515        /* Next, see if it matches one of our SNCLs 
    521         *********************************************/ 
     516         ******************************************/ 
    522517        sncl_idx = -1; 
    523518        for ( i=0; i<nThreshDefs; i++ ) { 
     
    539534            } 
    540535        } 
    541            
     536 
    542537        if ( sncl_idx == -1 ) 
    543538            continue; 
    544          
     539 
    545540        /* Initialize if necessary 
    546          **************************/ 
     541         *************************/ 
    547542        if ( td->awSamples == -1 ) { 
    548543            td->samprate    = tbh2x->samprate; 
     
    550545            td->datatype[1] = tbh2x->datatype[1]; 
    551546            td->datatype[2] = tbh2x->datatype[2]; 
     547            td->dataSize    = td->datatype[1] - '0'; 
    552548            td->gapseconds  = GapSamples / td->samprate; 
    553549            td->inEndtime   = tbh2x->starttime; 
    554550            td->awSamples = td->samprate * td->awSecs; 
    555             td->awPosn = 0; 
    556             td->awFull = 0; 
    557             td->awSum  = 0.0; 
    558             if ( td->datatype[1] == '2' ) { 
    559                 td->dataSize = 2; 
    560                 td->avgWindow = malloc( sizeof(int16_t) * td->awSamples); 
    561                 awShort = (int16_t*)(td->avgWindow); 
    562             } else { /*if ( tbh2x->datatype[1] == '4' )*/ 
    563                 td->dataSize = 4; 
    564                 td->avgWindow = malloc( sizeof(int32_t) * td->awSamples); 
    565                 awLong = (int32_t*)(td->avgWindow); 
    566             } 
    567             if ( td->avgWindow == NULL ) { 
    568                 logit( "e", "ewthresh: failed to malloc averaging window; exiting!\n" ); 
    569                 break; 
    570             } 
     551            /* Allocate averaging window if demeaning */ 
     552            if ( td->awSamples > 0 ) { 
     553                td->awPosn = 0; 
     554                td->awFull = 0; 
     555                td->awSum  = 0.0; 
     556                if ( td->dataSize == 2 ) { 
     557                    td->avgWindow = malloc( sizeof(int16_t) * td->awSamples); 
     558                    awShort = (int16_t*)(td->avgWindow); 
     559                } else { /* if ( tbh2x->dataSize == 4 ) */ 
     560                    td->avgWindow = malloc( sizeof(int32_t) * td->awSamples); 
     561                    awLong = (int32_t*)(td->avgWindow); 
     562                } 
     563                if ( td->avgWindow == NULL ) { 
     564                    logit( "e", "ewthresh: failed to malloc averaging window; exiting!\n" ); 
     565                    break; 
     566                } 
     567            }   
    571568        }   
    572569 
    573570        /* Check for a gap 
    574         *******************************************/ 
     571         *****************/ 
    575572        if ( td->inEndtime + td->gapseconds < tbh2x->starttime ) { 
    576573            logit( "e", "ewthresh: gap detected between %lf and %lf\n", td->inEndtime, tbh2x->starttime ); 
    577574            NoMessagesBefore = (time_t)(tbh2x->starttime + NMB_delay); 
    578             td->awPosn = 0; 
    579             td->awFull = 0; 
    580             td->awSum  = 0.0; 
     575            if ( td->awSamples > 0 ) { 
     576                td->awPosn = 0; 
     577                td->awFull = 0; 
     578                td->awSum  = 0.0; 
     579            } 
    581580            td->inEndtime = tbh2x->starttime; 
    582             if ( ( tbh2x->datatype[1]=='2' && td->dataSize!=2 ) || 
    583                  ( tbh2x->datatype[1]=='4' && td->dataSize!=4 ) || 
     581            if ( ( td->dataSize != ( tbh2x->datatype[1] - '0' ) ) || 
    584582                 ( td->samprate != tbh2x->samprate            ) ) { 
    585583                /* Window size may have changed */ 
     
    588586                td->datatype[1] = tbh2x->datatype[1]; 
    589587                td->datatype[2] = tbh2x->datatype[2]; 
     588                td->dataSize    = td->datatype[1] - '0'; 
    590589                td->gapseconds  = GapSamples / td->samprate; 
    591590                td->awSamples   = td->samprate * td->awSecs; 
    592                 if ( td->datatype[1] == '2' ) { 
    593                     td->dataSize = 2; 
    594                     td->avgWindow = realloc(  td->avgWindow, sizeof(int16_t) * td->awSamples); 
    595                     awShort = (int16_t*)(td->avgWindow); 
    596                 } else { /*if ( tbh2x->datatype[1] == '4' )*/ 
    597                     td->dataSize = 4; 
    598                     td->avgWindow = realloc(  td->avgWindow, sizeof(int32_t) * td->awSamples); 
    599                     awLong = (int32_t*)(td->avgWindow); 
    600                 } 
    601                 if ( td->avgWindow == NULL ) { 
    602                     logit( "e", "ewthresh: failed to realloc averaging window after gap; exiting!\n" ); 
    603                     break; 
     591                /* Reallocate averaging window if demeaning */ 
     592                if ( td->awSamples > 0 ) { 
     593                    if ( td->dataSize == 2 ) { 
     594                        td->avgWindow = realloc(  td->avgWindow, sizeof(int16_t) * td->awSamples); 
     595                        awShort = (int16_t*)(td->avgWindow); 
     596                    } else { /*if ( tbh2x->dataSize == 4 )*/ 
     597                        td->avgWindow = realloc(  td->avgWindow, sizeof(int32_t) * td->awSamples); 
     598                        awLong = (int32_t*)(td->avgWindow); 
     599                    } 
     600                    if ( td->avgWindow == NULL ) { 
     601                        logit( "e", "ewthresh: failed to realloc averaging window after gap; exiting!\n" ); 
     602                        break; 
     603                    } 
    604604                } 
    605605            } 
     
    609609        isMagnitude = td->isMagnitude; 
    610610 
    611         /* Compute and remove mean value from data 
    612         *******************************************/ 
    613  
    614         posn = td->awPosn; 
    615         for ( i = 0; i < tbh2x->nsamp; i++ ) { 
    616  
    617             if ( td->awFull ) 
    618                 /* Window is full, so remove oldest entry from sum */ 
    619                 td->awSum -= (dataSize==2 ? awShort[posn] : awLong[posn]); 
    620  
    621             /* Add newest entry to sum & window; get new bias */ 
    622             if ( dataSize==2 ) 
    623                 td->awSum += ( awShort[posn++] = waveShort[i] ); 
    624             else 
    625                 td->awSum += ( awLong[posn++]  = waveLong[i]  ); 
    626             bias = round( td->awSum / td->awSamples ); 
    627  
    628             if ( td->awFull ) {                         
    629  
    630                 /* Remove bias and check for a new max */ 
     611        /* Optionally compute and remove mean value from data and find the max 
     612        **********************************************************************/ 
     613 
     614        /* If demeaning (window length > 0) */ 
     615        if ( td->awSamples > 0 ) { 
     616 
     617            posn = td->awPosn; 
     618            for ( i = 0; i < tbh2x->nsamp; i++ ) { 
     619 
     620                if ( td->awFull ) 
     621                    /* Window is full, so remove oldest entry from sum */ 
     622                    td->awSum -= (dataSize==2 ? awShort[posn] : awLong[posn]); 
     623 
     624                /* Add newest entry to sum & window; get new bias */ 
    631625                if ( dataSize==2 ) 
    632                     datum = awShort[posn-1] - bias; 
     626                    td->awSum += ( awShort[posn++] = waveShort[i] ); 
    633627                else 
    634                     datum = awLong[posn-1]  - bias; 
     628                    td->awSum += ( awLong[posn++]  = waveLong[i]  ); 
     629                bias = round( td->awSum / td->awSamples ); 
     630 
     631                if ( td->awFull ) { 
     632 
     633                    /* Remove bias and check for a new max */ 
     634                    if ( dataSize==2 ) 
     635                        datum = awShort[posn-1] - bias; 
     636                    else 
     637                        datum = awLong[posn-1]  - bias; 
     638                    if ( isMagnitude && ( datum < 0 ) ) 
     639                        datum = -datum; 
     640                    if ( datum > max ) { 
     641                        max = datum; 
     642                        theTimeDouble = 
     643                            tbh2x->starttime + i * ( 1.0 / td->samprate ); 
     644                    } 
     645                    if ( posn == td->awSamples ) 
     646                        posn = 0; 
     647 
     648                } else  
     649                if ( posn == td->awSamples ) { 
     650 
     651                    td->awFull = 1; 
     652                    posn = 0; 
     653 
     654                    /* We filled window for first time, the data are in the cache */ 
     655                    for ( j = 0; j < td->awSamples; j++ ) { 
     656 
     657                        /* Remove bias and check for a new max */ 
     658                        if ( dataSize==2 ) 
     659                            datum = awShort[j] - bias; 
     660                        else 
     661                            datum = awLong[j]  - bias; 
     662                        if ( isMagnitude && ( datum < 0 ) ) 
     663                            datum = -datum; 
     664                        if ( datum > max ) { 
     665                            max = datum; 
     666                            theTimeDouble = 
     667                                tbh2x->starttime + 
     668                                ( j + i - td->awSamples ) * ( 1.0 / td->samprate ); 
     669                        } 
     670                    } 
     671                } 
     672 
     673            } 
     674            td->awPosn = posn; 
     675 
     676            td->inEndtime = tbh2x->starttime + ( tbh2x->nsamp / td->samprate ); 
     677 
     678            if ( !td->awFull ) 
     679                /* Windows isn't full yet, so no valid bias to work from */ 
     680                continue; 
     681  
     682        /* Not demeaning (window length == 0) */ 
     683        } else { 
     684 
     685            for ( i = 0; i < tbh2x->nsamp; i++ ) { 
     686                if ( dataSize==2 ) 
     687                    datum = waveShort[i]; 
     688                else 
     689                    datum = waveLong[i]; 
    635690                if ( isMagnitude && ( datum < 0 ) ) 
    636691                    datum = -datum; 
     
    640695                        tbh2x->starttime + i * ( 1.0 / td->samprate ); 
    641696                } 
    642                 if ( posn == td->awSamples ) 
    643                     posn = 0; 
    644  
    645             } else  
    646             if ( posn == td->awSamples ) { 
    647  
    648                 td->awFull = 1; 
    649                 posn = 0; 
    650  
    651                 /* We filled window for first time, the data are in the cache */ 
    652                 for ( j = 0; j < td->awSamples; j++ ) { 
    653  
    654                     /* Remove bias and check for a new max */ 
    655                     if ( dataSize==2 ) 
    656                         datum = awShort[j] - bias; 
    657                     else 
    658                         datum = awLong[j]  - bias; 
    659                     if ( isMagnitude && ( datum < 0 ) ) 
    660                         datum = -datum; 
    661                     if ( datum > max ) { 
    662                         max = datum; 
    663                         theTimeDouble = 
    664                             tbh2x->starttime + 
    665                             ( j + i - td->awSamples ) * ( 1.0 / td->samprate ); 
    666                     } 
    667                 } 
    668             } 
    669  
    670         } 
    671         td->awPosn = posn; 
     697            } 
    672698 
    673699            td->inEndtime = tbh2x->starttime + ( tbh2x->nsamp / td->samprate ); 
    674          
    675         if ( !td->awFull ) 
    676             /* Windows isn't full yet, so no valid bias to work from */ 
    677             continue; 
    678   
     700 
     701        } 
     702 
    679703        /* If converted max exceeds threshold, spit out a message 
    680         *********************************************************/ 
     704         ********************************************************/ 
    681705 
    682706        if ( threshDef[sncl_idx].conversion != 1.0 ) { 
     
    684708            convFactor = threshDef[sncl_idx].conversion; 
    685709        } 
    686          
     710 
    687711        /* This block was moved down by ER (Q-con) 31.07.2015 to show the correct (converted) amplitudes */ 
    688712        if ( DebugLevel > 1 ) { 
     
    695719                             threshDef[sncl_idx].threshold, max*convFactor, max, 
    696720                             asctime( &theTimeStruct ) ); 
    697         }  
     721        } 
    698722                  Amax[sncl_idx] = max*convFactor; 
    699723                  /*fprintf(stderr,"amax:    %lu\n",Amax[sncl_idx]);*/ 
     
    719743                } 
    720744                threshDef[sncl_idx].lastSent = curTime; 
    721                          
     745 
    722746                if (DebugLevel > 0) { 
    723747                    logit("t", "ThreshAlert Message: %s\n", msg); 
     
    751775                            if ( Amax[myidx]<Amin_coinci ) 
    752776                                Amin_coinci = Amax[myidx]; 
    753                         }    
     777                        } 
    754778                    } 
    755779                    fprintf(stderr,"\n \n"); 
     
    772796    *****************/ 
    773797    MessageStackerStatus = MSGSTK_ERR; /* file a complaint to the main thread */ 
    774     KillSelfThread(); /* main thread will restart us */ 
     798    KillSelfThread();                  /* main thread will restart us */ 
    775799    return THR_NULL_RET; 
    776800} 
    777801 
    778802/***************************************************************************** 
    779  *  ewthresh_config() processes command file(s) using kom.c functions;         * 
    780  *                    exits if any errors are encountered.               * 
     803 *  ewthresh_config() processes command file(s) using kom.c functions;       * 
     804 *                    exits if any errors are encountered.                   * 
    781805 *****************************************************************************/ 
    782 void ewthresh_config( char *configfile ) 
    783 { 
     806static void ewthresh_config( char *configfile ) { 
     807 
    784808    int      ncommand;     /* # of required commands you expect to process   */ 
    785809    char     init[10];     /* init flags, one byte for each required command */ 
     
    793817    char     *nstr; 
    794818    int      old_err, opt_int; 
    795     
     819 
    796820    /* Set to zero one init flag for each required command 
    797821     *****************************************************/ 
    798822    ncommand = 7; 
    799     for( i=0; i<ncommand; i++ )  
     823    for( i=0; i<ncommand; i++ ) 
    800824        init[i] = 0; 
    801825    nLogo = 0; 
     
    812836    /* Process all command files 
    813837     ***************************/ 
    814     while ( nfiles > 0 ) {   /* While there are command files open */ 
     838    while ( nfiles > 0 ) {     /* While there are command files open */ 
    815839        while( k_rd() )  {     /* Read next line from active file  */ 
    816840            com = k_str();     /* Get the first token from line */ 
     
    866890            } 
    867891 
    868  
    869892         /* Maximum size (bytes) for incoming/outgoing messages 
    870893          *****************************************************/ 
     
    875898 
    876899         /* Add a SCNL to monitor & its threshold 
    877           ********************************************************/ 
     900          ***************************************/ 
    878901  /*6*/     else if ( k_its("Threshold") || k_its("ConvertedThreshold") ) { 
    879902                char *s; 
     
    902925                if ( old_err == 0 ) {                
    903926                    opt_int = k_int(); 
    904                     if ( k_err() == 0 )   
     927                    if ( k_err() == 0 ) { 
     928                        if ( opt_int < 0 ){ 
     929                            logit( "e", "%s: Negative seconds in (Converted)Threshold; exiting!\n", 
     930                            Argv0 ); 
     931                            exit(-1); 
     932                        } 
    905933                        threshDef[nThreshDefs].awSecs = opt_int; 
    906                     else 
     934                    } else 
    907935                        threshDef[nThreshDefs].awSecs = 10; 
    908936                } 
     
    932960 
    933961            /* Conditions to fire off a triglist message 
    934             ********************************************************/ 
     962            ********************************************/ 
    935963  /*opt*/   else if( k_its("ThreshVotes") ) { 
    936964                if ( tvNumTrig > 0) { 
     
    10401068        logit("t", "Config file %s parsed, %d threshold checks will be performed\n", configfile, nThreshDefs); 
    10411069    } 
    1042     return; 
     1070 
    10431071} 
    10441072 
    10451073/**************************************************************************** 
    1046  *  ewthresh_lookup( )   Look up important info from earthworm.h tables       * 
     1074 *  ewthresh_lookup( )   Look up important info from earthworm.h tables     * 
    10471075 ****************************************************************************/ 
    1048 void ewthresh_lookup( void ) 
    1049 { 
    1050 /* Look up keys to shared memory regions 
    1051    *************************************/ 
     1076static void ewthresh_lookup( void ) { 
     1077 
     1078    /* Look up keys to shared memory regions 
     1079     ***************************************/ 
    10521080    if ( ( InRingKey = GetKey(InRing) ) == -1 ) { 
    10531081        fprintf( stderr, 
     
    10641092 
    10651093    /* Look up installations of interest 
    1066      *********************************/ 
     1094     ***********************************/ 
    10671095    if ( GetLocalInst( &InstId ) != 0 ) { 
    10681096        fprintf( stderr, 
     
    10731101 
    10741102    /* Look up modules of interest 
    1075      ***************************/ 
     1103     *****************************/ 
    10761104    if ( GetModId( MyModName, &MyModId ) != 0 ) { 
    10771105        fprintf( stderr, 
     
    10821110 
    10831111    /* Look up message types of interest 
    1084      *********************************/ 
     1112     ***********************************/ 
    10851113    if ( GetType( "TYPE_HEARTBEAT", &TypeHeartBeat ) != 0 ) { 
    10861114        fprintf( stderr, 
     
    10931121        exit( -1 ); 
    10941122    } 
    1095      return; 
     1123 
    10961124} 
    10971125 
    10981126/*************************************************************************** 
    1099  * ewthresh_status() builds a heartbeat or error message & puts it into      * 
     1127 * ewthresh_status() builds a heartbeat or error message & puts it into    * 
    11001128 *                 shared memory.  Writes errors to log file & screen.     * 
    11011129 ***************************************************************************/ 
    1102 void ewthresh_status( unsigned char type, short ierr, char *note ) 
    1103 { 
     1130static void ewthresh_status( unsigned char type, short ierr, char *note ) { 
     1131 
    11041132    MSG_LOGO    logo; 
    11051133    char        msg[256]; 
     
    11081136 
    11091137    /* Build the message 
    1110     *******************/ 
     1138     *******************/ 
    11111139    logo.instid = InstId; 
    11121140    logo.mod    = MyModId; 
     
    11371165    } 
    11381166 
    1139    return; 
    11401167} 
    11411168 
    11421169/*************************************************************************** 
    1143  * ewthresh_free()  free all previously allocated memory                     * 
     1170 * ewthresh_free()  free all previously allocated memory                   * 
    11441171 ***************************************************************************/ 
    1145 void ewthresh_free( void ) 
    1146 { 
     1172static void ewthresh_free( void ) { 
     1173 
    11471174    free (MSrawmsg);             /* MessageStacker's "raw" retrieved message */ 
    1148     return; 
     1175 
    11491176} 
    11501177 
  • trunk/src/seismic_processing/ewthresh/ewthresh.d

    r7469 r7470  
    1616 # If threshold value is signed +-, then the absolute value of the data is compared 
    1717 # to the absolute value of the threshold value (see example +-threshold value) 
    18  # Final optional argument is size of averaging window in seconds; if not present,  
    19  # assumed to be 10 
     18 # Final optional argument is length of data demeaning window, in seconds 
     19 # If not present, the demeaning window length is set to 10 
     20 # A demeaning window length of 0 disables data demeaning 
    2021 # 
    2122 Threshold 0202 BHZ QT TT +-749.0      
     
    2526 # and conversion factor multiplier from counts to units of thresh 
    2627 # this can be used where input tracebuf2's are not of the tracebuf2x flavor 
    27  # Final optional argument is size of averaging window in seconds; if not present,  
    28  # assumed to be 10 
     28 # Final optional argument is length of data demeaning window, in seconds 
     29 # If not present, the demeaning window length is set to 10 
     30 # A demeaning window length of 0 disables data demeaning (see example) 
    2931 # 
    30  #ConvertedThreshold STA HNZ NN LL 749.0 0.938 
     32 #ConvertedThreshold STA HNZ NN LL 749.0 0.938 0 
    3133 
    3234 DebugLevel 0   # set to 1 to see thresh messages on stderr,  
Note: See TracChangeset for help on using the changeset viewer.