source: trunk/src/libsrc/util/parse_usnsn.c @ 7513

Revision 7513, 24.1 KB checked in by baker, 6 months ago (diff)

cleanup warning: variable set but not used [-Wunused-but-set-variable]

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/*
2
3   parse_usnsn.c
4
5
6     Routines used to parse a text message from NEIC.
7   
8     A successful call to ParseNSNMsg fills the NSNStruct
9     with values from the text message contained in NsnMsg.
10
11     If debug is not 0, debug info will be written. If debug > 1,
12     a file with the parsed values of the message will be
13     written in the debug_dir directory.
14
15     ParseNSNMsg returns EW_SUCCESS if everything goes well,
16     otherwise it returns EW_FAILURE. 
17
18     Only ParseNSNMsg() should be called from outside of this
19     file. All other functions in here are utilities used
20     by ParseNSNMsg()
21
22*/
23     
24#include <math.h>
25#include <stdio.h>
26#include <stdlib.h>
27#include <string.h>
28
29#include "earthworm.h"
30#include "parse_usnsn.h"
31#include "rw_mag.h"
32
33#define     MAX_LINES       1000
34#define     MAX_LINE_SIZE   300
35
36extern  int             epochsec17 (double *, char *);
37
38static  int             ConvertNSNMsg (char *, int, char **, int *);
39static  int             ParsePhaseMagnitude (char *, PhaseMag *);
40static  int             ParsePhase (char *, Phase *, char *, int *, double *);
41static  int             ParseMagnitude (char *, OriginMag *);
42static  int             ParseEllipse (char *, double, Err_Elipse *);
43static  int             AppendDateStr (char     *, char *);
44static  int             BuildDateStr (char *, char *);
45static  int     GetNextLine (char **, int *, char *);
46
47/************************************************************************
48 * ParseNSNMsg() - Fill the msg struct from the text supplied in
49 *                 nsnbuf.
50 ************************************************************************/
51int     ParseNSNMsg (char *NsnMsg, int msgLen, 
52                        NSNStruct *msgStruct, int debug, char *debug_dir)
53{
54        int             i, j;
55        char    datestr[15];
56        char    DateStr[20];
57        char    tmp1[256];
58        char    tmp2[256];
59        char    tmp3[256];
60        int             lineno;
61        FILE    *fp;
62        char    filename[100];
63    char    **nsnbuf;
64    int     nlines;
65
66
67        if ((NsnMsg == NULL) || (msgStruct == NULL) || (debug_dir == NULL))
68        {
69                logit ("e", "Invalid parameters passed in.\n");
70                return EW_FAILURE;
71        }       
72
73        nsnbuf = (char **) malloc (MAX_LINES * sizeof (char *));
74        for (i = 0; i < MAX_LINES; i++)
75                nsnbuf[i] = (char *) malloc (MAX_LINE_SIZE * sizeof (char));
76
77
78        /* Create nsnbuf (array of lines) for easier parsing
79         ****************************************************/
80        if (ConvertNSNMsg (NsnMsg, msgLen, nsnbuf, &nlines) != EW_SUCCESS)
81        {
82                logit ("", "Call to ConvertNSNMsg failed\n");
83                return EW_FAILURE;
84        }
85
86
87        /* skip the first two lines */
88        lineno = 2;
89
90
91        /* First, we have to see if this is a deletion message.
92           We don't do anything with it, so if we get it, we'll
93           just return FAILURE, and let the calling program deal
94           with the ramifications.
95         ********************************************************/
96        sscanf (nsnbuf[lineno + 3], "%s\n", tmp1);
97        if (strcmp (tmp1, "EVENT") == 0)
98        {
99                /* Yup, it's a deletion message */
100
101                /* extract the NSN event key */
102                strncpy (msgStruct->EventKey, (nsnbuf[lineno + 3] + 21), 4);
103                msgStruct->EventKey[4] = '\0';
104               
105                return RETURN_DELETE;
106        }
107
108        /* see if this is an automatic, or a reviewed solution */
109        sscanf (nsnbuf[lineno], "%s\n", tmp1);
110        if (strcmp (tmp1, "The") == 0)
111                /* Yup, it's an automatic: skip four more lines */
112                lineno = lineno + 4;
113        /* Else, it's a reviewed solution message: we are at the first line */
114
115/*
116 * line 1; extract date, comment, event key, whether it is preliminary
117 *********************************************************************/
118        strncpy (datestr, (nsnbuf[lineno] + DATE_BASE), 11);
119        datestr[11] = '\0';
120
121        if (BuildDateStr (datestr, msgStruct->EventDate) != EW_SUCCESS)
122        {
123                logit ("e", "Call to BuildDateStr failed.\n");
124                return EW_FAILURE;
125        }
126
127        strncpy (msgStruct->EventKey, (nsnbuf[lineno] + EVENT_KEY_BASE), 4);
128        msgStruct->EventKey[4] = '\0';
129
130        if (nsnbuf[lineno][PRELIM_BASE] == 'p')
131        {
132                msgStruct->automatic = 1;
133        }
134        else
135        {
136                msgStruct->automatic = 0;
137        }
138
139       
140/*
141 * line 2; extract origin time and error
142 *********************************************************************/
143        lineno = lineno + 1;
144        if (GetNextLine (nsnbuf, &lineno, "ot") == EW_SUCCESS)
145        {
146                sscanf (nsnbuf[lineno], "    ot  = %s   +/-   %s\n", tmp1, tmp2);
147
148                strcpy (DateStr, msgStruct->EventDate);
149                if (AppendDateStr (DateStr, tmp1) != EW_SUCCESS)
150                {
151                        logit ("e", "Call to AppendDateStr failed.\n");
152                        return EW_FAILURE;
153                }
154
155                epochsec17 (&msgStruct->ot, DateStr);
156                msgStruct->ot_err = (double) atof (tmp2);
157        }
158        else
159        {
160                logit ("e", "GetNextLine returned EW_FAILURE; exitting\n");
161                return EW_FAILURE;
162        }
163
164/*
165 * line 3; extract latitude
166 *********************************************************************/
167        lineno = lineno + 1;
168        if (GetNextLine (nsnbuf, &lineno, "lat") == EW_SUCCESS)
169        {
170                sscanf (nsnbuf[lineno], "    lat = %s   +/-   %s\n", tmp1, tmp2);
171
172                msgStruct->lat = (float) atof (tmp1);
173                msgStruct->lat_err = (float) atof (tmp2);
174        }
175        else
176        {
177                logit ("e", "GetNextLine returned EW_FAILURE; exitting\n");
178                return EW_FAILURE;
179        }
180
181/*
182 * line 4; extract longitude
183 *********************************************************************/
184        lineno = lineno + 1;
185        if (GetNextLine (nsnbuf, &lineno, "lon") == EW_SUCCESS)
186        {
187                sscanf (nsnbuf[lineno], "    lon = %s   +/-   %s\n", tmp1, tmp2);
188
189                msgStruct->lon = (float) atof (tmp1);
190                msgStruct->lon_err = (float) atof (tmp2);
191        }
192        else
193        {
194                logit ("e", "GetNextLine returned EW_FAILURE; exitting\n");
195                return EW_FAILURE;
196        }
197
198
199/*
200 * line 5; extract depth
201 *********************************************************************/
202        lineno = lineno + 1;
203        if (GetNextLine (nsnbuf, &lineno, "dep") == EW_SUCCESS)
204        {
205                /* Depth could have an error */
206                if (nsnbuf[lineno][DEPTH_BASE] == '+')
207                {
208                        sscanf (nsnbuf[lineno], "    dep = %s   +/-   %s\n", tmp1, tmp2);
209                        msgStruct->depth = (float) atof (tmp1);
210                        msgStruct->depth_err = (float) atof (tmp2);
211
212                }
213                else
214                {
215                        /* no +/- error, we have some string there */
216                        sscanf (nsnbuf[lineno], "    dep = %s\n", tmp1);
217                        msgStruct->depth = (float) atof (tmp1);
218                        msgStruct->depth_err = (double) 0.0;
219                        msgStruct->depth_fixed = 1;
220                }
221        }
222        else
223        {
224                logit ("e", "GetNextLine returned EW_FAILURE; exitting\n");
225                return EW_FAILURE;
226        }
227
228/*
229 * line 6; extract number of phases and std error
230 *********************************************************************/
231        lineno = lineno + 1;
232        if (GetNextLine (nsnbuf, &lineno, "nph") == EW_SUCCESS)
233        {
234                sscanf (nsnbuf[lineno], "    nph = %s of %s    se = %s  \n", tmp1, tmp2, tmp3);
235                msgStruct->nph_used = atoi (tmp1);
236                msgStruct->nph_assoc = atoi (tmp2);
237                msgStruct->std_error = (double) atof (tmp3);
238        }
239        else
240        {
241                logit ("e", "GetNextLine returned P3DB_FAILURE; exitting\n");
242                return EW_FAILURE;
243        }
244
245
246/*
247 * line 7; extract the error elipse
248 *********************************************************************/
249        lineno = lineno + 1;
250        if (GetNextLine (nsnbuf, &lineno, "error") == EW_SUCCESS)
251        {
252                strncpy (tmp1, (nsnbuf[lineno] + ELLIPSE_BASE), (size_t) ELLIPSE_LENGTH);
253                tmp1[ELLIPSE_LENGTH] ='\0';
254
255                if (ParseEllipse (tmp1, msgStruct->depth_err, &msgStruct->error) != EW_SUCCESS)
256                {
257                        logit ("e", "Call to ParseEllipse failed.\n");
258                        return EW_FAILURE;
259                }
260        }
261        else
262        {
263                logit ("e", "GetNextLine returned EW_FAILURE; exitting\n");
264                return EW_FAILURE;
265        }
266
267/*
268 * line 8; extract magnitudes
269 *********************************************************************/
270        lineno = lineno + 1;
271        if (GetNextLine (nsnbuf, &lineno, "mb") == EW_SUCCESS)
272        {
273                msgStruct->numMags = 5;
274                if (ParseMagnitude (nsnbuf[lineno], msgStruct->O_mag) != EW_SUCCESS)
275                {
276                        logit ("e", "Call to ParseMagnitude failed.\n");
277                        return EW_FAILURE;
278                }
279        }
280        else
281        {
282                logit ("e", "GetNextLine returned EW_FAILURE; exitting\n");
283                return EW_FAILURE;
284        }
285
286/*
287 * line 9; find the beginning of the picks section
288 *********************************************************************/
289        lineno = lineno + 1;
290        if (GetNextLine (nsnbuf, &lineno, "sta") == EW_SUCCESS)
291        {
292
293                /* Now, read and parse all the phases */
294                msgStruct->nph_actual = 0;
295                msgStruct->Dmin = EARTH_CIRCUM;
296                for (i = 0; i < msgStruct->nph_assoc; i++)
297                {
298                        lineno = lineno + 1;
299                        if (ParsePhase (nsnbuf[lineno], &msgStruct->phases[msgStruct->nph_actual],
300                                                        msgStruct->EventDate, &msgStruct->nph_actual, 
301                                                        &msgStruct->Dmin) != EW_SUCCESS)
302                        {
303                                logit ("e", "Call to ParsePhase failed.\n");
304                                return EW_FAILURE;
305                        }
306                }
307
308
309                if (debug > 10)
310                {
311                        /* Print the parsed version of the message
312                         ********************************************/
313                        sprintf (filename, "%s/%s-%s", 
314                                                debug_dir, msgStruct->EventDate, msgStruct->EventKey);
315                       
316                        fp = fopen (filename, "wt");
317
318
319                        /*** This is where we are done ****/
320                        fprintf (fp, "\n===> PRINTING SUMMARY FOR EVENT %s \n", msgStruct->EventKey);
321                        fprintf (fp, "Event Date: %s\n", msgStruct->EventDate);
322                        fprintf (fp, 
323                                                "ot=%0.2f,%0.2f; lat=%0.2f,%0.2f; lon=%0.2f,%0.2f; dep=%0.2f,%0.2f\n", 
324                                                        msgStruct->ot, msgStruct->ot_err,
325                                                        msgStruct->lat, msgStruct->lat_err,
326                                                        msgStruct->lon, msgStruct->lon_err,
327                                                        msgStruct->depth, msgStruct->depth_err);
328                        fprintf (fp, "Magnitudes computed: \n");
329                        fprintf (fp, "\t %c (%d) = %0.2f from %d phases\n", 
330                                                                                msgStruct->O_mag[0].magLabel,
331                                                                                msgStruct->O_mag[0].MagType,
332                                                                                msgStruct->O_mag[0].magAvg, 
333                                                                                msgStruct->O_mag[0].numStas);
334                        fprintf (fp, "\t %c (%d) = %0.2f from %d phases\n", 
335                                                                                msgStruct->O_mag[1].magLabel,
336                                                                                msgStruct->O_mag[1].MagType,
337                                                                                msgStruct->O_mag[1].magAvg, 
338                                                                                msgStruct->O_mag[1].numStas);
339                        fprintf (fp, "\t %c (%d) = %0.2f from %d phases\n", 
340                                                                                msgStruct->O_mag[2].magLabel,
341                                                                                msgStruct->O_mag[2].MagType,
342                                                                                msgStruct->O_mag[2].magAvg, 
343                                                                                msgStruct->O_mag[2].numStas);
344                        fprintf (fp, "\t %c (%d) = %0.2f from %d phases\n", 
345                                                                                msgStruct->O_mag[3].magLabel,
346                                                                                msgStruct->O_mag[3].MagType,
347                                                                                msgStruct->O_mag[3].magAvg,     
348                                                                                msgStruct->O_mag[3].numStas);
349                        fprintf (fp, "\t %c (%d) = %0.2f from %d phases\n", 
350                                                                                msgStruct->O_mag[4].magLabel,
351                                                                                msgStruct->O_mag[4].MagType,
352                                                                                msgStruct->O_mag[4].magAvg, 
353                                                                                msgStruct->O_mag[4].numStas);
354                       
355                        fprintf (fp, "\nThere were total of %d phases, of which %d were marked as used\n",
356                                                        msgStruct->nph_assoc, msgStruct->nph_used);
357                        fprintf (fp, "Std error (RMS) was %0.2f: \n", msgStruct->std_error);
358                        fprintf (fp, "Of those, we parsed the following %d phases: \n", msgStruct->nph_actual);
359                        for (i = 0; i < msgStruct->nph_actual; i++)
360                        {
361                          fprintf (fp, "%s %s (%c %c) %0.2f   %0.1f,%0.1f,%d MAGS  ",
362                                                        msgStruct->phases[i].sta, msgStruct->phases[i].phase,
363                                                        msgStruct->phases[i].onset, msgStruct->phases[i].motion,
364                                                        msgStruct->phases[i].ot, msgStruct->phases[i].res,
365                                                        msgStruct->phases[i].dist, msgStruct->phases[i].azm);
366                       
367                          for (j = 0; j < msgStruct->phases[i].num_mags; j++)
368                          {
369                            if (msgStruct->phases[i].mag[j].used == 1)
370                              fprintf (fp, "USED %c (%d),%0.1f,%0.2f ==> %0.1f  ", 
371                                        msgStruct->phases[i].mag[j].magLabel,
372                                        msgStruct->phases[i].mag[j].MagType,
373                                        msgStruct->phases[i].mag[j].value,
374                                        msgStruct->phases[i].mag[j].period,
375                                        msgStruct->phases[i].mag[j].mag);
376                            else
377                              fprintf (fp, "NOT USED %c (%d),%0.1f,%0.2f ==> %0.1f  ", 
378                                        msgStruct->phases[i].mag[j].magLabel,
379                                        msgStruct->phases[i].mag[j].MagType,
380                                        msgStruct->phases[i].mag[j].value,
381                                        msgStruct->phases[i].mag[j].period,
382                                        msgStruct->phases[i].mag[j].mag);
383                          }
384                          fprintf (fp, "\n");
385                       
386                        }
387
388                        fclose (fp);
389                }
390               
391        }
392        else
393        {
394                logit ("", "GetNextLine returned EW_FAILURE; exitting\n");
395                return EW_FAILURE;
396        }
397
398
399        /* free up allocated space */
400        for (i = 0; i < MAX_LINES; i++)
401                free ((void *) nsnbuf[i]);
402        free ((void *) nsnbuf);
403
404/*
405logit ("", "BEFORE RETURN\n");
406for (i = 0; i < msgStruct->nph_actual; i++)
407  logit ("", "Chan %d, <%s>\n", i, msgStruct->phases[i].sta);
408*/
409
410
411        return EW_SUCCESS;
412
413}
414
415
416/************************************************************************
417 * ConvertNSNMsg () - fill the buffer with the stuff in msg.
418 *   set nlines to the number of lines read.
419 ************************************************************************/
420static  int             ConvertNSNMsg (char *msg, int msgsize, char **buffer, int *nlines)
421{
422
423        int             i, j, done;
424        char    *line;
425
426        if ((buffer == NULL) || (msg == NULL) || (msgsize < 0))
427        {
428                logit ("e", "ConvertNSNMsg: Invalid parameters passed in.\n");
429                return EW_FAILURE;
430        }
431
432        *nlines = 0;
433
434        done = FALSE;
435        i = 0;
436        j = 0;
437        while (done == FALSE)
438        {
439               
440                line = buffer[*nlines];
441
442                while ((msg[i] != '\n') && (i < msgsize))
443                {
444                        line[j] = msg[i];
445                        i = i + 1;
446                        j = j + 1;
447                }
448                if (msg[i] == '\n')
449                {
450/**
451                        line[j] = '\0';
452**/
453                        line[j] = '\n';
454                        *nlines = *nlines + 1;
455                        j = 0;
456                        i = i + 1;
457                }
458                else
459                {
460                        line[j] = '\0';
461                        done = TRUE;
462                }
463                       
464        }
465
466        return EW_SUCCESS;
467}
468
469
470
471/************************************************************************
472 * GetNextLine () - return the next line from the message (in buffer)
473 *  where the first word of the line is given by argument word.
474 ************************************************************************/
475static  int     GetNextLine (char **buffer, int *lineno, char *word)
476{
477
478        char    tmp[256];
479        int             done;
480
481        if ((buffer == NULL) || (word == NULL))
482        {
483                logit ("", "Invalid arguments passed in.\n");
484                return EW_FAILURE;
485        }
486
487        done = FALSE;
488        while (done == FALSE)
489        {
490                if (strlen (buffer[*lineno]) == 1)
491                        ;
492                else
493                {
494                        /* Check the first word */
495
496                        sscanf (buffer[*lineno], "%s\n", tmp);
497
498                        if (strcmp (tmp, word) == 0)
499                        {
500                                done = TRUE;
501                        }
502                        else
503                                ;
504                }
505
506                if (done != TRUE)
507                        *lineno = *lineno + 1;
508        }
509
510        return EW_SUCCESS;
511}
512
513
514/************************************************************************
515 * BuildDateStr () - Create a date string suitable for a call to
516 *   epochsec17, from an NSN format date string.
517 ************************************************************************/
518static  int             BuildDateStr (char *in, char *out)
519{
520
521        char    year[6];
522        char    month[6];
523        char    day[6];
524
525        if ((in == NULL) || (out == NULL))
526        {
527                logit ("", "Invalid arguments passed in.\n");
528                return EW_FAILURE;
529        }
530
531        strncpy (day, in, 2);
532        day[2] = '\0';
533
534        if (day[0] == ' ')
535                day[0] ='0';
536
537        /* figure out the month */
538        if (in[3] == 'J')
539        {
540                if (in[4] == 'A')
541                        sprintf (month, "01");
542                else if (in[4] == 'U')
543                {
544                        if (in[5] == 'N')
545                                sprintf (month, "06");
546                        else if (in[5] == 'L')
547                                sprintf (month, "07");
548                        else
549                        {
550                                logit ("", "Unknown month %s!\n", month);
551                                return EW_FAILURE;
552                        }
553                }
554                else
555                {
556                        logit ("", "Unknown month %s!\n", month);
557                        return EW_FAILURE;
558                }
559        }
560        else if (in[3] == 'M')
561        {
562                if (in[5] == 'R')
563                        sprintf (month, "03");
564                else if (in[5] == 'Y')
565                        sprintf (month, "05");
566                else
567                {
568                        logit ("", "Unknown month %s!\n", month);
569                        return EW_FAILURE;
570                }
571        }
572        else if (in[3] == 'A')
573        {
574                if (in[4] == 'P')
575                        sprintf (month, "04");
576                else if (in[4] == 'U')
577                        sprintf (month, "08");
578                else
579                {
580                        logit ("", "Unknown month %s!\n", month);
581                        return EW_FAILURE;
582                }
583        }
584        else if (in[3] == 'F')
585                sprintf (month, "02");
586        else if (in[3] == 'S')
587                sprintf (month, "09");
588        else if (in[3] == 'O')
589                sprintf (month, "10");
590        else if (in[3] == 'N')
591                sprintf (month, "11");
592        else if (in[3] == 'D')
593                sprintf (month, "12");
594        else
595        {
596                logit ("", "Unknown month %s!\n", month);
597                return EW_FAILURE;
598        }
599
600        strncpy (year, (in + 7), 4);
601        year[4] = '\0';
602
603        sprintf (out, "%s%s%s", year, month, day);
604
605
606        return EW_SUCCESS;
607
608}
609
610
611/************************************************************************
612 * AppendDateStr () - Append hours, minutes, and seconds to the
613 *   date, to create a string suitable for a call to epochsec17
614 ************************************************************************/
615static  int             AppendDateStr (char     *orig, char *append)
616{
617
618        int             i, j;
619        char    tmp[10];
620
621        /* strip off ':'s and append to the old date string */
622
623        if ((orig == NULL) || (append == NULL))
624        {
625                logit ("", "Invalid arguments passed in.\n");
626                return EW_FAILURE;
627        }
628
629        i = 0;
630        j = 0;
631
632        for (i = 0; i < 11; i++)
633        {
634                if (append[i] == ':')
635                        ;
636                else
637                {
638                        tmp[j] = append[i];
639                        j = j + 1;
640                }
641        }
642        tmp[j] = '\0';
643
644        strcat (orig, tmp);
645
646        return EW_SUCCESS;
647                       
648
649}
650
651/************************************************************************
652 * ParseEllipse () - fill the Ellipse structure from the NSN formatted
653 *   error elipse string
654 ************************************************************************/
655static  int             ParseEllipse (char *str, double depth_err, Err_Elipse *error)
656{
657
658        int             i, j, k, l, index;
659        double  err[9];
660        char    tmp[10];
661
662        if ((str == NULL) || (error == NULL))
663        {
664                logit ("", "Invalid arguments passed in.\n");
665                return EW_FAILURE;
666        }
667
668        /* Extract numbers */
669        i = 0;
670        index = 0;
671        /* Loop over 3 sets of numbers */
672        for (k = 0; k < 3; k++)
673        {
674                /* Loop over 3 numbers in each set */
675                for (l = 0; l < 3; l++)
676                {
677                        j = 0;
678                        while ((i < ELLIPSE_LENGTH) && (str[i] != ',') && (str[i] != ';'))
679                        {
680                                tmp[j] = str[i];
681                                j = j + 1;
682                                i = i + 1;
683                        }
684                       
685                        /* Got a number, convert it */
686                        tmp[j] = '\0';
687                        err[index] = atof (tmp);
688                        index = index + 1;
689                        i = i + 1;
690                }
691        }
692
693
694        /* For some reason, the meaning of the ellipse changes
695         * if depth is fixed:
696         *
697         *   ind 0  =  Semi-major strike
698         *   ind 1  =  Semi-minor strike
699         *   ind 2  =  Intermediate strike
700         *
701         *   ind 3  =  Semi-major dip
702         *   ind 4  =  Semi-minor dip
703         *   ind 5  =  Intermediate dip
704         *
705         *   ind 6  =  Semi-major length
706         *   ind 7  =  Semi-minor length
707         *   ind 8  =  Intermediate length
708         *
709         *  For non-fixed depth, the Semi-minor and intermediate axes
710         *  are swapped.
711         *
712         */
713
714        if (depth_err != 0.0)
715        {
716                error->maj_s = err[0];
717                error->maj_d = err[3];
718                error->maj_l = err[6];
719
720                error->int_s = err[1];
721                error->int_d = err[4];
722                error->int_l = err[7];
723
724                error->min_s = err[2];
725                error->min_d = err[5];
726                error->min_l = err[8];
727        }
728        else
729        {
730                error->maj_s = err[0];
731                error->maj_d = err[3];
732                error->maj_l = err[6];
733
734                error->min_s = err[1];
735                error->min_d = err[4];
736                error->min_l = err[7];
737
738                error->int_s = err[2];
739                error->int_d = err[5];
740                error->int_l = err[8];
741        }
742
743        return EW_SUCCESS;
744
745}
746
747/************************************************************************
748 * ParseMagnitude () - fill the Mag structure from the NSN formatted
749 *   magnitudes string
750 ************************************************************************/
751static  int             ParseMagnitude (char *str, OriginMag *mag)
752{
753
754        char    tmp[10];
755
756        if ((str == NULL) || (mag == NULL))
757        {
758                logit ("", "Invalid arguments passed in.\n");
759                return EW_FAILURE;
760        }
761
762
763        /* HACK: we only know about duration and local mags */
764       
765        /* Mb */
766        mag[0].magLabel = 'b';
767        mag[0].MagType = MAGTYPE_LOCAL_ZERO2PEAK;
768        strncpy (tmp, (str + MB_BASE), MAG_LEN);
769        tmp[MAG_LEN] = '\0';
770        mag[0].magAvg = (double) atof (tmp);
771
772        strncpy (tmp, (str + MB_DATUM), DATUM_LEN);
773        tmp[DATUM_LEN] = '\0';
774        mag[0].numStas = (int) atoi (tmp);
775
776
777        /* ML */
778        mag[1].magLabel = 'L';
779        mag[1].MagType = MAGTYPE_LOCAL_ZERO2PEAK;
780        strncpy (tmp, (str + ML_BASE), MAG_LEN);
781        tmp[MAG_LEN] = '\0';
782        mag[1].magAvg = (double) atof (tmp);
783
784        strncpy (tmp, (str + ML_DATUM), DATUM_LEN);
785        tmp[DATUM_LEN] = '\0';
786        mag[1].numStas = (int) atoi (tmp);
787
788
789        /* Mblg */
790        mag[2].magLabel = 'g';
791        mag[2].MagType = MAGTYPE_LOCAL_ZERO2PEAK;
792        strncpy (tmp, (str + MBLG_BASE), MAG_LEN);
793        tmp[MAG_LEN] = '\0';
794        mag[2].magAvg = (double) atof (tmp);
795
796        strncpy (tmp, (str + MBLG_DATUM), DATUM_LEN);
797        tmp[DATUM_LEN] = '\0';
798        mag[2].numStas = (int) atoi (tmp);
799
800
801        /* Md */
802        mag[3].magLabel = 'd';
803        mag[3].MagType = MAGTYPE_DURATION;
804        strncpy (tmp, (str + MD_BASE), MAG_LEN);
805        tmp[MAG_LEN] = '\0';
806        mag[3].magAvg = (double) atof (tmp);
807
808        strncpy (tmp, (str + MD_DATUM), DATUM_LEN);
809        tmp[DATUM_LEN] = '\0';
810        mag[3].numStas = (int) atoi (tmp);
811
812
813        /* MS */
814        mag[4].magLabel = 'S';
815        mag[4].MagType = MAGTYPE_LOCAL_ZERO2PEAK;
816        strncpy (tmp, (str + MS_BASE), MAG_LEN);
817        tmp[MAG_LEN] = '\0';
818        mag[4].magAvg = (double) atof (tmp);
819
820        strncpy (tmp, (str + MS_DATUM), DATUM_LEN);
821        tmp[DATUM_LEN] = '\0';
822        mag[4].numStas = (int) atoi (tmp);
823
824        return EW_SUCCESS;
825}
826
827/************************************************************************
828 * ParsePhase () - fill the Phase structure from the NSN formatted
829 *   phase string
830 ************************************************************************/
831static  int             ParsePhase (char *str, Phase *phase, char *EventDate, 
832                                                                        int *num_phases, double *Dmin)
833{
834        char    tmp[256];
835        char    datestr[256];
836        int             i, j;
837
838        if ((str == NULL) || (phase == NULL))
839        {
840                logit ("", "Invalid arguments passed in\n");
841                return EW_FAILURE;
842        }
843
844
845        /* ingore phases that don't start with the station name */
846        if (str[1] == ' ')
847        {
848                return EW_SUCCESS;
849        }
850
851
852        strncpy (phase->sta, (str + STA_BASE), STA_LEN);
853        phase->sta[STA_LEN] = '\0';
854
855        strncpy (tmp, (str + PHA_BASE), PHA_LEN);
856        tmp[PHA_LEN] = '\0';
857
858        j = 0;
859        phase->onset = ' ';
860        phase->motion = ' ';
861        for (i = 0; i < PHA_LEN; i++)
862        {
863                if (tmp[i] == '?')
864                        phase->automatic = 1;
865                /* onset codes */
866                else if (tmp[i] == 'i')
867                        phase->onset = 'i';
868                else if (tmp[i] == 'e')
869                        phase->onset = 'e';
870                else if (tmp[i] == 'q')
871                        phase->onset = 'q';
872
873                /* first motion codes */
874                else if (tmp[i] == 'c')
875                        phase->motion = 'c';
876                else if (tmp[i] == 'd')
877                        phase->motion = 'd';
878                else if (tmp[i] == 'u')
879                        phase->motion = 'u';
880                else if (tmp[i] == 'r')
881                        phase->motion = 'r';
882                else if (tmp[i] == ' ')
883                        ;
884
885                /* part of the phase code */
886                else
887                {
888                        phase->phase[j] = tmp[i];
889                        j = j + 1;
890                }
891        }
892
893        if (j >= PHA_LEN)
894        {
895                logit ("e", "MAX Phase length (%d) exceeded!\n", PHA_LEN);
896                return EW_FAILURE;
897        }
898        phase->phase[j] = '\0';
899
900        strncpy (tmp, (str + OT_BASE), OT_LEN);
901        tmp[OT_LEN] = '\0';
902
903        strcpy (datestr, EventDate);
904        if (AppendDateStr (datestr, tmp) != EW_SUCCESS)
905        {
906                logit ("", "Call to AppendDateStr failed.\n");
907                return EW_FAILURE;
908        }
909        epochsec17 (&phase->ot, datestr);
910
911
912        strncpy (tmp, (str + RES_BASE), RES_LEN);
913        tmp[RES_LEN] = '\0';
914        phase->res = (double) atof (tmp);
915
916        if (str[RES_USED] == 'X')
917                phase->res_used = 1;
918        else
919                phase->res_used = 0;
920
921        strncpy (tmp, (str + DIST_BASE), DIST_LEN);
922        tmp[DIST_LEN] = '\0';
923        phase->dist = (double) atof (tmp);
924
925        /* convert from degrees to km */
926        phase->dist = (phase->dist * EARTH_CIRCUM)/360.0;
927
928        if (phase->dist <= *Dmin)
929        {
930                *Dmin = phase->dist;
931        }
932
933        strncpy (tmp, (str + AZM_BASE), AZM_LEN);
934        tmp[AZM_LEN] = '\0';
935        phase->azm = (int) atoi (tmp);
936
937
938        /* magnitudes */
939        phase->num_mags = 0;
940        if (str[MAG1_BASE] != ' ')
941        {
942                if (ParsePhaseMagnitude ((str+MAG1_BASE), &phase->mag[0]) != EW_SUCCESS)
943                {
944                        logit ("", "Call to ParsePhaseMagnitude failed\n");
945                        return EW_FAILURE;
946                }
947                phase->num_mags = phase->num_mags + 1;
948
949        }
950        if (str[MAG2_BASE] != ' ')
951        {
952
953                if (ParsePhaseMagnitude ((str+MAG2_BASE), &phase->mag[1]) != EW_SUCCESS)
954                {
955                        logit ("", "Call to ParsePhaseMagnitude failed\n");
956                        return EW_FAILURE;
957                }
958                phase->num_mags = phase->num_mags + 1;
959        }
960
961        *num_phases = *num_phases + 1;
962        return EW_SUCCESS;
963}
964
965/************************************************************************
966 * ParsePhaseMagnitude () - fill the PhaseMag structure from the NSN
967 *   formatted phase string
968 ************************************************************************/
969static  int             ParsePhaseMagnitude (char *str, PhaseMag *mag)
970{
971        char    *ptr;
972        char    tmp[5];
973        int             expn, mult;
974        mult = 0;
975
976        if ((str == NULL) || (mag == NULL))
977        {
978                logit ("", "Invalid arguments passed in\n");
979                return EW_FAILURE;
980        }
981
982
983        /* Hack: we only know duration and local mags */
984        mag->magLabel = str[0];
985        if (mag->magLabel == 'b')
986                mag->MagType = MAGTYPE_LOCAL_ZERO2PEAK;
987        else if (mag->magLabel == 'L')
988                mag->MagType = MAGTYPE_LOCAL_ZERO2PEAK;
989        else if (mag->magLabel == 'g') /* HACK -- we don't have Mblg type yet */
990                mag->MagType = MAGTYPE_LOCAL_ZERO2PEAK;
991        else if (mag->magLabel == 'd')
992                mag->MagType = MAGTYPE_DURATION;
993        else if (mag->magLabel == 'S')
994                mag->MagType = MAGTYPE_LOCAL_ZERO2PEAK;
995        else
996        {
997                logit ("", "Invalid magnitude type: %c\n", mag->magLabel);
998                return EW_FAILURE;
999        }
1000
1001        ptr = str + 2;
1002        strncpy (tmp, ptr, 3);
1003        tmp[3] = '\0';
1004        mag->value = (double) atof (tmp);
1005
1006        ptr = ptr + 3;
1007        if (ptr[0] == '+')
1008                mult = 1;
1009        else if (ptr[0] == '-')
1010                mult = -1;
1011
1012        ptr = ptr + 1;
1013        strncpy (tmp, ptr, 1);
1014        tmp[1] = '\0';
1015        expn = mult * ((int) atoi (tmp));
1016        mag->value = (double) (mag->value * pow (10.0, (double) expn));
1017
1018        ptr = ptr + 1;
1019        strncpy (tmp, ptr, 4);
1020        tmp[4] = '\0';
1021        mag->period = (double) atof (tmp);
1022
1023        ptr = ptr + 5;
1024        strncpy (tmp, ptr, 3);
1025        tmp[3] = '\0';
1026        mag->mag = (double) atof (tmp);
1027
1028        ptr = ptr + 3;
1029
1030        if (ptr[0] != 'X')
1031                mag->used = 1;
1032        else
1033                mag->used = 0;
1034
1035
1036        return EW_SUCCESS;
1037
1038}
Note: See TracBrowser for help on using the repository browser.