source: trunk/src/libsrc/util/wfdiscputaway.c @ 7215

Revision 7215, 31.8 KB checked in by baker, 9 months ago (diff)

use drop-in replacement gmtime_ew() for gmtime_r()

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1/******************************************************************
2 * wfdiscputaway.c - routines to enable wfdisc data to be stored from
3 *                Earthworm
4 *
5 ******************************************************************/
6
7#include <stdio.h>
8#include <time.h>
9#include <stdlib.h>
10#include <string.h>
11#include <errno.h>
12#include <math.h>
13#include <float.h>
14#ifndef _WINNT
15#include <unistd.h>
16#endif
17#include <fcntl.h>
18#include <time.h>                       /* time_t */
19
20#include "earthworm.h"
21#include "trace_buf.h"
22#include "swap.h"
23#include "ws_clientII.h"
24#include "site.h"
25#include "kom.h"
26#include "time_ew.h"                    /* gmtime_ew() */
27#include "chron3.h"
28
29#include "wfdischead.h"
30#include "seihead.h"
31
32/* private global variables */
33int global_output_format;
34char storage_dir[65];
35//char w_dir[65]; //In case we want the w files to be in different locations from the wfdisc files
36char eventDate[8];
37char eventTime[6];
38char wfdisc_name[256]; //Arbitrary, since 33 characters was too small.  I should define both 33 and 256 for use in snprintf the filenames
39//wfdisc_params params_data[200]; //Size is arbitrary, what is max # of channels?  set as 200 here
40int num_chan_data;
41FP_PAIR fp_array[256];
42int fp_array_size;
43char dirpath[22]; //The path the wfdisc will be placed in
44//
45//Config struct
46wfdisc_config config;
47
48int ymd2doy(char* yyyymmdd);
49FILE* open_wfdisc_file(char* station, char *channel, char* evtDate);
50int initialize(char *config_filename, wfdisc_config *config_local); //Returns fail or success, if fail calling program should return fail as well
51
52/**********************************************************************
53 * WFDISCPA_init
54 *
55 * Description: initialise wfdisc put away routines
56 *
57 * Input parameters: output_dir - the directory to be used for wfdisc
58 *                                output files
59 *                   output_format - "intel" or "sparc" for byte ordering
60 *                   debug - flag for debugging output
61 * Output parameters: none
62 * Returns: EW_SUCCESS or EW_FAILURE
63 *
64 * Comments:
65 *
66 ***********************************************************************/
67int WFDISCPA_init (char *output_dir, char *output_format, int debug)
68
69{
70 
71//  FILE* wfdisc_param;
72//  FILE* wfdisc_loc_param;
73//  int w_dir_len;
74  char * EW_PARAMS;
75  char wfdisc_params_full_path[256];
76
77  if (debug)
78  {
79    logit ("e", "Entering WFDISCPA_init\n");
80  }
81 
82  /* make sure that the output directory exists */
83  if (CreateDir (output_dir) != EW_SUCCESS)
84  {
85    logit ("e", "WFDISCPA_init: Call to CreateDir failed\n");
86    return EW_FAILURE;
87  }
88
89  //Make output dir the CWD
90  if ( -1 == chdir_ew(output_dir) ) {
91        logit("e", "WFDISCPA_init: Call to chdir to:%s failed\n", output_dir); 
92        return EW_FAILURE;
93  }
94 
95  //Copy dir name to global variable
96  strncpy(storage_dir, output_dir, 65);
97
98  //Call Initialize for file wfdisc_waveman.d
99
100  //Read in wfdisc_w_loc.d file
101//  if (debug) logit ("e", "Reading wfdisc_w_loc.d file for .w save location\n");
102  EW_PARAMS = getenv("EW_PARAMS");
103  snprintf(wfdisc_params_full_path, 256, "%s/%s", EW_PARAMS, "wfdisc_waveman.d");
104//  wfdisc_loc_param = fopen(wfdisc_params_full_path, "r");
105  if (initialize(wfdisc_params_full_path,&config) == EW_FAILURE) return EW_FAILURE ;
106//  if (wfdisc_loc_param == NULL) {
107//      logit ("e", "WFDISCPA_init: unable to open wfdisc_w_loc.d, assuming .w files stored in same loc as .wfdisc\n");
108//      strncpy(w_dir, storage_dir, 65);
109//  } else if ((w_dir_len = fread(w_dir, sizeof(char), 65, wfdisc_loc_param)) > 0) {
110//      //Good, we have copied the data in
111//      w_dir[w_dir_len-1] = '\0';
112//      if (debug) logit ("e", "WFDISCPA_init: .w files will be saved to %s, filename length = %d\n", w_dir, w_dir_len);
113//  } else {
114//      snprintf(w_dir, 3, "./");
115//  }
116//  fclose(wfdisc_loc_param);
117
118  //Get .w dir if it exists
119  //If exists
120  //Copy into w_dir
121  //else
122  //copy ./ into w_dir
123//  if (CreateDir (w_dir) != EW_SUCCESS)
124//  {
125//    logit ("e", "WFDISCPA_init: Call to CreateDir failed\n");
126//    return EW_FAILURE;
127//  }
128
129  //This can be relative since we are already in output dir
130  //Make output dir the CWD
131//  if ( -1 == chdir_ew(w_dir) ) {
132//      logit("e", "WFDISCPA_init: Call to chdir to:%s failed\n", w_dir);
133//      return EW_FAILURE;
134//  }
135  //Make output dir the CWD
136  if ( -1 == chdir_ew(output_dir) ) {
137        logit("e", "WFDISCPA_init: Call to chdir to:%s failed\n", output_dir); 
138        return EW_FAILURE;
139  }
140
141  if (! strcmp (output_format, "intel"))
142    global_output_format = INTEL_OUTPUT;
143  else if (! strcmp (output_format, "sparc"))
144    global_output_format = SPARC_OUTPUT;
145  else
146  {
147    logit ("e", "WFDISCPA_init: can't recognise OutputFormat (%s)\n", output_format);
148    return EW_FAILURE;
149  }
150
151  //Read in wfdisc_params.d file
152//  EW_PARAMS = getenv("EW_PARAMS");
153//  snprintf(wfdisc_params_full_path, 256, "%s/%s", EW_PARAMS, "wfdisc_params.d");
154//  wfdisc_param = fopen(wfdisc_params_full_path, "r");
155//  num_chan_data = 0;
156//  if (!wfdisc_param) {
157    //Error, didn't open the params file
158//      logit("e", "Error opening params file: %s\n", wfdisc_params_full_path);
159//  } else {
160//    while (!feof(wfdisc_param)) {
161//      if(num_chan_data >= 200) {
162//          logit("e", "Too much channel data(%d lines) in %s\n", 200, wfdisc_params_full_path);
163//          break;
164//        }
165//        comment_char = fgetc(wfdisc_param);
166//        if(comment_char < '0' || (comment_char > '9' && comment_char < 'A') || (comment_char > 'Z' && comment_char < 'a') || comment_char > 'z') {
167//              fgets(comment_line, sizeof comment_line, wfdisc_param);
168//        } else {
169//              fseek( wfdisc_param, -1, SEEK_CUR);
170//        }
171//      fscanf(wfdisc_param, "%7s%9s%d %f %f %7s%2s\n", params_data[num_chan_data].sta, params_data[num_chan_data].chan,
172//                                                        &params_data[num_chan_data].chanid, &params_data[num_chan_data].calib,
173//                                                                                                &params_data[num_chan_data].calper, params_data[num_chan_data].instype,
174//                                                                                                        params_data[num_chan_data].segtype);
175          //Create new wfdisc_param entry
176//        num_chan_data++;
177//    }
178//  }
179
180  //Set fp_array_size to 0 to start
181  fp_array_size=0;
182
183  return EW_SUCCESS;
184
185}
186
187/****************************************************************************
188 * WFDISCPA_next_ev
189 *
190 * Description: called when a snippet has been received,
191 *              before it is processed
192 *
193 * Input parameters: trace_req - array of trace request structures
194 *                   n_reqs - size of array
195 *                   output_dir - output directory
196 *                   e_date, e_time - event time in the form
197 *                                    'ccyymmdd' and 'hhmmss.ff'
198 *                   debug - flag for debugging output
199 * Output parameters: none
200 * Returns: EW_SUCCESS or EW_FAILURE
201 *
202 * Comments:
203 *
204 ***********************************************************************/
205int WFDISCPA_next_ev (TRACE_REQ *trace_req, int n_reqs, char *output_dir,
206                   char *e_date, char *e_time, char *subnet, int debug)
207{
208
209  if (debug)
210  {
211    logit ("e", "Entering WFDISCPA_next_ev, date/time: %s %s\n", e_date, e_time);
212  }
213
214  strncpy(eventDate, e_date, 8);
215  strncpy(eventTime, e_time, 6);
216
217  //Create wfdisc file name, shall use subnet.date.etime.wfdisc
218  //Requested by ISLA to change to yyyyddd_hh.wfdisc
219  // IGD 02/10/2017 Requested by ISLA now to change to yyyymmdd_hh.wfdisc
220  snprintf(wfdisc_name, 256, "%c%c%c%c%c%c%c%c_%c%c.wfdisc",  eventDate[0], eventDate[1], eventDate[2], eventDate[3], 
221                                                              eventDate[4], eventDate[5], eventDate[6], eventDate[7], 
222                                                              eventTime[0], eventTime[1]);
223  if (debug)
224  {
225     logit ("e", "WFDISCPA_next_ev: wfdisc filename %s\n", wfdisc_name);
226  }
227
228
229  if (debug)
230  {
231    logit ("e", "WFDISCPA_next_ev data: n_reqs: %d, output_dir: %s, e_date: %s, e_time: %s, subnet: %s\n",n_reqs, output_dir,  e_date, e_time, subnet);
232  }
233
234  return EW_SUCCESS;
235
236}
237
238/*****************************************************************************
239 * WFDISCPA_next
240 *
241 * Description: called once for each trace to be put away
242 *
243 * Input parameters: trace_req - the data to be stored
244 *                   gap_thresh - size of any gap in seconds
245 *                   debug - flag for debugging output
246 * Output parameters: none
247 * Returns: EW_SUCCESS or EW_FAILURE
248 *
249 * Comments: see pa_find_data()
250 *
251 *****************************************************************************/
252int WFDISCPA_next (TRACE_REQ *trace_req, double gap_thresh, int debug)
253
254{
255
256  int status, loop_count, param_index, change_bit_order = (int)FALSE;
257  int last_status = 0;
258  int32_t prev_samples;
259  double sample_time;
260  char *data_ptr;
261  struct Found_data data;
262  char datatype[3];
263  char lddate[19]; //Needs space for the null character from strftime, so makeing 19 bytes
264  char dfile_name[33]; // 33 taken from WFDISC30 struct in gbase libraries
265  FILE * w_fp;
266  long foff = 0; //byte offset for .w file
267  //Used for jdate //
268  struct tm start_tm;
269  struct Greg gregorian;
270  time_t start_time;
271  long jdate = -1;
272
273  //Used for current date in lddate in wfdisc record
274  struct tm *t;
275  int chars_copied;
276  time_t current_time;
277
278  //Used for getting param info
279  int i;
280
281
282  FILE* wfdisc_fp;
283
284  if (debug) logit ("e", "Entering WFDISCPA_next\n");
285  if (debug) logit ("e", "WFDISCPA_next data; gap_thresh: %lf\n", gap_thresh);
286  if (debug) logit ("e", "WFDISCPA_next trace_req data; sta:%s, chan:%s, net:%s, loc:%s, pinno:%d, reqStarttime:%lf, reqEndtime:%lf, partial:%d, pBuf:0x%08lx, bufLen:%ld, timeout:%ld, fill:%ld, retFlag:%d, waitSec:%lf, actStarttime:%lf, actEndtime:%lf, actLen:%ld, samprate:%lf\n",
287                                       trace_req->sta, trace_req->chan, trace_req->net, 
288                                                                           trace_req->loc, trace_req->pinno, 
289                                                                           trace_req->reqStarttime, trace_req->reqEndtime, 
290                                                                           trace_req->partial, (unsigned long)trace_req->pBuf, trace_req->bufLen,
291                                                                           trace_req->timeout, trace_req->fill, (int)trace_req->retFlag,
292                                                                           trace_req->waitSec, trace_req->actStarttime, 
293                                                                           trace_req->actEndtime, trace_req->actLen, trace_req->samprate);
294  if (debug) logit ("e", "WFDISCPA_next data:0x%x \n", trace_req->pBuf[0]);
295
296  prev_samples = 0;
297
298  //Get current date
299  ////Include <ctime.h>
300  time(&current_time);
301  t = localtime(&current_time);
302  chars_copied = (int)strftime(lddate, 19, " %Y%m%d %H:%M:%S", t);
303  //printf ("Chars copied to string array: %d, array:%s\n", chars_copied, lddate);
304
305  //See if there was param info
306  param_index = -1; //If this is not changed, there was no param data for this station/channel
307  for (i=0;i<config.n_calib_params; i++) {
308    //Compare sta and chan
309        if (!strcmp(config.calib_params[i].sta, trace_req->sta) && !strcmp(config.calib_params[i].chan, trace_req->chan) ) {
310          //Success
311          param_index = i;
312      if (debug) logit ("e", "Found wfdisc param data for sta: %s chan:%s\n", trace_req->sta, trace_req->chan);
313        }
314  }
315
316  data.n_samples = 1;
317
318  /* IGD 02/10/2017: I am changing logic below at request of Milton G. so we do not have main subdir anymore
319   * and filename is now yyyymmdd_hh.wfdisc, not yyyydoy_hh.w as before. notes below are updated
320   */
321  //Create all the dirs neccessary and logic for the content of the wfdisc and w files.
322        //If station is listed as special: Use file specified
323        //If all stations get the same file: Use file specified
324        //Else if all stations get their own file: create yyyy/mm/station/yyyymmdd_hh.wfdisc
325        //build dir path yyyy/mm/station and call RecursiveCreateDir()
326  wfdisc_fp = open_wfdisc_file(trace_req->sta, trace_req->chan, eventDate);
327//  snprintf(dirpath, 22, "%c%c%c%c/%c%c/%s", eventDate[0], eventDate[1], eventDate[2],
328//                                                  eventDate[3], eventDate[4], eventDate[5],
329//                                                                                                trace_req->sta);
330//     
331//  if (RecursiveCreateDir (dirpath) != EW_SUCCESS)
332//  {
333//    logit ("e", "WFDISCPA_next: Call to CreateDir failed\n");
334//    return EW_FAILURE;
335//  }
336//  //Change dir to dirpath and open wfdisc for writing
337//  if ( -1 == chdir_ew(dirpath) ) {
338//      logit("e", "WFDISCPA_next: Call to chdir to:%s failed\n", dirpath);
339//      return EW_FAILURE;
340//  }
341//  if (CreateDir (w_dir) != EW_SUCCESS)
342//  {
343//    logit ("e", "WFDISCPA_next: Call to CreateDir failed\n");
344//    return EW_FAILURE;
345//  }
346//
347//  wfdisc_fp = fopen(wfdisc_name, "a+");
348//  if (!wfdisc_fp) {
349//    logit("e", "WFDISCPA_next: error opening file %s for writing\n", wfdisc_fp );
350//      return EW_FAILURE;
351//  }
352
353        //and yyyy/mm/station/(.w configged file location)/yyyyddd_hh.w
354        //For any of these, make container directories recursively
355       
356       
357  //Create .w file
358  snprintf(dfile_name, 33, "%s%s%s%s.%c%c%c%c%c%c%c%c_%c%c.w", trace_req->sta, 
359                                       trace_req->chan, trace_req->net, trace_req->loc, 
360                                                                           eventDate[0], eventDate[1], eventDate[2],  eventDate[3],
361                                                                           eventDate[4], eventDate[5], eventDate[6],  eventDate[7], 
362                                                                           eventTime[0], eventTime[1]);
363
364  //Chdir to the storage_dir before and after to make sure I can use relative dirs
365  if ( -1 == chdir_ew(storage_dir) ) {
366  }
367  if ( -1 == chdir_ew(dirpath) ) {
368        logit("e", "WFDISCPA_next: Call to chdir to:%s failed\n", dirpath); 
369        return EW_FAILURE;
370  }
371  if ( -1 == chdir_ew(config.w_dir) ) {
372        logit("e", "WFDISCPA_next: Call to chdir to:%s failed\n", config.w_dir); 
373        return EW_FAILURE;
374  }
375  w_fp = fopen(dfile_name, "w+");
376  if (!w_fp) {logit("e", "WFDISCPA_next: error opening file %s for writing\n", dfile_name) ; }
377  if ( -1 == chdir_ew(storage_dir) ) {
378        logit("e", "WFDISCPA_next: Call to chdir to:%s failed\n", storage_dir); 
379        return EW_FAILURE;
380  }
381 
382  sample_time = trace_req->reqStarttime;
383 
384  //////////////////////////
385  //For loop which goes till all data for this channel is taken care of
386  //////////////////////////
387 
388  for (sample_time = trace_req->reqStarttime, loop_count = 0;
389    (sample_time < trace_req->reqEndtime) && (data.n_samples > 0);
390    sample_time += ((double) data.n_samples / data.sample_rate), loop_count ++)
391  {
392
393    status = pa_find_data (trace_req, sample_time, &data);
394    switch (status)
395    {
396      case FD_FOUND_REQUESTED:
397            break;
398      case FD_FOUND_GAP:
399                last_status = status;
400                prev_samples = 0;
401        break;
402      case FD_NO_MORE_DATA:
403            last_status = status;
404                prev_samples = 0;
405       /* if no data has been found on previous calls, then exit
406        *        * so that no data will be recorded for this channel */
407        if (sample_time == trace_req->reqStarttime) return EW_SUCCESS;
408        /* otherwise calculate the size of the gap to the end of requested data */
409        data.n_samples = (int32_t) (data.sample_rate * (trace_req->reqEndtime - sample_time));
410        break;
411      case FD_BAD_DATATYPE:
412        logit("e", "WFDISCPA_next: unrecognised data type code, skipping this scn: %s.%s.%s.%s\n",
413             trace_req->sta, trace_req->chan, trace_req->net, trace_req->loc);
414        return EW_FAILURE;
415      case FD_CHANGED_SRATE:
416        logit("e", "WFDISCPA_next: bad sample rate, skipping this scn: %s.%s.%s.%s\n",
417             trace_req->sta, trace_req->chan, trace_req->net, trace_req->loc);
418        return EW_FAILURE;
419    }
420
421    if (debug) logit ("e", "Loop %d: %s %ld @ %.1lfHz, time %.3lf\n",
422           loop_count, status == FD_FOUND_REQUESTED ? "samples" : "gap",
423           (long)data.n_samples, data.sample_rate, sample_time);
424    if (debug && status == FD_FOUND_REQUESTED) logit ("e", "num_samples %ld @ %.1lfHz, start_time %.3lf end_time %.3lf\n",
425           (long)data.n_samples, data.sample_rate, sample_time, sample_time + ((double) data.n_samples / data.sample_rate));
426
427    data_ptr = data.data;
428    if (status == FD_FOUND_REQUESTED) {
429          switch(data.trace_hdr->datatype [0])
430          {
431                case 's':
432                  if (debug) logit("e", "incoming byte order is sparc\n");
433                  if (global_output_format == SPARC_OUTPUT) {
434                        change_bit_order = FALSE;
435                  } else if (global_output_format == INTEL_OUTPUT) {
436                        change_bit_order = TRUE;
437                  }
438                  break;
439                case 'i':
440                  if (debug) logit("e", "incoming byte order is intel\n");
441                  if (global_output_format == SPARC_OUTPUT) {
442                    change_bit_order = TRUE;
443                  } else if (global_output_format == INTEL_OUTPUT) {
444                    change_bit_order = FALSE;
445                  }
446                  break;
447                default:
448                  logit ("e", "WFDISCPA_next: can't handle that datatype byte order: %d\n", (int)data.trace_hdr->datatype [0]);
449                  return EW_FAILURE;
450          }
451      switch(data.data_type_code)
452      {
453        case FD_SHORT_INT:
454                  if (global_output_format == SPARC_OUTPUT) {
455                    snprintf(datatype, 3, "s2");
456                        if (debug) logit("e", "outgoing datatype is short int sparc\n");
457                  } else if (global_output_format == INTEL_OUTPUT) {
458                snprintf(datatype, 3, "i2");
459                    if (debug) logit("e", "outgoing datatype is short int intel\n");
460                  } else {
461                    logit ("e", "WFDISCPA_next: can't handle that datatype code: %d-%d\n", global_output_format, data.data_type_code);
462                    return EW_FAILURE;
463                  }
464          break;
465            case FD_LONG_INT:
466                  if (global_output_format == SPARC_OUTPUT) {
467                    snprintf(datatype, 3, "s4");
468                        if (debug) logit("e", "outgoing datatype is long int sparc\n");
469              } else if (global_output_format == INTEL_OUTPUT) {
470                    snprintf(datatype, 3, "i4");
471                    if (debug) logit("e", "outgoing datatype is long int intel\n");
472                  } else {
473                    logit ("e", "WFDISCPA_next: can't handle that datatype code: %d-%d\n", global_output_format, data.data_type_code);
474                        return EW_FAILURE;
475                  }
476                  break;
477            default:
478              //Error, do I handle that datatype?
479              logit ("e", "WFDISCPA_next: can't handle that datatype code: %d\n", data.data_type_code);
480                  return EW_FAILURE;
481      }
482
483          //This was needed to keep it writing, bugfix.
484          wfdisc_fp = open_wfdisc_file(trace_req->sta, trace_req->chan, eventDate);
485          if(last_status == FD_FOUND_REQUESTED) {
486            if (debug) logit("e", "WFDISC_next: Update existing wfdisc record\n");
487                //Need to update the last record
488                //Seek back to the endtime entry and write new endtime and numsamples
489                fseek(wfdisc_fp, -223, SEEK_CUR);
490                fprintf(wfdisc_fp, "%16.6lf%9ld", sample_time + ((double) (data.n_samples - 1) / data.sample_rate), (long)(data.n_samples + prev_samples));
491                //Seek to end of file
492                fseek(wfdisc_fp, 0, SEEK_END);
493                prev_samples += data.n_samples;
494          } else {
495            //This is the start of a new wfdisc record
496            if (debug) logit("e", "WFDISC_next: Start of a new wfdisc record\n");
497                //
498                //Convert sample_time to julian date
499                //First convert epoch to tm struct
500                start_time = (time_t) sample_time;
501                gmtime_ew(&start_time, &start_tm); 
502                //Then convert tm struct to gregorian date
503                tm_to_gregorian(&start_tm, &gregorian);
504                //Then convert gregorian to julian
505                jdate = julian(&gregorian);
506                //
507                //If no param data found, use defaults
508                if (param_index == -1) {
509          fprintf(wfdisc_fp, "%-7s%-9s%16.6lf%9d%9d%9ld %16.6lf%9ld%12.6f %16.10f %16.6f %-7s%-2s%-3s%-2s%-65s%-33s %9ld%9d%-18s\n",
510                     trace_req->sta, trace_req->chan, sample_time, /* wfid */ -1, /* chanid */ -1,
511                         /* jdate */ jdate, /* endtime */ sample_time + ((double) (data.n_samples - 1) / data.sample_rate),
512                             /* nsamp */ (long)data.n_samples, /* samprate */ data.sample_rate, /* calib */ (double)0,
513                             /* calper */ (double)-1, /* instype */ "-", /* segtype */ "-", /* datatype */ datatype, /* clip */ "-",
514                             /* dir */ config.w_dir, /* dfile */ dfile_name, /* foff */ foff, /* commid */ -1, /* lddate */ lddate);
515            } else {
516          fprintf(wfdisc_fp, "%-7s%-9s%16.6lf%9d%9ld%9ld %16.6lf%9ld%12.6f %16.10f %16.6f %-7s%-2s%-3s%-2s%-65s%-33s %9ld%9d%-18s\n",
517                     trace_req->sta, trace_req->chan, sample_time, /* wfid */ -1, /* chanid */ (long)config.calib_params[param_index].chanid,
518                         /* jdate */ jdate, /* endtime */ sample_time + ((double) (data.n_samples - 1) / data.sample_rate),
519                             /* nsamp */ (long)data.n_samples, /* samprate */ data.sample_rate, /* calib */ config.calib_params[param_index].calib,
520                             /* calper */ config.calib_params[param_index].calper, /* instype */ config.calib_params[param_index].instype, 
521                                 /* segtype */ config.calib_params[param_index].segtype, /* datatype */ datatype, /* clip */ "-",
522                             /* dir */ config.w_dir, /* dfile */ dfile_name, /* foff */ foff, /* commid */ -1, /* lddate */ lddate);
523                }
524            prev_samples += data.n_samples;
525          }
526      //If FD_FOUND_REQUESTED Open new .w file
527
528      // logit("e", "sample_time += %lf\n", ((double) data.n_samples / data.sample_rate));
529      //logit("e", "num samples: %d\n", data.n_samples);
530      switch (data.data_type_code)
531      {
532        case FD_SHORT_INT:
533                  if (change_bit_order == FALSE) {
534                    if (debug) logit("e", "Writing data out direct from buffer, no byte order change\n");
535            foff += (long)(sizeof (short) * fwrite(data_ptr, (sizeof (short)), data.n_samples, w_fp));
536                  } else if (change_bit_order == TRUE) {
537                    if (debug) logit("e", "Changing byte order of data for output\n");
538                    //REORDER shorts
539                        for (i=0; i<data.n_samples; i++) {
540                          foff += (long)(sizeof (char) * fwrite(&data_ptr[i*2+1], (sizeof (char)), 1, w_fp));
541                          foff += (long)(sizeof (char) * fwrite(&data_ptr[i*2+0], (sizeof (char)), 1, w_fp));
542                        }
543                  }
544          break;
545            case FD_LONG_INT:
546                  if (change_bit_order == FALSE) {
547                    if (debug) logit("e", "Writing data out direct from buffer, no byte order change\n");
548                    foff += (long)(sizeof (int32_t) * fwrite(data_ptr, (sizeof (int32_t)), data.n_samples, w_fp));
549                  } else if (change_bit_order == TRUE) {
550                    if (debug) logit("e", "Changing byte order of data for output\n");
551                    //REORDER longs
552                        for (i=0; i<data.n_samples; i++) {
553                          foff += (long)(sizeof (char) * fwrite(&data_ptr[i*4+3], (sizeof (char)), 1, w_fp));
554                          foff += (long)(sizeof (char) * fwrite(&data_ptr[i*4+2], (sizeof (char)), 1, w_fp));
555                          foff += (long)(sizeof (char) * fwrite(&data_ptr[i*4+1], (sizeof (char)), 1, w_fp));
556                          foff += (long)(sizeof (char) * fwrite(&data_ptr[i*4+0], (sizeof (char)), 1, w_fp));
557                        }
558                  }
559              break;
560      }
561          last_status = status;
562    }
563  }
564 
565  fclose(w_fp);
566 
567  if (debug)
568  {
569    logit ("e", "Successful completion of WFDISCPA_next\n");
570  }
571  return EW_SUCCESS;
572
573}
574
575
576/************************************************************************
577 * WFDISCPA_end_ev
578 *
579 * Description: called when an event has been completely processed
580 *
581 * Input parameters: debug - flag for debugging output
582 * Output parameters: none
583 * Returns: EW_SUCCESS or EW_FAILURE
584 *
585 * Comments:
586 *
587 *****************************************************************************/
588int WFDISCPA_end_ev (int debug)
589
590{
591  int i=0;
592//  int empty = 0;
593  if (debug)
594  {
595    logit ("e", "Entering WFDISCPA_end_ev\n");
596  }
597  for (i=0; i<fp_array_size; i++)
598  { 
599    fclose(fp_array[i].wfdisc_fp);
600  }
601
602  return EW_SUCCESS;
603
604}
605
606/************************************************************************
607 * WFDISCPA_close
608 *
609 * Description: called at program shutdown
610 *
611 * Input parameters: debug - flag for debugging output
612 * Output parameters: none
613 * Returns: EW_SUCCESS or EW_FAILURE
614 *
615 * Comments:
616 *
617 *****************************************************************************/
618int WFDISCPA_close (int debug)
619{
620
621  if (debug)
622  {
623    logit ("e", "Entering WFDISCPA_close\n");
624  }
625
626  return EW_SUCCESS;
627
628}
629
630
631/************************
632 * ymd2doy
633 *
634 * Description: called to convert the char string YYYYMMDD to the day of the year integer
635 *
636 * Input char* containing YYYYMMDD
637 * Returns integer for the day of the year
638 *
639 * ****************************/
640int ymd2doy(char* yyyymmdd) 
641{
642  int leapyear = 0;
643  int year = 0;
644  int month = 0;
645  int day = 0;
646  int doy = 0;
647  char ascii_year[5] = "";
648  char ascii_month[3] = "";
649  char ascii_day[3] = "";
650  strncpy(ascii_year, yyyymmdd, 4);
651  strncpy(ascii_month, &yyyymmdd[4], 2);
652  strncpy(ascii_day, &yyyymmdd[6], 2);
653
654  year = atoi((char*)ascii_year);
655  if (((year % 4) == 0 && (year % 100) != 0) || (year % 400) == 0) { leapyear = 1; }
656  month = atoi((char*)ascii_month);
657  day = atoi((char*)ascii_day);
658
659  switch ( month )
660  { 
661    case 1:
662          doy = 0 + day;
663      break;
664        case 2:
665          doy = 31 + day;
666          break;
667        case 3:
668          doy = 59 + leapyear + day;
669          break;
670        case 4:
671          doy = 90 + leapyear + day;
672          break;
673        case 5:
674          doy = 120 + leapyear + day;
675          break;
676        case 6:
677          doy = 151 + leapyear + day;
678          break;
679        case 7:
680          doy = 181 + leapyear + day;
681          break;
682        case 8:
683          doy = 212 + leapyear + day;
684          break;
685        case 9:
686          doy = 243 + leapyear + day;
687          break;
688        case 10:
689          doy = 273 + leapyear + day;
690          break;
691        case 11:
692          doy = 304 + leapyear + day;
693          break;
694        case 12:
695          doy = 334 + leapyear + day;
696          break;
697  }
698  return doy;
699}
700       
701
702FILE* open_wfdisc_file(char* station, char* channel, char* evtDate) 
703{
704  char *output_name;
705  int i=0;
706  if ( -1 == chdir_ew(storage_dir) ) {
707   logit("e", "WFDISCPA_next: Call to chdir to:%s failed\n", storage_dir); 
708   return EW_FAILURE;
709  }
710  output_name = station;
711  //If station exists in config.spec_array then use config.spec_array[i]->outname instead of station
712  for(i=0; i<config.n_spec_array; i++)
713  {
714    if (strncmp("*", config.spec_array[i].sta,7) == 0)
715        {
716          output_name = config.spec_array[i].outname;
717          break;
718        }
719    if ((strncmp(station, config.spec_array[i].sta, 7) == 0) && 
720            ((strncmp(channel, config.spec_array[i].chan, 9) == 0) || 
721                 (strncmp("*", config.spec_array[i].chan, 9) == 0 )))
722        {
723          output_name = config.spec_array[i].outname;
724          break;
725        }
726  }
727  //If station exists in wfdisc_fp_array then return it,
728  //else open file and add to the array and return that fp
729  //
730  //If there are no entries in wfdisc_fp_array then open
731  //new file add it and return it
732  if (fp_array_size == 0) 
733  {
734    snprintf(dirpath, 22, "%c%c%c%c/%c%c/%s/", evtDate[0], evtDate[1], evtDate[2],
735                                                    evtDate[3], evtDate[4], evtDate[5], 
736                                                    output_name);
737       
738    if (RecursiveCreateDir (dirpath) != EW_SUCCESS)
739    {
740      logit ("e", "WFDISCPA_next: Call to CreateDir failed\n");
741      return EW_FAILURE;
742    }
743    //Change dir to dirpath and open wfdisc for writing
744    if ( -1 == chdir_ew(dirpath) ) {
745          logit("e", "WFDISCPA_next: Call to chdir to:%s failed\n", dirpath); 
746          return EW_FAILURE;
747    }
748    if (CreateDir (config.w_dir) != EW_SUCCESS)
749    {
750      logit ("e", "WFDISCPA_next: Call to CreateDir failed\n");
751      return EW_FAILURE;
752    }
753
754    fp_array[0].wfdisc_fp = fopen(wfdisc_name, "w+");
755    if (!fp_array[0].wfdisc_fp) { 
756      logit("e", "WFDISCPA_next: error opening wfdisc file %s for writing\n", wfdisc_name );
757          return EW_FAILURE;
758    }
759        //Add station to array
760        strncpy(fp_array[0].sta, output_name, 7);
761        fp_array_size=1;
762        return fp_array[0].wfdisc_fp;
763    //Create dir structure and open file
764        //add fp to array
765        //return fp
766  } else {
767    for(i=0; i<fp_array_size; i++) 
768    {
769      //If station == fp_array[i]->station
770      if (strncmp(output_name, fp_array[i].sta, 7) == 0) 
771      {
772        return fp_array[i].wfdisc_fp;
773      }
774      //return fp_array[i]->wfdisc_fp;
775    }
776
777    snprintf(dirpath, 22, "%c%c%c%c/%c%c/%s/", evtDate[0], evtDate[1], evtDate[2],
778                                                    evtDate[3], evtDate[4], evtDate[5], 
779                                                    output_name);
780
781       
782    if (RecursiveCreateDir (dirpath) != EW_SUCCESS)
783    {
784      logit ("e", "WFDISCPA_next: Call to CreateDir failed\n");
785      return EW_FAILURE;
786    }
787    //Change dir to dirpath and open wfdisc for writing
788    if ( -1 == chdir_ew(dirpath) ) {
789          logit("e", "WFDISCPA_next: Call to chdir to:%s failed\n", dirpath); 
790          return EW_FAILURE;
791    }
792    if (CreateDir (config.w_dir) != EW_SUCCESS)
793    {
794      logit ("e", "WFDISCPA_next: Call to CreateDir failed\n");
795      return EW_FAILURE;
796    }
797
798    fp_array[fp_array_size].wfdisc_fp = fopen(wfdisc_name, "w+");
799    if (!fp_array[fp_array_size].wfdisc_fp) { 
800      logit("e", "WFDISCPA_next: error opening wfdisc file %s for writing\n", wfdisc_name);
801          return EW_FAILURE;
802    }
803
804        //Add station to array
805    strncpy(fp_array[fp_array_size].sta, output_name, 7);
806    //printf("fp_array_size: %d, sta: %s, \n", fp_array_size, fp_array[fp_array_size].sta);
807    fp_array_size++;
808    return fp_array[fp_array_size].wfdisc_fp;
809  }
810}
811
812
813int initialize(char *config_filename, wfdisc_config *config_local)
814{
815  int n_files, success, found;
816  char *command, *ptr;
817  wfdisc_params *calib_params_ptr;
818  wfdisc_spec *wfdisc_spec_ptr;
819  char *sta=NULL, *chan=NULL, *instype=NULL, *segtype=NULL, *outname=NULL,
820       *calib_str=NULL, *calper_str=NULL;
821  int32_t chanid = 0;
822  float calib, calper;
823
824  //Initialize my config
825  strcpy (config_local->w_dir, "");
826  config_local->n_calib_params = 0;
827  config_local->calib_params = (wfdisc_params *) 0;
828  config_local->n_spec_array = 0;
829  config_local->spec_array = (wfdisc_spec *) 0;
830  config_local->allinone = 0;
831
832  n_files = k_open(config_filename);
833  if(n_files == 0) 
834  {
835    logit("e", "WFDISCPA_init: Initialization failed to open config file %s\n", config_filename);
836    return EW_SUCCESS;
837  }
838  /* while a configuration file is open ... */
839  while (n_files > 0)
840  {
841    /* for each line in the file ... */
842    while (k_rd ())
843    {
844      /* Get the first token from line, remove blank lines and comments */
845      command = (char *)k_str();
846      if (! command) continue;
847      if (*command == '#') continue;
848
849      /* process the command */
850      if (*command == '@')
851      {
852        /* Open a nested configuration file */
853        success = n_files+1;
854        n_files = k_open (command +1);
855        if (n_files != success)
856        {
857          logit("e", "WFDISCPA_init: Initialization Error opening command file <%s>\n",
858                   command +1);
859          return EW_FAILURE;
860        }
861      }
862          else if (k_its("w_location"))
863          {
864            ptr = (char *)k_str();
865                if (ptr) strcpy (config_local->w_dir, ptr);
866          }
867          //else if (k_its("wfdisc_separate"))
868          //{
869          //  config_local->allinone = 1;
870          //}
871          else if (k_its("calib"))
872          {
873            //Import to the calib_params array
874                //
875                found = 1;
876                if ((sta = (char *)k_str()) == NULL) found = 0;
877                else if ((chan = (char *)k_str()) == NULL) found = 0;
878                else if ((chanid = k_int()) == 0) found = 0;
879                else if ((calib_str = (char *)k_str()) == NULL) found = 0;
880                else if ((calper_str = (char *)k_str()) == NULL) found = 0;
881                else if ((instype = (char *)k_str()) == NULL) found = 0;
882                else if ((segtype = (char *)k_str()) == NULL) found = 0;
883        calib = (float)atof(calib_str);
884        calper = (float)atof(calper_str);
885        if (!found) 
886                {
887                  logit("e", "WFDISCPA_init Reading calib parameters failed\n");
888                  return EW_FAILURE;
889                }
890                //realloc memory
891                //Need to define this ptr
892                calib_params_ptr = realloc(config_local->calib_params, 
893                                           sizeof(wfdisc_params) * (config_local->n_calib_params + 1));
894                if (!calib_params_ptr) 
895                {
896                  logit("e", "WFDISCPA_init: Not enough memory available to store all calib parameters\n");
897                  return EW_FAILURE;
898                }
899                config_local->calib_params = calib_params_ptr;
900                calib_params_ptr += config_local->n_calib_params;
901                config_local->n_calib_params++;
902
903                strcpy(calib_params_ptr->sta, sta);
904                strcpy(calib_params_ptr->chan, chan);
905                calib_params_ptr->chanid = chanid;
906                calib_params_ptr->calib = calib;
907                calib_params_ptr->calper = calper;
908                strcpy(calib_params_ptr->instype, instype);
909                strcpy(calib_params_ptr->segtype, segtype);
910          }
911          else if (k_its("wfdisc_spec"))
912          {
913            //Import to the spec_array
914                found = 1;
915                if ((outname = (char *)k_str()) == NULL) found = 0;
916                else if ((sta = (char *)k_str()) == NULL) found = 0;
917                else if ((chan = (char *)k_str()) == NULL) found = 0;
918                if (!found)
919                {
920                  logit("e", "WFDSICPA_init: Reading wfdisc_spec parameters failed\n");
921                  return EW_FAILURE;
922                }
923                wfdisc_spec_ptr = realloc(config_local->spec_array, 
924                                          sizeof(wfdisc_spec) * (config_local->n_spec_array + 1));
925                if (!wfdisc_spec_ptr) 
926                {
927                  logit("e", "WFDISCPA_init: Not enough memory available to store all spec parameters\n");
928                  return EW_FAILURE;
929                }
930                config_local->spec_array = wfdisc_spec_ptr;
931                wfdisc_spec_ptr +=config_local->n_spec_array;
932                config_local->n_spec_array ++;
933       
934                strncpy(wfdisc_spec_ptr->outname, outname, 20);
935        strncpy(wfdisc_spec_ptr->sta, sta, 7);
936                strncpy(wfdisc_spec_ptr->chan, chan, 9);
937          }
938        }
939    n_files=k_close();
940  }
941  return EW_SUCCESS;
942}
Note: See TracBrowser for help on using the repository browser.