source: trunk/src/libsrc/util/rw_strongmotionII.c @ 8019

Revision 8019, 27.5 KB checked in by kevin, 3 months ago (diff)

Added Arias Intensity and ColorPGA option

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/* rw_strongmotionII.c
2 *
3 * Contains functions in that convert from a
4 * TYPE_STRONGMOTION message to a structure and visa versa.
5 *
6 * written by Lynn Dietz   October, 1999
7 */
8
9#include <stdio.h>
10#include <string.h>
11#include <time.h>
12
13#include "earthworm.h"
14#include "chron3.h"
15#include "time_ew.h"
16#include "rw_strongmotionII.h"
17
18#define ABS(X) (((X) >= 0) ? (X) : -(X))
19
20static int   strappend( char *s1, int s1max, char *s2 );
21static char *datestr24( double t, char *pbuf, int len );
22static int   addtimestr( char *buf, int buflen, double t );
23
24#if 0
25static int   tokenlength( char *begtok, char c );
26#endif
27
28static char *sNullDate = "0000/00/00 00:00:00.000";
29static char *sUnknown  = "?";
30#define SMLINE 512
31
32/* Where we are in the message */
33#define HAVE(ln) (ln&smState)
34#define SM_SCNL 1<<0
35#define SM_TIME 1<<1
36#define SM_ALT  1<<2
37#define SM_PGA  1<<3
38#define SM_PGV  1<<4
39#define SM_PGD  1<<5
40#define SM_RSA  1<<6
41#define SM_QID  1<<7
42#define SM_AI   1<<8
43#define SM_ALL (SM_SCNL | SM_TIME | SM_ALT | SM_PGA | SM_PGV | SM_PGD | SM_RSA | SM_QID | SM_AI)
44#define SM_REQ (SM_SCNL | SM_TIME)
45
46/*************************************************************
47 * sm_init()                                                 *
48 * Initialize a SM_INFO structure in an appropriate fashion. *
49 *************************************************************/
50static void sm_init( SM_INFO *sm)
51{
52    memset( sm, 0, sizeof(SM_INFO) );     /* zero output structure */
53    sm->altcode = SM_ALTCODE_NONE;
54    sm->pga = SM_NULL;
55    sm->pgv = SM_NULL;
56    sm->pgd = SM_NULL;
57   
58    return;
59}
60
61/********************************************************************
62 * rd_strongmotionII()                                              *
63 * Reads an one ascii TYPE_STRONGMOTION2 message and fills in a     *
64 * SM_INFO structure.                                               *
65 * Since there may be more than one TYPE_STRONGMOTION2 message in   *
66 * a buffer, pass in a pointer to the message buffer. On return,    *
67 * this pointer will get moved to the start of the next message,    *
68 * or to the position of the terminating NULL byte if there is no   *
69 * following message.                                               *
70 * Returns: 1 on success                                            *
71 *          0 on no message found                                   *
72 *         -1 on failure                                            *
73 ********************************************************************/
74int rd_strongmotionII( char **msgP, SM_INFO *sm, int logErr)
75{
76   char     line[SMLINE]; /* pointer to current line in msg */
77   char     *nextline;  /* working pointer into msg */
78   int       i;
79   struct tm stm;       /* time structure for timestamp */
80   time_t    tsec;      /* timestamp in whole sec since 1970 */   
81   int       msec;      /* thousandths of seconds field of timestamp */
82   int       smState;   /* keep track of our message state */
83   int       status; 
84
85   nextline = *msgP;
86   smState = 0;
87   status = 0;
88   /* Loop over lines in the message */
89   while( nextline && *nextline )
90   {
91       char *lineP, *mP;
92       char *token;
93       int lc;
94
95       /* Read a line from the message into working buffer, without overflow */
96       lineP = line;
97       for (mP = nextline, lc = 0; 
98            *mP && *mP != '\n' && lc < SMLINE-1; 
99            mP++, lineP++, lc++) {
100           *lineP = *mP;
101       }
102       if (line[lc-1] == '\r') lc--;
103       line[lc++] = '\n'; /* terminate with newline, for strtok */
104       line[lc] = '\0';
105       /* Did we get to the end of the line in our message? */
106       if (lc == SMLINE -1 ) {
107           if (logErr)
108               logit("t", "SM message long line truncated: <%s>\n", line);
109           for ( ; *mP && *mP != '\n'; mP++) {
110               /* skip to end of line */
111           }
112       }
113       /* Don't advance nextline pointer until         *
114        * we're sure we will process this current line */
115
116       /* We have a copy of the line, chop it into tokens */
117       if (strlen(line)==0) goto NextLine;
118       token = strtok(line, " \t");
119       if (token == NULL) {
120           if (logErr)
121               logit("t", "no token found in SM line <%s>\n", line);
122           status = -1;
123           goto NextLine;
124       }
125       
126       /* We are looking for the SCNL line that starts a message */
127       if (strcmp(token, "SCNL:") == 0) {
128           if (! HAVE(SM_SCNL) ) {
129               sm_init(sm);  /* initialize for new SM message */
130               smState = 0;  /* reset state for new SM message */
131               
132               token = strtok(NULL, ".");
133               if (token == NULL) {
134                   if (logErr) 
135                       logit("t", "error parsing SCNL from SM line <%s>\n", line);
136                   status = -1;
137                   goto NextLine;
138               }
139               if( strlen(token) >= TRACE_STA_LEN ) {
140                   if (logErr)
141                       logit("t", "station name <%s> too long; max %d\n",
142                             token, TRACE_STA_LEN);
143                   status = -1;
144                   goto NextLine;
145               }
146               strcpy( sm->sta, token); 
147               token = strtok(NULL, ".");
148               if (token == NULL) {
149                   if (logErr) 
150                       logit("t", "error parsing SCNL from SM line <%s>\n", line);
151                   status = -1;
152                   goto NextLine;
153               }
154               if( strlen(token) >= TRACE_CHAN_LEN ) {
155                   if (logErr)
156                       logit("t", "channel name <%s> too long; max %d\n", 
157                             token, TRACE_CHAN_LEN);
158                   status = -1;
159                   goto NextLine;
160               }
161               strcpy( sm->comp, token ); 
162               token = strtok(NULL, ".");
163               if (token == NULL) {
164                   if (logErr) 
165                       logit("t", "error parsing SCNL from SM line <%s>\n", line);
166                   status = -1;
167                   goto NextLine;
168               }
169               if( strlen(token) >= TRACE_NET_LEN ) {
170                   if (logErr)
171                       logit("t", "network name <%s> too long; max %d\n",
172                             token, TRACE_NET_LEN);
173                   status = -1;
174                   goto NextLine;
175               }
176               strcpy( sm->net, token );
177               /* location code might be empty, so we treat this differently */
178               token += strlen(token) + 1;
179               if ( *token == '\n' || *token == ' ' || *token == '\t' ) {
180                   sm->loc[0] = '\0';
181               } else {
182                   token = strtok(NULL, " \t\n");
183                   if (token == NULL) {
184                       if (logErr) 
185                           logit("t", "error parsing SM SCNL line <%s>\n", line);
186                       status = -1;
187                       goto NextLine;
188                   }
189                   if( strlen(token) >= TRACE_LOC_LEN ) {
190                       if (logErr)
191                           logit("t", "location name <%s> too long; max %d\n",
192                                 token, TRACE_LOC_LEN);
193                       status = -1;
194                       goto NextLine;
195                   }
196                   strcpy( sm->loc, token );
197                   if (sm->loc[0] == '-' || sm->loc[0] == '?')
198                       sm->loc[0] = '\0';
199               }
200               
201               smState |= SM_SCNL;
202
203               /* There might be more on this line, but we ignore it today */
204
205           } else {
206               /* We found another SCNL line, so we past the end of our message */
207               if ( ! HAVE(SM_REQ) ) {
208                   if (logErr) 
209                       logit("t", "incomplete SM message for <%s.%s.%s.%s>\n",
210                             sm->sta, sm->comp, sm->net, sm->loc);
211                   status = -1;
212               }
213               goto LastLine;
214           }
215           /* end of SCNL line processing */
216       }
217       else if (strcmp(token, "TIME:") == 0) {
218           if (HAVE(SM_SCNL) ) {
219               memset( &stm, 0, sizeof(struct tm) );
220               token = strtok(NULL, " ");
221               if (token == NULL) {
222                   if (logErr) 
223                       logit("t", "error parsing SM TIME line <%s>\n", line);
224                   status = -1;
225                   goto NextLine;
226               }
227               if( sscanf( token, "%d/%d/%d", 
228                           &stm.tm_year, &stm.tm_mon, &stm.tm_mday) != 3) {
229                   if (logErr) 
230                       logit("t", "error parsing date from <%s>\n", line);
231                   status = -1;
232                   goto NextLine;
233               }
234               token = strtok(NULL, " \t\n");
235               if (token == NULL) {
236                   if (logErr) 
237                       logit("t", "error parsing SM TIME line <%s>\n", line);
238                   status = -1;
239                   goto NextLine;
240               }
241               if ( sscanf( token, "%d:%d:%d.%d", &stm.tm_hour,
242                  &stm.tm_min, &stm.tm_sec, &msec ) != 4 ) {
243                   if (logErr) 
244                       logit("t", "error parsing date from <%s>\n", line);
245                   status = -1;
246                   goto NextLine;
247               }
248               stm.tm_year -= 1900;  /* convert to definition of struct tm */
249               stm.tm_mon  -= 1;     /* convert to definition of struct tm */
250               tsec  = timegm( &stm );
251               sm->t = (double)tsec + 0.001*(double)msec;
252               smState |= SM_TIME;
253           } else {
254               /* still looking for SCNL line to start message */
255               goto NextLine;
256           }
257           /* End of TIME line processing */
258       }
259       else if ( strcmp(token, "ALT:") == 0) {
260           if (HAVE(SM_SCNL) ) {
261               memset( &stm, 0, sizeof(struct tm) );
262               token = strtok(NULL, " \t");
263               if (token == NULL) {
264                   if (logErr) 
265                       logit("t", "error parsing SM ALT line <%s>\n", line);
266                   status = -1;
267                   goto NextLine;
268               }
269               if( sscanf( token, "%d/%d/%d", 
270                           &stm.tm_year, &stm.tm_mon, &stm.tm_mday) != 3) {
271                   if (logErr) 
272                       logit("t", "error parsing date from <%s>\n", line);
273                   status = -1;
274                   goto NextLine;
275               }
276               token = strtok(NULL, " \t");
277               if (token == NULL) {
278                   if (logErr) 
279                       logit("t", "error parsing SM ALT line <%s>\n", line);
280                   status = -1;
281                   goto NextLine;
282               }
283               if ( sscanf( token, "%d:%d:%d.%d", &stm.tm_hour,
284                  &stm.tm_min, &stm.tm_sec, &msec ) != 4 ) {
285                   if (logErr) 
286                       logit("t", "error parsing date from <%s>\n", line);
287                   status = -1;
288                   goto NextLine;
289               }
290               token = strtok(NULL, " \t");
291               if (token == NULL) {
292                   if (logErr) 
293                       logit("t", "error parsing SM ALT line <%s>\n", line);
294                   status = -1;
295                   goto NextLine;
296               }
297               if (strcmp(token, "CODE:") != 0) {
298                   if (logErr) 
299                       logit("t", "error parsing SM ALT line <%s>\n", line);
300                   status = -1;
301                   goto NextLine;
302               }
303               token = strtok(NULL, " \t\n");
304               if (token == NULL) {
305                   if (logErr) 
306                       logit("t", "error parsing SM ALT line <%s>\n", line);
307                   status = -1;
308                   goto NextLine;
309               }
310               if ( sscanf( token, "%d", &sm->altcode) != 1 ) {
311                   if (logErr) 
312                       logit("t", "error parsing ALT code from <%s>\n", line);
313                   status = -1;
314                   goto NextLine;
315               }
316               stm.tm_year -= 1900;  /* convert to definition of struct tm */
317               stm.tm_mon  -= 1;     /* convert to definition of struct tm */
318               tsec  = timegm( &stm );
319               sm->talt = (double)tsec + 0.001*(double)msec;
320               smState |= SM_ALT;
321           } else {
322               /* still looking for SCNL line to start message */
323               goto NextLine;
324           }
325           /* End of ALT line processing */
326       }
327       else if (strcmp(token, "PGA:") == 0) {
328           if (HAVE(SM_SCNL) ) {
329               token = strtok(NULL, " \t");
330               if (token == NULL) {
331                   if (logErr) 
332                       logit("t", "error parsing SM PGA line <%s>\n", line);
333                   status = -1;
334                   goto NextLine;
335               }
336               if( sscanf( token, "%lf", &sm->pga) != 1) {
337                   if (logErr) 
338                       logit("t", "error parsing PGA from <%s>\n", line);
339                   status = -1;
340                   goto NextLine;
341               }
342               memset( &stm, 0, sizeof(struct tm) );
343               token = strtok(NULL, " \t");
344               if (token == NULL) {
345                   if (logErr) 
346                       logit("t", "error parsing SM PGA line <%s>\n", line);
347                   status = -1;
348                   goto NextLine;
349               }
350               if (strcmp(token, "TPGA:") != 0) {
351                   if (logErr) 
352                       logit("t", "error parsing SM PGA line <%s>\n", line);
353                   status = -1;
354                   goto NextLine;
355               }
356               token = strtok(NULL, " \t");
357               if (token == NULL) {
358                   if (logErr) 
359                       logit("t", "error parsing SM PGA line <%s>\n", line);
360                   status = -1;
361                   goto NextLine;
362               }
363               if( sscanf( token, "%d/%d/%d", 
364                           &stm.tm_year, &stm.tm_mon, &stm.tm_mday) != 3) {
365                   if (logErr) 
366                       logit("t", "error parsing date from <%s>\n", line);
367                   status = -1;
368                   goto NextLine;
369               }
370               token = strtok(NULL, " \t\n");
371               if (token == NULL) {
372                   if (logErr) 
373                       logit("t", "error parsing SM PGA line <%s>\n", line);
374                   status = -1;
375                   goto NextLine;
376               }
377               if ( sscanf( token, "%d:%d:%d.%d", &stm.tm_hour,
378                  &stm.tm_min, &stm.tm_sec, &msec ) != 4 ) {
379                   if (logErr) 
380                       logit("t", "error parsing date from <%s>\n", line);
381                   status = -1;
382                   goto NextLine;
383               }
384               if( stm.tm_year == 0 ) {
385                   sm->tpga = 0.0;
386               } else {
387                   stm.tm_year -= 1900;
388                   stm.tm_mon  -= 1;
389                   tsec  = timegm( &stm );
390                   sm->tpga = (double)tsec + 0.001*(double)msec;
391               }
392               smState |= SM_PGA;
393           } else {
394               /* still looking for SCNL line to start message */
395               goto NextLine;
396           }
397           /* End of PGA line processing */
398       }
399       else if (strcmp(token, "PGV:") == 0) {
400           if (HAVE(SM_SCNL) ) {
401               token = strtok(NULL, " \t");
402               if (token == NULL) {
403                   if (logErr) 
404                       logit("t", "error parsing SM PGV line <%s>\n", line);
405                   status = -1;
406                   goto NextLine;
407               }
408               if( sscanf( token, "%lf", &sm->pgv) != 1) {
409                   if (logErr) 
410                       logit("t", "error parsing PGV from <%s>\n", line);
411                   status = -1;
412                   goto NextLine;
413               }
414               memset( &stm, 0, sizeof(struct tm) );
415               token = strtok(NULL, " \t");
416               if (token == NULL) {
417                   if (logErr) 
418                       logit("t", "error parsing SM PGV line <%s>\n", line);
419                   status = -1;
420                   goto NextLine;
421               }
422               if (strcmp(token, "TPGV:") != 0) {
423                   if (logErr) 
424                       logit("t", "error parsing SM PGV line <%s>\n", line);
425                   status = -1;
426                   goto NextLine;
427               }
428               token = strtok(NULL, " \t");
429               if (token == NULL) {
430                   if (logErr) 
431                       logit("t", "error parsing SM PGV line <%s>\n", line);
432                   status = -1;
433                   goto NextLine;
434               }
435               if( sscanf( token, "%d/%d/%d", 
436                           &stm.tm_year, &stm.tm_mon, &stm.tm_mday) != 3) {
437                   if (logErr) 
438                       logit("t", "error parsing date from <%s>\n", line);
439                   status = -1;
440                   goto NextLine;
441               }
442               token = strtok(NULL, " \t\n");
443               if (token == NULL) {
444                   if (logErr) 
445                       logit("t", "error parsing SM PGV line <%s>\n", line);
446                   status = -1;
447                   goto NextLine;
448               }
449               if ( sscanf( token, "%d:%d:%d.%d", &stm.tm_hour,
450                  &stm.tm_min, &stm.tm_sec, &msec ) != 4 ) {
451                   if (logErr) 
452                       logit("t", "error parsing date from <%s>\n", line);
453                   status = -1;
454                   goto NextLine;
455               }
456               if( stm.tm_year == 0 ) {
457                   sm->tpgv = 0.0;
458               } else {
459                   stm.tm_year -= 1900;
460                   stm.tm_mon  -= 1;
461                   tsec  = timegm( &stm );
462                   sm->tpgv = (double)tsec + 0.001*(double)msec;
463               }
464               smState |= SM_PGV;
465           } else {
466               /* still looking for SCNL line to start message */
467               goto NextLine;
468           }
469           /* End of PGV line processing */
470       }
471       else if (strcmp(token, "PGD:") == 0) {
472           if (HAVE(SM_SCNL) ) {
473               token = strtok(NULL, " \t");
474               if (token == NULL) {
475                   if (logErr) 
476                       logit("t", "error parsing SM PGD line <%s>\n", line);
477                   status = -1;
478                   goto NextLine;
479               }
480               if( sscanf( token, "%lf", &sm->pgd) != 1) {
481                   if (logErr) 
482                       logit("t", "error parsing PGD from <%s>\n", line);
483                   status = -1;
484                   goto NextLine;
485               }
486               memset( &stm, 0, sizeof(struct tm) );
487               token = strtok(NULL, " \t");
488               if (token == NULL) {
489                   if (logErr) 
490                       logit("t", "error parsing SM PGD line <%s>\n", line);
491                   status = -1;
492                   goto NextLine;
493               }
494               if (strcmp(token, "TPGD:") != 0) {
495                   if (logErr) 
496                       logit("t", "error parsing SM PGD line <%s>\n", line);
497                   status = -1;
498                   goto NextLine;
499               }
500               token = strtok(NULL, " \t");
501               if (token == NULL) {
502                   if (logErr) 
503                       logit("t", "error parsing SM PGD line <%s>\n", line);
504                   status = -1;
505                   goto NextLine;
506               }
507               if( sscanf( token, "%d/%d/%d", 
508                           &stm.tm_year, &stm.tm_mon, &stm.tm_mday) != 3) {
509                   if (logErr) 
510                       logit("t", "error parsing date from <%s>\n", line);
511                   status = -1;
512                   goto NextLine;
513               }
514               token = strtok(NULL, " \t\n");
515               if (token == NULL) {
516                   if (logErr) 
517                       logit("t", "error parsing SM PGD line <%s>\n", line);
518                   status = -1;
519                   goto NextLine;
520               }
521               if ( sscanf( token, "%d:%d:%d.%d", &stm.tm_hour,
522                  &stm.tm_min, &stm.tm_sec, &msec ) != 4 ) {
523                   if (logErr) 
524                       logit("t", "error parsing date from <%s>\n", line);
525                   status = -1;
526                   goto NextLine;
527               }
528               if( stm.tm_year == 0 ) {
529                   sm->tpgd = 0.0;
530               } else {
531                   stm.tm_year -= 1900;
532                   stm.tm_mon  -= 1;
533                   tsec  = timegm( &stm );
534                   sm->tpgd = (double)tsec + 0.001*(double)msec;
535               }
536               smState |= SM_PGD;
537           } else {
538               /* still looking for SCNL line to start message */
539               goto NextLine;
540           }
541           /* End of PGD line processing */
542       }
543       else if (strcmp(token, "RSA:") == 0) {
544           if (HAVE(SM_SCNL) ) {
545               token = strtok(NULL, "/");
546               if (token == NULL) {
547                   if (logErr) 
548                       logit("t", "error parsing SM RSA line <%s>\n", line);
549                   status = -1;
550                   goto NextLine;
551               }
552               if( sscanf( token, "%d", &sm->nrsa) != 1) {
553                   if (logErr) 
554                       logit("t", "error parsing RSA from <%s>\n", line);
555                   status = -1;
556                   goto NextLine;
557               }
558               for (i = 0; i < sm->nrsa; i++) {
559                   token = strtok(NULL, "/");
560                   if (token == NULL) {
561                       if (logErr) 
562                           logit("t", "error parsing SM RSA line <%s>\n", line);
563                       status = -1;
564                       goto NextLine;
565                   }
566                   if( sscanf( token, "%lf %lf", 
567                               &(sm->pdrsa[i]), &(sm->rsa[i]) ) != 2 ) {
568                       if (logErr) 
569                           logit("t", "error parsing RSA from <%s>\n", line);
570                       status = -1;
571                       goto NextLine;
572                   }
573               }
574               smState |= SM_RSA;
575           } else {
576               /* still looking for SCNL line to start message */
577               goto NextLine;
578           }
579           /* End of RSA line processing */
580       }
581       else if (strcmp(token, "QID:") == 0) {
582           if (HAVE(SM_SCNL) ) {
583               token = strtok(NULL, " ");
584               if (token == NULL) {
585                   if (logErr) 
586                       logit("t", "error parsing SM QID line <%s>\n", line);
587                   status = -1;
588                   goto NextLine;
589               }
590               if (strlen(token) >= EVENTID_SIZE) {
591                   if (logErr) 
592                       logit("t", "event id too long in QID line <%s>, max %d\n",
593                             line, EVENTID_SIZE-1);
594                   status = -1;
595                   goto NextLine;
596               }
597               if( strcmp(token, sUnknown)==0 ||
598                   strcmp(token, "-"     )==0   )  /* CGS's NULL string */
599                   sm->qid[0] = '\0';
600               else
601                   strcpy(sm->qid, token);
602
603               token = strtok(NULL, " \n");
604               if (token == NULL) {
605                   if (logErr) 
606                       logit("t", "error parsing SM QID line <%s>\n", line);
607                   status = -1;
608                   goto NextLine;
609               }
610               if (strlen(token) >= EVENTID_SIZE) {
611                   if (logErr) 
612                       logit("t", "author id too long in QID line <%s>, max %d\n",
613                             line, AUTHOR_FIELD_SIZE-1);
614                   status = -1;
615                   goto NextLine;
616               }
617               if (strcmp(token, sUnknown)==0 ||
618                   strcmp(token, "-"     )==0   )  /* CGS's NULL string */
619                   sm->qauthor[0] = '\0';
620               else
621                   strcpy(sm->qauthor, token);
622               smState |= SM_QID;
623           } else {
624               /* still looking for SCNL line to start message */
625               goto NextLine;
626           }
627           /* End of QID line processing */
628       }
629       else if (strcmp(token, "AI:") == 0) {
630           if (HAVE(SM_SCNL) ) {
631               token = strtok(NULL, " \n");
632               if (token == NULL) {
633                   if (logErr) 
634                       logit("t", "error parsing SM AI line <%s>\n", line);
635                   status = -1;
636                   goto NextLine;
637               }
638               if( sscanf( token, "%lf", &sm->ai) != 1) {
639                   if (logErr) 
640                       logit("t", "error parsing AI from <%s>\n", line);
641                   status = -1;
642                   goto NextLine;
643               }
644               smState |= SM_AI;
645           } else {
646               /* still looking for SCNL line to start message */
647               goto NextLine;
648           }
649           /* End of AI line processing */
650       } else {
651           /* unknown line; skip it for now */
652           goto NextLine;
653       }
654
655   NextLine:
656       nextline = mP+1;
657   } /* end of loop over message */
658       
659 LastLine:
660   *msgP = nextline;
661   if (HAVE(SM_REQ) )
662       status = 1;
663   
664   return( status );
665}
666
667/********************************************************************
668 * wr_strongmotionII()                                              *
669 * Reads a SM_INFO structure and writes an ascii TYPE_STRONGMOTION2 *
670 * message (null terminated)                                        *
671 * Returns 0 on success, -1 on failure (buffer overflow)            *
672 ********************************************************************/
673int wr_strongmotionII( SM_INFO *sm, char *buf, int buflen )
674{
675   char     tmp[256]; /* working buffer */
676   char    *qid;
677   char    *qauthor;
678   int      i;
679
680   memset( buf, 0, (size_t)buflen );    /* zero output buffer */
681
682/* channel codes */
683   sprintf( buf, "SCNL: %s.%s.%s.%s", 
684            sm->sta, sm->comp, sm->net, sm->loc );
685
686/* field time */
687   if( strappend( buf, buflen, "\nTIME: " ) ) return ( -1 );
688   datestr24( sm->t, tmp, 256 ); 
689   if( strappend( buf, buflen, tmp ) ) return( -1 );
690
691/* alternate time & its code */
692   if( strappend( buf, buflen, "\nALT: " ) ) return ( -1 );
693   if( addtimestr( buf, buflen, sm->talt ) ) return ( -1 );
694   sprintf( tmp, " CODE: %d", sm->altcode );
695   if( strappend( buf, buflen, tmp ) ) return( -1 );
696
697/* Print peak acceleration value & time */
698   sprintf( tmp, "\nPGA: %.6lf TPGA: ", (sm->pga!=SM_NULL ? ABS(sm->pga) : sm->pga) );
699   if( strappend( buf, buflen, tmp ) ) return( -1 );
700   if( addtimestr( buf, buflen, sm->tpga ) ) return ( -1 );
701     
702/* Print peak velocity value & time */
703   sprintf( tmp, "\nPGV: %.6lf TPGV: ", (sm->pgv!=SM_NULL ? ABS(sm->pgv) : sm->pgv) );
704   if( strappend( buf, buflen, tmp ) ) return( -1 );
705   if( addtimestr( buf, buflen, sm->tpgv ) ) return ( -1 );
706     
707/* Print peak displacement value & time */
708   sprintf( tmp, "\nPGD: %.6lf TPGD: ", (sm->pgd!=SM_NULL ? ABS(sm->pgd) : sm->pgd) );
709   if( strappend( buf, buflen, tmp ) ) return( -1 );
710   if( addtimestr( buf, buflen, sm->tpgd ) ) return ( -1 );
711
712/* Print the response spectrum */
713   sprintf( tmp, "\nRSA: %d", sm->nrsa );
714   if( strappend( buf, buflen, tmp ) ) return( -1 );
715   for( i=0; i<sm->nrsa; i++ )
716   {
717     sprintf( tmp, "/%.2lf %.6lf", sm->pdrsa[i], sm->rsa[i] );
718     if( strappend( buf, buflen, tmp ) ) return( -1 );
719   }   
720
721/* Print the eventid & event author */
722   qid     = sm->qid;
723   qauthor = sm->qauthor;
724   if( strlen(qid)     == 0 ) qid     = sUnknown;
725   if( strlen(qauthor) == 0 ) qauthor = sUnknown;
726   sprintf( tmp, "\nQID: %s %s\n", qid, qauthor );
727   if( strappend( buf, buflen, tmp ) ) return( -1 );
728
729/* Print the AI (Arias Intensity) */
730   if( sm->ai != 0. )
731   {
732     sprintf( tmp, "AI: %.6lf\n", sm->ai );
733     if( strappend( buf, buflen, tmp ) ) return( -1 );
734   }
735
736   return( 0 );
737}
738
739
740
741/********************************************************************
742 * log_strongmotionII()                                             *
743 * Writes the contents of a SM_INFO structure to an Earthworm       *
744 * log file                                                         *
745 ********************************************************************/
746void log_strongmotionII( SM_INFO *sm )
747{
748   char date[30];
749   int  i;
750
751   logit("", "SCNL: %s.%s.%s.%s\n", 
752           sm->sta, sm->comp, sm->net, sm->loc );
753 
754/* Log time values */
755   datestr24( sm->t, date, 30 );
756   logit("", "Time: %s  (%.3lf)\n", date, sm->t );
757   datestr24( sm->talt, date, 30 );
758   logit("", "Alt:  %s  (%.3lf)  code: %d\n", 
759            date, sm->talt, sm->altcode );
760
761
762/* Print peak acceleration values */
763   datestr24( sm->tpga, date, 30 );
764   logit("", "PGA: %.6lf  TGPA: %s (%.3lf)\n",
765            sm->pga, date, sm->tpga );
766     
767/* Print peak velocity values */
768   datestr24( sm->tpgv, date, 30 );
769   logit("", "PGV: %.6lf  TGPV: %s (%.3lf)\n",
770            sm->pgv, date, sm->tpgv );
771
772/* Print peak displacement values */
773   datestr24( sm->tpgd, date, 30 );
774   logit("", "PGD: %.6lf  TGPD: %s (%.3lf)\n",
775            sm->pgd, date, sm->tpgd );
776
777
778/* Print number of points in the response spectrum */
779   logit("","RSA: %d ", sm->nrsa );
780   for( i=0; i<sm->nrsa; i++ )
781   {
782      logit("", " /%.2lf %.6lf", sm->pdrsa[i], sm->rsa[i] );
783   }   
784
785/* Print eventid & author */
786   logit("","\nQID: %s %s\n", sm->qid, sm->qauthor);
787
788/* Print the AI (Arias Intensity) */
789   if( sm->ai != 0. )
790   {
791     logit("","AI: %.6lf\n", sm->ai );
792   }
793
794   return;
795}
796
797
798/**********************************************************
799 * Converts time (double, seconds since 1970:01:01) to    *
800 * a 23-character, null-terminated string in the form of  *
801 *            yyyy/mm/dd hh:mm:ss.sss                     *
802 * Time is displayed in UTC                               *
803 * Target buffer must be 24-chars long to have room for   *
804 * null-character                                         *
805 **********************************************************/
806char *datestr24( double t, char *pbuf, int len )
807{
808   time_t    tt;       /* time as time_t                  */
809   struct tm stm;      /* time as struct tm               */
810   int       t_msec;   /* milli-seconds part of time      */
811
812/* Make sure target is big enough
813 ********************************/
814   if( len < 24 ) return( (char *)NULL );
815
816/* Convert double time to other formats
817 **************************************/
818   t += 0.0005;  /* prepare to round to the nearest 1000th */
819   tt     = (time_t) t;
820   t_msec = (int)( (t - tt) * 1000. );
821   gmtime_ew( &tt, &stm );
822
823/* Build character string
824 ************************/
825   sprintf( pbuf,
826           "%04d/%02d/%02d %02d:%02d:%02d.%03d",
827            stm.tm_year+1900,
828            stm.tm_mon+1,
829            stm.tm_mday,
830            stm.tm_hour,
831            stm.tm_min,
832            stm.tm_sec,
833            t_msec );
834
835   return( pbuf );
836}
837
838
839/********************************************************************
840 * addtimestr() append a date string to the end of existing string  *
841 *   Return -1 if result would overflow the target,                 *
842 *           0 if everything went OK                                *
843 ********************************************************************/
844int addtimestr( char *buf, int buflen, double t )
845{
846   char tmp[30];
847
848   if( t == 0.0 )
849   {
850     if( strappend( buf, buflen, sNullDate ) ) return( -1 );
851   } else {
852     datestr24( t, tmp, 30 ); 
853     if( strappend( buf, buflen, tmp ) ) return( -1 );
854   }
855   return( 0 );
856}
857
858/********************************************************************
859 * strappend() append second null-terminated character string to    *
860 * the first as long as there's enough room in the target buffer    *
861 * for both strings and the null-byte                               *
862 ********************************************************************/
863int strappend( char *s1, int s1max, char *s2 )
864{
865   if( (int)strlen(s1)+(int)strlen(s2)+1 > s1max ) return( -1 );
866   strcat( s1, s2 );
867   return( 0 );
868}
869
870/********************************************************************
871 * tokenlength() given a null-terminated character string and a     *
872 * character that delimits the end of a token, tokenlength returns  *
873 * the length (in bytes) of the next token. If the character wasn't *
874 * found, tokenlength returns the length of the string.             *
875 ********************************************************************/
876
877#if 0
878
879int tokenlength( char *begtok, char c )
880{
881   char    *endtok;   /* points to the end of this token */
882
883   endtok = strchr( begtok, c );
884   if( endtok == NULL ) return( (int)strlen(begtok) );
885   return( (int)(endtok-begtok) );
886}
887
888#endif
889
890/* Sample TYPE_STRONGMOTION2 message (between ------):
891------------------------------------------------
892SCNL: CMB.BHZ.BK.
893TIME: 2001/02/25 02:37:00.000
894ALT:  2001/02/25 02:40:40.000 CODE: 1
895PGA: 6.846210 TPGA: 2001/02/25 02:37:00.000
896PGV: 0.140000 TPGV: 2001/02/25 02:37:00.000
897PGD: 0.000000 TPGD: 2001/02/25 02:37:00.000
898RSA: 3/0.30 4.415404/1.00 0.925639/3.00 0.297907
899QID: 41059467 014024003:UCB
900------------------------------------------------
901*/
Note: See TracBrowser for help on using the repository browser.