Changeset 7987


Ignore:
Timestamp:
03/31/19 02:20:08 (3 weeks ago)
Author:
stefan
Message:

needed more real header values

Location:
branches/cosmos
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • branches/cosmos

  • branches/cosmos/include/cosmos0putaway.h

    r7986 r7987  
    1616 
    1717#define TAG_FILE        '.tag'        /* file containing the last known file tag */ 
    18 #define GAP_FILL        "NaN" 
     18/* #define GAP_FILL        "NaN" // this is what we want, but for the moment we'll use 0  */ 
     19#define GAP_FILL        "0" 
    1920#define MAXTXT           150 
    2021 
  • branches/cosmos/include/pa_subs.h

    r7902 r7987  
    3737int COSMOS0PA_init(int, char *, char *, int); 
    3838int COSMOS0PA_next_ev(TRACE_REQ *, char *, char *, char*, char*, int, int, double); 
     39int COSMOS0PA_header(TRACE_REQ *, char *, char *, char*, char*, int, int, double); /* Looks the same as above because we copied it */ 
    3940int COSMOS0PA_next(TRACE_REQ *, double, long, int, int, double); 
    4041int COSMOS0PA_end_ev(int); 
  • branches/cosmos/src/libsrc/util/cosmos0putaway.c

    r7983 r7987  
    9797        } 
    9898 
     99        /* Allocate the meta structures */ 
     100        if ((cosmos_info = (COSMOS *)calloc(1, sizeof(COSMOS))) 
     101                == (COSMOS *)NULL) { 
     102                logit("e", 
     103                        "Out of memory for COSMOS structures.\n"); 
     104                return EW_FAILURE; 
     105        } 
     106        sprintf(cosmos_info->OutDir, "%s", OutDir); 
    99107        /* Make sure that the top level output directory exists */ 
    100         if (RecursiveCreateDir(OutDir) != EW_SUCCESS) 
     108        if (RecursiveCreateDir(cosmos_info->OutDir) != EW_SUCCESS) 
    101109        { 
    102110                logit("e", "COSMOS0PA_init: Call to RecursiveCreateDir failed\n"); 
     
    127135*   for writing.                                                        * 
    128136*                                                                       * 
    129 *   This also opens the library file, and writes its contents to our    * 
    130 *   output file                                                         * 
     137*   This also opens the arc hypo file, and writes its struct to our     * 
     138*   struct                                                              * 
    131139*************************************************************************/ 
    132140int COSMOS0PA_next_ev(TRACE_REQ *ptrReq, 
     
    186194 
    187195 
    188         sprintf(COSMOS0File, "%s/%s%s%s%s.v0", OutDir, 
    189                 ptrReq->sta, yr, mo, dy); 
    190  
    191         /* cos_date "06/17/2018, 18:34:38.004 GMT (Q=5) "<-35 chars; Q stands for Quality, we have no way to know that */ 
    192         sprintf(cos_date, "%s/%s/%s, %s:%s:%s  UTC", mo, dy, year, hr, mn, sec); 
    193  
     196        sprintf(cosmos_info->LibDir, "%s", LibDir); 
     197        sprintf(cosmos_info->EventTime, "%s", EventTime); 
     198        sprintf(cosmos_info->EventDate, "%s", EventDate); 
     199 
     200        /* I think we already created this, but, it is OK to try again. */ 
    194201        RecursiveCreateDir(OutDir); 
    195202        sprintf(COSMOS0LibFile, "%s/%s_%s_%s_%s.dlv0",  
    196203                LibDir, ptrReq->net, ptrReq->sta, ptrReq->loc, ptrReq->chan); 
    197204 
    198         if (debug == 1) 
    199                 logit("t", "Opening COSMOS0 library file header %s\n", COSMOS0LibFile); 
    200  
    201         /* open library file just for reading */ 
    202         if ((COSMOS0Libfp = fopen(COSMOS0LibFile, "r")) == NULL) 
    203         { 
    204                 logit("e", "COSMOS0PA_next_ev: unable to open file %s: %s\n", 
    205                         COSMOS0LibFile, strerror(errno)); 
    206                 return EW_FAILURE; 
    207         } 
    208  
    209         if (debug == 1) 
    210                 logit("et", "Opening COSMOS0 file %s\n", COSMOS0File); 
    211  
    212         /* open file */ 
    213         if ((COSMOS0fp = fopen(COSMOS0File, "wt")) == NULL) 
    214         { 
    215                 logit("e", "COSMOS0PA_next_ev: unable to open file %s: %s\n", 
    216                         COSMOS0File, strerror(errno)); 
    217                 return EW_FAILURE; 
    218         } 
    219205        /* If there's enough time to implement, this filename should be able to be specified in the dot D file. */ 
    220206        sprintf(EventArcFile, "%s/event.arc", LibDir); 
     
    250236        /* We should be able to do something like               origintime = arcmsg.sum.ot - GSEC1970; after parse_arc */ 
    251237        if (debug == 1) logit("et", "COSMOS0PA_next_ev: Debug: Arc parsing %s\n", EventArcFile); 
    252         if (parse_arc(fbuffer, &arcmsg) != 0 ) 
     238        if (parse_arc(fbuffer, &cosmos_info->arcmsg) != 0 ) 
    253239        { 
    254240                logit("et", "COSMOS0PA_next_ev: Error parsing %s\n", 
    255241                        EventArcFile); 
    256242        } 
     243 
     244        return (EW_SUCCESS); 
     245} 
     246 
     247 
     248/************************************************************************ 
     249*   This we open the COSMOS0 file                                       * 
     250*   for writing.                                                        * 
     251*                                                                       * 
     252*   This also opens the library file, and writes its contents to our    * 
     253*   output file                                                         * 
     254*************************************************************************/ 
     255int COSMOS0PA_header(TRACE_REQ *ptrReq, 
     256        char *OutDir, char *LibDir, char *EventDate, char *EventTime, 
     257        int cadence, int debug, double Multiplier) 
     258 
     259{ 
     260        char    COSMOS0File[4 * MAXTXT]; 
     261        char    COSMOS0LibFile[4 * MAXTXT]; 
     262        char    EventArcFile[4 * MAXTXT]; 
     263        /*      char    c; */ 
     264        char    year[5]; 
     265        char    yr[3]; 
     266        char    mo[3]; 
     267        char    dy[3]; 
     268        char    hr[3]; 
     269        char    mn[3]; 
     270        char    sec[7]; 
     271        char    cos_date[35]; /* Start date of data requested */ 
     272        char    record_id[35]; 
     273        char    str[COSMOSLINELEN]; 
     274        char    tempstr[COSMOSLINELEN]; 
     275        char    tempstr2[COSMOSLINELEN]; 
     276        char    fifteen[16]; 
     277        int     LineNumber = 0; 
     278        time_t  rawtime; 
     279        struct tm * timeinfo; 
     280        size_t  nfbuffer;               /* Read bytes */ 
     281        char    *fbuffer;               /* File read buffer */ 
     282        static long      MaxMessageSize = 100000;  /* size (bytes) of largest msg */ 
     283        HypoArc                 arcmsg;                 /* ARC message */ 
     284        char            timestr[80];                                    /* Holds time messages */ 
     285        time_t          ot; 
     286        struct tm * (*timefunc)(const time_t *); 
     287        char            time_type[30] = { 0 };                                  /* Time type UTC or local */ 
     288 
     289 
     290                                                                                                                /* Grab the date-related substrings that we need for filenames. */ 
     291        strncpy(year, EventDate, 4); 
     292        year[4] = '\0'; 
     293        strncpy(yr, EventDate + 2, 2); 
     294        yr[2] = '\0'; 
     295        strncpy(mo, EventDate + 4, 2); 
     296        mo[2] = '\0'; 
     297        strncpy(dy, EventDate + 6, 2); 
     298        dy[2] = '\0'; 
     299 
     300        strncpy(hr, EventTime, 2); 
     301        hr[2] = '\0'; 
     302        strncpy(mn, EventTime + 2, 2); 
     303        mn[2] = '\0'; 
     304        strncpy(sec, EventTime + 4, 5); 
     305        sec[5] = '\0'; 
     306 
     307        cos_date[34] = '\0'; 
     308        record_id[34] = '\0'; 
     309        tempstr[0] = '\0'; 
     310 
     311 
     312        sprintf(COSMOS0File, "%s/%s_%s_%s_%s_%s%s%s_%s%s.v0", OutDir, 
     313                ptrReq->net, ptrReq->sta, ptrReq->loc, ptrReq->chan, year, mo, dy, hr, mn); 
     314 
     315        /* cos_date "06/17/2018, 18:34:38.004 GMT (Q=5) "<-35 chars; Q stands for Quality, we have no way to know that */ 
     316        sprintf(cos_date, "%s/%s/%s, %s:%s:%s  UTC", mo, dy, year, hr, mn, sec); 
     317 
     318        RecursiveCreateDir(OutDir); 
     319        sprintf(COSMOS0LibFile, "%s/%s_%s_%s_%s.dlv0", 
     320                LibDir, ptrReq->net, ptrReq->sta, ptrReq->loc, ptrReq->chan); 
     321 
     322        if (debug == 1) 
     323                logit("t", "Opening COSMOS0 library file header %s\n", COSMOS0LibFile); 
     324 
     325        /* open library file just for reading */ 
     326        if ((COSMOS0Libfp = fopen(COSMOS0LibFile, "r")) == NULL) 
     327        { 
     328                logit("e", "COSMOS0PA_next_ev: unable to open file %s: %s\n", 
     329                        COSMOS0LibFile, strerror(errno)); 
     330                return EW_FAILURE; 
     331        } 
     332 
     333        if (debug == 1) 
     334                logit("et", "Opening COSMOS0 file %s\n", COSMOS0File); 
     335 
     336        /* open file */ 
     337        if ((COSMOS0fp = fopen(COSMOS0File, "wt")) == NULL) 
     338        { 
     339                logit("e", "COSMOS0PA_next_ev: unable to open file %s: %s\n", 
     340                        COSMOS0File, strerror(errno)); 
     341                return EW_FAILURE; 
     342        } 
     343        arcmsg = cosmos_info->arcmsg; 
    257344        timefunc = localtime; 
    258         ot = (time_t)(arcmsg.sum.ot - GSEC1970);  
     345        ot = (time_t)(arcmsg.sum.ot - GSEC1970); 
    259346        timeinfo = timefunc(&ot); 
    260347        /* Copy the library file to the putaway file*/ 
    261 /*      c = fgetc(COSMOS0Libfp); 
     348        /*      c = fgetc(COSMOS0Libfp); 
    262349        while (c != EOF) 
    263350        { 
    264                 fputc(c, COSMOS0fp); 
    265                 c = fgetc(COSMOS0Libfp); 
    266         } 
    267 */ 
     351        fputc(c, COSMOS0fp); 
     352        c = fgetc(COSMOS0Libfp); 
     353        } 
     354        */ 
    268355        while (fgets(str, COSMOSLINELEN, COSMOS0Libfp) != NULL) { 
    269                 LineNumber++ ; 
     356                LineNumber++; 
     357                sprintf(tempstr, "                                                                                ");/*clear it*/ 
     358                sprintf(fifteen, "               "); 
    270359                switch (LineNumber) { 
    271360                case 2: /*  2 1-40 Earthquake name (before a name has been assigned, may appear as “Record of”; test 
    272                                         records may use “Test Record of”, etc.). 
    273                                         41-80 Earthquake date and time (including time zone). */ 
     361                                records may use “Test Record of”, etc.). 
     362                                41-80 Earthquake date and time (including time zone). */ 
    274363                        strftime(timestr, 80, "Record of                 Earthquake of %B %d, %Y, %H:%M:%S   UTC", timeinfo); 
    275364                        fprintf(COSMOS0fp, "%s\n", timestr); 
    276365                        break; 
    277366                case 3: /*3 12-46 Hypocenter: 12-20 Latitude (positive North); 22-31 Longitude (positive East); and 
    278                                         35-37 Depth (km); 40-46 Source agency for hypocenter information. 
    279                                         47-80 Magnitude(s), including source agency for values (may be entered manually, so 
    280                                         spacing may be variable).**/ 
    281                         sprintf(tempstr, "Hypocenter: %9.4f %9.4f H=%3.0fkm M=%3.1f, Md=%3.1f", 
    282                                 arcmsg.sum.lat, arcmsg.sum.lon, arcmsg.sum.z, arcmsg.sum.Mpref, arcmsg.sum.Md); 
     367                                35-37 Depth (km); 40-46 Source agency for hypocenter information. 
     368                                47-80 Magnitude(s), including source agency for values (may be entered manually, so 
     369                                spacing may be variable).**/ 
     370                        sprintf(tempstr, "Hypocenter: %9.4f %9.4f H=%3.0fkm Md=%3.1f, Ml=%3.1f", 
     371                                arcmsg.sum.lat, arcmsg.sum.lon, arcmsg.sum.z, arcmsg.sum.Md, arcmsg.sum.Mpref);  
    283372                        fprintf(COSMOS0fp, "%s\n", tempstr); 
    284373                        break; 
    285374                case 4: /*      4 9-42 Earthquake origin date and time, in UTC (i.e., GMT), with source agency; 43-80, 
    286                                         For use by preparing agency; may include note, e.g., “Preliminary Processing”, etc.*/ 
    287  
    288                         /* Prepare origin time. Second can have tenths place, so leaving two spaces here to indicate  
    289                            we're not going to that level of precision, the timestruct doesn't have tenths. Probably worth revisiting.*/ 
    290                         strftime(timestr, 80, "%m/%d/%Y, %H:%M:%S  ", timeinfo);  
     375                                For use by preparing agency; may include note, e.g., “Preliminary Processing”, etc.*/ 
     376 
     377                                /* Prepare origin time. Second can have tenths place, so leaving two spaces here to indicate 
     378                                we're not going to that level of precision, the timestruct doesn't have tenths. Probably worth revisiting.*/ 
     379                        strftime(timestr, 80, "%m/%d/%Y, %H:%M:%S  ", timeinfo); 
    291380                        sprintf(tempstr, "Origin: %s UTC", timestr); 
    292381                        fprintf(COSMOS0fp, "%s\n", tempstr); 
    293382                        break; 
    294383                case 8: /*  Record information: 
    295                                         8 17-50 Record start time (date and time of first sample; may be approximate - precise value 
    296                                         should be obtained from real header) and time quality (0 through 5 correspond to 
    297                                         lowest through highest quality). 
    298                                         59-80 Record identification, assigned by preparing agency. 
    299                                     "06/17/2018, 18:34:38.004 GMT (Q=5) "<- 35 chars   " (Q=5) " "38199368.SB.WLA.00.HN " <- 22char*/  
    300                         /* strncpy(record_id, str + 45, 34); no, we're not going to use any of the prev string */ 
    301                         /* We pad with white space, because we're going to overwrite some of it, and we'll only copy 
    302                            the relevant characters to go up to 80, andything too long will get truncated. */ 
     384                                8 17-50 Record start time (date and time of first sample; may be approximate - precise value 
     385                                should be obtained from real header) and time quality (0 through 5 correspond to 
     386                                lowest through highest quality). 
     387                                59-80 Record identification, assigned by preparing agency. 
     388                                "06/17/2018, 18:34:38.004 GMT (Q=5) "<- 35 chars   " (Q=5) " "38199368.SB.WLA.00.HN " <- 22char*/ 
     389                                /* strncpy(record_id, str + 45, 34); no, we're not going to use any of the prev string */ 
     390                                /* We pad with white space, because we're going to overwrite some of it, and we'll only copy 
     391                                the relevant characters to go up to 80, andything too long will get truncated. */ 
    303392                        sprintf(tempstr, "Rcrd start time:%s                             ", cos_date); 
    304                         sprintf(tempstr2, "RcrdId:%zu.%s.%s.%s.%s                  ",  
    305                                 arcmsg.sum.qid,ptrReq->net, ptrReq->sta, ptrReq->loc, ptrReq->chan); 
     393                        sprintf(tempstr2, "RcrdId:%lu.%s.%s.%s.%s                  ", 
     394                                arcmsg.sum.qid, ptrReq->net, ptrReq->sta, ptrReq->loc, ptrReq->chan); 
    306395                        strncpy(tempstr + 51, tempstr2, 29); 
    307396                        tempstr[80] = '\0'; /* Chop off any extra junk */ 
     
    309398                        break; 
    310399                case 10: /* 10 20-27 Length of raw record, as recorded (seconds); 45-54 Maximum of raw (uncorrected) 
    311                                         record in g (or other units);* 60-67 Time max occurs in raw record (secs after start).  
    312                                         Example: 
    313                                         Raw record length = 175.340  sec, Uncor max = 100000000, at   40.220 sec. */ 
     400                                 record in g (or other units);* 60-67 Time max occurs in raw record (secs after start). 
     401                                 Example: 
     402                                 Raw record length = 175.340  sec, Uncor max = 100000000, at   40.220 sec. */ 
    314403                        sprintf(tempstr, "Raw record length = %f", (ptrReq->reqEndtime - ptrReq->reqStarttime)); 
    315404                        strncpy(tempstr + 28, "sec, Uncor max =                                    ", 53); 
     
    317406                        break; 
    318407                case 11: /*"Record Information; Line 11 
    319                                         11-40 Processing/release date, time and agency. 
    320                                         48-80 Maximum of data series in file, units, and time of maximum (seconds after start).*" 
    321                                         What should I put here? An example file looks like: 
    322                                         "Processed: 06/17/18 12:00 PDT UCB                                   " 
    323                                 */ 
     408                                 11-40 Processing/release date, time and agency. 
     409                                 48-80 Maximum of data series in file, units, and time of maximum (seconds after start).*" 
     410                                 What should I put here? An example file looks like: 
     411                                 "Processed: 06/17/18 12:00 PDT UCB                                   " 
     412                                 */ 
    324413                        time(&rawtime); 
    325414                        timeinfo = gmtime(&rawtime); 
    326                         sprintf(tempstr, "Processed: %d/%d/%d %d:%d UTC                                       ",  
     415                        sprintf(tempstr, "Processed: %d/%d/%d %d:%d UTC                                       ", 
    327416                                (timeinfo->tm_mon + 1), 
    328417                                timeinfo->tm_mday, 
    329418                                (timeinfo->tm_year + 1900), 
    330                                 timeinfo->tm_hour,  
     419                                timeinfo->tm_hour, 
    331420                                timeinfo->tm_min 
    332421                        ); 
    333422                        fprintf(COSMOS0fp, "%s\n", tempstr); 
    334423                        break; 
     424                /* Real Headers include Earthquake information similar to comments above, comments for humans, below for PRISM*/ 
     425                case 27: /* Site geology stuff from the database are the first 4 params in this line, so read them in and leave 
     426                                    them be. But the 5th param we'll overwrite here with Earthquake latitude (decimal degrees, North positive)*/ 
     427                        sprintf(fifteen, "%15.6f", arcmsg.sum.lat); 
     428                        strncpy(str + 60, fifteen, 15); 
     429                        fprintf(COSMOS0fp, "%s", str); 
     430                        break; 
     431                case 28: /* Earthquake longitude (decimal degrees, East positive), Earthquake depth (km)., Moment magnitude, M., Surface-wave magnitude, MS., Local magnitude, ML.*/ 
     432                        sprintf(tempstr, "%15.6f%15.6f%15.6f%15.6f%15.6f", arcmsg.sum.lon, arcmsg.sum.z, -999.0, -999.0, arcmsg.sum.Mpref); 
     433                        fprintf(COSMOS0fp, "%s\n", tempstr); 
     434                        break; 
     435                case 29: /* Other magnitude; I guess I'll put Md here, Epicentral distance to station (km)., Epicenter-to-station azimuth (CW from north) <- we don't have those two, so -999 */ 
     436                        sprintf(fifteen, "%15.6f", arcmsg.sum.Md); 
     437                        strncpy(str, fifteen, 15);                       
     438                        sprintf(fifteen, "%15.6f", -999.0); 
     439                        strncpy(str + 15, fifteen, 15); 
     440                        strncpy(str + 30, fifteen, 15); 
     441                        fprintf(COSMOS0fp, "%s", str); 
     442                        break; 
    335443                case 47: /*AQMS normally writes this comment, but we're not using AQMS*/ 
    336                         /* Example: | RcrdId: NC.72282711.NC.C031.HNE.01 */ 
    337                         sprintf(tempstr, "| RcrdId: %s.%zu.%s.%s.%s.%s ", /* FIX: If anyone knows what I can put here instead of 72282711, I'll do it!*/ 
     444                                 /* Example: | RcrdId: NC.72282711.NC.C031.HNE.01 */ 
     445                        sprintf(tempstr, "| RcrdId: %s.%lu.%s.%s.%s.%s ", /* FIX: If anyone knows what I can put here instead of 72282711, I'll do it!*/ 
    338446                                ptrReq->net, arcmsg.sum.qid, ptrReq->net, ptrReq->sta, ptrReq->chan, ptrReq->loc); 
    339447                        fprintf(COSMOS0fp, "%s\n", tempstr); 
    340448                        break; 
    341449                case 48: /*AQMS normally writes this comment, but we're not using AQMS*/ 
    342                         /*Example:|<SCNL>C031.HNE.NC.01    <AUTH> 2015/03/01 16:46:25.000*/ 
     450                                 /*Example:|<SCNL>C031.HNE.NC.01    <AUTH> 2015/03/01 16:46:25.000*/ 
    343451                        sprintf(tempstr, "|<SCNL> %s.%s.%s.%s    <AUTH> %d/%d/%d %d:%d:%d.000", 
    344452                                ptrReq->sta, ptrReq->chan, ptrReq->net, ptrReq->loc, 
    345                                 (timeinfo->tm_year + 1900),     (timeinfo->tm_mon + 1), timeinfo->tm_mday, 
     453                                (timeinfo->tm_year + 1900), (timeinfo->tm_mon + 1), timeinfo->tm_mday, 
    346454                                timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec); 
    347455                        fprintf(COSMOS0fp, "%s", tempstr); 
    348456                        break; 
    349                 default:  
    350                         fprintf(COSMOS0fp, "%s", str);           
     457                default: 
     458                        fprintf(COSMOS0fp, "%s", str); 
    351459                } 
    352460 
     
    391499        char    sample[12]; 
    392500        char    elevendigits[12]; 
     501        char    eightdigits[9]; 
    393502        char   *msg_p;        /* pointer into tracebuf data */ 
    394503        double  begintime = 0, starttime = 0, endtime = 0, currenttime = 0; 
     
    420529                return EW_FAILURE; 
    421530        } 
     531 
     532 
     533        COSMOS0PA_header(getThis, cosmos_info->OutDir, cosmos_info->LibDir, cosmos_info->EventDate, cosmos_info->EventTime, Cadence, debug, Multiplier); 
    422534        /* Used for computing trace statistics */ 
    423535        total = 0; 
     
    462574/*      sprintf(tempstr, "17770    raw accel.pts,   approx  178  secs, units=counts (50),Format=(10I8)   \n");*/ 
    463575        sprintf(tempstr, "         raw accel.pts,   approx           , units=counts (50),Format=(10I8)    \n"); 
    464         raw_counts = (getThis->reqEndtime - getThis->reqStarttime ) * samprate; 
     576        raw_counts = (getThis->reqEndtime - getThis->reqStarttime ) * samprate;  
    465577        sprintf(tempstr2, "%d", raw_counts); 
    466578        strncpy(tempstr, tempstr2, strlen(tempstr2)); 
     
    618730                /* WRITE DATA */ 
    619731 
    620                 while (i < 7 && j < nsamp_this_scn) 
     732                while (i < 10 && j < nsamp_this_scn) 
    621733                { 
     734                        sprintf(eightdigits, "        "); /* we want leading spaces */ 
    622735                        if (COSMOS0Buffer[j] != getThis->fill) { 
    623                                 sprintf(elevendigits, "           "); /* we want leading spaces */ 
    624736                                if (((int)(COSMOS0Buffer[j] * Multiplier) > 999999) || ((int)(COSMOS0Buffer[j] * Multiplier) < -99999)) { 
    625737                                        sprintf(sample, GAP_FILL); 
     
    629741                                        sprintf(sample, "%d", (int)(COSMOS0Buffer[j] * Multiplier)); 
    630742                                } 
    631                                 strcpy(elevendigits + 11 - strlen(sample), sample); 
    632                                 strcpy(hour_line + s_place, elevendigits); 
     743                                strcpy(eightdigits + 8 - strlen(sample), sample); 
     744                                strcpy(hour_line + s_place, eightdigits); 
    633745                        } 
    634746                        else { 
     
    636748                                //strcpy(hour_line + s_place, "  9999"); 
    637749                                sprintf(sample, GAP_FILL); 
    638                                 strcpy(elevendigits + 11 - strlen(sample), sample); 
    639                                 strcpy(hour_line + s_place, elevendigits);                               
     750                                strcpy(eightdigits + 8 - strlen(sample), sample); 
     751                                strcpy(hour_line + s_place, eightdigits);                                
    640752                        } 
    641                         s_place = s_place + 11; 
     753                        s_place = s_place + 8; 
    642754 
    643755                        total += (int)(COSMOS0Buffer[j] * Multiplier); 
     
    650762                *               Two chars 'cr'= 13 and 'nl'= 10. 
    651763                */ 
    652                 hour_line[77] = ' '; /*Replace that null that sprintf got us*/ 
     764                /*hour_line[77] = ' '; /*Replace that null that sprintf got us*/ 
    653765                hour_line[80] = '\n'; 
    654766 
     
    659771                        return EW_FAILURE; 
    660772                } 
     773        } 
     774        /* After we process all of the data, we have to write: 
     775                        End-of-Data Flag Line: 
     776                N+1 1 -11 End of data flag string, “End-of-data for..”. 
     777                21-36 Station channel number and physical parameter of data (a checksum may optionally 
     778                be included on the remainder of this line).  */ 
     779        sprintf(tempstr, "                                                                                ");/*clear it*/ 
     780        sprintf(tempstr, "End-of-data for %s.%s.%s.%s acceleration", getThis->sta, getThis->chan, getThis->net, getThis->loc ); 
     781 
     782        if (fwrite(tempstr, 81, 1, COSMOS0fp) != 1) 
     783        { 
     784                logit("et", "COSMOS0PA_next: error writing COSMOS0 dynamic header line. \n"); 
     785                return EW_FAILURE; 
    661786        } 
    662787        return EW_SUCCESS; 
Note: See TracChangeset for help on using the changeset viewer.