/*************************************************************************** * mst_writemseedgroup: * * Pack MSTraceGroup data into Mini-SEED records by calling mst_pack() * for each MSTrace in the group and write to a specified file. * * Returns the number of records written on success and -1 on error. ***************************************************************************/ int mst_writemseedgroup (MSTraceGroup *mstg, const char *msfile, flag overwrite, int reclen, flag encoding, flag byteorder, flag verbose) { MSTrace *mst; FILE *ofp; char srcname[50]; char *perms = (overwrite) ? "wb" : "ab"; int trpackedrecords; int packedrecords = 0; if (!mstg || !msfile) return -1; /* Open output file or use stdout */ if (strcmp (msfile, "-") == 0) { ofp = stdout; } else if ((ofp = fopen (msfile, perms)) == NULL) { ms_log (1, "Cannot open output file %s: %s\n", msfile, strerror (errno)); return -1; } /* Pack each MSTrace in the group */ mst = mstg->traces; while (mst) { if (mst->numsamples <= 0) { mst = mst->next; continue; } trpackedrecords = mst_pack (mst, &ms_record_handler_int, ofp, reclen, encoding, byteorder, NULL, 1, verbose - 1, NULL); if (trpackedrecords < 0) { mst_srcname (mst, srcname, 1); ms_log (1, "Cannot write Mini-SEED for %s\n", srcname); } else { packedrecords += trpackedrecords; } mst = mst->next; } /* Close file and return record count */ fclose (ofp); return packedrecords; } /* End of mst_writemseedgroup() */
main() { outfile = fopen("int32_Steim2_littleEndian.mseed", "w"); int psamples; int precords; MSTrace *mst; char srcname[50]; psamples = 0; int *mychar; mychar = (int *) malloc(50 * sizeof(int)); // Write integers from 1 to 50. int i = 1; for(i; i<51; i++){ mychar[i-1] = i; } mst = mst_init (NULL); /* Populate MSTrace values */ strcpy (mst->network, "XX"); strcpy (mst->station, "TEST"); strcpy (mst->channel, "BHE"); mst->starttime = ms_seedtimestr2hptime ("2004,350,00:00:00.000000"); mst->samprate = 1.0; /* The datasamples pointer and numsamples counter will be adjusted by the packing routine, the datasamples array must be dynamic memory allocated by the malloc() family of routines. */ mst->datasamples = mychar; mst->numsamples = 50; mst->samplecnt = 50; mst->sampletype = 'i'; mst_srcname (mst, srcname, 0); /* Pack 512 byte, big-endian records, ´write Chars */ precords = mst_pack (mst, &record_handler, srcname, 256, DE_STEIM2, 0, &psamples, 1, verbose, NULL); ms_log (0, "Packed %d samples into %d records\n", psamples, precords); fclose(outfile); mst_free (&mst); }
/*************************************************************************** * mst_writemseed: * * Pack MSTrace data into Mini-SEED records by calling mst_pack() and * write to a specified file. * * Returns the number of records written on success and -1 on error. ***************************************************************************/ int mst_writemseed (MSTrace *mst, const char *msfile, flag overwrite, int reclen, flag encoding, flag byteorder, flag verbose) { FILE *ofp; char srcname[50]; char *perms = (overwrite) ? "wb" : "ab"; int packedrecords = 0; if (!mst || !msfile) return -1; /* Open output file or use stdout */ if (strcmp (msfile, "-") == 0) { ofp = stdout; } else if ((ofp = fopen (msfile, perms)) == NULL) { ms_log (1, "Cannot open output file %s: %s\n", msfile, strerror (errno)); return -1; } /* Pack the MSTrace */ if (mst->numsamples > 0) { packedrecords = mst_pack (mst, &ms_record_handler_int, ofp, reclen, encoding, byteorder, NULL, 1, verbose - 1, NULL); if (packedrecords < 0) { mst_srcname (mst, srcname, 1); ms_log (1, "Cannot write Mini-SEED for %s\n", srcname); } } /* Close file and return record count */ fclose (ofp); return (packedrecords >= 0) ? packedrecords : -1; } /* End of mst_writemseed() */
main() { outfile = fopen("fullASCII_bigEndian.mseed", "w"); int psamples; int precords; MSTrace *mst; char srcname[50]; psamples = 0; // Allocate char array. One more allocated char is necessary for // the zero terminating last char. char *mychar = (char *) malloc(96 * sizeof(char)); // Copy contents to char. In this case copy all ASCII chars. strcpy(mychar, " !\"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~"); mst = mst_init (NULL); /* Populate MSTrace values */ strcpy (mst->network, "XX"); strcpy (mst->station, "TEST"); strcpy (mst->channel, "BHE"); mst->starttime = ms_seedtimestr2hptime ("2004,350,00:00:00.000000"); mst->samprate = 1.0; /* The datasamples pointer and numsamples counter will be adjusted by the packing routine, the datasamples array must be dynamic memory allocated by the malloc() family of routines. */ mst->datasamples = mychar; /* pointer to 8-bit ascii data samples */ mst->numsamples = 95; mst->samplecnt = 95; mst->sampletype = 'a'; /* declare type to be 8 bit ASCII */ mst_srcname (mst, srcname, 0); /* Pack 256 byte, big-endian records, write chars */ precords = mst_pack (mst, &record_handler, srcname, 256, DE_ASCII, 1, &psamples, 1, verbose, NULL); ms_log (0, "Packed %d samples into %d records\n", psamples, precords); fclose(outfile); mst_free (&mst); }
int main (int argc, char **argv) { MSRecord *msr = 0; MSTraceGroup *mstg = 0; MSTrace *mst; int retcode; int totalrecs = 0; int totalsamps = 0; int packedsamples; int packedrecords; int lastrecord; int iseqnum = 1; #ifndef WIN32 /* Signal handling, use POSIX calls with standardized semantics */ struct sigaction sa; sa.sa_flags = SA_RESTART; sigemptyset (&sa.sa_mask); sa.sa_handler = term_handler; sigaction (SIGINT, &sa, NULL); sigaction (SIGQUIT, &sa, NULL); sigaction (SIGTERM, &sa, NULL); sa.sa_handler = SIG_IGN; sigaction (SIGHUP, &sa, NULL); sigaction (SIGPIPE, &sa, NULL); #endif /* Process given parameters (command line and parameter file) */ if (parameter_proc (argc, argv) < 0) return -1; /* Setup input encoding format if specified */ if ( encodingstr ) { int inputencoding = strtoul (encodingstr, NULL, 10); if ( inputencoding == 0 && errno == EINVAL ) { ms_log (2, "Error parsing input encoding format: %s\n", encodingstr); return -1; } MS_UNPACKENCODINGFORMAT (inputencoding); } /* Init MSTraceGroup */ mstg = mst_initgroup (mstg); /* Loop over the input file */ while ( (retcode = ms_readmsr (&msr, inputfile, reclen, NULL, &lastrecord, 1, 1, verbose)) == MS_NOERROR ) { totalrecs++; totalsamps += msr->samplecnt; msr_print (msr, ppackets); if ( packreclen >= 0 ) msr->reclen = packreclen; else packreclen = msr->reclen; if ( packencoding >= 0 ) msr->encoding = packencoding; else packencoding = msr->encoding; if ( byteorder >= 0 ) msr->byteorder = byteorder; else byteorder = msr->byteorder; /* After unpacking the record, the start time in msr->starttime is a potentially corrected start time, if correction has been applied make sure the correction bit flag is set as it will be used as a packing template. */ if ( msr->fsdh->time_correct && ! (msr->fsdh->act_flags & 0x02) ) { ms_log (1, "Setting time correction applied flag for %s_%s_%s_%s\n", msr->network, msr->station, msr->location, msr->channel); msr->fsdh->act_flags |= 0x02; } /* If no samples in the record just pack the header */ if ( outfile && msr->numsamples == 0 ) { msr_pack_header (msr, 1, verbose); record_handler (msr->record, msr->reclen, NULL); } /* Pack each record individually */ else if ( outfile && ! tracepack ) { msr->sequence_number = iseqnum; packedrecords = msr_pack (msr, &record_handler, NULL, &packedsamples, 1, verbose); if ( packedrecords == -1 ) ms_log (2, "Cannot pack records\n"); else ms_log (1, "Packed %d records\n", packedrecords); iseqnum = msr->sequence_number; } /* Pack records from a MSTraceGroup */ else if ( outfile && tracepack ) { mst = mst_addmsrtogroup (mstg, msr, 0, -1.0, -1.0); if ( ! mst ) { ms_log (2, "Error adding MSRecord to MStrace!\n"); break; } /* Reset sequence number and free previous template */ if ( mst->prvtptr ) { MSRecord *tmsr = (MSRecord *) mst->prvtptr; /* Retain sequence number from previous template */ msr->sequence_number = tmsr->sequence_number; msr_free (&tmsr); } else { msr->sequence_number = 1; } /* Copy MSRecord and store as template */ mst->prvtptr = msr_duplicate (msr, 0); if ( ! mst->prvtptr ) { ms_log (2, "Error duplicating MSRecord for template!\n"); break; } /* Pack traces based on selected method */ packedrecords = 0; if ( tracepack == 1 ) { mst = mstg->traces; while ( mst ) { packedrecords += mst_pack (mst, &record_handler, NULL, packreclen, packencoding, byteorder, &packedsamples, lastrecord, verbose, (MSRecord *)mst->prvtptr); mst = mst->next; } ms_log (1, "Packed %d records\n", packedrecords); } if ( tracepack == 2 && lastrecord ) { mst = mstg->traces; while ( mst ) { packedrecords += mst_pack (mst, &record_handler, NULL, packreclen, packencoding, byteorder, &packedsamples, lastrecord, verbose, (MSRecord *)mst->prvtptr); mst = mst->next; } ms_log (1, "Packed %d records\n", packedrecords); } } } if ( retcode != MS_ENDOFFILE ) ms_log (2, "Error reading %s: %s\n", inputfile, ms_errorstr(retcode)); /* Make sure everything is cleaned up */ ms_readmsr (&msr, NULL, 0, NULL, NULL, 0, 0, 0); mst_freegroup (&mstg); if ( outfile ) fclose (outfile); getchar(); return 0; } /* End of main() */
static PyObject* mseed_store_traces (PyObject *dummy, PyObject *args) { char *filename; MSTrace *mst = NULL; PyObject *array = NULL; PyObject *in_traces = NULL; PyObject *in_trace = NULL; PyArrayObject *contiguous_array = NULL; int i; char *network, *station, *location, *channel; char mstype; int msdetype; int psamples, precords; int numpytype; int length; FILE *outfile; if (!PyArg_ParseTuple(args, "Os", &in_traces, &filename)) { PyErr_SetString(MSeedError, "usage store_traces(traces, filename)" ); return NULL; } if (!PySequence_Check( in_traces )) { PyErr_SetString(MSeedError, "Traces is not of sequence type." ); return NULL; } outfile = fopen(filename, "w" ); if (outfile == NULL) { PyErr_SetString(MSeedError, "Error opening file."); return NULL; } for (i=0; i<PySequence_Length(in_traces); i++) { in_trace = PySequence_GetItem(in_traces, i); if (!PyTuple_Check(in_trace)) { PyErr_SetString(MSeedError, "Trace record must be a tuple of (network, station, location, channel, starttime, endtime, samprate, data)." ); Py_DECREF(in_trace); return NULL; } mst = mst_init (NULL); if (!PyArg_ParseTuple(in_trace, "ssssLLdO", &network, &station, &location, &channel, &(mst->starttime), &(mst->endtime), &(mst->samprate), &array )) { PyErr_SetString(MSeedError, "Trace record must be a tuple of (network, station, location, channel, starttime, endtime, samprate, data)." ); mst_free( &mst ); Py_DECREF(in_trace); return NULL; } strncpy( mst->network, network, 10); strncpy( mst->station, station, 10); strncpy( mst->location, location, 10); strncpy( mst->channel, channel, 10); mst->network[10] = '\0'; mst->station[10] = '\0'; mst->location[10] ='\0'; mst->channel[10] = '\0'; if (!PyArray_Check(array)) { PyErr_SetString(MSeedError, "Data must be given as NumPy array." ); mst_free( &mst ); Py_DECREF(in_trace); return NULL; } numpytype = PyArray_TYPE(array); switch (numpytype) { case NPY_INT32: assert( ms_samplesize('i') == 4 ); mstype = 'i'; msdetype = DE_STEIM1; break; case NPY_INT8: assert( ms_samplesize('a') == 1 ); mstype = 'a'; msdetype = DE_ASCII; break; case NPY_FLOAT32: assert( ms_samplesize('f') == 4 ); mstype = 'f'; msdetype = DE_FLOAT32; break; case NPY_FLOAT64: assert( ms_samplesize('d') == 8 ); mstype = 'd'; msdetype = DE_FLOAT64; break; default: PyErr_SetString(MSeedError, "Data must be of type float64, float32, int32 or int8."); mst_free( &mst ); Py_DECREF(in_trace); return NULL; } mst->sampletype = mstype; contiguous_array = PyArray_GETCONTIGUOUS((PyArrayObject*)array); length = PyArray_SIZE(contiguous_array); mst->numsamples = length; mst->samplecnt = length; mst->datasamples = calloc(length,ms_samplesize(mstype)); memcpy(mst->datasamples, PyArray_DATA(contiguous_array), length*ms_samplesize(mstype)); Py_DECREF(contiguous_array); precords = mst_pack (mst, &record_handler, outfile, 4096, msdetype, 1, &psamples, 1, 0, NULL); mst_free( &mst ); Py_DECREF(in_trace); } fclose( outfile ); Py_INCREF(Py_None); return Py_None; }