source: trunk/src/seismic_processing/eqfilterII/eqfilterII.c @ 7775

Revision 7775, 73.3 KB checked in by alexander, 18 months ago (diff)

Changed StartThread?(), StartThreadWithArg?(), WaitThread?() and KillThread?() to use thread ids specified by ew_thread_t

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*********************************************************************
2     eqfilterII                        Mitch Withers, August 2004.
3 
4     cloned from eqfilter.
5
6     no longer hardwired to hypo.  Accept:
7   TYPE_HYP2000ARC  (as output by eqproc)
8   TYPE_LOC_GLOBAL  (as output by glproc)
9   TYPE_RAYLOC      (as output by rayloc_ew)
10
11     For now, we only process the location struct which includes
12     only lat, lon, dep, gap, dmin, rms, pick_count
13
14*********************************************************************/
15
16#ifdef _OS2
17#define INCL_DOSMEMMGR
18#define INCL_DOSSEMAPHORES
19#include <os2.h>
20#endif
21
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25#include <time.h>
26#include <earthworm.h>
27#include <kom.h>
28#include <swap.h>
29#include <transport.h>
30#include <trace_buf.h>
31#include <mem_circ_queue.h>
32#include <sys/types.h>
33#include <global_loc_rw.h>
34#include <read_arc.h>
35#include <rayloc_message_rw.h>
36
37#include "eqfilterII.h"
38
39static  SHM_INFO  InRegion;      /* shared memory region to use for i/o    */
40static  SHM_INFO  OutRegion;     /* shared memory region to use for i/o    */
41
42#define BUFLEN MAX_BYTES_PER_EQ
43
44#define   NUM_COMMANDS  6       /* how many required commands in the config file */
45#define   MAX_STR 255
46
47#define   MAXLOGO   5
48MSG_LOGO  GetLogo[MAXLOGO];       /* array for requesting module,type,instid */
49short     nLogo;
50 
51
52/* The message queue
53 *******************/
54#define QUEUE_SIZE              1000        /* How many msgs can we queue */
55QUEUE   MsgQueue;                               /* from queue.h */
56
57/* Thread stuff */
58#define THREAD_STACK 8192
59static ew_thread_t tidProcessor;    /* Processor thread id */
60static ew_thread_t tidStacker;      /* Thread moving messages from InRing */
61                                 /* to MsgQueue */
62int MessageStackerStatus = 0;      /* 0=> Stacker thread ok. <0 => dead */
63int ProcessorStatus = 0;           /* 0=> Processor thread ok. <0 => dead */
64
65
66
67/* Things to read or derive from configuration file
68 **************************************************/
69static char    InRingName[MAX_RING_STR];      /* name of transport ring for i/o    */
70static char    OutRingName[MAX_RING_STR];     /* name of transport ring for i/o    */
71static char    MyModName[MAX_MOD_STR];       /* this module's given name          */
72static char    MyProgName[256];     /* this module's program name        */
73static int     LogSwitch;           /* 0 if no logfile should be written */
74static long    HeartBeatInterval;   /* seconds between heartbeats        */
75static int     Debug = 0;                       /* 1- print debug, 0- no debug       */
76static int     AllowUndefInst = 0;              /* 1- write out msgs from unknown installations */
77
78/* Things to look up in the earthworm.h tables with getutil.c functions
79 **********************************************************************/
80static long          InKey;         /* key of transport ring for i/o     */
81static long          OutKey;        /* key of transport ring for i/o     */
82static unsigned char InstId;        /* local installation id             */
83static unsigned char MyModId;       /* Module Id for this program        */
84static unsigned char TypeHeartBeat; 
85static unsigned char TypeError;
86static unsigned char InstWild;
87static unsigned char ModWild;
88
89static unsigned char TypeLocGlobal, TypeHyp2000Arc, TypeRayloc;
90
91/* Error messages used by eqfilterII
92 *********************************/
93#define  ERR_MISSMSG       0   /* message missed in transport ring       */
94#define  ERR_TOOBIG        1   /* retreived msg too large for buffer     */
95#define  ERR_NOTRACK       2   /* msg retreived; tracking limit exceeded */
96#define  ERR_QUEUE         4   /* trouble with the MsgQueue operation */
97
98static char  errText[256];    /* string for log/error messages          */
99
100pid_t MyPid;    /** Hold our process ID to be sent with heartbeats **/
101
102/* Functions in this source file
103 *******************************/
104static  int     eqfilterII_config (char *);
105static  int     eqfilterII_lookup (void);
106static  void    eqfilterII_status (unsigned char, short, char *);
107thr_ret                 MessageStacker (void *);
108thr_ret                 Processor (void *);
109int                     area (int *, int, float *, float *, float *, float *);
110int                     cntsct (int, float *, float *, float *, float *);
111int                     isect (float, float, float, float, float *, float *);
112void IsLimit1LTArgLTLimit2(int *, int, PARTEST2 *, unsigned char, float, int *);
113void IsLimitLTArg(int *, int, PARTEST1 *, unsigned char, float, int *);
114void IsLimitGTArg(int *, int, PARTEST1 *, unsigned char, float, int *);
115int eqfiltmsg(char *, EQSUM *, unsigned char);
116int hyp2eqfilt(char *, EQSUM *);
117int glloc2eqfilt(char *, EQSUM *);
118int rayloc2eqfilt(char *, EQSUM *);
119
120main (int argc, char **argv)
121{
122  time_t                timeNow;       /* current time                  */ 
123  time_t                timeLastBeat;  /* time last heartbeat was sent  */
124  long                  recsize;       /* size of retrieved message     */
125  MSG_LOGO              reclogo;       /* logo of retrieved message     */
126  char                  *flushmsg;
127  int                   i, j, k;
128
129  /* Check command line arguments
130   ******************************/
131  if (argc != 2)
132  {
133    fprintf (stderr, "Usage: eqfilterII <configfile>\n");
134    return EW_FAILURE;
135  }
136
137  /* To be used in logging functions
138   *********************************/
139  if (get_prog_name (argv[0], MyProgName) != EW_SUCCESS)
140  {
141    fprintf (stderr, "eqfilterII: Call to get_prog_name failed.\n");
142    return EW_FAILURE;
143  }
144
145  /* Initialize name of log-file & open it
146   ***************************************/
147  logit_init (argv[1], 0, 256, 1);
148
149  /* Read the configuration file(s)
150   ********************************/
151  if (eqfilterII_config(argv[1]) != EW_SUCCESS)
152  {
153    logit( "e", "eqfilterII: Call to eqfilterII_config failed \n");
154    return EW_FAILURE;
155  }
156  logit ("" , "%s(%s): Read command file <%s>\n", 
157         MyProgName, MyModName, argv[1]);
158
159  /* Look up important info from earthworm.h tables
160   ************************************************/
161  if (eqfilterII_lookup() != EW_SUCCESS)
162  {
163    logit( "e", "%s(%s): Call to eqfilterII_lookup failed \n",
164             MyProgName, MyModName);
165    return EW_FAILURE;
166  }
167  /* run through the logos and make sure only valid message types
168     were configured.
169   **************************************************************/
170  for(i=0; i<nLogo; i++){
171    if(GetLogo[i].type != TypeHyp2000Arc && 
172           GetLogo[i].type != TypeLocGlobal && 
173           GetLogo[i].type != TypeRayloc){
174      logit( "e", "%s(%s): Unsupported message type (%d)\n",
175               MyProgName, MyModName, GetLogo[i].type);
176      return EW_FAILURE;
177    }
178  }
179
180  /* Reinitialize logit to desired logging level
181   *********************************************/
182  logit_init (argv[1], 0, 256, LogSwitch);
183
184  /* Get our process ID
185   **********************/
186  if ((MyPid = getpid ()) == -1)
187  {
188    logit ("e", "%s(%s): Call to getpid failed. Exiting.\n",
189           MyProgName, MyModName);
190    return (EW_FAILURE);
191  }
192
193  /* Bail if InRing == OutRing
194   ***************************/
195  if(strcmp(InRingName,OutRingName)==0)
196  {
197    logit("e","FATAL ERROR: eqfilterII InRing=%s == OutRing = %s. Exiting\n",
198          InRingName,OutRingName);
199    return(EW_FAILURE);
200  }
201
202  /* Attach to Input shared memory ring
203   *******************************************/
204  tport_attach (&InRegion, InKey);
205  logit ("", "%s(%s): Attached to public memory region %s: %d\n", 
206         MyProgName, MyModName, InRingName, InKey);
207
208  /* Attach to Output shared memory ring
209   *******************************************/
210  tport_attach (&OutRegion, OutKey);
211  logit ("", "%s(%s): Attached to public memory region %s: %d\n", 
212         MyProgName, MyModName, OutRingName, OutKey);
213
214  /* Force a heartbeat to be issued in first pass thru main loop
215   *************************************************************/
216  timeLastBeat = time (&timeNow) - HeartBeatInterval - 1;
217
218  /* Flush the incoming transport ring
219   ***********************************/
220  if ((flushmsg = (char *) malloc (BUFLEN)) ==  NULL)
221  {
222    logit ("e", "eqfilterII: can't allocate flushmsg; exiting.\n");
223    return EW_FAILURE;
224  }
225
226  while (tport_getmsg (&InRegion, GetLogo, nLogo, &reclogo,
227         &recsize, flushmsg, (BUFLEN - 1)) != GET_NONE);
228
229  /* Show off our regions, if Debug is requested
230   **********************************************/
231  if (Debug == 1)
232  {
233    logit ("", "eqfilterII: Program starting - NumInsts = %d:\n", numInst);
234    for (i = 0; i < numInst; i++)
235    {
236      logit ("", "Inst %d - %d Inclusion regions \n", AuthReg[i].instid,
237             AuthReg[i].numIncReg);
238      for (j = 0; j < AuthReg[i].numIncReg; j++)
239      {
240        logit ("", "Reg %d (%d): ", j, AuthReg[i].IncRegion[j].num_sides);
241        for (k = 0; k < (AuthReg[i].IncRegion[j].num_sides + 1); k++)
242        {
243          logit ("", "[%0.2f, %0.2f] ", AuthReg[i].IncRegion[j].x[k],
244                 AuthReg[i].IncRegion[j].y[k]);
245        }
246        logit ("", "\n");
247      }
248
249      logit ("", "Inst %d - %d Exclusion regions \n", AuthReg[i].instid,
250             AuthReg[i].numExcReg);
251      for (j = 0; j < AuthReg[i].numExcReg; j++)
252      {
253        logit ("", "Reg %d (%d): ", j, AuthReg[i].ExcRegion[j].num_sides);
254        for (k = 0; k < (AuthReg[i].ExcRegion[j].num_sides + 1); k++)
255        {
256          logit ("", "[%0.2f, %0.2f] ", AuthReg[i].ExcRegion[j].x[k],
257                 AuthReg[i].ExcRegion[j].y[k]);
258        }
259        logit ("", "\n");
260      }
261    }
262    if(NDepthTest>0)
263    {
264      for(i=0; i<NDepthTest; i++)
265      {
266        logit("","DepthTest: %d %f %f\n",DepthTest[i].instid,
267              DepthTest[i].var1,DepthTest[i].var2);
268      }
269    }
270 
271    if(NnphTest>0)
272    {
273      for(i=0; i<NnphTest; i++)
274      {
275        logit("","nphTest: %d %f\n",nphTest[i].instid,nphTest[i].var);
276      }
277    }
278
279    if(NnphtotTest>0)
280    {
281      for(i=0; i<NnphtotTest; i++)
282      {
283        logit("","nphtotalTest: %d %f\n",nphtotTest[i].instid,nphtotTest[i].var)
284;
285      }
286    }
287
288    if(NnstaTest>0)
289    {
290      for(i=0; i<NnstaTest; i++)
291      {
292        logit("","nstaTest: %d %f\n",nstaTest[i].instid,nstaTest[i].var);
293      }
294    }
295
296    if(NGapTest>0)
297    {
298      for(i=0; i<NGapTest; i++)
299      {
300        logit("","GapTest: %d %f\n",GapTest[i].instid,GapTest[i].var);
301      }
302    }
303 
304    if(NGDminTest>0)
305    {
306      for(i=0; i<NGDminTest; i++)
307      {
308        logit("","GDminTest: %d %f\n",GDminTest[i].instid,GDminTest[i].var);
309      }
310    }
311
312    if(NDminTest>0)
313    {
314      for(i=0; i<NDminTest; i++)
315      {
316        logit("","DminTest: %d %f\n",DminTest[i].instid,DminTest[i].var);
317      }
318    }
319 
320    if(NRMSTest>0)
321    {
322      for(i=0; i<NRMSTest; i++)
323      {
324        logit("","RMSTest: %d %f\n",RMSTest[i].instid,RMSTest[i].var);
325      }
326    }
327
328    if(NMaxE0Test>0)
329    {
330      for(i=0; i<NMaxE0Test; i++)
331      {
332        logit("","MaxE0Test: %d %f\n",MaxE0Test[i].instid,MaxE0Test[i].var);
333      }
334    }
335
336    if(NMaxERHTest>0)
337    {
338      for(i=0; i<NMaxERHTest; i++)
339      {
340        logit("","MaxERHTTest: %d %f\n",MaxERHTest[i].instid,MaxERHTest[i].var);
341      }
342    }
343
344    if(NMaxERZTest>0)
345    {
346      for(i=0; i<NMaxERZTest; i++)
347      {
348        logit("","MaxERZTest: %d %f\n",MaxERZTest[i].instid,MaxERZTest[i].var);
349      }
350    }
351
352    if(NMaxAVHTest>0)
353    {
354      for(i=0; i<NMaxAVHTest; i++)
355      {
356        logit("","MaxAVHTest: %d %f\n",MaxAVHTest[i].instid,MaxAVHTest[i].var);
357      }
358    }
359
360
361    if(NMinMagTest>0)
362    {
363      for(i=0; i<NMinMagTest; i++)
364      {
365        logit("","MinMagTest: %d %f\n",MinMagTest[i].instid,MinMagTest[i].var);
366      }
367    }
368
369    if(NNcodaTest>0)
370    {
371      for(i=0; i<NNcodaTest; i++)
372      {
373        logit("","NcodaTest: %d %f %f\n",NcodaTest[i].instid,NcodaTest[i].var1,NcodaTest[i].var2);
374      }
375    }
376 
377  }
378
379  /* Create MsgQueue mutex */
380  CreateMutex_ew();
381
382  /* Allocate the message Queue
383   ********************************/
384  initqueue (&MsgQueue, QUEUE_SIZE, BUFLEN);
385
386  /* Start message stacking thread which will read
387   * messages from the InRing and put them into the Queue
388   *******************************************************/
389  if (StartThread (MessageStacker, (unsigned) THREAD_STACK, &tidStacker) == -1)
390  {
391    logit( "e", "eqfilterII: Error starting MessageStacker thread.  Exiting.\n");
392    tport_detach (&InRegion);
393    tport_detach (&OutRegion);
394    return EW_FAILURE;
395  }
396
397  MessageStackerStatus = 0; /*assume the best*/
398
399  /* Start processing thread which will read messages from
400   * the Queue, process them and write them to the OutRing
401   *******************************************************/
402  if (StartThread (Processor, (unsigned) THREAD_STACK, &tidProcessor) == -1)
403  {
404    logit( "e", "eqfilterII: Error starting Processor thread.  Exiting.\n");
405    tport_detach (&InRegion);
406    tport_detach (&OutRegion);
407    return EW_FAILURE;
408  }
409
410  ProcessorStatus = 0; /*assume the best*/
411
412/*--------------------- setup done; start main loop -------------------------*/
413
414  /* We don't do much here - just beat our heart
415   * and check on our threads
416   **********************************************/
417  while (tport_getflag (&InRegion) != TERMINATE  &&
418         tport_getflag (&InRegion) !=  MyPid )
419  {
420
421    /* send eqfilterII' heartbeat
422    ***************************/
423    if (time (&timeNow) - timeLastBeat  >=  HeartBeatInterval) 
424    {
425      timeLastBeat = timeNow;
426      eqfilterII_status (TypeHeartBeat, 0, ""); 
427    }
428
429    /* Check on our threads */
430    if (MessageStackerStatus < 0)
431    {
432      logit ("et", "eqfilterII: MessageStacker thread died. Exiting\n");
433      return EW_FAILURE;
434    }
435
436    if (ProcessorStatus < 0)
437    {
438      logit ("et", "eqfilterII: Processor thread died. Exiting\n");
439      return EW_FAILURE;
440    }
441
442    sleep_ew (1000);
443
444  } /* wait until TERMINATE is raised  */ 
445
446  /* Termination has been requested
447   ********************************/
448  tport_detach (&InRegion);
449  tport_detach (&OutRegion);
450  logit ("t", "eqfilterII: Termination requested; exiting!\n" );
451  return EW_SUCCESS;
452
453}
454
455/******************************************************************************
456 *  eqfilterII_config() processes command file(s) using kom.c functions;        *
457 *                    exits if any errors are encountered.                    *
458 ******************************************************************************/
459static int eqfilterII_config (char *configfile)
460{
461  char  init[NUM_COMMANDS];   /* init flags, one byte for each required command */
462  int   nmiss;                /* number of required commands that were missed   */
463  char  *com;
464  char  *str;
465  int   nfiles;
466  int   success;
467  int   i, j, gotit, num_sides, tmpint;
468  unsigned char instid;
469
470  /* Set to zero one init flag for each required command
471  *****************************************************/   
472  for (i = 0; i < NUM_COMMANDS; i++)
473    init[i] = 0;
474
475  nLogo = 0;
476  numInst = 0;
477
478  NDepthTest=0;
479  NnphTest=0;
480  NnphtotTest=0;
481  NnstaTest=0;
482  NGapTest=0;
483  NGDminTest=0;
484  NDminTest=0;
485  NRMSTest=0;
486  NMaxE0Test=0;
487  NMaxERHTest=0;
488  NMaxERZTest=0;
489  NMaxAVHTest=0;
490  NMinMagTest=0;
491  NNcodaTest=0;
492
493
494  /* Open the main configuration file
495   **********************************/
496  nfiles = k_open (configfile); 
497  if (nfiles == 0) 
498  {
499    logit("e", "eqfilterII: Error opening command file <%s>; exiting!\n", configfile);
500    return EW_FAILURE;
501  }
502
503  /* Process all command files
504   ***************************/
505  while (nfiles > 0)   /* While there are command files open */
506  {
507    while (k_rd ())        /* Read next line from active file  */
508    { 
509      com = k_str ();         /* Get the first token from line */
510
511      /* Ignore blank lines & comments
512       *******************************/
513      if (!com)
514        continue;
515
516      if (com[0] == '#')
517        continue;
518
519      /* Open a nested configuration file
520       **********************************/
521      if (com[0] == '@') 
522      {
523        success = nfiles + 1;
524        nfiles  = k_open (&com[1]);
525        if (nfiles != success) 
526        {
527          logit("e", "eqfilterII: Error opening command file <%s>; exiting!\n",
528                   &com[1]);
529          return EW_FAILURE;
530        }
531        continue;
532      }
533
534      /* Process anything else as a command
535       ************************************/
536/*0*/ if (k_its ("MyModuleId")) 
537      {
538        if ((str = k_str ()) != NULL)
539        {
540          strcpy (MyModName, str);
541          init[0] = 1;
542        }
543      }
544/*1*/ else if (k_its ("InRing")) 
545      {
546      if ((str = k_str ()) != NULL)
547        {
548          strcpy (InRingName, str);
549          init[1] = 1;
550        }
551      }
552/*2*/ else if (k_its ("OutRing")) 
553      {
554        if ((str = k_str ()) != NULL)
555        {
556          strcpy (OutRingName, str);
557          init[2] = 1;
558        }
559      }
560/*3*/ else if (k_its ("HeartBeatInt")) 
561      {
562        HeartBeatInterval = k_long ();
563        init[3] = 1;
564      }
565/*4*/ else if (k_its ("LogFile"))
566      {
567        LogSwitch = k_int();
568        init[4] = 1;
569      }
570
571/*NR*/else if (k_its ("Debug"))
572      {
573        Debug = 1;
574      }
575
576/*NR*/else if (k_its ("AllowUndefInst"))
577      {
578        AllowUndefInst = 1;
579      }
580
581      /* Enter installation & module types to get
582       *******************************************/
583/*5*/ else if (k_its ("GetEventsFrom")) 
584      {
585        if (nLogo >= MAXLOGO) 
586        {
587          logit("e", "eqfilterII: Too many <GetMsgLogo> commands in <%s>; "
588                   "; max=%d; exiting!\n", configfile, (int) MAXLOGO);
589          return EW_FAILURE;
590        }
591        if ((str = k_str())) 
592        {
593          if (GetInst (str, &GetLogo[nLogo].instid) != 0) 
594          {
595            logit("e", "eqfilterII: Invalid installation name <%s> in "
596                     "<GetEventsFrom> cmd; exiting!\n", str);
597            return EW_FAILURE;
598          }
599        }
600        if ((str = k_str())) 
601        {
602          if (GetModId (str, &GetLogo[nLogo].mod) != 0) 
603          {
604            logit("e", "eqfilterII: Invalid module name <%s> in <GetEventsFrom> "
605                     "cmd; exiting!\n", str);
606            return EW_FAILURE;
607          }
608        }
609        /* We'll always fetch arc messages */
610        if ((str = k_str())) 
611          {
612            if (GetType (str, &GetLogo[nLogo].type) != 0) 
613            {
614              logit("e", "eqfilterII: Invalid msgtype <%s> in <GetEventsFrom> "
615                       "cmd; exiting!\n", str);
616              return EW_FAILURE;
617            }
618            nLogo++;
619            init[5] = 1;
620         }
621      }
622/*NR*/else if (k_its ("InclRegion")) 
623      {
624        if ((str = k_str())) 
625        {
626          if (GetInst (str, &instid) != 0) 
627          {
628            logit("e", "eqfilterII: Invalid installation name <%s> in <InclRegion> "
629                     "cmd; exiting!\n", str);
630            return EW_FAILURE;
631          }
632        }
633
634        /* see if already have this instid */
635        i = -1;
636        gotit = FALSE;
637        while (gotit == FALSE)
638        {
639          if ((i = i + 1) >= numInst)
640          {
641            gotit = TRUE;
642            i = -1;
643          }
644          else if (AuthReg[i].instid == instid)
645          {
646            gotit = TRUE;
647          }
648
649        }
650
651        if (i >= 0)
652        {
653          tmpint = AuthReg[i].numIncReg;
654
655          /* Read in the arrays */
656          num_sides = k_int ();
657          if ((num_sides <= 2) || (num_sides > MAX_SIDES))
658          {
659            logit("e", "eqfilterII: Invalid NumSides (%d) in <InclRegion> cmd.\n", num_sides);
660            return EW_FAILURE;
661          }
662
663          AuthReg[i].IncRegion[tmpint].num_sides = num_sides;
664
665          for (j = 0; (j < num_sides + 1); j++)
666          {
667            AuthReg[i].IncRegion[tmpint].x[j] = (float) k_val ();
668            AuthReg[i].IncRegion[tmpint].y[j] = (float) k_val ();
669          }
670
671          AuthReg[i].numIncReg = AuthReg[i].numIncReg + 1;
672
673        }
674        else
675        {
676
677          /* add this instid to the list */
678          if ((numInst + 1) > MAX_INST)
679          {
680            logit("e", "%s: too many installations; exiting!\n", MyProgName);
681            return EW_FAILURE;
682          }
683
684          AuthReg[numInst].instid = instid;
685
686          /* Read in the arrays */
687          num_sides = k_int ();
688          if ((num_sides <= 2) || (num_sides > MAX_SIDES))
689          {
690            logit("e", "eqfilterII: Invalid NumSides (%d) in <InclRegion> cmd.\n", num_sides);
691            return EW_FAILURE;
692          }
693         
694          AuthReg[numInst].IncRegion[0].num_sides = num_sides;
695
696
697          for (j = 0; (j < num_sides + 1); j++)
698          {
699            AuthReg[numInst].IncRegion[0].x[j] = (float) k_val ();
700            AuthReg[numInst].IncRegion[0].y[j] = (float) k_val ();
701          }
702         
703          AuthReg[numInst].numIncReg = 1;
704          numInst = numInst + 1;
705         
706        }
707      }
708
709/*NR*/else if (k_its ("ExclRegion")) 
710      {
711
712        if ((str = k_str())) 
713        {
714          if (GetInst (str, &instid) != 0) 
715          {
716            logit("e", "eqfilterII: Invalid installation name <%s> in <ExclRegion> cmd;"
717                    " exiting!\n", str);
718            return EW_FAILURE;
719          }
720        }
721
722        /* see if already have this instid */
723        i = -1;
724        gotit = FALSE;
725        while (gotit == FALSE)
726        {
727          if ((i = i + 1) >= numInst)
728          {
729            gotit = TRUE;
730            i = -1;
731          }
732          else if (AuthReg[i].instid == instid)
733          {
734            gotit = TRUE;
735          }
736        }
737
738        if (i >= 0)
739        {
740          tmpint = AuthReg[i].numExcReg;
741
742          /* Read in the arrays */
743       
744          num_sides = k_int ();
745          if ((num_sides <= 2) || (num_sides > MAX_SIDES))
746          {
747            logit("e", "eqfilterII: Invalid NumSides (%d) in <ExclRegion> cmd.\n", num_sides);
748            return EW_FAILURE;
749          }
750
751          AuthReg[i].ExcRegion[tmpint].num_sides = num_sides;
752
753          for (j = 0; (j < num_sides + 1); j++)
754          {
755            AuthReg[i].ExcRegion[tmpint].x[j] = (float) k_val ();
756            AuthReg[i].ExcRegion[tmpint].y[j] = (float) k_val ();
757          }
758
759          AuthReg[i].numExcReg = AuthReg[i].numExcReg + 1;
760
761        }
762        else
763        {
764          /* add this instid to the list */
765          if ((numInst + 1) > MAX_INST)
766          {
767            logit("e", "%s: too many installations; exiting!\n", MyProgName);
768            return EW_FAILURE;
769          }
770     
771          AuthReg[numInst].instid = instid;
772     
773          /* Read in the arrays */
774          num_sides = k_int ();
775          if ((num_sides <= 2) || (num_sides > MAX_SIDES))
776          {
777            logit("e", "eqfilterII: Invalid NumSides (%d) in <ExclRegion> cmd.\n", num_sides);
778            return EW_FAILURE;
779          }
780       
781          AuthReg[numInst].ExcRegion[0].num_sides = num_sides;
782       
783          for (j = 0; (j < num_sides + 1); j++)
784          {
785            AuthReg[numInst].ExcRegion[0].x[j] = (float) k_val ();
786            AuthReg[numInst].ExcRegion[0].y[j] = (float) k_val ();
787          }
788          AuthReg[numInst].numExcReg = 1;
789          numInst = numInst + 1;
790        }
791      }
792
793      /* left Lucky's authreg stuff alone above, but for added tests,
794       * we don't really care if we have duplicate entries or not for
795       * a given instid.  We just do all tests for each instid.
796       **************************************************************/
797/*NR*/else if (k_its ("DepthTest")) 
798      {
799        if ((str = k_str()))
800        {
801          if (GetInst (str, &instid) != 0)
802          {
803            logit("e", "eqfilterII: Invalid installation name <%s> in <DepthTest> cmd;"                      " exiting!\n", str);
804            return EW_FAILURE;
805          }
806        } 
807        if( (NDepthTest+1) > MAX_INST)
808        {
809          logit("e", "eqfilterII: too many installations for DepthTest; exiting!\n");
810          return EW_FAILURE;
811        }
812        DepthTest[NDepthTest].var1 = (float) k_val();
813        DepthTest[NDepthTest].var2 = (float) k_val();
814        DepthTest[NDepthTest].instid = instid;
815        NDepthTest++;
816      }
817/*NR*/else if (k_its ("nphTest"))
818      { 
819        if ((str = k_str()))
820        {
821          if (GetInst (str, &instid) != 0)
822          {
823            logit("e", "eqfilterII: Invalid installation name <%s> in <nphTest> cmd;"
824                    " exiting!\n", str);
825            return EW_FAILURE;
826          }
827        }
828        if((NnphTest+1)>MAX_INST)
829        {
830          logit("e", "eqfilterII: too many installations for nphTest; exiting!\n");
831          return EW_FAILURE;
832        }
833        nphTest[NnphTest].var = (float) k_val();
834        nphTest[NnphTest].instid = instid;
835        NnphTest++;
836      } 
837/*NR*/else if (k_its ("nphtotalTest"))
838      {
839        if ((str = k_str()))
840        {
841          if (GetInst (str, &instid) != 0)
842          {
843            logit("e", "eqfilter: Invalid installation name <%s> in <nphtotalTest> cmd;"
844                    " exiting!\n", str);
845            return EW_FAILURE;
846          }
847        }
848        if((NnphtotTest+1)>MAX_INST)
849        {
850          logit("e", "eqfilter: too many installations for nphtotalTest; exiting!\n");
851          return EW_FAILURE;
852        }
853        nphtotTest[NnphtotTest].var = (float) k_val();
854        nphtotTest[NnphtotTest].instid = instid;
855        NnphtotTest++;
856      } 
857/*NR*/else if (k_its ("nstaTest"))
858      {
859        if ((str = k_str()))
860        {
861          if (GetInst (str, &instid) != 0)
862          {
863            logit("e", "eqfilterII: Invalid installation name <%s> in <nstaTest> cmd;"
864                    " exiting!\n", str);
865            return EW_FAILURE;
866          }
867        }
868        if((NnstaTest+1)>MAX_INST)
869        {
870          logit("e", "eqfilterII: too many installations for nstaTest; exiting!\n");
871          return EW_FAILURE;
872        }
873        nstaTest[NnstaTest].var = (float) k_val();
874        nstaTest[NnstaTest].instid = instid;
875        NnstaTest++;
876      }
877/*NR*/else if (k_its ("GapTest"))
878      { 
879        if ((str = k_str()))
880        {
881          if (GetInst (str, &instid) != 0)
882          {
883            logit("e", "eqfilterII: Invalid installation name <%s> in <GapTest> cmd;"
884                    " exiting!\n", str);
885            return EW_FAILURE;
886          }
887        }
888        i=NGapTest;
889        if((NGapTest+1)>MAX_INST)
890        {
891          logit("e", "eqfilterII: too many installations for GapTest; exiting!\n");
892          return EW_FAILURE; 
893        }
894        GapTest[NGapTest].var = (float) k_val();
895        GapTest[NGapTest].instid = instid;
896        NGapTest++;
897      }
898/*NR*/else if (k_its ("GDminTest"))
899      { 
900        if ((str = k_str()))
901        {
902          if (GetInst (str, &instid) != 0)
903          {
904            logit("e", "eqfilterII: Invalid installation name <%s> in <GDminTest> cmd;"
905                    " exiting!\n", str);
906            return EW_FAILURE;
907          }
908        }
909        i=NGDminTest;
910        if((NGDminTest+1)>MAX_INST)
911        {
912          logit("e", "eqfilterII: too many installations for GDminTest; exiting!\n");
913          return EW_FAILURE; 
914        }
915        GDminTest[NGDminTest].var = (float) k_val();
916        GDminTest[NGDminTest].instid = instid;
917        NGDminTest++;
918      }
919/*NR*/else if (k_its ("DminTest"))
920      {
921        if ((str = k_str()))
922        {
923          if (GetInst (str, &instid) != 0)
924          {
925            logit("e", "eqfilter: Invalid installation name <%s> in <DminTest> cmd;"
926                    " exiting!\n", str);
927            return EW_FAILURE;
928          }
929        }
930        i=NDminTest;
931        if((NDminTest+1)>MAX_INST)
932        {
933          logit("e", "eqfilter: too many installations for DminTest; exiting!\n");
934          return EW_FAILURE;
935        }
936        DminTest[NDminTest].var = (float) k_val();
937        DminTest[NDminTest].instid = instid;
938        NDminTest++;
939      }
940/*NR*/else if (k_its ("RMSTest"))
941      { 
942        if ((str = k_str()))
943        {
944          if (GetInst (str, &instid) != 0)
945          {
946            logit("e", "eqfilterII: Invalid installation name <%s> in <RMSTest> cmd;"
947                    " exiting!\n", str);
948            return EW_FAILURE;
949          }
950        }
951        i=NRMSTest;
952        if((NRMSTest+1)>MAX_INST)
953        {
954          logit("e", "eqfilterII: too many installations for RMSTest; exiting!\n");
955          return EW_FAILURE; 
956        }
957        RMSTest[NRMSTest].var = (float) k_val();
958        RMSTest[NRMSTest].instid = instid;
959        NRMSTest++;
960      }
961/*NR*/else if (k_its ("MaxE0Test"))
962      { 
963        if ((str = k_str()))
964        {
965          if (GetInst (str, &instid) != 0)
966          {
967            logit("e", "eqfilter: Invalid installation name <%s> in <MaxE0Test> cmd;"
968                    " exiting!\n", str);
969            return EW_FAILURE;
970          }
971        }
972        if((NMaxE0Test+1)>MAX_INST)
973        {
974          logit("e", "eqfilter: too many installations for MaxE0Test; exiting!\n");
975          return EW_FAILURE;
976        }
977        MaxE0Test[NMaxE0Test].var = (float) k_val();
978        MaxE0Test[NMaxE0Test].instid = instid;
979        NMaxE0Test++;
980      }
981/*NR*/else if (k_its ("MaxERHTest"))
982      { 
983        if ((str = k_str()))
984        {
985          if (GetInst (str, &instid) != 0)
986          {
987            logit("e", "eqfilter: Invalid installation name <%s> in <MaxERHTest> cmd;"
988                    " exiting!\n", str);
989            return EW_FAILURE;
990          }
991        }
992        if((NMaxERHTest+1)>MAX_INST)
993        {
994          logit("e", "eqfilter: too many installations for MaxERHTest; exiting!\n");
995          return EW_FAILURE;
996        }
997        MaxERHTest[NMaxERHTest].var = (float) k_val();
998        MaxERHTest[NMaxERHTest].instid = instid;
999        NMaxERHTest++;
1000      }
1001/*NR*/else if (k_its ("MaxERZTest"))
1002      { 
1003        if ((str = k_str()))
1004        {
1005          if (GetInst (str, &instid) != 0)
1006          {
1007            logit("e", "eqfilter: Invalid installation name <%s> in <MaxERZTest> cmd;"
1008                    " exiting!\n", str);
1009            return EW_FAILURE;
1010          }
1011        }
1012        if((NMaxERZTest+1)>MAX_INST)
1013        {
1014          logit("e", "eqfilter: too many installations for MaxERZTest; exiting!\n");
1015          return EW_FAILURE;
1016        }
1017        MaxERZTest[NMaxERZTest].var = (float) k_val();
1018        MaxERZTest[NMaxERZTest].instid = instid;
1019        NMaxERZTest++;
1020      }
1021/*NR*/else if (k_its ("MaxAVHTest"))
1022      {
1023        if ((str = k_str()))
1024        {
1025          if (GetInst (str, &instid) != 0)
1026          {
1027            logit("e", "eqfilter: Invalid installation name <%s> in <MaxAVHTest> cmd;"
1028                    " exiting!\n", str);
1029            return EW_FAILURE;
1030          }
1031        }
1032        if((NMaxAVHTest+1)>MAX_INST)
1033        {
1034          logit("e", "eqfilter: too many installations for MaxAVHTest; exiting!\n");
1035          return EW_FAILURE;
1036        }
1037        MaxAVHTest[NMaxAVHTest].var = (float) k_val();
1038        MaxAVHTest[NMaxAVHTest].instid = instid;
1039        NMaxAVHTest++;
1040      }
1041/*NR*/else if (k_its ("MinMagTest"))
1042      { 
1043        if ((str = k_str()))
1044        {
1045          if (GetInst (str, &instid) != 0)
1046          {
1047            logit("e", "eqfilter: Invalid installation name <%s> in <MinMagTest> cmd;"
1048                    " exiting!\n", str);
1049            return EW_FAILURE;
1050          }
1051        }
1052        if((NMinMagTest+1)>MAX_INST)
1053        {
1054          logit("e", "eqfilter: too many installations for MinMagTest; exiting!\n");
1055          return EW_FAILURE;
1056        }
1057        MinMagTest[NMinMagTest].var = (float) k_val();
1058        MinMagTest[NMinMagTest].instid = instid;
1059        NMinMagTest++;
1060      }
1061/*NR*/else if (k_its ("NcodaTest"))
1062      {
1063        if ((str = k_str()))
1064        {
1065          if (GetInst (str, &instid) != 0)
1066          {
1067            logit("e", "eqfilter: Invalid installation name <%s> in <NcodaTest> cmd;"
1068                    " exiting!\n", str);
1069            return EW_FAILURE;
1070          }
1071        }
1072        if((NNcodaTest+1)>MAX_INST)
1073        {
1074          logit("e", "eqfilter: too many installations for NcodaTest; exiting!\n");
1075          return EW_FAILURE;
1076        }
1077        NcodaTest[NNcodaTest].var1 = (float) k_val();
1078        NcodaTest[NNcodaTest].var2 = (float) k_val();
1079        NcodaTest[NNcodaTest].instid = instid;
1080        NNcodaTest++;
1081      }
1082      /* Unknown command
1083       *****************/ 
1084      else 
1085      {
1086        logit("e", "eqfilterII: <%s> Unknown command in <%s>.\n", com, configfile);
1087        continue;
1088      }
1089
1090      /* See if there were any errors processing the command
1091       *****************************************************/
1092      if (k_err ()) 
1093      {
1094        logit("e", "eqfilterII: Bad <%s> command in <%s>; exiting!\n", com, configfile);
1095        return EW_FAILURE;
1096      }
1097
1098    } /** while k_rd() **/
1099
1100    nfiles = k_close ();
1101
1102  } /** while nfiles **/
1103
1104  /* After all files are closed, check init flags for missed commands
1105   ******************************************************************/
1106  nmiss = 0;
1107  for (i = 0; i < NUM_COMMANDS; i++) 
1108  {
1109    if (!init[i]) 
1110    {
1111      nmiss++;
1112    }
1113  }
1114
1115  if (nmiss) 
1116  {
1117    logit("e", "eqfilterII: ERROR, no ");
1118    if (!init[0])  logit("e", "<MyModuleId> "    );
1119    if (!init[1])  logit("e", "<InRing> "        );
1120    if (!init[2])  logit("e", "<OutRing> "       );
1121    if (!init[3])  logit("e", "<HeartBeatInt> "  );
1122    if (!init[4])  logit("e", "<LogFile> "       );
1123    if (!init[5])  logit("e", "<GetEventsFrom> " );
1124
1125    logit("e", "command(s) in <%s>; exiting!\n", configfile);
1126    return EW_FAILURE;
1127  }
1128
1129  return EW_SUCCESS;
1130}
1131
1132/******************************************************************************
1133 *  eqfilterII_lookup( )   Look up important info from earthworm.h tables       *
1134 ******************************************************************************/
1135static int eqfilterII_lookup( void )
1136{
1137
1138  /* Look up keys to shared memory regions
1139  *************************************/
1140  if ((InKey = GetKey (InRingName)) == -1) 
1141  {
1142    logit( "e", "eqfilterII:  Invalid ring name <%s>; exiting!\n", InRingName);
1143    return EW_FAILURE;
1144  }
1145
1146  if ((OutKey = GetKey (OutRingName) ) == -1) 
1147  {
1148    logit( "e", "eqfilterII:  Invalid ring name <%s>; exiting!\n", OutRingName);
1149    return EW_FAILURE;
1150  }
1151
1152  /* Look up installations of interest
1153  *********************************/
1154  if (GetLocalInst (&InstId) != 0) 
1155  {
1156    logit( "e", "eqfilterII: error getting local installation id; exiting!\n");
1157    return EW_FAILURE;
1158  }
1159
1160  if (GetInst ("INST_WILDCARD", &InstWild ) != 0) 
1161  { 
1162    logit( "e", "eqfilterII: error getting wildcard installation id; exiting!\n");
1163    return EW_FAILURE;
1164  }
1165
1166  /* Look up modules of interest
1167  ******************************/
1168  if (GetModId (MyModName, &MyModId) != 0) 
1169  {
1170    logit( "e", "eqfilterII: Invalid module name <%s>; exiting!\n", MyModName);
1171    return EW_FAILURE;
1172  }
1173
1174  if (GetModId ("MOD_WILDCARD", &ModWild) != 0) 
1175  {
1176    logit( "e", "eqfilterII: Invalid module name <MOD_WILDCARD>; exiting!\n");
1177    return EW_FAILURE;
1178  }
1179
1180  /* Look up message types of interest
1181  *********************************/
1182  if (GetType ("TYPE_HEARTBEAT", &TypeHeartBeat) != 0) 
1183  {
1184    logit( "e", "eqfilterII: Invalid message type <TYPE_HEARTBEAT>; exiting!\n");
1185    return EW_FAILURE;
1186  }
1187
1188  if (GetType ("TYPE_ERROR", &TypeError) != 0) 
1189  {
1190    logit( "e", "eqfilterII: Invalid message type <TYPE_ERROR>; exiting!\n");
1191    return EW_FAILURE;
1192  }
1193
1194  if (GetType ("TYPE_LOC_GLOBAL", &TypeLocGlobal) != 0) 
1195  {
1196    logit( "e", "eqfilterII: Invalid message type <TYPE_LOC_GLOBAL>; exiting!\n");
1197    return EW_FAILURE;
1198  }
1199  if (GetType ("TYPE_HYP2000ARC", &TypeHyp2000Arc) != 0) 
1200  {
1201    logit( "e", "eqfilterII: Invalid message type <TYPE_HYP2000ARC>; exiting!\n");
1202    return EW_FAILURE;
1203  }
1204  if (GetType ("TYPE_RAYLOC", &TypeRayloc) != 0) 
1205  {
1206    logit( "e", "eqfilterII: Invalid message type <TYPE_RAYLOC>; exiting!\n");
1207    return EW_FAILURE;
1208  }
1209
1210  return EW_SUCCESS;
1211
1212} 
1213
1214/******************************************************************************
1215 * eqfilterII_status() builds a heartbeat or error message & puts it into       *
1216 *                   shared memory.  Writes errors to log file & screen.      *
1217 ******************************************************************************/
1218static void eqfilterII_status( unsigned char type, short ierr, char *note )
1219{
1220  MSG_LOGO    logo;
1221  char        msg[256];
1222  long        size;
1223  time_t        t;
1224 
1225  /* Build the message
1226  *******************/ 
1227  logo.instid = InstId;
1228  logo.mod    = MyModId;
1229  logo.type   = type;
1230
1231  time (&t);
1232
1233  if (type == TypeHeartBeat)
1234  {
1235    sprintf (msg, "%ld %ld\n\0", (long) t, (long) MyPid);
1236  }
1237  else if (type == TypeError)
1238  {
1239    sprintf (msg, "%ld %hd %s\n\0", (long) t, ierr, note);
1240    logit ("et", "%s(%s): %s\n", MyProgName, MyModName, note);
1241  }
1242
1243  size = strlen (msg);   /* don't include the null byte in the message */     
1244
1245  /* Write the message to shared memory
1246  ************************************/
1247  if (tport_putmsg (&OutRegion, &logo, size, msg) != PUT_OK)
1248  {
1249    if (type == TypeHeartBeat) 
1250    {
1251      logit ("et","%s(%s):  Error sending heartbeat.\n", MyProgName, MyModName);
1252    }
1253    else if (type == TypeError) 
1254    {
1255      logit ("et","%s(%s):  Error sending error:%d.\n", MyProgName, MyModName, ierr);
1256    }
1257  }
1258
1259}
1260
1261
1262/********************** Message Stacking Thread *******************
1263 *           Move messages from transport to memory queue         *
1264 ******************************************************************/
1265thr_ret MessageStacker (void *dummy)
1266{
1267  char          *msg;           /* "raw" retrieved message */
1268  int           res;
1269  long          recsize;        /* size of retrieved message */
1270  MSG_LOGO      reclogo;        /* logo of retrieved message */
1271  int           ret;
1272
1273  /* Allocate space for input/output messages
1274   *******************************************/
1275  if ((msg = (char *) malloc (BUFLEN)) == (char *) NULL)
1276  {
1277    logit ("e", "eqfilterII: error allocating msg; exiting!\n");
1278    goto error;
1279  }
1280
1281
1282  /* Tell the main thread we're ok
1283   ********************************/
1284  MessageStackerStatus = 0;
1285
1286  /* Start service loop, picking up messages
1287   *****************************************/
1288  while (1)
1289  {
1290    /* Get a message from transport ring, carefully checking error codes
1291     *******************************************************************/
1292    res = tport_getmsg (&InRegion, GetLogo, nLogo, &reclogo,
1293                        &recsize, msg, BUFLEN-1);
1294
1295    if (res == GET_NONE)  /* no messages for us now */
1296    {
1297      sleep_ew(100); 
1298      continue;
1299    } 
1300
1301    if (res != GET_OK)    /* some kind of error code, speak */
1302    {
1303      if (res == GET_TOOBIG) /* msg too big for buffer */
1304      {
1305        sprintf (errText, "msg[%ld] i%d m%d t%d too long for target", recsize,
1306                           (int) reclogo.instid, (int) reclogo.mod, (int)reclogo.type);
1307        eqfilterII_status (TypeError, ERR_TOOBIG, errText);
1308        continue;
1309      }
1310      else if (res == GET_MISS)  /* got msg, but may have missed some */
1311      {
1312        sprintf (errText, "missed msg(s) i%d m%d t%d in %s", (int) reclogo.instid,
1313                           (int) reclogo.mod, (int)reclogo.type, InRingName);
1314        eqfilterII_status (TypeError, ERR_MISSMSG, errText);
1315      }
1316      else if (res == GET_NOTRACK) /* got msg, can't tell if any were missed */
1317      {
1318        sprintf (errText, "no tracking for logo i%d m%d t%d in %s", (int) reclogo.instid, 
1319                           (int) reclogo.mod, (int)reclogo.type, InRingName);
1320        eqfilterII_status (TypeError, ERR_NOTRACK, errText);
1321      }
1322    }
1323
1324 /* Queue retrieved msg (res==GET_OK,GET_MISS,GET_NOTRACK)
1325  ********************************************************/
1326    RequestMutex ();
1327    ret = enqueue (&MsgQueue, msg, recsize, reclogo); 
1328    ReleaseMutex_ew ();
1329
1330    if (ret != 0)
1331    {
1332      if (ret == -2)  /* Serious: quit */
1333      {
1334        sprintf (errText, "internal queue error. Terminating.");
1335        eqfilterII_status (TypeError, ERR_QUEUE, errText);
1336        goto error;
1337      }
1338      if (ret == -1)
1339      {
1340        sprintf (errText,"queue cannot allocate memory. Lost message.");
1341        eqfilterII_status (TypeError, ERR_QUEUE, errText);
1342        continue;
1343      }
1344      if (ret == -3) 
1345      {
1346        sprintf (errText, "Queue full. Message lost.");
1347        eqfilterII_status (TypeError, ERR_QUEUE, errText);
1348        continue;
1349      }
1350    } /* problem from enqueue */
1351
1352  } /* while (1) */
1353
1354  /* we're quitting
1355   *****************/
1356  error:
1357    MessageStackerStatus = -1; /* file a complaint to the main thread */
1358    KillSelfThread (); /* main thread will restart us */
1359 
1360}
1361
1362
1363
1364/********************** Message Processing Thread ****************
1365 *
1366 * This is where all the action is: grab a message from the
1367 * queue, determine the originating installation ID. Find
1368 * the list of IncRegion and ExcRegion polygons that define
1369 * the authoritative region for the installation. Extract
1370 * the location of the event from the message, and determine
1371 * if the event is within the authoritative region. If it is,
1372 * write the hypoinverse arc message to OutRing.
1373 *
1374 ******************************************************************/
1375thr_ret Processor (void *dummy)
1376{
1377
1378  int ret, i, j, k;
1379  int gotMsg, gotit, gotit2;
1380  long msgSize;
1381  MSG_LOGO reclogo;           /* logo of retrieved message */
1382  float lat, lon;
1383  static char record[BUFLEN]; /* dare we assume global locs are biggest? */
1384  static char record2[BUFLEN]; /* StringToLoc isolator */
1385  int  PASS;                /* number of tests that passed */
1386  unsigned char INST_WILDCARD;
1387  EQSUM locmsg;
1388  int retVal = -1;
1389
1390  GetInst("INST_WILDCARD",&INST_WILDCARD);
1391  while (1)
1392  {
1393    gotMsg = FALSE;
1394    while (gotMsg == FALSE)
1395      {
1396        strcpy(record,"\0");
1397        /* Grab the next message
1398        ************************/
1399        RequestMutex ();
1400        ret = dequeue (&MsgQueue, record, &msgSize, &reclogo);
1401
1402        /* Warning: once you call StringToLoc then your string is no
1403           no longer suitable for another call to it, whether in this
1404           routine out uploaded to the shared memory and called by
1405           another module.  So, just make a sacred copy, record2, for
1406           sending to putmsg if all tests pass.
1407         ***********************************************************/
1408        strncpy(record2,record,msgSize);
1409        ReleaseMutex_ew ();
1410
1411        if (ret < 0)  /* empty queue */
1412        {
1413          sleep_ew (500);
1414        }
1415        else  /* for a message from queue */
1416        {
1417          gotMsg = TRUE;
1418          PASS=TRUE;
1419
1420          retVal = eqfiltmsg(record, &locmsg, reclogo.type);
1421          if(retVal != 0)
1422          {
1423               logit("pt", "eqfilterII: Failed to convert Input Message into str
1424ucture\n");
1425               PASS=FALSE;
1426               goto FinishedTesting;
1427          }
1428
1429          /********************************
1430            Begin Authoritative region test
1431           ********************************/
1432
1433          i = -1;
1434          gotit = FALSE;
1435          while (gotit == FALSE)
1436          {
1437            if ((i = i + 1) >= numInst)
1438            {
1439              gotit = TRUE;
1440              i = -1;
1441            }
1442            else if (AuthReg[i].instid == reclogo.instid)
1443            {
1444              gotit = TRUE;
1445            }
1446 
1447          } /* while */
1448 
1449          if (i < 0)
1450          {
1451
1452            /* Don't know about this installation
1453            **************************************/
1454
1455            if (AllowUndefInst == 1)
1456            {
1457              /* write message out anyway because AllowUndefInst is set
1458              *********************************************************/
1459              if (Debug == 1)
1460                logit ("", "eqfilterII: Don't have any regions for inst %d; "
1461                       "Allowing passing anyway because AllowUndefInst IS set\n",
1462                       reclogo.instid);
1463
1464            }
1465            else
1466            {
1467              if (Debug == 1)
1468                logit ("", "eqfilterII: Don't have any regions for inst %d; "
1469                       "IGNORING because AllowUndefInst is NOT set\n",
1470                       reclogo.instid);
1471             
1472              PASS=FALSE;
1473              goto FinishedTesting;
1474            }
1475          } else if (locmsg.elat == (float)EQSUM_NULL || 
1476                   locmsg.elon == (float)EQSUM_NULL){
1477            logit("","eqfilterII: NULL epicenter values: lat = %f, lon = %f\n",
1478                      locmsg.elat,locmsg.elon);
1479          } else {
1480            /* Extract lat and lon of the event from the arc message
1481             *******************************************************/
1482
1483            lat = locmsg.elat;
1484            lon = locmsg.elon;
1485
1486            if (Debug == 1)
1487              logit ("", "Inst %d, coords %0.2f, %0.2f ==> ", reclogo.instid, lat, lon);
1488
1489            gotit = FALSE;
1490            for (j = 0; ((j < AuthReg[i].numIncReg) && (gotit == FALSE)); j++)
1491            {
1492              /* See if the lat,lon point is inside of this polygon
1493               ****************************************************/
1494
1495              area (&ret, AuthReg[i].IncRegion[j].num_sides, AuthReg[i].IncRegion[j].x, 
1496                  AuthReg[i].IncRegion[j].y, &lat, &lon);
1497
1498              if (ret == 1)
1499              {
1500                if (Debug == 1)
1501                  logit ("", "in InclRegion %d ==> ", j);
1502
1503                /* Point was inside one of the IncRegions, now
1504                 * see if the point falls inside one of the
1505                 * regions which are to be excluded
1506                 **********************************************/
1507
1508                gotit2 = FALSE;
1509                for (k = 0; ((k <  AuthReg[i].numExcReg) && (gotit2 == FALSE)); k++)
1510                {
1511                  area (&ret, AuthReg[i].ExcRegion[j].num_sides, AuthReg[i].ExcRegion[j].x, 
1512                        AuthReg[i].ExcRegion[j].y, &lat, &lon);
1513
1514                  if (ret == 1)
1515                  {
1516                    /* This point should be excluded, based on ExclRegion */
1517                    if (Debug == 1)
1518                      logit ("", "in ExclRegion %d ==> IGNORING.\n", k);
1519
1520                    PASS=FALSE;
1521                    gotit2 = TRUE;
1522                    goto FinishedTesting;
1523                  }
1524
1525                }
1526
1527                if (gotit2 == FALSE)
1528                {       
1529                  if (Debug == 1)
1530                    logit ("", "not in any ExclRegion ==> Okay to pass so far.\n");
1531
1532                  gotit = TRUE;
1533
1534                } /* if not found in ExclRegions */
1535
1536              } /* if found in InclRegions */
1537
1538              if (gotit == FALSE)
1539              {
1540                logit ("", "not in any InclRegion ==> IGNORING.\n");
1541                PASS=FALSE;
1542                goto FinishedTesting;
1543              }
1544 
1545            } /* if num inst > 0 */
1546          }  /* i<numInst */
1547
1548          /*******************************
1549            Begin Depth Test
1550           *******************************/
1551          if(locmsg.edepth == (float)EQSUM_NULL && NDepthTest>0){
1552            logit("","null edepth (%f), skipping test\n",locmsg.edepth);
1553          } else if(NDepthTest>0) {
1554            gotit=FALSE;
1555            IsLimit1LTArgLTLimit2(&gotit, NDepthTest, DepthTest, 
1556                                  reclogo.instid, locmsg.edepth , &PASS);
1557
1558            /* if not found in the list, are wildcards enabled
1559                  note that we really do need a second loop to
1560                  avoid clobbering defined instid's with wildcards.
1561             **************************************************/
1562            if(gotit==FALSE)
1563              IsLimit1LTArgLTLimit2(&gotit, NDepthTest, DepthTest, 
1564                                    INST_WILDCARD, locmsg.edepth , &PASS);
1565
1566            if(gotit==FALSE) 
1567              PASS=FALSE;
1568
1569            if(PASS==FALSE) {
1570              if(Debug==1) logit("t","eqfilterII: event failed DepthTest\n");
1571              goto FinishedTesting;
1572            }
1573          }
1574
1575          /***************
1576            Begin nphTest
1577           ***************/
1578          if(locmsg.npha == (int)EQSUM_NULL && NnphTest>0){
1579            logit("","null npha (%d), skipping test\n",locmsg.npha);
1580          } else if(NnphTest>0) {
1581            gotit=FALSE;
1582            IsLimitLTArg(&gotit, NnphTest, nphTest, reclogo.instid, (float)locmsg.npha, &PASS);
1583
1584            if(gotit==FALSE)
1585              IsLimitLTArg(&gotit, NnphTest, nphTest, INST_WILDCARD, (float)locmsg.npha, &PASS);
1586
1587            if(gotit==FALSE) 
1588              PASS=FALSE;
1589
1590            if(PASS==FALSE) {
1591              if(Debug==1) logit("t","eqfilterII: event failed nphTest\n");
1592              goto FinishedTesting;
1593            }
1594          }
1595
1596          /*******************
1597            Begin nphtotalTest
1598           *******************/
1599          if(NnphtotTest>0)
1600          {
1601            gotit=FALSE;
1602            IsLimitLTArg(&gotit, NnphtotTest, nphtotTest, reclogo.instid,
1603                         (float)locmsg.nphtot, &PASS);
1604
1605            if(gotit==FALSE)
1606              IsLimitLTArg(&gotit, NnphtotTest, nphtotTest, INST_WILDCARD,
1607                           (float)locmsg.nphtot, &PASS);
1608
1609            if(gotit==FALSE)
1610              PASS=FALSE;
1611
1612            if(PASS==FALSE) {
1613              if(Debug==1) logit("t","eqfilter:  event failed nphtotalTest\n");
1614              goto FinishedTesting;
1615            }
1616          }
1617
1618          /***************
1619            Begin nstaTest
1620           ***************/
1621          if(locmsg.nsta == (int)EQSUM_NULL && NnstaTest>0){
1622            logit("","null nsta (%d), skipping test\n",locmsg.nsta);
1623          } else if(NnstaTest>0) {
1624            gotit=FALSE;
1625            IsLimitLTArg(&gotit, NnstaTest, nstaTest, reclogo.instid, \
1626                         (float)locmsg.nsta, &PASS);
1627
1628            if(gotit==FALSE)
1629              IsLimitLTArg(&gotit, NnstaTest, nstaTest, INST_WILDCARD, \
1630                           (float)locmsg.nsta, &PASS);
1631
1632            if(gotit==FALSE)
1633              PASS=FALSE;
1634
1635            if(PASS==FALSE) {
1636              if(Debug==1) logit("t","eqfilterII: event failed nstaTest\n");
1637              goto FinishedTesting;
1638            }
1639          }
1640
1641
1642          /***************
1643            Begin GapTest
1644           ***************/
1645          if(locmsg.gap == (float)EQSUM_NULL && NGapTest>0){
1646            logit("","null gap (%f), skipping test\n",locmsg.gap);
1647          } else if(NGapTest>0) {
1648            gotit=FALSE;
1649            IsLimitGTArg(&gotit, NGapTest, GapTest, reclogo.instid, (float)locmsg.gap, &PASS);
1650     
1651            if(gotit==FALSE)
1652              IsLimitGTArg(&gotit, NGapTest, GapTest, INST_WILDCARD, (float)locmsg.gap, &PASS);
1653
1654            if(gotit==FALSE) 
1655              PASS=FALSE;
1656
1657            if(PASS==FALSE) {
1658              if(Debug==1) logit("t","eqfilterII: event failed GapTest\n");
1659              goto FinishedTesting;
1660            }
1661          }
1662
1663          /***************
1664            Begin GDminTest
1665           ***************/
1666          if(locmsg.gdmin == (float)EQSUM_NULL && NGDminTest>0){
1667            logit("","null gdmin (%f), skipping test\n",locmsg.gdmin);
1668          } else if(NGDminTest>0) {
1669            gotit=FALSE;
1670            IsLimitGTArg(&gotit, NGDminTest, GDminTest, reclogo.instid, (float)locmsg.gdmin, &PASS);
1671     
1672            if(gotit==FALSE)
1673              IsLimitGTArg(&gotit, NGDminTest, GDminTest, INST_WILDCARD, (float)locmsg.gdmin, &PASS);
1674
1675            if(gotit==FALSE) 
1676              PASS=FALSE;
1677
1678            if(PASS==FALSE) {
1679              if(Debug==1) logit("t","eqfilterII: event failed GDminTest\n");
1680              goto FinishedTesting;
1681            }
1682          }
1683          /***************
1684            Begin DminTest
1685           ***************/
1686          if(NDminTest>0)
1687          {
1688            gotit=FALSE;
1689            IsLimitGTArg(&gotit, NDminTest, DminTest, reclogo.instid, (float)locmsg.dmin, &PASS);
1690
1691            if(gotit==FALSE)
1692              IsLimitGTArg(&gotit, NDminTest, DminTest, INST_WILDCARD, (float)locmsg.dmin, &PASS);
1693
1694            if(gotit==FALSE)
1695              PASS=FALSE;
1696
1697            if(PASS==FALSE) {
1698              if(Debug==1) logit("t","eqfilter: event failed DminTest\n");
1699              goto FinishedTesting;
1700            }
1701          }
1702
1703          /***************
1704            Begin RMSTest
1705           ***************/
1706          if(locmsg.rms == (float)EQSUM_NULL && NRMSTest>0){
1707            logit("","null rms (%f), skipping test\n",locmsg.rms);
1708          } else if(NRMSTest>0) {
1709            gotit=FALSE;
1710            IsLimitGTArg(&gotit, NRMSTest, RMSTest, reclogo.instid, (float)locmsg.rms, &PASS);
1711     
1712            if(gotit==FALSE)
1713              IsLimitGTArg(&gotit, NRMSTest, RMSTest, INST_WILDCARD, (float)locmsg.rms, &PASS);
1714
1715            if(gotit==FALSE) 
1716              PASS=FALSE;
1717
1718            if(PASS==FALSE) {
1719              if(Debug==1) logit("t","eqfilterII: event failed RMSTest\n");
1720              goto FinishedTesting;
1721            }
1722          }
1723          /***************
1724            Begin MaxE0Test
1725           ***************/
1726          if(NMaxE0Test>0)
1727          {
1728            gotit=FALSE;
1729            IsLimitGTArg(&gotit, NMaxE0Test, MaxE0Test, reclogo.instid, (float)locmsg.e0, &PASS);
1730
1731            if(gotit==FALSE)
1732              IsLimitGTArg(&gotit, NMaxE0Test, MaxE0Test, INST_WILDCARD, (float)locmsg.e0, &PASS);
1733
1734            if(gotit==FALSE)
1735              PASS=FALSE;
1736
1737            if(PASS==FALSE) {
1738              if(Debug==1) logit("t","eqfilter: event failed MaxE0Test\n");
1739              goto FinishedTesting;
1740            }
1741          }
1742
1743          /***************
1744            Begin MaxERHTest
1745           ***************/
1746          if(NMaxERHTest>0)
1747          {
1748            gotit=FALSE;
1749            IsLimitGTArg(&gotit, NMaxERHTest, MaxERHTest, reclogo.instid, (float)locmsg.errh, &PASS);
1750
1751            if(gotit==FALSE)
1752              IsLimitGTArg(&gotit, NMaxERHTest, MaxERHTest, INST_WILDCARD, (float)locmsg.errh, &PASS);
1753
1754            if(gotit==FALSE)
1755              PASS=FALSE;
1756
1757            if(PASS==FALSE) {
1758              if(Debug==1) logit("t","eqfilter: event failed MaxERHTest\n");
1759              goto FinishedTesting;
1760            }
1761          }
1762
1763          /***************
1764            Begin MaxERZTest
1765           ***************/
1766          if(NMaxERZTest>0)
1767          {
1768            gotit=FALSE;
1769            IsLimitGTArg(&gotit, NMaxERZTest, MaxERZTest, reclogo.instid, (float)locmsg.errz, &PASS);
1770
1771            if(gotit==FALSE)
1772              IsLimitGTArg(&gotit, NMaxERZTest, MaxERZTest, INST_WILDCARD, (float)locmsg.errz, &PASS);
1773
1774            if(gotit==FALSE)
1775              PASS=FALSE;
1776
1777            if(PASS==FALSE) {
1778              if(Debug==1) logit("t","eqfilter: event failed MaxERZTest\n");
1779              goto FinishedTesting;
1780            }
1781          }
1782
1783          /***************
1784            Begin MaxAVHTest
1785           ***************/
1786          if(NMaxAVHTest>0)
1787          {
1788            gotit=FALSE;
1789            IsLimitGTArg(&gotit, NMaxAVHTest, MaxAVHTest, reclogo.instid, (float
1790)locmsg.avh, &PASS);
1791
1792            if(gotit==FALSE)
1793              IsLimitGTArg(&gotit, NMaxAVHTest, MaxAVHTest, INST_WILDCARD, (float)locmsg.avh, &PASS);
1794
1795            if(gotit==FALSE)
1796              PASS=FALSE;
1797
1798            if(PASS==FALSE) {
1799              if(Debug==1) logit("t","eqfilter: event failed MaxAVHTest\n");
1800              goto FinishedTesting;
1801            }
1802          }
1803
1804
1805          /***************
1806            Begin MinMagTest
1807           ***************/
1808          if(NMinMagTest>0)
1809          {
1810            gotit=FALSE;
1811            IsLimitLTArg(&gotit, NMinMagTest, MinMagTest, reclogo.instid, (float)locmsg.Md, &PASS);
1812
1813            if(gotit==FALSE)
1814              IsLimitLTArg(&gotit, NMinMagTest, MinMagTest, INST_WILDCARD, (float)locmsg.Md, &PASS);
1815
1816            if(gotit==FALSE)
1817              PASS=FALSE;
1818
1819            if(PASS==FALSE) {
1820              if(Debug==1) logit("t","eqfilter: event failed MinMagTest\n");
1821              goto FinishedTesting;
1822            }
1823          }
1824          /*********************************************************************
1825            Begin NcodaTest
1826            this ones a bit different so we don't get to use the Isxxx routines
1827           ********************************************************************/
1828          if(NNcodaTest>0)
1829          {
1830/* note: this will perform the test successively on all configure Ncoda inst_id's
1831   so event must pass all or it will fail.  E.g. only the last configured inst_id
1832   really matters (unless it fails one prior to that).
1833*/
1834            gotit=FALSE;
1835            gotit2=FALSE;  /* this gotit is only used locally for this test */
1836            for(i=0; i<NNcodaTest; i++)
1837            {
1838              if(NcodaTest[i].instid==reclogo.instid)
1839                gotit2=gotit=TRUE; /* set the global gotit since we have at least one test */
1840              else
1841                gotit2=FALSE;
1842
1843              if(gotit2==TRUE && locmsg.ncoda < NcodaTest[i].var1 && locmsg.Md > NcodaTest[i].var2)
1844              {
1845                PASS=FALSE;
1846                if(Debug==1)
1847                { 
1848                  logit("et","eqfilter: event failed NcodaTest\n");
1849                  logit("et","          locmsg.ncoda = %f is less than %f\n",locmsg.ncoda,NcodaTest[i].var1);
1850                  logit("et","          AND Md = %f is greater than %f\n",locmsg.Md,NcodaTest[i].var2);
1851                } 
1852              }
1853              else if (gotit2 == TRUE && PASS==TRUE)
1854              { 
1855                if(Debug==1)
1856                  logit("et","eqfilter got %f codalen's with Md=%f\n",locmsg.ncoda,locmsg.Md);
1857              } 
1858            }  /* for i<NNcodatest */
1859
1860            /* do the wild thing */
1861            /* use the global gotit here so that this is only performed
1862               if no ncoda id's were found */
1863            if(gotit==FALSE)
1864            {
1865              for(i=0; i<NNcodaTest; i++)
1866              {
1867                if(NcodaTest[i].instid==INST_WILDCARD)
1868                  gotit2=gotit=TRUE;
1869                else
1870                  gotit2=FALSE;
1871
1872                if(gotit2==TRUE && locmsg.ncoda < NcodaTest[i].var1 && locmsg.Md > NcodaTest[i].var2)
1873                { 
1874                  PASS=FALSE;
1875                  if(Debug==1)
1876                  {
1877                    logit("et","eqfilter: event failed NcodaTest\n");
1878                    logit("et","          ncoda = %f is less than %f\n",
1879                           locmsg.ncoda,NcodaTest[i].var1);
1880
1881                    logit("et","          AND Md = %f is greater than %f\n",
1882                           locmsg.Md,NcodaTest[i].var2);
1883                  }
1884                } 
1885                else if (gotit2==TRUE && PASS==TRUE)
1886                { 
1887                  if(Debug==1)
1888                    logit("et","eqfilter got %f codalen's with Md=%f\n",locmsg.ncoda,locmsg.Md);
1889                }
1890              }  /* for i<NNcodatest */
1891            } /* if gotit2 == FALSE */
1892
1893            /* did we get at least one match? */
1894            if(gotit==FALSE)
1895            {
1896              PASS=FALSE;
1897              if(Debug==1)
1898              {
1899                logit("et","eqfilter: event failed NcodaTest\n");
1900                logit("et","          instid=%s not in configured list\n",reclogo.instid);
1901              }
1902            }
1903
1904          } /* if NNcodatTest > 0 */
1905
1906
1907       /**********************************************
1908        No more tests: pass the message if appropriate
1909       ***********************************************/
1910       FinishedTesting:
1911
1912          if(PASS==TRUE)
1913          {
1914            /* eqfilter used strlen(record) but should probably use
1915               whatever size dequeue told us it was*/
1916            if (tport_putmsg (&OutRegion, &reclogo, msgSize, record2) != PUT_OK)
1917            {
1918              logit ("et", "eqfilterII: Error writing message %d-%d-%d.\n", 
1919                            reclogo.instid, reclogo.mod, reclogo.type);
1920              ProcessorStatus = 1;
1921              KillSelfThread ();
1922            }
1923            else
1924            {
1925              logit ("et","eqfilterII passed message from inst:%d module:%d type:%d.\n",
1926                           reclogo.instid, reclogo.mod, reclogo.type);
1927              if (Debug==1){
1928                logit("et","Time: %s lat: %5.2f lon: %6.2f Dep: %6.2f \n",
1929                      locmsg.origin_time_char,locmsg.elat, locmsg.elon,
1930                      locmsg.edepth);
1931              }
1932            }
1933          }
1934          else
1935          {
1936            if (Debug==1)
1937            {
1938              logit ("et", "eqfilterII: Rejected message from inst:%d module:%d type:%d.\n",
1939                            reclogo.instid, reclogo.mod, reclogo.type);
1940              if (Debug==1){
1941                logit("et","lat: %5.2f lon: %6.2f Dep: %6.2f \n", 
1942                      locmsg.elat, locmsg.elon, locmsg.edepth);
1943              }
1944            }
1945          }
1946       } /* if ret > 0 */
1947
1948     } /* while no messages are dequeued */
1949
1950     ProcessorStatus = 0;
1951   }
1952
1953}
1954
1955/***************************************************************************************
1956 *  IsLimit1LTArgLTLimit2( int *gotit, int N, PARTEST2 *MyPar, unsigned char instid,
1957 *                         float myarg, int *PASS)
1958 *
1959 *      given a set of tests containing N members, check for MyPar.instid == instid
1960 *        if it is, then check for Mypar.var1 < myarg < Mypar.var2
1961 *           if it is not, then set PASS=FALSE;
1962 *
1963 ***************************************************************************************/
1964void IsLimit1LTArgLTLimit2(int *gotit, int N, PARTEST2 *MyPar, 
1965                           unsigned char instid, float myarg, int *PASS)
1966{
1967  int i;
1968  int gotit2;
1969
1970  if(N>=0)
1971  { 
1972    for(i=0; i<N; i++)
1973    {
1974      gotit2=FALSE;
1975      if(MyPar[i].instid == instid)
1976        *gotit=gotit2=TRUE;
1977 
1978      if (gotit2==TRUE)
1979      { 
1980        logit("et","gotit2==TRUE, instid=%d MyPar[i].instid=%d\n",instid,MyPar[i].instid);
1981        if (myarg > MyPar[i].var1 && myarg < MyPar[i].var2)
1982        {
1983          ;
1984        }
1985        else
1986        {
1987          *PASS=FALSE;
1988          if(Debug==1)
1989          {
1990            logit("et","eqfilterII/IsLimit1LTArgLTLimit2: event failed\n");
1991            logit("et","          event value=%.2f is not between limits %.2f and %.2f\n",
1992                   myarg, MyPar[i].var1, MyPar[i].var2);
1993          }
1994        } 
1995      } /* if gotit==TRUE */
1996    }   /*  for i<N */
1997  } /* if N>=0 */
1998} /* end subroutine */
1999
2000/***************************************************************************************
2001 *  IsLimitLTArg( int N, PARTEST1 *MyPar, unsigned char instid, float myarg, int *PASS)
2002 *
2003 *      given a set of tests containing N members, check for MyPar.instid == instid
2004 *        if it is, then check for Mypar.var1 < myarg
2005 *           if it is not, then set PASS=FALSE;
2006 *
2007 ***************************************************************************************/
2008void IsLimitLTArg(int *gotit, int N, PARTEST1 *MyPar, unsigned char instid, 
2009                  float myarg, int *PASS)
2010{
2011  int i;
2012  int gotit2;
2013
2014  if(N>=0)
2015  {
2016    for(i=0; i<N; i++)
2017    {
2018      gotit2=FALSE;
2019      if(MyPar[i].instid == instid)
2020        *gotit=gotit2=TRUE;
2021
2022      if (gotit2==TRUE)
2023      { 
2024        if ( MyPar[i].var < myarg )
2025        {
2026          ;
2027        }
2028        else
2029        {
2030          *PASS=FALSE;
2031          if(Debug==1)
2032          {
2033            logit("et","eqfilterII/IsLimitLTArg: event failed\n");
2034            logit("et","         event value=%.2f is less than or equal to limit=%.2f\n",
2035                   myarg, MyPar[i].var);
2036          }
2037        }
2038      } /* if gotit==TRUE */
2039    }   /*  for i<N */
2040  } /* if N>=0 */
2041} /* end subroutine */
2042
2043/***************************************************************************************
2044 *  IsLimitGTArg( int N, PARTEST1 *MyPar, unsigned char instid, float myarg, int *PASS)
2045 *
2046 *      given a set of tests containing N members, check for MyPar.instid == instid
2047 *        if it is, then check for Mypar.var1 > myarg
2048 *           if it is not, then set PASS=FALSE;
2049 *
2050 ***************************************************************************************/
2051void IsLimitGTArg(int *gotit, int N, PARTEST1 *MyPar, unsigned char instid, 
2052                  float myarg, int *PASS)
2053{
2054  int i;
2055  int gotit2;
2056 
2057  if(N>=0)
2058  {
2059    for(i=0; i<N; i++)
2060    {
2061      gotit2=FALSE;
2062      if(MyPar[i].instid == instid)
2063        *gotit=gotit2=TRUE;
2064 
2065      if (gotit2==TRUE)
2066      { 
2067        if ( MyPar[i].var > myarg )
2068        {
2069          ;
2070        }
2071        else
2072        {
2073          *PASS=FALSE;
2074          if(Debug==1)
2075          {
2076            logit("et","eqfilterII/IsLimitGTArg: event failed\n");
2077            logit("et","         event value=%.2f is greater than or equal to limit=%.2f\n",
2078                   myarg, MyPar[i].var);
2079          }
2080        }
2081      } /* if gotit==TRUE */
2082    }   /*  for i<N */
2083  } /* if N>=0 */
2084} /* end subroutine */
2085
2086
2087
2088/* eqfiltmsg. Put all the ifs here and add additional subroutines as
2089   message types are added
2090   *****************************************************************/
2091int eqfiltmsg(char *in_msg, EQSUM *out_msg, unsigned char msg_type)
2092{
2093  int ret;
2094
2095  ret = -1;
2096
2097  strcpy(out_msg->origin_time_char,"-12345");
2098  out_msg->tOrigin = (double)EQSUM_NULL;
2099  out_msg->elat = (float)EQSUM_NULL;
2100  out_msg->elon = (float)EQSUM_NULL;
2101  out_msg->edepth = (float)EQSUM_NULL;
2102  out_msg->gap = (float)EQSUM_NULL;
2103  out_msg->nsta = (int)EQSUM_NULL;
2104  out_msg->npha = (int)EQSUM_NULL;
2105  out_msg->nphtot = (int)EQSUM_NULL;
2106  out_msg->gdmin = (float)EQSUM_NULL;
2107  out_msg->dmin = (float)EQSUM_NULL;
2108  out_msg->rms = (float)EQSUM_NULL;
2109  out_msg->e0 = (float)EQSUM_NULL;
2110  out_msg->errh = (float)EQSUM_NULL;
2111  out_msg->errz = (float)EQSUM_NULL;
2112  out_msg->avh = (float)EQSUM_NULL;
2113  out_msg->Md = (float)EQSUM_NULL;
2114
2115  if (msg_type == TypeHyp2000Arc)
2116      ret = hyp2eqfilt(in_msg, out_msg);
2117  else if (msg_type == TypeLocGlobal)
2118      ret = glloc2eqfilt(in_msg, out_msg);
2119  else if (msg_type == TypeRayloc)
2120      ret = rayloc2eqfilt(in_msg, out_msg);
2121  else
2122    logit ("e", "eqfilterII: Uknown message type %d\n",msg_type);
2123   
2124  return(ret);
2125}
2126
2127/* hyp2eqfilt  from hyp2000arc to eqfiltsum */
2128int hyp2eqfilt(char *in_msg, EQSUM *out_msg)
2129{
2130  /* don't really need all these vars but I (withers) am lazy
2131     and did a straight copy and paste from eqfilter */
2132
2133  struct Hsum Sum;            /* Hyp2000 summary data */
2134  struct Hpck Pick;          /* Hyp2000 pick structure */
2135  char     *in;             /* working pointer to archive message    */
2136  char      line[MAX_STR];  /* to store lines from msg               */
2137  char      shdw[MAX_STR];  /* to store shadow cards from msg        */
2138  int       msglen;         /* length of input archive message       */
2139  int       nline;          /* number of lines (not shadows) so far  */
2140  float ncoda;
2141  int ret;
2142
2143  /*******************************************************
2144   * Read one data line and its shadow at a time from arcmsg; process them
2145   ***********************************************************************/
2146
2147  /* Initialize some stuff
2148   ***********************/
2149  nline  = 0;
2150  msglen = strlen( in_msg );
2151  in     = in_msg;
2152  while( in < in_msg+msglen ) {
2153    if ( sscanf( in, "%[^\n]", line ) != 1 ) {
2154      logit( "et", "eqfilterII: Error reading data from arcmsg\n" );
2155      return(-1);
2156    }
2157    in += strlen( line ) + 1;
2158    if ( sscanf( in, "%[^\n]", shdw ) != 1 ) {
2159      logit( "et", "eqfilterII: Error reading data shadow from arcmsg\n");
2160      return(-1);
2161    }
2162    in += strlen( shdw ) + 1;
2163    nline++;
2164
2165    /* Process the hypocenter card (1st line of msg) & its shadow
2166     ************************************************************/
2167    if( nline == 1 ) {                /* hypocenter is 1st line in msg */
2168      ncoda=0.0;
2169      if ( read_hyp( line, shdw, &Sum ) != 0) {
2170        logit ("e", "eqfilterII: Call to read_hyp failed.\n");
2171        return(-1);
2172      }
2173/*
2174      if (Debug == 1) {
2175        logit( "e", "eqfilterII got following EVENT MESSAGE:\n");
2176        logit( "e", "%s\n", line );
2177      }
2178*/
2179      continue;
2180    }
2181    if( strlen(line) < (size_t) 75 )  /* found the terminator line */
2182      break;
2183
2184    if ( read_phs( line, shdw, &Pick ) !=0) {
2185      logit ("e", "eqfilterII: Call to read_phs failed.\n");
2186      return(-1);
2187    }
2188    else if(Pick.codalen>0) {
2189      ncoda = ncoda + 1.0;
2190    }
2191/*
2192    if (Debug == 1) {
2193      logit( "e", "%s\n", line );
2194    }
2195*/
2196    continue;
2197  } /*end while over reading message*/
2198
2199  /* Sum call doesn't make sense */
2200  strcpy(out_msg->origin_time_char,(&Sum)->cdate);
2201  if(ret = epochsec17(&out_msg->tOrigin,out_msg->origin_time_char)!=0){
2202    logit("pt", ": Failed to convert Input Message into structure\n");
2203  }
2204  out_msg->elat = (double)Sum.lat;
2205  out_msg->elon = (double)Sum.lon;
2206  out_msg->edepth = (double)Sum.z;
2207  out_msg->gap = (double)Sum.gap;
2208  /* no nsta in Hsum */
2209  out_msg->npha = (int)Sum.nph;
2210  out_msg->nphtot = (int)Sum.nphtot;
2211  /* no gdmin in Hsum */
2212  out_msg->dmin = (double)Sum.dmin;
2213  out_msg->rms = (double)Sum.rms;
2214  out_msg->e0 = (double)Sum.e0;
2215  out_msg->errh = (double)Sum.erh;
2216  out_msg->errz = (double)Sum.erz;
2217  /* no avh in Hsum */
2218  out_msg->Md = (double)Sum.Md;
2219  out_msg->ncoda = (int)ncoda;
2220
2221  return(ret);
2222
2223}
2224
2225/* glloc2eqfilter  from loc_global to eqfiltsum */
2226int glloc2eqfilt(char *in_msg, EQSUM *out_msg)
2227{
2228  GLOBAL_LOC_STRUCT p_loc;
2229  int ret;
2230
2231  ret = StringToLoc(&p_loc, in_msg);
2232  if(ret != GLOBAL_MSG_SUCCESS) {
2233    logit("pt", "lib_global_loc: Failed to convert Input Message into structure\n");
2234    return(ret);
2235  }
2236
2237  /* something is wrong here */
2238  /* v6.2 used a time string, we now use epoch seconds
2239  strcpy(out_msg->origin_time_char,(&p_loc)->origin_time); */
2240
2241  out_msg->tOrigin = p_loc.tOrigin;
2242  /* convert to a date time string */
2243  ret = TimeToDTString( out_msg->tOrigin, out_msg->origin_time_char );
2244  if(ret != GLOBAL_MSG_SUCCESS )
2245    logit("pt", ": Failed to convert Input origin time to date string\n");
2246
2247  out_msg->elat = (double)p_loc.lat;
2248  out_msg->elon = (double)p_loc.lon;
2249  out_msg->edepth = (double)p_loc.depth;
2250  out_msg->gap = (double)p_loc.gap;
2251  /* no nsta in global_loc */
2252  /* no npha in global_loc */
2253  out_msg->nphtot = (int)p_loc.pick_count;
2254  /* no dmin in global_loc (we define dmin in km, gdmin in degrees) */
2255  out_msg->gdmin = (double)p_loc.dmin;
2256  out_msg->rms = (double)p_loc.rms;
2257  /* no e0 in global_loc */
2258  /* no errh in global_loc */
2259  /* no errz in global_loc */
2260  /* no avh in global_loc */
2261  /* no minmag in global_loc */
2262  /* no ncoda in global_loc */
2263
2264  return(ret);
2265
2266}
2267
2268/* rayloc2eqfilt  from rayloc to eqfiltsum */
2269rayloc2eqfilt(char *in_msg, EQSUM *out_msg)
2270{
2271  RAYLOC_MESSAGE_HEADER_STRUCT *p_struct = NULL;
2272  int ret,i;
2273
2274  ret = rayloc_MessageToRaylocHeader(&p_struct, in_msg);
2275 
2276  if(ret != RAYLOC_MSG_SUCCESS) {
2277    logit("pt", "rayloc2eqfilt: Failed to convert Input Message into structure\n");
2278    return(ret);
2279  }else{
2280    logit("", "rayloc2eqfilt: Succesfully converted Input Message into structure\n");
2281  }
2282
2283  /* temp kludge to create rayloc msg files */
2284/*
2285  RaylocHeaderToUniqueFile( p_struct );
2286*/
2287
2288  strcpy(out_msg->origin_time_char,p_struct->origin_time_char);
2289  out_msg->tOrigin = (double)p_struct->origin_time;
2290  out_msg->elat = (double)p_struct->elat;
2291  out_msg->elon = (double)p_struct->elon;
2292  out_msg->edepth = (double)p_struct->edepth;
2293  out_msg->gap = (double)p_struct->gap;
2294  out_msg->nsta = (int)p_struct->nsta;
2295  /* nphtot is really npha in rayloc */
2296  out_msg->nphtot = (int)p_struct->npha;
2297  out_msg->gdmin = (double)p_struct->dmin;
2298  out_msg->rms = (double)p_struct->se;
2299  out_msg->e0 = (double)p_struct->axis[0];
2300  for (i=1; i<3; i++){
2301    if((double)p_struct->axis[i] > out_msg->e0)
2302      out_msg->e0 = (double)p_struct->axis[i];
2303  }
2304  out_msg->errh = (double)p_struct->errh;
2305  out_msg->errz = (double)p_struct->errz;
2306  out_msg->avh = (double)p_struct->avh;
2307  /* no minmag in rayloc */
2308  /* no ncoda in global_loc */
2309
2310
2311  /* the rayloc lib allocates the struct space so make
2312     sure we tidy up.
2313   ***************************************************/
2314
2315  rayloc_FreeRaylocHeader( &p_struct );
2316
2317  return(ret);
2318
2319}
2320
2321/**************************************************************
2322   temporary routine used in rayloc2eqfilt to create cache of
2323   rayloc message files
2324 *************************************************************/
2325int RaylocHeaderToUniqueFile( RAYLOC_MESSAGE_HEADER_STRUCT *p_struct )
2326{
2327  FILE *fid;
2328  char MsgDir[]="/export/home/ew/RaylocMsgs";
2329  char MsgFile[2048];
2330  int i;
2331  char _author[10];
2332
2333  logit("","construcing filename %s, %lf, %ld\n",MsgDir,p_struct->origin_time,p_struct->event_id);
2334  sprintf(MsgFile,"%s/%ld.msg\0",MsgDir,p_struct->event_id);
2335  logit("","filename constructed: %s\n",MsgFile);
2336  if ( (fid=fopen(MsgFile,"w")) == NULL){
2337     logit("","eqfilterII: could not open %s for write\n",MsgFile);
2338  } else {
2339    /* the fprintf statements were stolen from rayloc_message_rw lib */
2340    EncodeAuthor( p_struct->logo, _author );
2341    fprintf(fid,
2342            "RLC %s %d %ld %s %.4f %.4f %.3f %d %d %d %d %.3f %.3f %c %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %c %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f %.3f\n",
2343             _author,
2344             p_struct->version,
2345             p_struct->event_id ,
2346             p_struct->origin_time_char ,
2347             p_struct->elat ,
2348             p_struct->elon ,
2349             p_struct->edepth ,
2350             p_struct->nsta ,
2351             p_struct->npha ,
2352             p_struct->suse ,
2353             p_struct->puse ,
2354             p_struct->gap ,
2355             p_struct->dmin ,
2356             p_struct->depth_flag ,
2357             p_struct->oterr ,
2358             p_struct->laterr ,
2359             p_struct->lonerr ,
2360             p_struct->deperr ,
2361             p_struct->se ,
2362             p_struct->errh ,
2363             p_struct->errz ,
2364             p_struct->avh ,
2365             p_struct->q ,
2366             p_struct->axis[0] ,
2367             p_struct->az[0] ,
2368             p_struct->dp[0] ,
2369             p_struct->axis[1] ,
2370             p_struct->az[1] ,
2371             p_struct->dp[1] ,
2372             p_struct->axis[2] ,
2373             p_struct->az[2] ,
2374             p_struct->dp[2]);
2375    for (i = 0; i < p_struct->numPicks; i++){
2376      EncodeAuthor( (p_struct->picks[i])->logo, _author );
2377      fprintf(fid, "PCK %s %d %ld %s %s %s %s %s %.3f %.3f %.3f %c\n",
2378                    _author,
2379                    (p_struct->picks[i])->version ,
2380                    (p_struct->picks[i])->pick_id ,
2381                    (p_struct->picks[i])->station ,
2382                    (p_struct->picks[i])->channel ,
2383                    (p_struct->picks[i])->network ,
2384                    (p_struct->picks[i])->location ,
2385                    (p_struct->picks[i])->phase_name ,
2386                    (p_struct->picks[i])->residual ,
2387                    (p_struct->picks[i])->dist ,
2388                    (p_struct->picks[i])->az ,
2389                    (p_struct->picks[i])->weight_flag);
2390    }
2391    fprintf(fid,"\n");
2392
2393    fclose(fid);
2394  }
2395}
Note: See TracBrowser for help on using the repository browser.