source: SH_SHM/trunk/source/seed_io/seedquickdump.c @ 341

Revision 341, 10.0 KB checked in by marcus, 12 years ago (diff)

r180 | walther | 2011-03-09 16:27:03 +0100 (Mi, 09 Mär 2011) | 3 lines

Merging most of the changes from marcus' branch. For full details please see
http://www.seismic-handler.org/portal/log/SH_SHM/branches/marcus?revs=101-106,123-171

Line 
1
2/* file seedquickdump.c
3 *      ===============
4 *
5 * $Revision: 180 $, $Date: 2011-03-09 16:27:03 +0100 (Mi, 09 MÀr 2011) $
6 *
7 * Dumps out Headerinfo of SEED files.
8 * K. Stammler, 10-Aug-98
9 *
10 */
11
12
13#include <stdio.h>
14#include <string.h>
15#include BASECNST
16#include BC_SYSBASE
17#include BC_CPAR
18#include BC_TCUSRDEF
19#include BC_UTUSRDEF
20#include BC_ERUSRDEF
21#include "seedcfg.h"
22#include "seed_lib.h"
23
24
25typedef struct {
26        WORD     block_id;        /* blockette ID = 1000 */
27        WORD     next_block;      /* next blockette */
28        UBYTE    algorithm;       /* compression algorithm */
29        UBYTE    dunno1;          /* ... */
30        UBYTE    reclthpow;       /* power of record length */
31        UBYTE    dunno2;          /* ... */
32} SeedDataOnlyBlocketteT;
33
34typedef struct {
35        WORD     block_id;        /* blockette ID = 1001 */
36        WORD     next_block;      /* next blockette */
37        UBYTE    timequal;        /* time quality */
38        UBYTE    dunno1;          /* ...*/
39} SeedDataExtBlocketteT;
40
41
42
43int main( int argc, char *argv[] )
44{
45        /* local variables */
46        STATUS   status;                    /* return status */
47        int      recsize;                   /* SEED record size in bytes */
48        char     recsize_par[cBcLineLth];   /* record size parameter string */
49        SeedSbyteT *seedrec;                /* pointer to SEED record */
50        SeedDataHeaderT *seedhdr;           /* pointer to seed data header */
51        char     seedfile[BC_FILELTH+1];    /* name of SEED file */
52        int      read_ret;                  /* fread return values */
53        NTIME    ntime;                     /* numeric time */
54        FILE     *fp;                       /* pointer to SEED file */
55        char     sfd_t_start[BC_TIMELTH+1]; /* start time */
56        char     sfd_t_end[BC_TIMELTH+1];   /* end time */
57        int      sfd_recno;                 /* number of records in file */
58        char     sfd_stream[BC_LINELTH+1];  /* stream string */
59        BOOLEAN  sfd_swap_hdr;              /* swap header necessary */
60        int      i;                         /* counter */
61        long     fsize;                     /* file size */
62        float    dt;                        /* sample distance in sec */
63        char     *csrc, *cdst;              /* moving pointers */
64        char     outfile[BC_FILELTH+1];     /* output file */
65        FILE     *out;                      /* pointer to output file */
66        char     chanstr[BC_SHORTSTRLTH+1]; /* scratch string for channel */
67        int      byteoff;                   /* byte offset at beginning */
68        int      errcnt;                    /* error counter */
69        int      reccnt;                    /* record counter */
70        char     seq[cBcLineLth+1];         /* sequence number string */
71        SeedDataOnlyBlocketteT *donly;      /* data only blockette */
72        SeedDataExtBlocketteT *dext;        /* data extension blockette */
73        UWORD    tmp;                       /* scratch */
74        int      time_quality;              /* time quality factor */
75        char     lasttime[cBcTimeLth+1];    /* time of last record */
76        float    gaplth;                    /* length of gap in s */
77        unsigned long int usign;            /* first sample values */
78        BOOLEAN  print_locid;               /* print location ID */
79        char     showinfo[cBcLineLth+1];    /* show info qualifier */
80        BOOLEAN  b1000found;                /* blockette 1000 found */
81        int      gap_count=0;               /* gap counter */
82        float    gap_length=0.0;            /* total gap length in s */
83        int      jitter_count=0;            /* counts very small 'gaps' (<dt/2) */
84        BOOLEAN  write_newline;             /* write a new line after record */
85
86        /* executable code */
87
88        status = cBcNoError;
89        print_locid = FALSE;
90
91        pa_init( argc, argv );
92        if  (pa_pnumber() < 1 || pa_pnumber() > 2)  {
93                fprintf( stderr, "Usage: %s <seed-file> \n",
94                        pa_progname() );
95                return 1;
96        } /*endif*/
97        strcpy( seedfile, pa_pvalue(1) );
98        out = stdout;
99
100        /* check for record size qualifier */
101        recsize = 0;
102        if  (pa_qspecified("-seedrec"))  {
103                strcpy( recsize_par, pa_qvalue("-seedrec") );
104                if  (strcmp(recsize_par,"quickfind") == 0)  {
105                        /* just do nothing, leave recsize zero */
106                } else {
107                        if  (sscanf(recsize_par,"%d",&recsize) != 1)  {
108                                fprintf( stderr, "%s: illegal seedrec qualifier.  Abort.\n",
109                                        pa_progname() );
110                                return 1;
111                        } /*endif*/
112                } /*endif*/
113        } /*endif*/
114
115        if  (pa_qspecified("-locid"))  print_locid = TRUE;
116
117        *showinfo = '\0';
118        if  (pa_qvalue("-show") != NULL)  {
119                strcpy( showinfo, pa_qvalue("-show") );
120        } /*endif*/
121
122        /* allocate memory for SEED record */
123        seedrec = (SeedSbyteT *)sy_allocmem( 1, Seed_C_MAX_RECLTH, &status );
124        if  (Severe(&status))  err_writemsg( status, "", TRUE );
125
126        fp = fopen( seedfile, "rb" );
127        if  (fp == NULL)  {
128                fprintf( stderr, "*** %s: file %s not found\n", pa_progname(), seedfile );
129                fclose( out );
130                return 1;
131        } /*endif*/
132
133        /* determine record size if not specified */
134        if  (recsize == 0)  {
135                SeedQuickFindReclth( fp, &recsize, &byteoff );
136                if  (recsize <= 0)  {
137                        fclose( fp );
138                        if  (recsize == 0)  {
139                                fprintf( stderr, "%s: no valid SEED file %s\n",
140                                        pa_progname(), seedfile );
141                        } else {
142                                fprintf( stderr, "%s: cannot find record size in %s\n",
143                                        pa_progname(), seedfile );
144                        } /*endif*/
145                        return 1;
146                } /*endif*/
147        } /*endif*/
148
149        reccnt = 0;
150        gaplth = 0.0;
151        *lasttime = '\0';
152
153        /* read records */
154        FOREVER  {
155
156                reccnt++;
157
158                /* read next record */
159                read_ret = (int)fread( (char *)seedrec, recsize, 1, fp );
160                if  (read_ret != 1)  break;
161
162                /* check for swapping */
163                seedhdr = (SeedDataHeaderT *)seedrec;
164                sfd_swap_hdr = SeedSwapNecessary( seedhdr );
165                if  (sfd_swap_hdr)  SeedSwapHeader( seedhdr );
166
167                strncpy( seq, seedhdr->seqno, 6 );
168                seq[6] = '\0';
169                if  (seedhdr->indicator != 'D' && seedhdr->indicator != 'R'
170                        && seedhdr->indicator != 'Q')  {
171                        if  (*showinfo == '\0')
172                                printf( "%06d %6s %c\n", reccnt, seq, seedhdr->indicator );
173                        continue;
174                } /*endif*/
175
176                /* find start time */
177                SeedBtimeToNtime( &(seedhdr->starttime), &ntime, &status );
178                if  (Severe(&status))  {
179                        fprintf( stderr,
180                                "%s: could not read start time in file %s (status %d)\n",
181                                pa_progname(), seedfile, status );
182                        fclose( fp );
183                        fclose( out );
184                        return 1;
185                } /*endif*/
186                tc_n2t( &ntime, sfd_t_start, &status );
187                if  (Severe(&status))  {
188                        fprintf( stderr,
189                                "%s: could not convert start time (status %d) in file %s\n",
190                                pa_progname(), status, seedfile );
191                        fprintf( stderr, "%s: ntime: %d,%d,%d,%d,%d,%d,%d\n", pa_progname(),
192                                ntime.year, ntime.month, ntime.day, ntime.hour, ntime.min,
193                                ntime.sec, ntime.ms );
194                        fclose( fp );
195                        fclose( out );
196                        return 1;
197                } /*endif*/
198
199                /* channel name */
200                csrc = seedhdr->statcode;
201                cdst = sfd_stream;
202                *cdst = '\0';
203                while  (*csrc > ' ' && *csrc <= 'z')  *cdst++ = *csrc++;
204                *cdst++ = '-';
205                *cdst = '\0';
206                chanstr[0] = Cap( seedhdr->channel[0] );
207                chanstr[1] = Cap( seedhdr->channel[1] );
208                chanstr[2] = '\0';
209                if  (chanstr[0] <= ' ' || chanstr[0] > 'z')  chanstr[0] = '\0';
210                if  (chanstr[1] <= ' ' || chanstr[1] > 'z')  chanstr[1] = '\0';
211                ut_uncap( chanstr );
212
213                strcat( sfd_stream, chanstr );
214                strcat( sfd_stream, "-" );
215                i = (int)strlen( sfd_stream );
216                sfd_stream[i] = seedhdr->channel[2];
217                if  (chanstr[i] <= ' ' || chanstr[i] > 'z')  chanstr[i] = '\0';
218                sfd_stream[i+1] = '\0';
219                ut_uncap( sfd_stream );
220
221                /* get sample distance */
222                if  (seedhdr->smprate_fact == 0 || seedhdr->smprate_mult == 0)  {
223                        dt = 0.0;
224                } else {
225                        dt = SeedGetSampleDist( seedhdr );
226                } /*endif*/
227
228                tc_tadd( sfd_t_start, (float)(seedhdr->no_of_samples)*dt, sfd_t_end,
229                        &status );
230                if  (Severe(&status))  {
231                        fprintf( stderr, "%s: could not compute end time in file\n",
232                                pa_progname(), seedfile );
233                        fclose( fp );
234                        fclose( out );
235                        return 1;
236                } /*endif*/
237                if  (*lasttime != '\0')
238                        gaplth = tc_tdiff( sfd_t_start, lasttime, &status );
239
240                b1000found = FALSE;
241                time_quality = -1;
242                if  (seedhdr->first != 0)  {
243                        donly = (SeedDataOnlyBlocketteT *)(seedrec+(seedhdr->first));
244                        b1000found = (donly->block_id == 1000);
245                        if  (b1000found && donly->next_block > 0)  {
246                                dext = (SeedDataExtBlocketteT *)(seedrec+(donly->next_block));
247                                if  (dext->block_id == 1001)  {
248                                        time_quality = dext->timequal;
249                                } /*endif*/
250                                if  (!b1000found && dext->block_id == 1000)  b1000found = TRUE;
251                        } /*endif*/
252                } /*endif*/
253
254                usign = *((unsigned long int *)(seedrec+68));
255                /*
256                tmp = usign & 0x0000ffff;
257                usign >>= 16;
258                usign += (unsigned long)tmp * 65536;
259                */
260
261                write_newline = TRUE;
262                if  (*showinfo == '\0')  {
263                        printf( "%06d %6s %c %s %s %5d %7.5f %d ", reccnt, seq, seedhdr->indicator,
264                                sfd_stream, sfd_t_start, seedhdr->no_of_samples, dt, time_quality );
265
266                        if  (gaplth == 0.0)  {
267                                printf( "cont" );
268                        } else {
269                                printf( "%g", gaplth );
270                                if (Abs(gaplth) > (dt/2.0))  {
271                                        gap_length += Abs(gaplth);
272                                        gap_count++;
273                                } else {
274                                        jitter_count++;
275                                } /*endif*/
276                        } /*endif*/
277
278                        if  (seedhdr->timecorr != 0)  printf( " (%d)", seedhdr->timecorr );
279
280                        if  (print_locid)  printf( " %c%c", seedhdr->locid[0], seedhdr->locid[1] );
281
282                } else {
283
284                        if  (gaplth != 0.0)  {
285                                if (Abs(gaplth) > (dt/2.0))  {
286                                        gap_length += Abs(gaplth);
287                                        gap_count++;
288                                } else {
289                                        jitter_count++;
290                                } /*endif*/
291                        } /*endif*/
292
293                        if  (strcmp(showinfo,"netcode") == 0)  {
294                                printf( "%c%c ", seedhdr->network[0], seedhdr->network[1] );
295                        } else if  (strcmp(showinfo,"timecorr") == 0)  {
296                                printf( "%d ", seedhdr->timecorr );
297                        } else if  (strcmp(showinfo,"locid") == 0)  {
298                                printf( "%c%c ", seedhdr->locid[0], seedhdr->locid[1] );
299                        } else if  (strcmp(showinfo,"activity") == 0)  {
300                                printf( "%s 0x%x ", sfd_t_start, (int)(seedhdr->activity) );
301                        } else if  (strcmp(showinfo,"ioflags") == 0)  {
302                                printf( "%s 0x%x ", sfd_t_start, (int)(seedhdr->ioflags) );
303                        } else if  (strcmp(showinfo,"quality") == 0)  {
304                                printf( "%s 0x%x ", sfd_t_start, (int)(seedhdr->quality) );
305                        } else if  (strcmp(showinfo,"b1000") == 0)  {
306                                printf( "%d ", b1000found );
307                        } else {
308                                write_newline = FALSE;
309                        } /*endif*/
310
311                } /*endif*/
312
313                if  (write_newline)  printf( "\n" );
314
315                strcpy( lasttime, sfd_t_end );
316
317        } /*endfor*/
318
319        if  (strcmp(showinfo,"gaps") == 0)  {
320                printf( "gap_count %d gap_length %f jitter_count %d\n",
321                        gap_count, gap_length, jitter_count );
322        } /*endif*/
323
324        fclose( fp );
325        return 0;
326
327} /* end of main */
Note: See TracBrowser for help on using the repository browser.