Changeset 8040


Ignore:
Timestamp:
08/14/19 01:29:45 (5 days ago)
Author:
stefan
Message:

cosmos0putaway.c latest working version from cosmos branch

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/libsrc/util/cosmos0putaway.c

    r7982 r8040  
    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"); 
     
    114122                strcpy(COSMOS0OutputFormat, OutputFormat); 
    115123        } 
     124 
     125 
    116126        return EW_SUCCESS; 
    117127} 
     
    127137*   for writing.                                                        * 
    128138*                                                                       * 
    129 *   This also opens the library file, and writes its contents to our    * 
    130 *   output file                                                         * 
     139*   This also opens the arc hypo file, and writes its struct to our     * 
     140*   struct                                                              * 
    131141*************************************************************************/ 
    132142int COSMOS0PA_next_ev(TRACE_REQ *ptrReq, 
     
    135145 
    136146{ 
     147        char    COSMOS0LibFile[4 * MAXTXT]; 
     148/*      char    c; */ 
     149        char    year[5]; 
     150        char    yr[3]; 
     151        char    mo[3]; 
     152        char    dy[3]; 
     153        char    hr[3]; 
     154        char    mn[3]; 
     155        char    sec[7]; 
     156        char    cos_date[35]; /* Start date of data requested */ 
     157        char    record_id[35]; 
     158        char    tempstr[COSMOSLINELEN]; 
     159        int     LineNumber = 0; 
     160        char            time_type[30] = { 0 };                                  /* Time type UTC or local */ 
     161        size_t  nfbuffer;               /* Read bytes */ 
     162        char    *fbuffer;               /* File read buffer */ 
     163        static long      MaxMessageSize = 100000;  /* size (bytes) of largest msg */ 
     164 
     165 
     166        /* Grab the date-related substrings that we need for filenames. */ 
     167        strncpy(year, EventDate, 4); 
     168        year[4] = '\0'; 
     169        strncpy(yr, EventDate + 2, 2); 
     170        yr[2] = '\0'; 
     171        strncpy(mo, EventDate + 4, 2); 
     172        mo[2] = '\0'; 
     173        strncpy(dy, EventDate + 6, 2); 
     174        dy[2] = '\0'; 
     175 
     176        strncpy(hr, EventTime, 2); 
     177        hr[2] = '\0'; 
     178        strncpy(mn, EventTime + 2, 2); 
     179        mn[2] = '\0'; 
     180        strncpy(sec, EventTime + 4, 5); 
     181        sec[5] = '\0'; 
     182 
     183        cos_date[34] = '\0'; 
     184        record_id[34] = '\0';    
     185        tempstr[0]='\0'; 
     186 
     187 
     188        sprintf(cosmos_info->LibDir, "%s", LibDir); 
     189        sprintf(cosmos_info->EventTime, "%s", EventTime); 
     190        sprintf(cosmos_info->EventDate, "%s", EventDate); 
     191 
     192        /* I think we already created this, but, it is OK to try again. */ 
     193        RecursiveCreateDir(OutDir); 
     194        sprintf(COSMOS0LibFile, "%s/%s_%s_%s_%s.dlv0",  
     195                LibDir, ptrReq->net, ptrReq->sta, ptrReq->loc, ptrReq->chan); 
     196 
     197        /* If there's enough time to implement, this filename should be able to be specified in the dot D file. */ 
     198        sprintf(cosmos_info->EventArcFile, "%s/event.arc", cosmos_info->LibDir); 
     199        if (debug == 1) 
     200                logit("t", "Attempting to open event file which always must be named event.arc and located in the LibraryDirectory. \n LibraryDirectory is currently configured as: %s\n", 
     201                        cosmos_info->LibDir); 
     202 
     203        /* open Event file just for reading */ 
     204        if ((EVENTARCfp = fopen(cosmos_info->EventArcFile, "r")) == NULL) 
     205        { 
     206                logit("e", "COSMOS0PA_next_ev: unable to open file %s: %s\nAn .arc file is required to set event information in the COSMOS file format.", 
     207                        cosmos_info->EventArcFile, strerror(errno)); 
     208                return EW_FAILURE; 
     209        } 
     210 
     211        /* Read file to buffer 
     212        *********************/ 
     213        fbuffer = (char*)malloc(sizeof(char) * MaxMessageSize); /*check logic*/ 
     214        if (fbuffer == NULL) 
     215        { 
     216                logit("et", "Unable to allocate memory for filter buffer\n"); 
     217                return -1; 
     218        } 
     219 
     220        nfbuffer = fread(fbuffer, sizeof(char), 
     221                (size_t)MaxMessageSize, EVENTARCfp); 
     222        fclose(EVENTARCfp); // Done reading 
     223        if (nfbuffer == 0) 
     224        { 
     225                logit("eto", "COSMOS0PA_next_ev: No data read from %s\n\nAn .arc file is required to set event information in the COSMOS file format.", 
     226                        cosmos_info->EventArcFile); 
     227                return EW_FAILURE; 
     228        } 
     229        /* We should be able to do something like               origintime = arcmsg.sum.ot - GSEC1970; after parse_arc */ 
     230        if (debug == 1) logit("et", "COSMOS0PA_next_ev: Debug: Arc parsing %s\n", cosmos_info->EventArcFile); 
     231        //if (parse_arc(fbuffer, &cosmos_info->arcmsg) != 0) 
     232        if (parse_arc_no_shdw(fbuffer, &cosmos_info->arcmsg) != 0) 
     233        { 
     234                logit("et", "COSMOS0PA_next_ev: Error parsing %s\n", 
     235                        cosmos_info->EventArcFile); 
     236        } 
     237 
     238 
     239 
     240        return (EW_SUCCESS); 
     241} 
     242 
     243 
     244/************************************************************************ 
     245*   This we open the COSMOS0 file                                       * 
     246*   for writing.                                                        * 
     247*                                                                       * 
     248*   This also opens the library file, and writes its contents to our    * 
     249*   output file                                                         * 
     250*************************************************************************/ 
     251int COSMOS0PA_header(TRACE_REQ *ptrReq, 
     252        char *OutDir, char *LibDir, char *EventDate, char *EventTime, 
     253        int cadence, int debug, double Multiplier) 
     254 
     255{ 
    137256        char    COSMOS0File[4 * MAXTXT]; 
    138257        char    COSMOS0LibFile[4 * MAXTXT]; 
    139         char    EventArcFile[4 * MAXTXT]; 
    140 /*      char    c; */ 
     258        /*      char    c; */ 
    141259        char    year[5]; 
    142260        char    yr[3]; 
     
    151269        char    tempstr[COSMOSLINELEN]; 
    152270        char    tempstr2[COSMOSLINELEN]; 
     271        char    fifteen[16]; 
    153272        int     LineNumber = 0; 
    154273        time_t  rawtime; 
    155274        struct tm * timeinfo; 
    156         size_t  nfbuffer;               /* Read bytes */ 
    157         char    *fbuffer;               /* File read buffer */ 
    158275        static long      MaxMessageSize = 100000;  /* size (bytes) of largest msg */ 
    159276        HypoArc                 arcmsg;                 /* ARC message */ 
     
    164281 
    165282 
    166         /* Grab the date-related substrings that we need for filenames. */ 
     283                                                                                                                /* Grab the date-related substrings that we need for filenames. */ 
    167284        strncpy(year, EventDate, 4); 
    168285        year[4] = '\0'; 
     
    182299 
    183300        cos_date[34] = '\0'; 
    184         record_id[34] = '\0';    
    185         tempstr[0]='\0'; 
    186  
    187  
    188         sprintf(COSMOS0File, "%s/%s%s%s%s.v0", OutDir, 
    189                 ptrReq->sta, yr, mo, dy); 
     301        record_id[34] = '\0'; 
     302        tempstr[0] = '\0'; 
     303 
     304 
     305        sprintf(COSMOS0File, "%s/%s_%s_%s_%s_%s%s%s_%s%s.v0", OutDir, 
     306                ptrReq->net, ptrReq->sta, ptrReq->loc, ptrReq->chan, year, mo, dy, hr, mn); 
    190307 
    191308        /* 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 */ 
     
    193310 
    194311        RecursiveCreateDir(OutDir); 
    195         sprintf(COSMOS0LibFile, "%s/%s_%s_%s_%s.dlv0",  
     312        sprintf(COSMOS0LibFile, "%s/%s_%s_%s_%s.dlv0", 
    196313                LibDir, ptrReq->net, ptrReq->sta, ptrReq->loc, ptrReq->chan); 
    197314 
     
    206323                return EW_FAILURE; 
    207324        } 
     325        else { 
     326                logit("e", "COSMOS0PA_next_ev: Opened file %s\n", 
     327                        COSMOS0LibFile); 
     328        } 
    208329 
    209330        if (debug == 1) 
     
    217338                return EW_FAILURE; 
    218339        } 
    219         /* If there's enough time to implement, this filename should be able to be specified in the dot D file. */ 
    220         sprintf(EventArcFile, "%s/event.arc", LibDir); 
    221         if (debug == 1) 
    222                 logit("t", "Attempting to open event file which always must be named event.arc and located in the LibraryDirectory. \n LibraryDirectory is currently configured as: %s\n", LibDir); 
    223  
    224         /* open Event file just for reading */ 
    225         if ((EVENTARCfp = fopen(EventArcFile, "r")) == NULL) 
    226         { 
    227                 logit("e", "COSMOS0PA_next_ev: unable to open file %s: %s\nAn .arc file is required to set event information in the COSMOS file format.", 
    228                         EventArcFile, strerror(errno)); 
    229                 return EW_FAILURE; 
    230         } 
    231  
    232         /* Read file to buffer 
    233         *********************/ 
    234         fbuffer = (char*)malloc(sizeof(char) * MaxMessageSize); /*check logic*/ 
    235         if (fbuffer == NULL) 
    236         { 
    237                 logit("et", "Unable to allocate memory for filter buffer\n"); 
    238                 return -1; 
    239         } 
    240  
    241         nfbuffer = fread(fbuffer, sizeof(char), 
    242                 (size_t)MaxMessageSize, EVENTARCfp); 
    243         fclose(EVENTARCfp); // Done reading 
    244         if (nfbuffer == 0) 
    245         { 
    246                 logit( "eto", "COSMOS0PA_next_ev: No data read from %s\n\nAn .arc file is required to set event information in the COSMOS file format.", 
    247                         EventArcFile); 
    248                 return EW_FAILURE; 
    249         } 
    250         /* We should be able to do something like               origintime = arcmsg.sum.ot - GSEC1970; after parse_arc */ 
    251         if (debug == 1) logit("et", "COSMOS0PA_next_ev: Debug: Arc parsing %s\n", EventArcFile); 
    252         if (parse_arc(fbuffer, &arcmsg) != 0 ) 
    253         { 
    254                 logit("et", "COSMOS0PA_next_ev: Error parsing %s\n", 
    255                         EventArcFile); 
    256         } 
     340        arcmsg = cosmos_info->arcmsg; 
    257341        timefunc = localtime; 
    258         ot = (time_t)(arcmsg.sum.ot - GSEC1970);  
     342        ot = (time_t)(arcmsg.sum.ot - GSEC1970); 
    259343        timeinfo = timefunc(&ot); 
    260344        /* Copy the library file to the putaway file*/ 
    261 /*      c = fgetc(COSMOS0Libfp); 
     345        /*      c = fgetc(COSMOS0Libfp); 
    262346        while (c != EOF) 
    263347        { 
    264                 fputc(c, COSMOS0fp); 
    265                 c = fgetc(COSMOS0Libfp); 
    266         } 
    267 */ 
    268         while (fgets(str, COSMOSLINELEN, COSMOS0Libfp) != NULL) { 
    269                 LineNumber++ ; 
     348        fputc(c, COSMOS0fp); 
     349        c = fgetc(COSMOS0Libfp); 
     350        } 
     351        */ 
     352        while ((fgets(str, COSMOSLINELEN, COSMOS0Libfp) != NULL) && (LineNumber < 48)) { 
     353                LineNumber++; 
     354                sprintf(tempstr, "                                                                                ");/*clear it*/ 
     355                sprintf(fifteen, "               "); 
    270356                switch (LineNumber) { 
    271357                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). */ 
     358                                records may use “Test Record of”, etc.). 
     359                                41-80 Earthquake date and time (including time zone). */ 
    274360                        strftime(timestr, 80, "Record of                 Earthquake of %B %d, %Y, %H:%M:%S   UTC", timeinfo); 
    275361                        fprintf(COSMOS0fp, "%s\n", timestr); 
    276362                        break; 
    277363                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); 
     364                                35-37 Depth (km); 40-46 Source agency for hypocenter information. 
     365                                47-80 Magnitude(s), including source agency for values (may be entered manually, so 
     366                                spacing may be variable).**/ 
     367                        sprintf(tempstr, "Hypocenter: %9.4f %9.4f H=%3.0fkm Md=%3.1f, M=%3.1f", 
     368                                arcmsg.sum.lat, arcmsg.sum.lon, arcmsg.sum.z, arcmsg.sum.Md, arcmsg.sum.Mpref);  
    283369                        fprintf(COSMOS0fp, "%s\n", tempstr); 
    284370                        break; 
    285371                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);  
     372                                For use by preparing agency; may include note, e.g., “Preliminary Processing”, etc.*/ 
     373 
     374                                /* Prepare origin time. Second can have tenths place, so leaving two spaces here to indicate 
     375                                we're not going to that level of precision, the timestruct doesn't have tenths. Probably worth revisiting.*/ 
     376                        strftime(timestr, 80, "%m/%d/%Y, %H:%M:%S  ", timeinfo); 
    291377                        sprintf(tempstr, "Origin: %s UTC", timestr); 
    292378                        fprintf(COSMOS0fp, "%s\n", tempstr); 
    293379                        break; 
    294380                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. */ 
     381                                8 17-50 Record start time (date and time of first sample; may be approximate - precise value 
     382                                should be obtained from real header) and time quality (0 through 5 correspond to 
     383                                lowest through highest quality). 
     384                                59-80 Record identification, assigned by preparing agency. 
     385                                "06/17/2018, 18:34:38.004 GMT (Q=5) "<- 35 chars   " (Q=5) " "38199368.SB.WLA.00.HN " <- 22char*/ 
     386                                /* strncpy(record_id, str + 45, 34); no, we're not going to use any of the prev string */ 
     387                                /* We pad with white space, because we're going to overwrite some of it, and we'll only copy 
     388                                the relevant characters to go up to 80, andything too long will get truncated. */ 
    303389                        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); 
     390                        /* sprintf(tempstr2, "RcrdId:%lu.%s.%s.%s.%s                  ", 
     391                                arcmsg.sum.qid, ptrReq->net, ptrReq->sta, ptrReq->loc, ptrReq->chan); <- prism doesn't like this*/ 
     392                        /* sprintf(tempstr2,    "RcrdId:%s.%lu.%s.%s.%s.%s     ",  
     393                                ptrReq->net, arcmsg.sum.qid, ptrReq->net, ptrReq->sta, ptrReq->chan, ptrReq->loc); <- prism likes this but it might go beyond legal 80 chars/line */ 
     394                        sprintf(tempstr2, "RcrdId: (see comment)                   "); 
     395 
    306396                        strncpy(tempstr + 51, tempstr2, 29); 
    307397                        tempstr[80] = '\0'; /* Chop off any extra junk */ 
     
    309399                        break; 
    310400                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. */ 
     401                                 record in g (or other units);* 60-67 Time max occurs in raw record (secs after start). 
     402                                 Example: 
     403                                 Raw record length = 175.340  sec, Uncor max = 100000000, at   40.220 sec. */ 
    314404                        sprintf(tempstr, "Raw record length = %f", (ptrReq->reqEndtime - ptrReq->reqStarttime)); 
    315405                        strncpy(tempstr + 28, "sec, Uncor max =                                    ", 53); 
     
    317407                        break; 
    318408                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                                 */ 
     409                                 11-40 Processing/release date, time and agency. 
     410                                 48-80 Maximum of data series in file, units, and time of maximum (seconds after start).*" 
     411                                 What should I put here? An example file looks like: 
     412                                 "Processed: 06/17/18 12:00 PDT UCB                                   " 
     413                                 */ 
    324414                        time(&rawtime); 
    325415                        timeinfo = gmtime(&rawtime); 
    326                         sprintf(tempstr, "Processed: %d/%d/%d %d:%d UTC                                       ",  
     416                        sprintf(tempstr, "Processed: %d/%d/%d %d:%01d UTC                                       ", 
    327417                                (timeinfo->tm_mon + 1), 
    328418                                timeinfo->tm_mday, 
    329419                                (timeinfo->tm_year + 1900), 
    330                                 timeinfo->tm_hour,  
     420                                timeinfo->tm_hour, 
    331421                                timeinfo->tm_min 
    332422                        ); 
    333423                        fprintf(COSMOS0fp, "%s\n", tempstr); 
    334424                        break; 
     425                /* Real Headers include Earthquake information similar to comments above, comments for humans, below for PRISM*/ 
     426                case 27: /* Site geology stuff from the database are the first 4 params in this line, so read them in and leave 
     427                                    them be. But the 5th param we'll overwrite here with Earthquake latitude (decimal degrees, North positive)*/ 
     428                        sprintf(fifteen, "%15.6f", arcmsg.sum.lat); 
     429                        strncpy(str + 60, fifteen, 15); 
     430                        fprintf(COSMOS0fp, "%s", str); 
     431                        break; 
     432                case 28: /* Earthquake longitude (decimal degrees, East positive), Earthquake depth (km)., Moment magnitude, M., Surface-wave magnitude, MS., Local magnitude, ML.*/ 
     433                        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); 
     434                        fprintf(COSMOS0fp, "%s\n", tempstr); 
     435                        break; 
     436                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 */ 
     437                        sprintf(fifteen, "%15.6f", arcmsg.sum.Md); 
     438                        strncpy(str, fifteen, 15);                       
     439                        sprintf(fifteen, "%15.6f", -999.0); 
     440                        strncpy(str + 15, fifteen, 15); 
     441                        strncpy(str + 30, fifteen, 15); 
     442                        fprintf(COSMOS0fp, "%s", str); 
     443                        break; 
    335444                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!*/ 
     445                                 /* Example: | RcrdId: NC.72282711.NC.C031.HNE.01 */ 
     446                        sprintf(tempstr, "| RcrdId: %s.%lu.%s.%s.%s.%s ",  
    338447                                ptrReq->net, arcmsg.sum.qid, ptrReq->net, ptrReq->sta, ptrReq->chan, ptrReq->loc); 
    339448                        fprintf(COSMOS0fp, "%s\n", tempstr); 
    340449                        break; 
    341450                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*/ 
     451                                 /*Example:|<SCNL>C031.HNE.NC.01    <AUTH> 2015/03/01 16:46:25.000*/ 
    343452                        sprintf(tempstr, "|<SCNL> %s.%s.%s.%s    <AUTH> %d/%d/%d %d:%d:%d.000", 
    344453                                ptrReq->sta, ptrReq->chan, ptrReq->net, ptrReq->loc, 
    345                                 (timeinfo->tm_year + 1900),     (timeinfo->tm_mon + 1), timeinfo->tm_mday, 
     454                                (timeinfo->tm_year + 1900), (timeinfo->tm_mon + 1), timeinfo->tm_mday, 
    346455                                timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec); 
    347                         fprintf(COSMOS0fp, "%s", tempstr); 
    348                         break; 
    349                 default:  
    350                         fprintf(COSMOS0fp, "%s", str);           
     456                        fprintf(COSMOS0fp, "%s\n", tempstr); 
     457                        break; 
     458                default: 
     459                        fprintf(COSMOS0fp, "%s", str); 
    351460                } 
    352461 
     
    386495        TRACE2_HEADER *wf; 
    387496        char    datatype; 
    388         char    day_line[122]; 
    389         char    fourdigits[5]; 
    390497        char    hour_line[81] = ";                                                                                ";  
    391498        char    sample[12]; 
    392         char    elevendigits[12]; 
     499        char    eightdigits[9]; 
    393500        char   *msg_p;        /* pointer into tracebuf data */ 
    394501        double  begintime = 0, starttime = 0, endtime = 0, currenttime = 0; 
    395         double  samprate, unrounded; 
     502        double  samprate; 
    396503        float  *f_data; 
    397504        int     gap_count = 0; 
     
    399506        int     seconds = 0; 
    400507        int     s_place = 0; 
    401         int     tabular_base; 
    402508        int     total, raw_counts; 
    403509        long    nfill_max = 0l; 
     
    407513        long   *l_data; 
    408514        short  *s_data; 
    409         int    current_int; 
    410515        char    tempstr[COSMOSLINELEN]; 
    411516        char    tempstr2[COSMOSLINELEN]; 
     
    420525                return EW_FAILURE; 
    421526        } 
     527 
     528 
     529        COSMOS0PA_header(getThis, cosmos_info->OutDir, cosmos_info->LibDir, cosmos_info->EventDate, cosmos_info->EventTime, Cadence, debug, Multiplier); 
    422530        /* Used for computing trace statistics */ 
    423531        total = 0; 
     
    462570/*      sprintf(tempstr, "17770    raw accel.pts,   approx  178  secs, units=counts (50),Format=(10I8)   \n");*/ 
    463571        sprintf(tempstr, "         raw accel.pts,   approx           , units=counts (50),Format=(10I8)    \n"); 
    464         raw_counts = (getThis->reqEndtime - getThis->reqStarttime ) * samprate; 
     572        raw_counts = (getThis->reqEndtime - getThis->reqStarttime ) * samprate;  
    465573        sprintf(tempstr2, "%d", raw_counts); 
    466574        strncpy(tempstr, tempstr2, strlen(tempstr2)); 
     
    468576        sprintf(tempstr2, "%d secs", seconds); 
    469577        strncpy(tempstr + 34, tempstr2, strlen(tempstr2)); 
     578        if (!COSMOS0fp) { 
     579                logit("et", "Tried to write to a null file pointer, exiting. Does your library match your waveserver request?\n"); 
     580                exit(0); 
     581        } 
    470582        if (fwrite(tempstr, 81, 1, COSMOS0fp) != 1) 
    471583        { 
     
    594706 
    595707 
    596         while ((j < nsamp_this_scn) && (currenttime < getThis->reqEndtime)) 
     708        while ((j < nsamp_this_scn) && (currenttime < getThis->reqEndtime) && (j < raw_counts)) 
    597709        { 
    598710                /* Only give them what they asked for, not each sample we got back. 
     
    617729 
    618730                /* WRITE DATA */ 
    619  
    620                 while (i < 7 && j < nsamp_this_scn) 
     731                /* Even if there are more samples in this scn, we shouldn't have more than the raw counts the user asked for*/ 
     732                while (i < 10 && j < nsamp_this_scn && j < raw_counts) 
    621733                { 
     734                        sprintf(eightdigits, "        "); /* we want leading spaces */ 
    622735                        if (COSMOS0Buffer[j] != getThis->fill) { 
    623                                 sprintf(elevendigits, "           "); /* we want leading spaces */ 
    624                                 if (((int)(COSMOS0Buffer[j] * Multiplier) > 999999) || ((int)(COSMOS0Buffer[j] * Multiplier) < -99999)) { 
     736                                if (((int)(COSMOS0Buffer[j] * Multiplier) > 99999999) || ((int)(COSMOS0Buffer[j] * Multiplier) < -9999999)) { 
    625737                                        sprintf(sample, GAP_FILL); 
    626738                                        /* prevent out of range string */ 
     
    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; 
     
    674799int COSMOS0PA_end_ev(int debug) 
    675800{ 
    676         fclose(COSMOS0fp); 
     801        /* Actually we opened multiple files, one for each SCNL, and they should  
     802          all be closed by the time we get here; we don't know who they all are to  
     803          close them here. */ 
     804/*      fclose(COSMOS0fp); 
    677805 
    678806        if (debug == 1) 
    679                 logit("t", "Closing COSMOS0 file \n"); 
     807                logit("t", "Closing COSMOS0 file \n"); */ 
    680808 
    681809        return(EW_SUCCESS); 
Note: See TracChangeset for help on using the changeset viewer.