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

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