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

Revision 7946, 73.1 KB checked in by baker, 17 months ago (diff)

finish standardizing seismic_processing makefiles

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