int
main (int argc, char **argv)
{
int c,
errflg = 0;
char *in,
*out;
int orbin,
orbout;
double maxpkts = VERY_LARGE_NUMBER ;
int quit;
char *pktmatch = strdup(".*/pf/evtinfo"),
*reject = 0;
int nmatch;
int specified_after = 0;
double after = 0.0,
until = VERY_LARGE_NUMBER ;
double start_time,
end_time,
delta_t ;
double totpkts = 0,
totbytes = 0;
Flags flags;
static int last_pktid = -1;
static double last_pkttime = 0.0;
char *statefile = 0;
double last_burial = 0.0;
double decent_interval = 300.0;
int mode = PKT_NOSAMPLES;
int rcode;
char srcname[ORBSRCNAME_SIZE];
double pkttime = 0.0 ;
int pktid;
int nbytes;
char *packet = 0;
int packetsz = 0;
Packet *unstuffed = 0;
Pf *pf;
Tbl *tbl;
Arr *arr;
char *arrkey;
char *pffilename;
Tbl *channels;
char *net;
char *sta;
char *chan;
char netstachan[ORBSRCNAME_SIZE];
Srcname parts;
double maxtime,mintime,starttime,triggertime,duration,min_g,max_g,snr;
char *datalogger;
int evtfilesize,channelno,maxcts,mincts;
char *errors,*evtfilename,*ft,*filter,*srcid;
char *line;
int i;
Pf *pfnew;
Dbptr db;
int put_tests=0;
char *chanmatch=0;
Hook *hook=0;
char *tdummy=0;
char *match=malloc(100);
memset (&flags, 0, sizeof (flags));
elog_init (argc, argv);
elog_notify (0, "%s $Revision: 1.5 $ $Date: 2005/05/10 07:34:43 $\n",
Program_Name);
while ((c = getopt (argc, argv, "m:n:r:S:c:tvV")) != -1) {
switch (c) {
case 'm':
match = optarg;
sprintf(pktmatch,"%s/pf/evtinfo",match);
break;
case 'c':
chanmatch = optarg;
break;
case 't':
put_tests = 1;
break;
case 'n':
maxpkts = atoi (optarg);
break;
case 'r':
reject = optarg;
break;
case 'S':
statefile = optarg;
break;
case 'v':
flags.verbose++;
break;
case 'V':
flags.verbose++;
flags.verbose++;
break;
case '?':
errflg++;
}
}
if (errflg || argc - optind < 2 || argc - optind > 4)
usage ();
in = argv[optind++];
out = argv[optind++];
if (argc > optind) {
after = str2epoch (argv[optind++]);
specified_after = 1;
if (argc > optind) {
until = str2epoch (argv[optind++]);
if (until < after) {
until += after ;
}
}
}
if ((orbin = orbopen (in, "r&")) < 0)
die (0, "Can't open input '%s'\n", in);
if (statefile != 0) {
char *s;
if (exhume (statefile, &quit, RT_MAX_DIE_SECS, 0) != 0) {
elog_notify (0, "read old state file\n");
}
if (orbresurrect (orbin, &last_pktid, &last_pkttime) == 0) {
elog_notify (0, "resurrection successful: repositioned to pktid #%d @ %s\n",
last_pktid, s = strtime (last_pkttime));
free (s);
} else {
complain (0, "resurrection unsuccessful\n");
}
}
if ((orbout = orbopen (out, "w&")) < 0) {
die (0, "Can't open output '%s'\n", out);
}
if (pktmatch) {
nmatch = orbselect (orbin, pktmatch);
}
if (nmatch < 0) {
die (1, "select '%s' returned %d\n", pktmatch, nmatch);
}
if (reject) {
nmatch = orbreject (orbin, reject);
}
if (nmatch < 0) {
elog_die (1, "reject '%s' returned %d\n", reject, nmatch);
} else {
if (flags.verbose) {
elog_notify (1,"%d sources selected\n", nmatch);
}
}
if (specified_after) {
pktid = orbafter (orbin, after);
if (pktid < 0) {
char *s;
elog_complain (1, "seek to %s failed\n", s = strtime (after));
free (s);
pktid = forbtell (orbin);
elog_complain (1,"pktid is still #%d\n", pktid);
} else {
if (flags.verbose) elog_notify (1,"new starting pktid is #%d\n", pktid);
}
}
start_time = now ();
db = dbtmp("rt1.0");
while (!quit && pkttime < until && totpkts < maxpkts) {
rcode = orbreap (orbin,
&pktid, srcname, &pkttime, &packet, &nbytes, &packetsz);
switch (rcode) {
case 0:
totpkts++;
totbytes += nbytes;
if (flags.verbose>2) {
showPkt (pktid, srcname, pkttime, packet, nbytes, stdout, mode);
}
if (statefile != 0
&& last_pkttime - last_burial > decent_interval) {
bury ();
last_burial = pkttime;
}
if ((unstuffPkt (srcname, pkttime, packet, nbytes, &unstuffed))==Pkt_pf) {
pf = unstuffed->pf;
tbl= pfkeys(pf);
arrkey= gettbl(tbl,0);
pfget(pf,arrkey,&pfnew);
datalogger= pfget_string(pfnew,"datalogger");
duration= pfget_double(pfnew,"duration");
errors= pfget_string(pfnew,"errors");
evtfilename= pfget_string(pfnew,"evtfilename");
evtfilesize= pfget_int(pfnew,"evtfilesize");
ft= pfget_string(pfnew,"ft");
starttime= pfget_double(pfnew,"time");
triggertime= pfget_double(pfnew,"triggertime");
channels=pfget_tbl(pfnew,"channels");
if (strcasecmp(ft,"no")==0 || put_tests == 1) {
for (i=0; i<maxtbl(channels);i++) {
line=gettbl(channels,i);
sscanf(line,"%s %d %lf %d %lf %lf %d %lf",
netstachan,&channelno,&maxtime,&maxcts,&max_g,&mintime,&mincts,&min_g);
split_srcname(netstachan,&parts);
strcpy(parts.src_suffix,"GENC");
join_srcname(&parts,netstachan);
if (flags.verbose>1) printf("%s,%s\n", netstachan,tdummy=strtime(triggertime));
if (chanmatch == 0 ||
strmatches(parts.src_chan,chanmatch,&hook)) {
if (flags.verbose) elog_notify(1,"putting detev for %s,%s\n", netstachan,tdummy=strtime(triggertime));
db=dblookup(db,0,"detev",0,"dbSCRATCH");
dbputv(db,0,"sta",parts.src_sta,"chan",parts.src_chan,
"filter",K2_FILTER,
"time", triggertime,
"tron", starttime - triggertime,
"troff", starttime - triggertime + duration,
"iphase","K2",
"snr",(max_g * 1000.0 - min_g * 1000.0)/2.0,
0);
db2orbpkt(db,orbout);
} else {
if (flags.verbose>1) elog_notify(1,"ignoring %s,%s\n", netstachan,tdummy=strtime(triggertime));
}
}
}
}
last_pktid = pktid;
last_pkttime = pkttime;
}
}
if (statefile != 0)
bury ();
end_time = now ();
delta_t = end_time - start_time;
if (flags.verbose>1) {
if (totpkts > 0) {
elog_notify (1,"\n%.0f %.2f byte packets (%.1f kbytes) in %.3f seconds\n\t%10.3f kbytes/s\n\t%10.3f kbaud\n\t%10.3f pkts/s\n",
totpkts, totbytes / totpkts, totbytes / 1024,
delta_t,
totbytes / delta_t / 1024,
totbytes / delta_t / 1024 * 8,
totpkts / delta_t);
} else {
elog_notify (1,"\nno packets read\n");
}
}
if (orbclose (orbin)) {
elog_complain (1, "error closing read orb\n");
}
if (orbclose (orbout)) {
elog_complain (1, "error closing write orb\n");
}
return 0;
}
int main(void){
/* initialize EasyFlash and EasyLogger */
if ((easyflash_init() == EF_NO_ERR)&&(elog_init() == ELOG_NO_ERR)) {
/* set EasyLogger log format */
elog_set_fmt(ELOG_LVL_ASSERT, ELOG_FMT_ALL & ~ELOG_FMT_P_INFO);
elog_set_fmt(ELOG_LVL_ERROR, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_WARN, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_INFO, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_DEBUG, ELOG_FMT_ALL & ~(ELOG_FMT_FUNC | ELOG_FMT_P_INFO));
elog_set_fmt(ELOG_LVL_VERBOSE, ELOG_FMT_ALL & ~(ELOG_FMT_FUNC | ELOG_FMT_P_INFO));
/* set EasyLogger assert hook */
elog_assert_set_hook(elog_user_assert_hook);
/* initialize EasyLogger Flash plugin */
elog_flash_init();
/* start EasyLogger */
elog_start();
/* set EasyLogger assert hook */
elog_assert_set_hook(elog_user_assert_hook);
/* test logger output */
test_elog();
}
return 0;
}
int main(void) {
/* close printf buffer */
setbuf(stdout, NULL);
/* initialize EasyLogger */
elog_init();
/* set EasyLogger log format */
elog_set_fmt(ELOG_LVL_ASSERT, ELOG_FMT_ALL);
elog_set_fmt(ELOG_LVL_ERROR, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_WARN, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_INFO, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_DEBUG, ELOG_FMT_ALL & ~ELOG_FMT_FUNC);
elog_set_fmt(ELOG_LVL_VERBOSE, ELOG_FMT_ALL & ~ELOG_FMT_FUNC);
/* start EasyLogger */
elog_start();
/* dynamic set enable or disable for output logs (true or false) */
// elog_set_output_enabled(false);
/* dynamic set output logs's level (from ELOG_LVL_ASSERT to ELOG_LVL_VERBOSE) */
// elog_set_filter_lvl(ELOG_LVL_WARN);
/* dynamic set output logs's filter for tag */
// elog_set_filter_tag("main.test.a");
/* dynamic set output logs's filter for keyword */
// elog_set_filter_kw("Hello");
/* test logger output */
test_elog();
return EXIT_SUCCESS;
}
int main(void){
/* initialize EasyLogger */
elog_init();
/* set EasyLogger log format */
elog_set_fmt(ELOG_LVL_ASSERT, ELOG_FMT_ALL);
elog_set_fmt(ELOG_LVL_ERROR, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_WARN, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_INFO, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_DEBUG, ELOG_FMT_ALL & ~(ELOG_FMT_FUNC | ELOG_FMT_T_INFO | ELOG_FMT_P_INFO));
elog_set_fmt(ELOG_LVL_VERBOSE, ELOG_FMT_ALL & ~(ELOG_FMT_FUNC | ELOG_FMT_T_INFO | ELOG_FMT_P_INFO));
/* start EasyLogger */
elog_start();
/* dynamic set enable or disable for output logs (true or false) */
// elog_set_output_enabled(false);
/* dynamic set output logs's level (from ELOG_LVL_ASSERT to ELOG_LVL_VERBOSE) */
// elog_set_filter_lvl(ELOG_LVL_WARN);
/* dynamic set output logs's filter for tag */
// elog_set_filter_tag("main.test.a");
/* dynamic set output logs's filter for keyword */
// elog_set_filter_kw("Hello");
while (1) {
/* test logger output */
test_elog();
system("pause");
}
return 0;
}
int
main (int argc, char **argv)
{
int c,
errflg = 0;
Dbptr db;
char *table;
int verbose = 0;
int errors = 0;
long n;
Pf *pf;
elog_init (argc, argv);
if (pfread (Program_Name, &pf) != 0)
die (0, "Can't read parameter file\n");
Segtype = pfget_arr (pf, "segtype");
while ((c = getopt (argc, argv, "vV")) != -1) {
switch (c) {
case 'v':
verbose++;
break;
case 'V':
banner (Program_Name, 0) ;
exit (0);
default:
errflg++;
break;
}
}
if (errflg || argc - optind != 1)
usage ();
table = argv[optind++];
n = dbopen_table (table, "r", &db);
switch (n) {
case dbINVALID:
die (0, "Can't open input table '%s'", table);
break;
case 0:
die (0, "No records in input table '%s'", table);
break;
}
for (db.record = 0; db.record < n; db.record++) {
errors += autodrm_response (db);
}
return (errors == 0 ? 0 : 1);
}
static void mainboard_init(device_t dev)
{
set_clock_sources();
clock_external_output(1); /* For external MAX98090 audio codec. */
/*
* Confirmed by NVIDIA hardware team, we need to take ALL audio devices
* conntected to AHUB (AUDIO, APBIF, I2S, DAM, AMX, ADX, SPDIF, AFC) out
* of reset and clock-enabled, otherwise reading AHUB devices (In our
* case, I2S/APBIF/AUDIO<XBAR>) will hang.
*
* Note that CLK_H_MEM (MC) and CLK_H_EMC should be already either
* initialized by BootROM, or in romstage SDRAM initialization.
*/
clock_enable_clear_reset(CLK_L_GPIO | CLK_L_I2C1 | CLK_L_SDMMC4 |
CLK_L_I2S0 | CLK_L_I2S1 | CLK_L_I2S2 |
CLK_L_SPDIF | CLK_L_USBD | CLK_L_DISP1 |
CLK_L_HOST1X | CLK_L_PWM,
CLK_H_I2C2 | CLK_H_PMC | CLK_H_USB3,
CLK_U_CSITE | CLK_U_SDMMC3,
CLK_V_I2C4 | CLK_V_EXTPERIPH1 | CLK_V_APBIF |
CLK_V_AUDIO | CLK_V_I2S3 | CLK_V_I2S4 |
CLK_V_DAM0 | CLK_V_DAM1 | CLK_V_DAM2,
CLK_W_DVFS | CLK_W_AMX0 | CLK_W_ADX0,
CLK_X_DPAUX | CLK_X_SOR0 | CLK_X_AMX1 |
CLK_X_ADX1 | CLK_X_AFC0 | CLK_X_AFC1 |
CLK_X_AFC2 | CLK_X_AFC3 | CLK_X_AFC4 |
CLK_X_AFC5);
usb_setup_utmip((void*)TEGRA_USBD_BASE);
/* USB2 is the camera, we don't need it in firmware */
usb_setup_utmip((void*)TEGRA_USB3_BASE);
setup_pinmux();
i2c_init(0);
i2c_init(1);
i2c_init(3);
setup_kernel_info();
clock_init_arm_generic_timer();
setup_ec_spi();
#if CONFIG_ELOG
elog_init();
elog_add_boot_reason();
#endif
}
static void mainboard_init(device_t dev)
{
gpio_output(GPIO_RESET, 0);
configure_usb();
configure_emmc();
configure_codec();
/* No video. */
elog_init();
elog_add_watchdog_reset();
elog_add_boot_reason();
}
int main(int argc1, char *argv[])
{
route_init(NULL, 0);
route_register(&rt_filea_method);
route_register(&rt_fileov_method);
route_register(&rt_stdin_method);
route_register(&rt_stdout_method);
route_register(&rt_stderr_method);
route_register(&rt_rs_method);
if ( ! elog_init(1, "cascade test", NULL))
elog_die(FATAL, "didn't initialise elog\n");
out = route_open("stdout", NULL, NULL, 0);
err = route_open("stderr", NULL, NULL, 0);
rs_init();
/* run cascade with all the possible modes */
test_cascade(CASCADE_AVG, "avg",
TAB_SING, TAB_SINGINFO, TAB_SINGINFOKEY,
TAB_MULT, TAB_MULTINFO, TAB_MULTINFOKEY,
RES_AVGSING, RES_AVGSINGKEY, RES_AVGMULT, RES_AVGMULTKEY);
test_cascade(CASCADE_MIN, "min",
TAB_SING, TAB_SINGINFO, TAB_SINGINFOKEY,
TAB_MULT, TAB_MULTINFO, TAB_MULTINFOKEY,
RES_MINSING, RES_MINSINGKEY, RES_MINMULT, RES_MINMULTKEY);
test_cascade(CASCADE_MAX, "max",
TAB_SING, TAB_SINGINFO, TAB_SINGINFOKEY,
TAB_MULT, TAB_MULTINFO, TAB_MULTINFOKEY,
RES_MAXSING, RES_MAXSINGKEY, RES_MAXMULT, RES_MAXMULTKEY);
test_cascade(CASCADE_SUM, "sum",
TAB_SING, TAB_SINGINFO, TAB_SINGINFOKEY,
TAB_MULT, TAB_MULTINFO, TAB_MULTINFOKEY,
RES_SUMSING, RES_SUMSINGKEY, RES_SUMMULT, RES_SUMMULTKEY);
test_cascade(CASCADE_FIRST, "first",
TAB_SING, TAB_SINGINFO, TAB_SINGINFOKEY,
TAB_MULT, TAB_MULTINFO, TAB_MULTINFOKEY,
RES_FIRSTSING, RES_FIRSTSINGKEY, RES_FIRSTMULT,
RES_FIRSTMULTKEY);
test_cascade(CASCADE_LAST, "last",
TAB_SING, TAB_SINGINFO, TAB_SINGINFOKEY,
TAB_MULT, TAB_MULTINFO, TAB_MULTINFOKEY,
RES_LASTSING, RES_LASTSINGKEY, RES_LASTMULT,
RES_LASTMULTKEY);
rs_fini();
elog_fini();
route_close(err);
route_close(out);
route_fini();
printf("tests finished successfully\n");
exit(0);
}
void mexFunction ( int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[] )
{
int rc;
int argc = 1;
char **argv;
allot( char **, argv, 1 );
if( nrhs == 0 )
{
argv[0] = strdup( "Matlab" );
}
else if( nrhs == 1 )
{
if( ! mtlb_get_string( prhs[0], &argv[0] ) )
{
free( argv );
antelope_mexUsageMsgTxt ( USAGE );
return;
}
}
else
{
free( argv );
antelope_mexUsageMsgTxt ( USAGE );
return;
}
rc = elog_init( argc, argv );
elog_set( ELOG_CALLBACK, 0, antelope_mex_elog_callback );
strcpy( Program_Name, argv[0] );
plhs[0] = CreateDouble( (double) rc );
if( plhs[0] == NULL )
{
mexErrMsgTxt( "elog_init: failed to create return value" );
}
}
static void mainboard_init(device_t dev)
{
gpio_output(GPIO_RESET, 0);
configure_usb();
configure_emmc();
configure_codec();
configure_3g();
/* No video. */
elog_init();
elog_add_watchdog_reset();
elog_add_boot_reason();
/* If recovery mode is detected, reduce frequency and voltage to reduce
* heat in case machine is left unattended. chrome-os-partner:41201. */
if (recovery_mode_enabled()) {
printk(BIOS_DEBUG, "Reducing APLL freq for recovery mode.\n");
rkclk_configure_cpu(APLL_600_MHZ);
rk808_configure_buck(1, 900);
}
}
ElogErrCode init_elog(void)
{
/* close printf buffer */
setbuf(stdout, NULL);
/* initialize EasyLogger */
ElogErrCode ret = elog_init();
if(ELOG_NO_ERR != ret)
return ret;
/* set EasyLogger log format */
elog_set_fmt(ELOG_LVL_ASSERT, ELOG_FMT_ALL);
elog_set_fmt(ELOG_LVL_ERROR, ELOG_FMT_ALL & ~ELOG_FMT_P_INFO & ~ELOG_FMT_T_INFO);
elog_set_fmt(ELOG_LVL_WARN, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_INFO, ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME);
elog_set_fmt(ELOG_LVL_DEBUG, ELOG_FMT_ALL & ~ELOG_FMT_FUNC);
elog_set_fmt(ELOG_LVL_VERBOSE, ELOG_FMT_ALL & ~ELOG_FMT_FUNC);
/* start EasyLogger */
elog_start();
return ELOG_NO_ERR;
}
static PyObject *
python_elog_init( PyObject *self, PyObject *args ) {
char *usage = "Usage: _stock._elog_init( sys.argv )\n";
Tbl *arglist;
int iarg;
int rc;
if( ! PyArg_ParseTuple( args, "O&", parse_to_strtbl, &arglist ) ) {
USAGE;
return NULL;
}
if( _stock_argv != (char **) NULL ) {
for( iarg = 0; iarg < _stock_argc; iarg++ ) {
free( _stock_argv[iarg] );
}
free( _stock_argv );
}
_stock_argc = (int) maxtbl( arglist );
allot( char **, _stock_argv, _stock_argc );
for( iarg = 0; iarg < _stock_argc; iarg++ ) {
_stock_argv[iarg] = strdup( gettbl( arglist, iarg ) );
}
rc = elog_init( _stock_argc, _stock_argv );
freetbl( arglist, free );
return Py_BuildValue( "i", rc );
}
/**
* System initialization thread.
*
* @param parameter parameter
*/
void sys_init_thread(void* parameter){
set_system_status(SYSTEM_STATUS_INIT);
/* EasyLogger initialization */
if (elog_init() == ELOG_NO_ERR) {
/* set enabled format */
elog_set_fmt(ELOG_FMT_LVL | ELOG_FMT_TAG | ELOG_FMT_TIME /*| ELOG_FMT_P_INFO*/ | ELOG_FMT_T_INFO | ELOG_FMT_DIR
/*| ELOG_FMT_FUNC*/ | ELOG_FMT_LINE);
/* set EasyLogger assert hook */
elog_assert_set_hook(elog_user_assert_hook);
/* set hardware exception hook */
rt_hw_exception_install(exception_hook);
/* set RT-Thread assert hook */
rt_assert_set_hook(rtt_user_assert_hook);
/* initialize OK and switch to running status */
set_system_status(SYSTEM_STATUS_RUN);
} else {
/* initialize fail and switch to fault status */
set_system_status(SYSTEM_STATUS_FAULT);
}
rt_thread_delete(rt_thread_self());
}
static void mainboard_init(device_t dev)
{
soc_configure_funits(funits, ARRAY_SIZE(funits));
/* I2C6 bus (audio, etc.) */
soc_configure_i2c6pad();
i2c_init(I2C6_BUS);
setup_audio();
/* Temp hack for P1 board: Enable speaker amp (powerup, etc.) */
enable_ad4567_spkr_amp();
elog_init();
elog_add_boot_reason();
fix_ec_sw_sync();
/* configure panel gpio pads */
soc_configure_pads(lcd_gpio_padcfgs, ARRAY_SIZE(lcd_gpio_padcfgs));
/* if panel needs to bringup */
if (!vboot_skip_display_init())
configure_display_blocks();
}
int
main( int argc, char **argv )
{
int c;
int errflag = 0;
int orb;
int stop = 0;
long nrecs;
char *match = ".*/pf/st";
char *from = 0;
char *statefile = 0;
char *pfname = "orb2rrdc";
char *orbname;
char *dbcache;
char *rrdtool;
char command[STRSZ];
char net[STRSZ];
char sta[STRSZ];
char rrdvar[STRSZ];
char key[STRSZ];
char path[FILENAME_MAX];
Dbptr db;
Dbptr dbt;
Pf *pf;
char *Default_network;
Tbl *dlslines;
Arr *Dls_vars_dsparams;
Arr *Dls_vars_rras;
Tbl *Dls_vars_keys;
char *line;
char *dls_var;
char *dsparams;
Tbl *rras;
int i;
int j;
OrbreapThr *ort;
int pktid;
char srcname[ORBSRCNAME_SIZE];
double time = 0;
char *packet = 0;
int nbytes = 0;
int bufsize = 0;
Packet *pkt = 0;
int rc;
char *s;
Pf *dlspf;
Tbl *dlspfkeys;
char *element;
Tbl *parts;
double val;
Pf *pfval = 0;
elog_init( argc, argv );
while( ( c = getopt( argc, argv, "vVd:s:p:m:f:" ) ) != -1 ) {
switch( c ) {
case 'd':
CacheDaemon = optarg;
break;
case 'f':
from = optarg;
break;
case 'm':
match = optarg;
break;
case 'p':
pfname = optarg;
break;
case 's':
statefile = optarg;
break;
case 'v':
Verbose++;
break;
case 'V':
VeryVerbose++;
Verbose++;
break;
default:
elog_complain( 0, "Unknown option '%c'\n", c );
errflag++;
break;
}
}
if( errflag || argc - optind != 2 ) {
usage();
}
if( Verbose ) {
elog_notify( 0, "Starting at %s (%s $Revision$ $Date$)\n",
zepoch2str( str2epoch( "now" ), "%D %T %Z", "" ),
Program_Name );
}
orbname = argv[optind++];
dbcache = argv[optind++];
pfread( pfname, &pf );
rrdtool = pfget_string( pf, "rrdtool" );
if( rrdtool == NULL || ! strcmp( rrdtool, "" ) ) {
elog_die( 0, "Error: no rrdtool executable name specified in parameter file\n" );
} else if( ( rrdtool[0] == '/' && ! is_present( rrdtool ) ) || ( rrdtool[0] != '/' && ! datafile( "PATH", rrdtool ) ) ) {
elog_die( 0, "Error: can't find rrdtool executable by name of '%s' (check PATH environment "
"variable, or absolute path name if given)\n", rrdtool );
} else if( rrdtool[0] == '/' ) {
sprintf( command, "%s -", rrdtool );
} else {
sprintf( command, "rrdtool -" );
}
Suppress_egrep = pfget_string( pf, "suppress_egrep" );
if( Suppress_egrep != NULL && strcmp( Suppress_egrep, "" ) ) {
if( ! datafile( "PATH", "egrep" ) ) {
elog_complain( 0, "Ignoring suppress_egrep parameter: can't find egrep on path\n" );
} else {
sprintf( command, "%s 2>&1 | egrep -v '%s'", command, Suppress_egrep );
}
}
if( VeryVerbose ) {
elog_notify( 0, "Executing command: %s\n", command );
}
Rrdfp = popen( command, "w" );
if( Rrdfp == (FILE *) NULL ) {
elog_die( 0, "Failed to open socket to rrdtool command\n" );
}
orb = orbopen( orbname, "r&" );
if( orb < 0 ) {
elog_die( 0, "Failed to open orb '%s' for reading. Bye.\n", orbname );
}
orbselect( orb, match );
if( from != NULL && statefile == NULL ) {
pktid = orbposition( orb, from );
if( Verbose ) {
elog_notify( 0, "Positioned to packet %d\n", pktid );
}
} else if( from != NULL ) {
elog_complain( 0, "Ignoring -f in favor of existing state file\n" );
}
if( statefile != NULL ) {
stop = 0;
exhume( statefile, &stop, 15, 0 );
orbresurrect( orb, &pktid, &time );
if( Verbose ) {
elog_notify( 0, "Resurrecting state to pktid %d, time %s\n",
pktid, s = strtime( time ) );
free( s );
}
orbseek( orb, pktid );
}
dbopen( dbcache, "r+", &db );
if( db.database < 0 ) {
elog_die( 0, "Failed to open cache database '%s'. Bye.\n", dbcache );
} else {
db = dblookup( db, "", "rrdcache", "", "" );
if( db.table < 0 ) {
elog_die( 0, "Failed to lookup 'rrdcache' table in '%s'. Bye.\n", dbcache );
}
}
dbcrunch( db );
dbt = dbsubset( db, "endtime == NULL", NULL );
Rrd_files = newarr( 0 );
dbquery( dbt, dbRECORD_COUNT, &nrecs );
for( dbt.record = 0; dbt.record < nrecs; dbt.record++ ) {
dbgetv( dbt, 0, "net", &net, "sta", &sta, "rrdvar", &rrdvar, NULL );
dbfilename( dbt, (char *) &path );
sprintf( key, "%s:%s:%s", net, sta, rrdvar );
if( ! is_present( path ) ) {
elog_complain( 0, "WARNING: rrd file '%s', listed in database, does not exist. "
"Removing database entry.\n", path );
dbmark( dbt );
} else {
setarr( Rrd_files, key, strdup( path ) );
if( VeryVerbose ) {
elog_notify( 0, "Re-using rrd file '%s' for '%s'\n", path, key );
}
}
}
Rrdfile_pattern = pfget_string( pf, "rrdfile_pattern" );
Status_stepsize_sec = pfget_double( pf, "status_stepsize_sec" );
Default_network = pfget_string( pf, "default_network" );
dlslines = pfget_tbl( pf, "dls_vars" );
Dls_vars_dsparams = newarr( 0 );
Dls_vars_rras = newarr( 0 );
for( i = 0; i < maxtbl( dlslines ); i++ ) {
line = gettbl( dlslines, i );
strtr( line, "\t", " " );
rras = split( line, ' ' );
dls_var = shifttbl( rras );
dsparams = shifttbl( rras );
setarr( Dls_vars_dsparams, dls_var, dsparams );
setarr( Dls_vars_rras, dls_var, rras );
}
ort = orbreapthr_new( orb, -1., 0 );
for( ; stop == 0; ) {
orbreapthr_get( ort, &pktid, srcname, &time, &packet, &nbytes, &bufsize );
if( statefile ) {
rc = bury();
if( rc < 0 ) {
elog_complain( 0, "Unexpected failure of bury command! "
"(are there two orb2rrdc's running with the same state"
"file?)\n" );
clear_register( 1 );
}
}
rc = unstuffPkt( srcname, time, packet, nbytes, &pkt );
if( rc == Pkt_pf ) {
if( VeryVerbose ) {
/* Parameter files generally too big for elog */
fprintf( stderr, "Received a parameter-file '%s' at %s\n%s\n\n",
srcname,
s = strtime( time ),
pf2string( pkt->pf ) );
free( s );
} else if( Verbose ) {
elog_notify( 0, "Received a parameter-file '%s' at %s\n",
srcname, s = strtime( time ) );
free( s );
}
pfmorph( pkt->pf );
if( VeryVerbose ) {
fprintf( stderr, "Morphed parameter-file '%s' to interpret 'opt':\n%s\n\n",
srcname,
pf2string( pkt->pf ) );
}
pfget( pkt->pf, "dls", (void **) &dlspf );
dlspfkeys = pfkeys( dlspf );
Dls_vars_keys = keysarr( Dls_vars_dsparams );
for( i = 0; i < maxtbl( dlspfkeys ); i++ ) {
element = gettbl( dlspfkeys, i );
if( strcontains( element, "_", 0, 0, 0 ) ) {
parts = split( (s = strdup( element )), '_' );
sprintf( net, "%s", (char *) gettbl( parts, 0 ) );
sprintf( sta, "%s", (char *) gettbl( parts, 1 ) );
free( s );
freetbl( parts, 0 );
} else {
sprintf( net, "%s", Default_network );
sprintf( sta, "%s", element );
}
for( j = 0; j < maxtbl( Dls_vars_keys ); j++ ) {
dls_var = gettbl( Dls_vars_keys, j );
sprintf( key, "%s{%s}", element, dls_var );
if( pfresolve( dlspf, key, 0, &pfval ) < 0 ) {
elog_complain( 0, "Unable to extract variable '%s' "
"(not present or wrong type) from element '%s' "
"in packet from '%s', timestamped '%s'; Skipping\n",
key, element, srcname, s = strtime( time ) );
free( s );
pfval = 0;
continue;
} else if( pfval != (Pf *) NULL &&
pfval->value.s != (char *) NULL &&
! strcmp( pfval->value.s, "-" ) ) {
if( VeryVerbose ) {
elog_notify( 0, "Non-floating point value '-' in variable '%s', "
"in packet from '%s', timestamped '%s'; Skipping data point\n",
key, srcname, s = strtime( time ) );
free( s );
}
continue;
} else {
val = pfget_double( dlspf, key );
}
archive_dlsvar( db, net, sta, dls_var,
(char *) getarr( Dls_vars_dsparams, dls_var ),
(Tbl *) getarr( Dls_vars_rras, dls_var ),
time, val );
}
}
freetbl( dlspfkeys, 0 );
freetbl( Dls_vars_keys, 0 );
} else if( rc == Pkt_stash ) {
; /* Do nothing */
} else {
if( Verbose ) {
elog_notify( 0, "Received a packet that's not a parameter file "
"(type '%d' from unstuffPkt); skipping\n", rc );
}
}
}
}
int
main(int argc, char **argv)
{
double modified_after =now() , last_lddate, last_mtime, mtime;
char *orbname = NULL;
char *dbname = NULL;
int orb;
int naptime = -1, check_lddate_interval = -1;
Dbptr db, dbt, dbs;
char *prefix = NULL;
struct stat filestat;
int i;
Tbl *tablenames, *tables_containing_dfile, *check_tables = NULL,
*ignore_tables = NULL;
long table_present, recc, is_view;
char *tablename, *schemaname;
char *filename;
int counter = 0, force_check = 0;
char expr[512];
char *statefilename = NULL, *pfname = "dbnew2orb";
Pf *pf = NULL;
void *priv_dfile = (void *) NULL;
void *private = (void *) NULL;
int pmsi; /* poor man's string index, replacment for
* searchtbl... */
char *pmsp;
double lastburytime;
Relic relic;
char *s;
Expression *expr_lddate;
double *mtimes;
double *lddates;
elog_init(argc, argv);
if (argc < 2) {
usage();
exit(1);
}
for (argc--, argv++; argc > 0; argc--, argv++) {
if (!strcmp(*argv, "-modified_after")) {
argc--;
argv++;
if (argc < 1) {
complain(0, "Need -modified_after argument.\n");
usage();
exit(1);
}
modified_after = str2epoch(*argv);
} else if (!strcmp(*argv, "-prefix")) {
argc--;
argv++;
if (argc < 1) {
complain(0, "Need -prefix argument.\n");
usage();
exit(1);
}
prefix = *argv;
} else if (!strcmp(*argv, "-pf")) {
argc--;
argv++;
if (argc < 1) {
complain(0, "Need -pf argument.\n");
usage();
exit(1);
}
pfname = *argv;
} else if (!strcmp(*argv, "-state")) {
argc--;
argv++;
if (argc < 1) {
complain(0, "Need -state argument.\n");
usage();
exit(1);
}
statefilename = *argv;
} else if (!strcmp(*argv, "-sleep")) {
argc--;
argv++;
if (argc < 1) {
complain(0, "Need -sleep argument.\n");
usage();
exit(1);
}
naptime = atoi(*argv);
} else if (!strcmp(*argv, "-check_lddate_interval")) {
argc--;
argv++;
if (argc < 1) {
complain(0, "Need -check_lddate_interval argument.\n");
usage();
exit(1);
}
check_lddate_interval = atoi(*argv);
} else if (!strcmp(*argv, "-v")) {
verbose++;
} else if (**argv != '-') {
break;
} else {
complain(0, "Unrecognized argument '%s'.\n", *argv);
usage();
exit(1);
}
}
if (pfread(pfname, &pf)) {
elog_die(0, "parse_pf: pfread('%s') error.\n", pfname);
}
if (check_lddate_interval < 1) {
if (parse_param(pf, "check_lddate_interval", P_LINT, 1, &check_lddate_interval) < 0) {
elog_die(1, "parse_pf: sleep check_lddate_interval needed!\n");
} else {
if (check_lddate_interval < 0) {
check_lddate_interval = 1;
}
}
}
if (naptime < 1) {
if (parse_param(pf, "sleep", P_LINT, 1, &naptime) < 0) {
elog_die(1, "parse_pf: sleep value needed!\n");
} else {
if (naptime < 0) {
naptime = 1;
}
}
}
if (!prefix) {
if (parse_param(pf, "prefix", P_STR, 0, &prefix) < 0) {
printf("NO PREFIX!\n");
prefix = NULL;
}
}
parse_param(pf, "check_tables", P_TBL, 0, &check_tables);
if (check_tables) {
if (maxtbl(check_tables) < 1) {
freetbl(check_tables, 0);
check_tables = NULL;
}
}
parse_param(pf, "ignore_tables", P_TBL, 0, &ignore_tables);
if (ignore_tables) {
if (maxtbl(ignore_tables) < 1) {
freetbl(ignore_tables, 0);
ignore_tables = NULL;
}
}
/*
* no good here, would erase the table above pffree(pf);
*/
if (argc < 1) {
complain(0, "Need db argument.\n");
usage();
exit(1);
}
dbname = *argv;
argc--;
argv++;
if (argc < 1) {
complain(0, "Need orb argument.\n");
usage();
exit(1);
}
orbname = *argv;
argc--;
argv++;
if (argc > 0) {
complain(0, "Unrecognized argument '%s'.\n", *argv);
usage();
exit(1);
}
if (dbopen(dbname, "r", &db) < 0) {
elog_complain(0, "Can't open database");
exit(1);
}
dbquery(db, dbSCHEMA_NAME, &schemaname);
orb = orbopen(orbname, "w&");
if (orb < 0) {
elog_die(0, "orbopen(%s) error\n", orbname);
}
/*
* prepare for later call to dbquery(dbFIELD_TABLES) to find only
* tables containing lddate
*/
/*
* dbtables is much better, does not require the existence of table
* origin dbf = dblookup(db, 0, "origin", "lddate", "dbNULL");
* dbquery(dbf, dbFIELD_TABLES, &tablenames);
*/
dbex_compile(db, "max(lddate)", &expr_lddate, dbTIME);
tablenames = dbtables(db, "lddate");
tables_containing_dfile = dbtables(db, "dfile");
/* waste a few bytes... */
ntables = maxtbl(tablenames);
mtimes = malloc(ntables * sizeof(double));
lddates = malloc(ntables * sizeof(double));
bury_times = malloc(ntables * sizeof(double));
static_flags = malloc(ntables * sizeof(long));
if (statefilename) {
if (exhume(statefilename, &Stop, 10, mortician)) {
elog_notify(0, "read old state file\n");
} else {
elog_complain(0, "could not read old statefile\n");
}
}
for (i = 0; i < ntables; i++) {
/*
* mtimes[i] = modified_after; lddates[i] = modified_after;
*/
static_flags[i] = NEW_TABLE;
}
for (;;) {
tablenames = dbtables(db, "lddate");
for (i = 0; i < ntables; i++) {
tablename = gettbl(tablenames, i);
if (!tablename) {
continue;
}
dbt = dblookup(db, 0, tablename, 0, 0);
dbquery(dbt, dbTABLE_PRESENT, &table_present);
if (!table_present) {
continue;
}
dbquery(dbt, dbTABLE_IS_VIEW, &is_view);
if (is_view) {
continue;
}
/* lastid is not a good idea (my personal choice)... */
if (strcmp(tablename, "lastid") == 0) {
continue;
}
/* remove after Dan fixed the bug with remark */
if (strcmp(tablename, "remark") == 0) {
continue;
}
if (findtbl(tablename, tables_containing_dfile)) {
continue;
}
if (check_tables) {
if (!findtbl(tablename,check_tables)) {
if (verbose > 1 && static_flags[i]==NEW_TABLE) elog_notify(0,"ignoring table %s because it's NOT in 'check_tables'\n",tablename);
continue;
}
}
if (ignore_tables) {
if (findtbl(tablename,ignore_tables)) {
if (verbose > 1 && static_flags[i]==NEW_TABLE) elog_notify(0,"ignoring table %s because it's in 'ignore_tables'\n",tablename);
continue;
}
}
dbquery(dbt, dbRECORD_COUNT, &recc);
if (recc < 1) {
continue;
}
if (statefilename) {
if (static_flags[i] == NEW_TABLE) {
relic.dp = &bury_times[i];
if (resurrect(tablename, relic, TIME_RELIC) == 0) {
mtimes[i] = bury_times[i];
lddates[i] = bury_times[i];
if (verbose > 1) {
elog_notify(0, "resurrection successful: check %s after %s\n", tablename, s = strtime(bury_times[i]));
free(s);
}
} else {
bury_times[i] = modified_after;
mtimes[i] = modified_after;
lddates[i] = modified_after;
if (verbose > 1) {
elog_notify(0, "resurrection unsuccessful: check %s after %s\n", tablename, s = strtime(modified_after));
free(s);
}
}
static_flags[i] = TABLE_SEEN;
}
} else {
if (static_flags[i] == NEW_TABLE) {
bury_times[i] = modified_after;
mtimes[i] = modified_after;
lddates[i] = modified_after;
static_flags[i] = TABLE_SEEN;
}
}
dbquery(dbt, dbTABLE_FILENAME, &filename);
if (stat(filename, &filestat) < 0) {
elog_die(1, "stat(%s) error.\n", filename);
}
last_mtime = mtimes[i];
last_lddate = lddates[i];
mtime = filestat.st_mtime;
/*
* the whole mtime stuff is not soo good: mtime is
* typically > lddate, so setting modified_after to
* mtime will certainly ignore the last value. To get
* everything, I will have to keep 2 arrays: mtimes
* to detect file modifications and lddates to get
* the actual entries...
*/
if (force_check || mtime > last_mtime) {
sprintf(expr, "lddate > %f", last_lddate);
dbs = dbsubset(dbt, expr, 0);
dbquery(dbs, dbRECORD_COUNT, &recc);
if (recc > 0) {
if (dbrows2orb(dbs, orb, prefix) == 0) {
/*
* dbex_evalstr(dbs,
* "max(lddate)", dbTIME,
* &lddates[i]);
*/
dbex_eval(dbs, expr_lddate, 0, &lddates[i]);
mtimes[i] = mtime;
bury_times[i] = lddates[i];
}
}
dbfree(dbs);
}
/*
* a call to dbfree(dbt) would remove it from the
* list of tablenames, all later calls to tablename
* would return NIL...
*/
if (Stop) {
bury();
return (0);
}
}
sleep(naptime);
if ((counter + 1) >= check_lddate_interval) {
counter = 0;
force_check = 1;
} else {
force_check = 0;
counter++;
}
if (statefilename) {
double nowtime;
nowtime = now();
if (nowtime - lastburytime > 600.0) {
lastburytime = nowtime;
bury();
}
}
}
}
int main(int argc, char **argv)
{
SEGYBinaryFileHeader reel;
SEGYTraceHeader *header;
char *dbin;
char *outfile;
FILE *fp;
Pf *pf;
Arr *channels; /* channel order list */
Arr *table_list; /* array of valid tables */
int nchan;
char *stest;
float **traces;
char text_file_header[SEGY_TEXT_HEADER_SIZE];
Dbptr db, trdb, dbj;
Dbptr trdbss;
int nsamp0;
double time0, endtime0, samprate0;
long int nsamp;
double samprate;
int i,j;
char stime[30],etime[30];
char s[128];
double tlength;
double phi, theta;
char *newchan_standard[3]={"X1","X2","X3"};
char *trsubset="chan=~/X./";
char *newchan[3]={"R","T","Z"};
Tbl *sortkeys=newtbl(0);
char sta[10],chan[10];
double lat, lon, elev, dnorth, deast, edepth;
char segtype;
char refsta[10];
int total_traces=0;
char *time_str;
long int evid,shotid=1;
int rotate=0;
long int ntraces;
int ichan;
int map_to_cdp; /* logical switch to output data like cdp stacked data */
char *fmt="%Y %j %H %M %S %s";
char *pfname;
int Verbose=0;
/* New features added 2009 */
/* this is a boolean. If true (nonzero) it is assumed stdin will
contain four numbers: time,lat, lon, elev. If false, only the
time field is read and remainder of any input on each line is dropped.*/
int input_source_coordinates;
/* scale factor for source coordinates. Needed because segy uses
an int to store source coordinates. Sensible choices are
3600 for arc seconds and 10000 for a pseudodecimal. Note this
parameter is ignored unless input_source_coordinates is true.*/
int coordScale;
/* If true use passcal 32 bit extension num_samps as record length.
SEGY standard uses a 16 bit entry that easily overflows with large
shots at long offset. In this ase assume the 16 bit quantity is
meaningless. */
int use_32bit_nsamp;
/* This is switched on by argument switch. When set to a nonzero
(default) the reel headers are written. When 0 `
the reel headers will not be written -- used by seismic unix
and passcal*/
int write_reel_headers=1;
/* SEG-Y version to output. Default is original 1975 spec (rev 0) */
int16_t segy_format = SEGY_FORMAT_REV_0;
/* dbsubset query string */
char *substr=NULL;
/* text_header_description is a buffer holding a user-supplied description
* to be placed in the 3200-byte text header block. It is controlled by
* the parameter file value text_header_description or by the -d command
* line option, with the latter taking precedence */
char* text_header_description=NULL;
if(argc < 3) usage();
dbin = argv[1];
outfile = argv[2];
pfname = NULL;
for(i=3;i<argc;++i)
{
if(!strcmp(argv[i],"-pf"))
{
++i;
pfname = argv[i];
}
else if(!strcmp(argv[i],"-SU"))
{
write_reel_headers=0;
}
else if(!strcmp(argv[i],"-v"))
{
Verbose=1;
}
else if(!strcmp(argv[i],"-d"))
{
++i;
text_header_description = strdup(argv[i]);
}
else if(!strcmp(argv[i],"-ss"))
{
++i;
substr=argv[i];
}
else if(!strcmp(argv[i],"-V"))
{
++i;
if (!strcmp(argv[i],"0")) {segy_format = SEGY_FORMAT_REV_0;}
else if(!strcmp(argv[i],"1")) {segy_format = SEGY_FORMAT_REV_1_0;}
else if(!strcmp(argv[i],"SU"))
{
segy_format = SEGY_FORMAT_SU;
write_reel_headers=0;
}
else
{
elog_complain(0, "SEG-Y Version must be either 1 or 0");
usage();
}
}
else
{
usage();
}
}
/* Command-line parameter sanity checking */
if (write_reel_headers==0 && segy_format != SEGY_FORMAT_SU){
complain(0, "The SU option cannot be used with the -V option");
usage();
}
if(pfname == NULL) pfname = strdup("db2segy");
elog_init(argc, argv);
if(pfread(pfname,&pf)) {
elog_die(0,"pfread error for pf file %s.pf\n",argv[0]);
}
/* Read the text_header_description if we weren't passed the -d option */
if (!text_header_description) {
text_header_description=pfget_string(pf, "text_header_description");
}
/* rotation parameters */
rotate=pfget_boolean(pf,"rotate");
if(rotate)
{
phi = pfget_double(pf,"phi");
theta = pfget_double(pf,"theta");
}
/* This function creates the channel order list keyed by
station channel names */
channels = build_stachan_list(pf,&nchan,Verbose);
map_to_cdp = pfget_boolean(pf,"map_to_cdp");
if(map_to_cdp && Verbose)
elog_notify(0,"Casting data as CDP stacked section\n");
if(dbopen(dbin,"r",&db) == dbINVALID)
{
elog_complain(1,"Cannot open db %s\n", dbin);
usage();
}
/* We grab the sample rate and trace length (in seconds) and
use this to define global sample rates for the data.
SEG-Y REV0 REQUIRES fixed length records and sample rates, so
irregular sample rates will cause this program to die.
One could add a decimate/interpolate function, but this
is not currently implemented */
samprate0 = pfget_double(pf,"sample_rate");
tlength = pfget_double(pf,"trace_length");
nsamp0 = (int)(tlength*samprate0);
use_32bit_nsamp=pfget_boolean(pf,"use_32bit_nsamp");
if (ntohs(segy_format) >= 0x0100 && use_32bit_nsamp) {
elog_complain(0,"The 32-bit extension field is incompatible with SEG-Y REV 1. Ignoring 'use_32bit_nsamp' from the parameter file");
use_32bit_nsamp=0;
}
/* nsamp in segy is a 16 bit field. Handling depends on
setting of use_32bit_nsamp boolean */
if(nsamp0 > SEGY_MAX_NSAMP)
{
if(use_32bit_nsamp)
{
elog_notify(0,"Warning: segy uses a 16 bit entity to store number of samples\nThat field is garbage. Using the 32 bit extension field.");
}
else
{
elog_complain(0,
"Warning: segy uses a 16 bit entity to store number of samples. Requested %d samples per trace. Trucated to %d", nsamp0, SEGY_MAX_NSAMP);
nsamp0 = SEGY_MAX_NSAMP;
}
}
/* boolean. When nonzero set coordinates as geographic arc seconds values */
int use_geo_coordinates=pfget_boolean(pf,"use_geo_coordinates");
/* boolean. When nonzero, output decimal degrees instead of arcseconds if
* the requested output format supports it (rev1 only) */
int prefer_decimal_degrees=pfget_boolean(pf, "prefer_decimal_degrees");
/* We now have enough information to decide the coordUnits for all traces */
int coordUnits = 0;
if (!use_geo_coordinates) {
coordUnits=SEGY_TRACE_COORDUNITS_LENGTH;
} else if (ntohs(segy_format) >= 0x0100 && prefer_decimal_degrees) {
coordUnits=SEGY_TRACE_COORDUNITS_DECIMAL_DEGREES;
} else {
coordUnits=SEGY_TRACE_COORDUNITS_ARCSECONDS;
}
/* We should have set our coordinate units now */
assert(coordUnits!=0);
input_source_coordinates=pfget_boolean(pf,"input_source_coordinates");
if(input_source_coordinates)
{
coordScale=pfget_int(pf,"coordinate_scale_factor");
}
else if (coordUnits==SEGY_TRACE_COORDUNITS_DECIMAL_DEGREES)
{
/* Use a sane scalar for decimal degrees. 10000 gives four decimal
* places of accuracy, which matches the CSS3.0 spec for lat and lon */
coordScale=10000;
}
else
{
coordScale=1;
}
/* Print a diagnostic message if the user gave a sub-optimal value for the
* coordScale */
if (coordUnits == SEGY_TRACE_COORDUNITS_DECIMAL_DEGREES &&
coordScale < 10000)
{
elog_alert(0,
"The supplied parameter 'coordinate_scale_factor' value of %d is less than 10000, and will cause loss of precision for decimal degree coordinates.",
coordScale);
}
else if (coordUnits == SEGY_TRACE_COORDUNITS_ARCSECONDS)
{
if (coordScale > 1000) {
elog_alert(0,
"The supplied parameter 'coordinate_scale_factor' value of %d is greater than 1000, and will cause loss of precision for arcsecond coordinates.",
coordScale);
}
}
/* trace_gain_type: signed int */
int16_t trace_gain_type = pfget_int(pf,"trace_gain_type");
if (trace_gain_type < 0)
{
die(0, "The trace_gain_type must be zero or greater");
}
else
{
trace_gain_type=htons(trace_gain_type);
}
/* check list of tables defined in pf. Return array of
logicals that define which tables are valid and join
tables. */
table_list = check_tables(db,pf);
check_for_required_tables(table_list);
dbj = join_tables(db,pf,table_list);
if(dbj.record == dbINVALID) elog_die(0,"dbjoin error\n");
if(substr!=NULL) dbj=dbsubset(dbj,substr,0);
long int ndbrows;
dbquery(dbj,dbRECORD_COUNT,&ndbrows);
if(ndbrows<=0)
{
elog_complain(1,"Working database view is empty\n");
if(substr!=NULL) elog_complain(0,"Subset condtion =%s a likely problem\n",
substr);
usage();
}
fp = fopen(outfile,"w");
if(fp == NULL)
{
elog_complain(0,"Cannot open output file %s\n",outfile);
usage();
}
/* These are needed for sort below */
pushtbl(sortkeys,"sta");
pushtbl(sortkeys,"chan");
/* Set up and write the Textual File Header */
initialize_text_header(text_file_header, segy_format,
text_header_description);
if(write_reel_headers){
if ( fwrite(text_file_header,1,SEGY_TEXT_HEADER_SIZE,fp) \
!= SEGY_TEXT_HEADER_SIZE ) {
elog_die(1,"An error occurred writing the textual file header");
}
}
/* memory allocation for trace data. This is a large matrix
that is cleared for each event. This model works because of
segy's fixed length format.*/
traces = calloc(nchan, sizeof(float*));
if(traces == NULL)
elog_die(1,"out of memory");
for (int r = 0; r < nchan; r++)
{
traces[r] = calloc(nsamp0, sizeof(float));
if(traces[r] == NULL)
elog_die(1,"out of memory");
}
header = (SEGYTraceHeader *)calloc((size_t)nchan,sizeof(SEGYTraceHeader));
if(header == NULL)
elog_die(0,"Cannot alloc memory for %d segy header workspace\n",nchan);
if(write_reel_headers)
{
if (Verbose) {
elog_debug(0,"Binary Headers - Using segy_format code 0x%04X\n", ntohs(segy_format));
}
initialize_binary_file_header(&reel, segy_format);
/* now fill in the binary reel header and write it */
reel.kjob = htonl(1);
reel.kline = htonl(1);
reel.kreel = htonl(1);
reel.kntr = htons((int16_t)nchan);
reel.knaux = htons(0);
reel.sr = htons((int16_t)(1000000.0/samprate0));
reel.kfldsr = reel.sr;
reel.knsamp = htons((int16_t)nsamp0);
reel.kfsamp = htons((int16_t)nsamp0);
reel.dsfc = htons(5); /* This is ieee floats*/
reel.kmfold = htons(0);
if(map_to_cdp)
reel.ksort = htons(2);
else
reel.ksort = htons(1);
reel.kunits = htons(1); /* This sets units to always be meters */
if(fwrite((void *)(&reel),sizeof(SEGYBinaryFileHeader),1,fp) != 1)
{
elog_die(1,"Write error for binary reel header");
}
}
/* Now we enter a loop over stdin reading start times.
Program will blindly ask for data from each start time to
time+tlength. The trace buffer will be initialized to
zeros at the top of the loop always. If nothing is found
only zeros will be written to output.
*/
while((stest=fgets(s,80,stdin)) != NULL)
{
double slat,slon,selev; /* Used when reading source location*/
if(Verbose)
elog_notify(0,"Processing: %s\n",s);
for(i=0;i<nchan;++i)
{
initialize_trace_header(&(header[i]), segy_format);
header[i].gainType = trace_gain_type;
header[i].lineSeq = htonl(total_traces + i + 1);
header[i].reelSeq = header[i].lineSeq;
if(map_to_cdp)
{
header[i].cdpEns = htonl(i + 1);
header[i].traceInEnsemble = htonl(1);/* 1 trace per cdp faked */
}
else
{
header[i].channel_number = htonl(i + 1);
}
header[i].event_number = htonl(shotid);
header[i].energySourcePt = htonl(shotid);
for(j=0;j<nsamp0;++j) traces[i][j] = htonf((Trsample)0.0);
}
if(input_source_coordinates)
{
char stmp[40];
sscanf(s,"%s%ld%lf%lf%lf",stmp,&shotid,&slon,&slat,&selev);
time0=str2epoch(stmp);
if(coordUnits == SEGY_TRACE_COORDUNITS_ARCSECONDS) {
slat*=3600.0;
slon*=3600.0;
}
slat *= (double)coordScale;
slon *= (double)coordScale;
}
else
{
time0 = str2epoch(s);
}
endtime0 = time0 + tlength;
sprintf(stime,"%20.4f",time0);
sprintf(etime,"%20.4f",endtime0);
trdb.database = -1;
if(trload_css(dbj,stime,etime,&trdb,0, 0) < 0)
{
if(Verbose)
{
elog_notify(0,"trload_css failed for shotid=%ld",shotid);
elog_notify(0," No data in time range %s to %s\n",
strtime(time0),strtime(endtime0) );
elog_notify(0,"No data written for this shotid block.");
elog_notify(0," Handle this carefully in geometry definitions.\n");
}
continue;
}
/* This does gap processing */
repair_gaps(trdb);
trapply_calib(trdb);
if(rotate)
{
if(rotate_to_standard(trdb,newchan_standard))
elog_notify(0,"Data loss in rotate_to_standard for event %s to %s\n",
stime, etime);
/* This is need to prevent collisions of channel names */
trdbss = dbsubset(trdb,trsubset,0);
if(trrotate(trdbss,phi,theta,newchan))
elog_notify(0,"Data loss in trrotate for event %s to %s\n",
stime, etime);
}
if(Verbose)
elog_notify(0,"Station chan_name chan_number seq_number shotid evid\n");
trdb = dbsort(trdb,sortkeys,0,0);
dbquery(trdb,dbRECORD_COUNT,&ntraces);
if(Verbose) elog_debug(0,"Read %ld traces for event at time%s\n",
ntraces,strtime(time0));
for(trdb.record=0;trdb.record<ntraces;++trdb.record)
{
Trsample *trdata;
if(dbgetv(trdb,0,
"evid",&evid,
"sta",sta,
"chan",chan,
"nsamp", &nsamp,
"samprate",&samprate,
"data",&trdata,
"lat", &lat,
"lon", &lon,
"elev",&elev,
"refsta",refsta,
"dnorth",&dnorth,
"deast",&deast,
"edepth",&edepth,
"segtype",&segtype,
NULL) == dbINVALID)
{
elog_complain(0," dbgetv error reading record %ld. Trace will be skipped for station %s and channel %s",
trdb.record,sta,chan);
continue;
}
/* Allow 1 percent samprate error before killing */
double fsrskew=fabs((samprate-samprate0)/samprate0);
double frskewcut=0.01;
if(fsrskew>frskewcut)
{
elog_complain(0,"%s:%s sample rate %f is significantly different from base sample rate of %f. Trace skipped -- segy requires fixed sample rates",
sta,chan,samprate,samprate0);
continue;
}
if(nsamp > nsamp0)
{
elog_complain(0,"%s:%s trace has extra samples=%ld. Truncated to length %d",
sta, chan, nsamp, nsamp0);
nsamp = nsamp0;
}
else if(nsamp < nsamp0)
{
elog_complain(0,"%s:%s trace is shorter than expected %d samples. Zero padded after sample %ld",
sta, chan, nsamp0, nsamp);
}
ichan = get_channel_index(channels,sta,chan);
if(ichan > nchan)
{
elog_die(0,"Channel index %d outside limit of %d. Cannot continue",
ichan, nchan);
}
if(ichan >= 0)
{
if(Verbose)
elog_debug(0,"%s:%s\t%-d\t%-d\t%-ld\t%-ld\n",
sta,chan,ichan+1,
ntohl(header[ichan].reelSeq),
shotid, evid);
header[ichan].traceID = get_trace_id_code_from_segtype(segtype);
for(j=0;j<nsamp;++j) {
traces[ichan][j] = htonf((float)trdata[j]);
}
/* header fields coming from trace table */
header[ichan].samp_rate = htonl(
(int32_t) (1000000.0/samprate0));
/* according to the behavior specified in the man page:
* if use_geo_coordinates is false:
* - coordUnits is length (meters)
* - therefore, we use deast for X and dnorth for Y
* if use_geo_coordinates is true:
* - we're using either arcseconds or decimal degrees
* - and therefore, we use lon for X and lat for Y
*
* coordUnits is based on use_arcseconds and the requested
* version of segY */
/* set the coordinate units in the trace header */
header[ichan].coordUnits = coordUnits;
/* Pick the source db fields for our receiver X and Y */
double recLongOrX = 0;
double recLatOrY = 0;
if (coordUnits == SEGY_TRACE_COORDUNITS_LENGTH) {
/* Use deast and dnorth
* CSS3.0 Schema specifies deast and dnorth are in KM.
* SEG-Y specifies easting and northing as meters,
* hence the 1000.0 multiplier here. */
recLongOrX = deast * 1000.0;
recLatOrY = dnorth * 1000.0;
} else if (coordUnits == SEGY_TRACE_COORDUNITS_ARCSECONDS){
/* Use lat and lon, converted to arcseconds */
recLongOrX = lon * 3600.0;
recLatOrY = lat * 3600.0;
} else {
/* Default case, which covers decimal degrees */
recLongOrX = lon;
recLatOrY = lat;
}
/* Apply our coordScale - the user can specify negative numbers,
* but they are treated as inverting the value, not as a divisor
* as in the SEG-Y field usage. See below where we always treat
* the scalar as a divisor in the SEG-Y field */
recLongOrX *= (double)coordScale;
recLatOrY *= (double)coordScale;
/* Set the coordScale in the header.
* Note negative here. This is a oddity of segy that - means
* divide by this to get actual. Always make this negative in
* case user inputs a negative number.
* Don't set it -1 for cosmetic reasons */
if (abs(coordScale) == 1)
{
header[ichan].coordScale = htons(1);
} else
{
header[ichan].coordScale = htons(-abs(coordScale));
}
/* Finally, write out the X and Y */
header[ichan].recLongOrX
= htonl((int32_t)recLongOrX);
header[ichan].recLatOrY
= htonl((int32_t)recLatOrY);
/* CSS3.0 specfies elev as being in km, SEG-Y wants it in m */
header[ichan].recElevation = htonl((int32_t)(elev*1000.0));
header[ichan].deltaSample = htons(
(int16_t) (1000000.0/samprate0));
header[ichan].sampleLength = htons((int16_t)nsamp0);
if (ntohs(segy_format)<0x0100)
{
header[ichan].num_samps = htonl((int32_t)nsamp0);
}
/* This cracks the time fields */
time_str = epoch2str(time0,fmt);
int16_t hyear, hday, hhour, hminute, hsecond, hm_secs;
hyear=hday=hhour=hminute=hsecond=hm_secs=0;
sscanf(time_str,"%hd %hd %hd %hd %hd %hd",
&hyear, &hday, &hhour, &hminute, &hsecond, &hm_secs);
header[ichan].year = htons(hyear);
header[ichan].day = htons(hday);
header[ichan].hour = htons(hhour);
header[ichan].minute = htons(hminute);
header[ichan].second = htons(hsecond);
header[ichan].m_secs = htons(hm_secs);
if (ntohs(segy_format)<0x0100)
{
/* These are IRIS-PASSCAL extensions */
header[ichan].trigyear = header[ichan].year;
header[ichan].trigday = header[ichan].day;
header[ichan].trighour = header[ichan].hour;
header[ichan].trigminute = header[ichan].minute;
header[ichan].trigsecond = header[ichan].second;
}
free(time_str);
if(input_source_coordinates)
{
/* Write out our pre-scaled and optionally
* arcsecond-converted source lat/lon plus our elevation */
header[ichan].sourceLongOrX = htonl((int32_t)slon);
header[ichan].sourceLatOrY = htonl((int32_t)slat);
header[ichan].sourceSurfaceElevation
= htonl((int32_t)selev);
/* No easy way to specify both elev and depth*/
header[ichan].sourceDepth=htonl(0);
}
else if(map_to_cdp)
{
/* When faking CDP data we make this look
like a zero offset, single fold data set */
header[ichan].sourceLongOrX = header[ichan].recLongOrX;
header[ichan].sourceLatOrY = header[ichan].recLatOrY;
header[ichan].sourceSurfaceElevation
= header[ichan].recElevation;
header[ichan].sourceDepth = htonl(0);
header[ichan].sourceToRecDist = htonl(0);
}
else
{
/* This is the mechanism for adding other
information with added tables. The one
table currently supported is a "shot" table
that holds shot coordinates. If other tables
were added new functions could be added with
a similar calling sequence. This procedure
silently does nothing if a shot table is not
present.*/
set_shot_variable(db,table_list,
evid,&header[ichan]);
}
}
else
{
if(Verbose)
elog_notify(0,"Station %s and channel %s skipped\n",
sta,chan);
}
}
/* Now we write the data */
for(i=0;i<nchan;++i)
{
if(fwrite((void *)(&(header[i])),sizeof(SEGYTraceHeader),1,fp) != 1)
elog_die(0,"Write error on header for trace %d\n",total_traces+i);
if(fwrite((void *)traces[i],sizeof(float),
(size_t)nsamp0,fp) != nsamp0)
elog_die(0,"Write error while writing data for trace %d\n",
total_traces+i);
}
total_traces += nchan;
trdestroy(&trdb);
if(!input_source_coordinates) ++shotid;
}
return 0 ;
}
int main(int argc, char **argv)
{
SegyReel reel;
SegyHead *header;
char *dbin;
char *outfile;
FILE *fp;
Pf *pf;
Arr *channels; /* channel order list */
Arr *table_list; /* array of valid tables */
int nchan;
char *stest;
float **traces;
char reel1[3200];
Dbptr db, trdb, dbj;
Dbptr trdbss;
int nsamp0;
double time0, endtime0, samprate0;
long int nsamp;
double samprate;
int i,j;
char stime[30],etime[30];
char s[128];
double tlength;
double phi, theta;
char *newchan_standard[3]={"X1","X2","X3"};
char *trsubset="chan=~/X./";
char *newchan[3]={"R","T","Z"};
Tbl *sortkeys=newtbl(0);
char sta[10],chan[10];
double lat, lon, elev, dnorth, deast, edepth;
char refsta[10];
int total_traces=0;
char *time_str;
long int evid,shotid=1;
int rotate=0;
long int ntraces;
int ichan;
int map_to_cdp; /* logical switch to output data like cdp stacked data */
char *fmt="%Y %j %H %M %S %s";
char *pfname;
int Verbose=0;
/* New features added 2009 */
/* this is a boolean. If true (nonzero) it is assumed stdin will
contain four numbers: time,lat, lon, elev. If false, only the
time field is read and remainder of any input on each line is dropped.*/
int input_source_coordinates;
/* scale factor for source coordinates. Needed because segy uses
an int to store source coordinates. Sensible choices are
3600 for arc seconds and 10000 for a pseudodecimal. Note this
parameter is ignored unless input_source_coordinates is true.*/
int coordScale;
/* If true use passcal 32 bit extension num_samps as record length.
SEGY standard uses a 16 bit entry that easily overflows with large
shots at long offset. In this ase assume the 16 bit quantity is
meaningless. */
int use_32bit_nsamp;
/* This is switched on by argument switch. When set to a nonzero
(default) the reel headers are written. When 0 `
the reel heades will not be written -- used by seismic unix
r
and passcal*/
int write_reel_headers=1;
char *substr=NULL;
if(argc < 3) usage();
dbin = argv[1];
outfile = argv[2];
pfname = NULL;
for(i=3;i<argc;++i)
{
if(!strcmp(argv[i],"-pf"))
{
++i;
pfname = argv[i];
}
else if(!strcmp(argv[i],"-SU"))
{
write_reel_headers=0;
}
else if(!strcmp(argv[i],"-v"))
{
Verbose=1;
}
else if(!strcmp(argv[i],"-ss"))
{
++i;
substr=argv[i];
}
else
{
usage();
}
}
if(pfname == NULL) pfname = strdup("db2segy");
elog_init(argc, argv);
if(pfread(pfname,&pf))
elog_die(0,"pfread error for pf file %s.pf\n",argv[0]);
/* rotation parameters */
rotate=pfget_boolean(pf,"rotate");
if(rotate)
{
phi = pfget_double(pf,"phi");
theta = pfget_double(pf,"theta");
}
/* This function creates the channel order list keyed by
station channel names */
channels = build_stachan_list(pf,&nchan,Verbose);
map_to_cdp = pfget_boolean(pf,"map_to_cdp");
if(map_to_cdp && Verbose)
fprintf(stdout,"Casting data as CDP stacked section\n");
if(dbopen(dbin,"r",&db) == dbINVALID)
{
fprintf(stderr,"Cannot open db %s\n", dbin);
usage();
}
/* We grab the sample rate and trace length (in seconds) and
use this to define global sample rates for the data.
segy REQUIRES fixed length records and sample rates, so
irregular sample rates will cause this program to die.
One could add a decimate/interpolate function, but this
is not currently implemented */
samprate0 = pfget_double(pf,"sample_rate");
tlength = pfget_double(pf,"trace_length");
nsamp0 = (int)(tlength*samprate0);
use_32bit_nsamp=pfget_boolean(pf,"use_32bit_nsamp");
/* nsamp in segy is a 16 bit field. Handling depends on
setting of use_32bit_nsamp boolean */
if(nsamp0 > 32767)
{
if(use_32bit_nsamp)
{
elog_notify(0,"Warning: segy ues a 16 bit entity to store number of samples\nThat field is garbage. Using the 32 bit extension field.\n");
}
else
{
elog_complain(0,
"Warning: segy uses a 16 bit entity to store number of samples\nRequested %d samples per trace. Trucated to 32767\n",nsamp0);
nsamp0 = 32767;
}
}
input_source_coordinates=pfget_boolean(pf,"input_source_coordinates");
if(input_source_coordinates)
{
coordScale=pfget_int(pf,"coordinate_scale_factor");
}
else
{
coordScale=1;
}
/* boolean. When nonzero set coordinates as geographic arc seconds values */
int use_geo_coordinates=pfget_boolean(pf,"use_geo_coordinates");
/* check list of tables defined in pf. Return array of
logicals that define which tables are valid and join
tables. */
table_list = check_tables(db,pf);
check_for_required_tables(table_list);
dbj = join_tables(db,pf,table_list);
if(dbj.record == dbINVALID) elog_die(0,"dbjoin error\n");
if(substr!=NULL) dbj=dbsubset(dbj,substr,0);
long int ndbrows;
dbquery(dbj,dbRECORD_COUNT,&ndbrows);
if(ndbrows<=0)
{
fprintf(stderr,"Working database view is empty\n");
if(substr!=NULL) fprintf(stderr,"Subset condtion =%s a likely problem\n",
substr);
usage();
}
fp = fopen(outfile,"w");
if(fp == NULL)
{
fprintf(stderr,"Cannot open output file %s\n",outfile);
usage();
}
/* These are needed for sort below */
pushtbl(sortkeys,"sta");
pushtbl(sortkeys,"chan");
/*The reel1 header in true blue segy is ebcdic. We are goingto
just fill it with nulls and hope for the best */
for(i=0;i<3200;i++) reel1[i] = '\0';
/* Just blindly write this turkey. Bad form, but tough*/
if(write_reel_headers) fwrite(reel1,1,3200,fp);
/* memory allocation for trace data. This is a large matrix
that is cleared for each event. This model works because of
segy's fixed length format. This routine is a descendent of
numerical recipes routine found in libgenloc. This is not
the most efficient way to do this, but it simplifies the
algorithm a lot. */
traces = matrix(0,nchan,0,nsamp0);
if(traces == NULL)
elog_die(0,"Cannot alloc trace data matrix work space of size %d by %d\n",
nchan, nsamp0);
header = (SegyHead *)calloc((size_t)nchan,sizeof(SegyHead));
if(header == NULL)
elog_die(0,"Cannot alloc memory for %d segy header workspace\n",nchan);
if(write_reel_headers)
{
/* now fill in the binary reel header and write it */
reel.kjob = 1;
reel.kline = 1;
reel.kreel = 1;
reel.kntr = (int16_t)nchan;
reel.knaux = 0;
reel.sr = (int16_t)(1000000.0/samprate0);
reel.kfldsr = reel.sr;
reel.knsamp = (int16_t)nsamp0;
reel.kfsamp = (int16_t)nsamp0;
reel.dsfc=5; /* This is ieee floats*/
reel.kmfold = 0;
if(map_to_cdp)
reel.ksort = 2;
else
reel.ksort = 1;
reel.kunits = 1; /* This sets units to always be meters */
for(i=0;i<344;++i)reel.unused2[i]='\0';
if(fwrite((void *)(&reel),sizeof(SegyReel),1,fp) != 1)
{
fprintf(stderr,"Write error for binary reel header\n");
exit(-2);
}
}
/* Now we enter a loop over stdin reading start times.
Program will blindly ask for data from each start time to
time+tlength. The trace buffer will be initialized to
zeros at the top of the loop always. If nothing is found
only zeros will be written to output.
*/
while((stest=fgets(s,80,stdin)) != NULL)
{
double slat,slon,selev; /* Used when reading source location*/
if(Verbose)
fprintf(stdout,"Processing: %s\n",s);
for(i=0;i<nchan;++i)
{
initialize_header(&(header[i]));
header[i].lineSeq = total_traces + i + 1;
header[i].reelSeq = header[i].lineSeq;
if(map_to_cdp)
{
header[i].cdpEns = i + 1;
header[i].traceInEnsemble = 1; /* 1 trace per cdp faked */
}
else
{
header[i].channel_number = i + 1;
}
header[i].event_number = shotid;
header[i].energySourcePt=shotid;
for(j=0;j<nsamp0;++j) traces[i][j] = (Trsample)0.0;
}
if(input_source_coordinates)
{
char stmp[40];
sscanf(s,"%s%ld%lf%lf%lf",stmp,&shotid,&slon,&slat,&selev);
time0=str2epoch(stmp);
}
else
{
time0 = str2epoch(s);
}
endtime0 = time0 + tlength;
sprintf(stime,"%20.4f",time0);
sprintf(etime,"%20.4f",endtime0);
trdb.database = -1;
if(trload_css(dbj,stime,etime,&trdb,0, 0) < 0)
{
if(Verbose)
{
fprintf(stdout,"trload_css failed for shotid=%ld",shotid);
fprintf(stdout," No data in time range %s to %s\n",
strtime(time0),strtime(endtime0) );
fprintf(stdout,"No data written for this shotid block.");
fprintf(stdout," Handle this carefully in geometry definitions.\n");
}
continue;
}
/* This does gap processing */
repair_gaps(trdb);
trapply_calib(trdb);
if(rotate)
{
if(rotate_to_standard(trdb,newchan_standard))
elog_notify(0,"Data loss in rotate_to_standard for event %s to %s\n",
stime, etime);
/* This is need to prevent collisions of channel
names */
trdbss = dbsubset(trdb,trsubset,0);
if(trrotate(trdbss,phi,theta,newchan))
elog_notify(0,"Data loss in trrotate for event %s to %s\n",
stime, etime);
}
if(Verbose)
fprintf(stdout,"Station chan_name chan_number seq_number shotid evid\n");
trdb = dbsort(trdb,sortkeys,0,0);
dbquery(trdb,dbRECORD_COUNT,&ntraces);
if(Verbose) fprintf(stdout,"Read %ld traces for event at time%s\n",
ntraces,strtime(time0));
for(trdb.record=0;trdb.record<ntraces;++trdb.record)
{
Trsample *trdata;
if(dbgetv(trdb,0,
"evid",&evid,
"sta",sta,
"chan",chan,
"nsamp", &nsamp,
"samprate",&samprate,
"data",&trdata,
"lat", &lat,
"lon", &lon,
"elev",&elev,
"refsta",refsta,
"dnorth",&dnorth,
"deast",&deast,
"edepth",&edepth,
NULL) == dbINVALID)
{
elog_complain(0," dbgetv error reading record %ld\nTrace will be skipped for station %s and channel %s\n",
trdb.record,sta,chan);
continue;
}
/* Allow 1 percent samprate error before killing */
double fsrskew=fabs((samprate-samprate0)/samprate0);
double frskewcut=0.01;
if(fsrskew>frskewcut)
{
elog_complain(0,"%s:%s sample rate %f is significantly different from base sample rate of %f\nTrace skipped -- segy requires fixed sample rates\n",
sta,chan,samprate,samprate0);
continue;
}
if(nsamp > nsamp0)
{
elog_complain(0,"%s:%s trace has extra samples=%ld\nTruncated to length %d\n",
sta, chan, nsamp, nsamp0);
nsamp = nsamp0;
}
else if(nsamp < nsamp0)
{
elog_complain(0,"%s:%s trace is shorter than expected %d samples\nZero padded after sample %ld\n",
sta, chan, nsamp0, nsamp);
}
ichan = get_channel_index(channels,sta,chan);
if(ichan > nchan) elog_die(0,"Channel index %d outside limit of %d\nCannot continue\n",
ichan, nchan);
if(ichan >= 0)
{
if(Verbose)
fprintf(stdout,"%s:%s\t%-d\t%-d\t%-ld\t%-ld\n",
sta,chan,ichan+1,
header[ichan].reelSeq,
shotid, evid);
header[ichan].traceID = 1;
for(j=0;j<nsamp;++j)
traces[ichan][j] = (float)trdata[j];
/* header fields coming from trace table */
header[ichan].samp_rate = (int32_t)
(1000000.0/samprate0);
if(!use_geo_coordinates && ( coordScale==1))
{
header[ichan].recLongOrX = (int32_t)(deast*1000.0);
header[ichan].recLatOrY = (int32_t)(dnorth*1000.0);
}
else
{
/* Note negative here. This is a oddity
of segy that - means divide by this to
get actual. Always make this negative in case
user inputs a negative number. */
header[ichan].coordScale=-abs(coordScale);
/* Force 2 = geographic coordinates. Standard says when this is
so units are arc seconds, hence we multiply deg by 3600*coordScale */
if(use_geo_coordinates)
{
header[ichan].coordUnits=2;
header[ichan].recLongOrX
=(int32_t)(lon*3600.0*(double)coordScale);
header[ichan].recLatOrY
=(int32_t)(lat*3600.0*(double)coordScale);
}
else
{
header[ichan].recLongOrX
=(int32_t)(lon*(double)coordScale);
header[ichan].recLatOrY
=(int32_t)(lat*(double)coordScale);
}
}
header[ichan].recElevation = (int32_t)(elev*1000.0);
header[ichan].deltaSample = (int16_t)
(1000000.0/samprate0);
header[ichan].sampleLength = (int16_t)nsamp0;
header[ichan].num_samps = (int32_t)nsamp0;
/* This cracks the time fields */
time_str = epoch2str(time0,fmt);
sscanf(time_str,"%hd %hd %hd %hd %hd %hd",
&header[ichan].year,
&header[ichan].day,
&header[ichan].hour,
&header[ichan].minute,
&header[ichan].second,
&header[ichan].m_secs);
/* These are PASSCAL extensions, but we'll
go ahead and set them anyway.*/
header[ichan].trigyear = header[ichan].year;
header[ichan].trigday = header[ichan].day;
header[ichan].trighour = header[ichan].hour;
header[ichan].trigminute = header[ichan].minute;
header[ichan].trigsecond = header[ichan].second;
free(time_str);
if(input_source_coordinates)
{
if(use_geo_coordinates)
{
slat*=3600.0;
slon*=3600.0;
}
header[ichan].sourceLongOrX
=(int32_t)(slon*(double)coordScale);
header[ichan].sourceLatOrY
=(int32_t)(slat*(double)coordScale);
header[ichan].sourceSurfaceElevation
=(int32_t)selev;
/* No easy way to specify both elev and depth*/
header[ichan].sourceDepth=0;
}
else if(map_to_cdp)
{
/* When faking CDP data we make this look
like a zero offset, single fold data set */
header[ichan].sourceLongOrX = header[ichan].recLongOrX;
header[ichan].sourceLatOrY = header[ichan].recLatOrY;
header[ichan].sourceSurfaceElevation = header[ichan].recElevation;
header[ichan].sourceDepth = 0;
header[ichan].sourceToRecDist = 0;
}
else
{
/* This is the mechanism for adding other
information with added tables. The one
table currently supported is a "shot" table
that holds shot coordinates. If other tables
were added new functions could be added with
a similar calling sequence. This procedure
silently does nothing if a shot table is not
present.*/
set_shot_variable(db,table_list,
evid,&header[ichan]);
}
}
else
{
if(Verbose)
fprintf(stdout,"Station %s and channel %s skipped\n",
sta,chan);
}
}
/* Now we write the data */
for(i=0;i<nchan;++i)
{
if(fwrite((void *)(&(header[i])),sizeof(SegyHead),1,fp) != 1)
elog_die(0,"Write error on header for trace %d\n",total_traces+i);
if(fwrite((void *)traces[i],sizeof(float),
(size_t)nsamp0,fp) != nsamp0)
elog_die(0,"Write error while writing data for trace %d\n",
total_traces+i);
}
total_traces += nchan;
trdestroy(&trdb);
if(!input_source_coordinates) ++shotid;
}
return 0 ;
}
int main (int argc, char **argv)
{
Dbptr master_db, dbtmp;
char dbname[512]; /* dbtmp name assigned by maketmpdb */
char *orbname;
char *pffile=NULL;
Pf *pf; /* Input pf object handle */
Arr *arr_sta;
Arr *arr_a; /*Array object associative array -- purely a place holder*/
Arr *arr_phase;
int i;
char *statefile=NULL;
Point origin;
int orbin,orbout; /* We establish both a read and write connection
on seperate sockets so we can use orbreap on
the input */
int quit=0,last_pktid;
double last_pkttime;
int exhume_rcode; /* value returned by exhume*/
char *packet=0;
int orid_used;
Location_options o;
RTlocate_Options rt_opts;
ORB_Hypocenter hyp;
/* This initialization is necessary for the orb_arrivals_in routine
to work correctly on the first pass*/
hyp.assocs = NULL;
elog_init(argc, argv);
elog_notify (0, "$Revision$ $Date$") ;
if(argc < 2) usage(argv[0]);
orbname = argv[1];
for(i=2;i<argc;++i)
{
if(!strcmp(argv[i],"-pf"))
{
++i;
pffile = argv[i];
}
else if(!strcmp(argv[i],"-S"))
{
++i;
statefile = argv[i];
}
else
{
/* For this kind of program it seems wise to make it a fatal error to
have the arguments botched */
elog_complain(0,"Unrecognized argument %s\n",argv[i]);
usage(argv[0]);
}
}
/* set default this way*/
if(pffile == NULL) pffile = strdup(DEFAULT_PFFILE);
if(statefile == NULL) statefile = strdup(DEFAULT_STATEFILE);
/* parse parameter file and form all the genloc control and
internal static data structures */
i = pfread(pffile,&pf);
if(i != 0) elog_die(1,"Pfread error\n");
o = parse_options_pf (pf);
arr_sta = load_station_table(pf);
arr_a = load_array_table(pf);
arr_phase = parse_phase_parameter_file(pf);
/* Note this is a slightly different use of these variables
than that used by other genloc routines. Here we use it
like a coordinate system origin to select range of distances
to use. We actually reset these again in the location function,
but check them here to make sure these variables are in the
parameter space. pfget_double will cause the program to die
if these aren't defined.*/
origin.lat = pfget_double(pf,"center_latitude");
origin.lon = pfget_double(pf,"center_longitude");
origin.z = 0.0;
rt_opts = parse_rt_options(pf);
if(dbopen(rt_opts.work_db,"r+",&master_db ) == dbINVALID)
elog_die(1,"Unable to open master database %s\n",
rt_opts.work_db);
/* Now we open the orb server connections */
if( (orbin=orbopen(orbname,"r&")) < 0)
elog_die(0,"Cannot open ring buffer %s for reading\n",orbname);
if(orbselect(orbin,"/db/event|/db/origin|/db/assoc|/db/arrival") < 0)
elog_die(0,"Cannot select any db records from ring buffer %s\n",
orbname);
/* These are the state saving routines. quit is set nonzero
whenever the program catches a signal. We call bury below when
this happens. exhume_state is a function because I expect
it could be used again */
exhume_rcode = exhume ( statefile, 0, 0, 0 );
exhume_state(exhume_rcode);
if ( orbresurrect ( orbin, &last_pktid, &last_pkttime ) == 0 )
elog_complain( 0, "resurrection successful: repositioned to pktid #%d\n", last_pktid ) ;
else
{
orbseek (orbin, ORBOLDEST);
last_pktid = orbtell(orbin);
elog_complain( 0, "resurrection unsuccessful\nStarting at beginning of current orb at packet id %d\n",last_pktid ) ;
}
/* The following is basically a trick to create a db pointer that
never references any tables. This is the preferred approach for
orbpkt2db records which utilize the scratch record of this database
pointer. The fact that we destroy the file this creates turns
out to be a feature of datascope we can exploit here. */
if (maketmpdb ("css3.0", &dbtmp, dbname) < 0) {
elog_complain(0, "maketmpdb() error.\n");
exit (1);
}
/* This little routine initilizes the null record for each table
used here. This was necessary because we assemble records in the
scratch record. This sets proper nulls in fields that are not
referenced by this program. */
if(initialize_scratch_records(dbtmp) == dbINVALID)
elog_complain(0,"Warning: errors initializing null records in tables. May generate invalid data in some fields\n");
/*
unlink (dbname);
*/
if( (orbout=orbopen(orbname,"w&")) < 0)
elog_die(0,"Cannot open ring buffer %s for writing\n",orbname);
/* This loop is broken only by an error. We call bury after each
event is processed saving the current packet id. This should
effectively skip events that cause orbgenloc to die for some
reason. */
while(1)
{
int return_code;
return_code = orb_arrivals_in(orbin, dbtmp, &hyp,
&last_pktid,rt_opts);
if(return_code)
{
if(return_code < 0)
elog_complain(0,"Error reading db records from orb\nCurrent event skipped\n");
else
elog_complain(0,"Sequencing error reading db packets from orbassoc.\nOne or more events were probably skipped\n");
continue;
}
if(bury())
elog_complain(0,
"bury failed writing statefile %s\n",statefile);
compute_location(o,rt_opts,arr_sta,arr_a,arr_phase,
pf,master_db, dbtmp, hyp, orbout);
/* when last_pktid is -1 orb_arrivals_in does not do
an orbseek, so we always reset it here */
last_pktid = -1;
/* This is the only appropriate place to release
this space. This block is malloced in orb_arrivals_in*/
free(hyp.assocs);
hyp.assocs = NULL;
}
}
void main(int argc, char **argv)
{
Dbptr db, dbv, dbge, dbgg;
/*ensemble_mode is primary grouping, grouping_on set if secondary on*/
int ensemble_mode,grouping_on;
Tbl *ensemble_keys;
Tbl *group_keys;
int i;
char *pfi=NULL;
Pf *pf,*pfo_head,*pfo_total;
Tbl *process_list;
int dryrun=0;
char *sift_exp=NULL;
int sift;
/*Attributes listed in require will abort program if missing
passthrough parameters will generate an error message but not
cause the program to abort. Both contain pointers to Attribute_map*/
Tbl *require,*passthrough;
Attribute_map *amap;
FILE *fp;
Tbl *error_list;
char *tag;
int sleep_time;
DB2PFS_verbose=0;
/*crack the command line*/
if(argc<3) usage();
elog_init(argc,argv);
if(dbopen(argv[1],"r",&db)==dbINVALID)
{
elog_complain(0,"dbopen failed on database %s\n",argv[1]);
usage();
}
for(i=3;i<argc;++i)
{
if(!strcmp(argv[i],"-pf"))
{
++i;
if(i>argc) usage();
pfi=argv[i];
}
else if(!strcmp(argv[i],"-V"))
usage();
else if(!strcmp(argv[i],"-v"))
DB2PFS_verbose=1;
else if(!strcmp(argv[i],"-n"))
dryrun=1;
else if(!strcmp(argv[i],"-sift"))
{
++i;
if(i>argc) usage();
sift=1;
sift_exp=argv[i];
}
else
usage();
}
if(!dryrun)
{
fp=fopen(argv[2],"r+");
if(fp==NULL) usage();
}
if(pfi==NULL) pfi=strdup("db2pfstream");
if(pfread(pfi,&pf))
elog_die(0,"Error reading parameter file %s.pf\n",pfi);
sleep_time=pfget_int(pf,"sleep_time");
/* The output view gets a virtual table name that tags the
overall collection of stuff. This comes from the parameter file
to make this program general, BUT it must be coordinated with
the reader code. */
tag = pfget_string(pf,"virtual_table_name");
if(tag==NULL)elog_die(0,"Required parameter (virtual_table_name) missing from parameter file\n");
ensemble_mode = pfget_boolean(pf,"ensemble_mode");
if(ensemble_mode)
{
ensemble_keys=pfget_tbl(pf,"ensemble_keys");
if(ensemble_keys==NULL)
elog_die(0,
"ensemble_mode is on, but no grouping keys defined\nCheck parameter file\n");
group_keys=pfget_tbl(pf,"group_keys");
if(group_keys==NULL)
grouping_on = 0;
else
{
if(maxtbl(group_keys)>0)
grouping_on = 1;
else
grouping_on = 0;
}
}
if(DB2PFS_verbose && ensemble_mode)
{
char sm[128];
char *key;
strcpy(sm,"Defining ensemble with keys: ");
for(i=0;i<maxtbl(ensemble_keys);++i)
{
key=gettbl(ensemble_keys,i);
strcat(sm,key);
}
elog_log(0,"%s\n",sm);
if(grouping_on)
{
strcpy(sm,"Grouping ensemble with keys: ");
for(i=0;i<maxtbl(group_keys);++i)
{
key = gettbl(group_keys,i);
strcat(sm,key);
}
elog_log(0,"%s\n",sm);
}
}
/*This function calls dbprocess using a tbl from pf*/
dbv=dbform_working_view(db,pf,"dbprocess_list");
if(dbv.record==dbINVALID)
elog_die(0,"dbprocess failed: check database and parameter file parameter dbprocess_list\n");
if(sift_exp!=NULL)dbv=dbsubset(dbv,sift_exp,0);
/*Now we form the groupings if needed */
if(ensemble_mode)
{
dbge = dbgroup(dbv,ensemble_keys,"ensemble",1);
if(dbge.record == dbINVALID)
elog_die(0,"dbgroup with ensemble keys failed\n");
if(grouping_on)
{
dbgg = dbgroup(dbv,group_keys,"groups",2);
if(dbgg.record == dbINVALID)
elog_die(0,"dbgroup on secondary grouping keys failed\n");
}
}
/*This builds the maps of which attributes will be saved */
require = pfget_Attribute_map(pf,"require");
if(require==NULL)
elog_die(0,"Error in parameter file for parameter require\n");
passthrough = pfget_Attribute_map(pf,"passthrough");
if(passthrough==NULL)
elog_die(0,"Error in parameter file for parameter passthrough\n");
/* Unfortunately, we have two different loops for ensemble mode
and single object mode */
if(ensemble_mode)
{
int number_ensembles;
Dbptr db_bundle_1;
Dbptr db_bundle_2;
int is_ensemble, ie_ensemble;
int isg, ieg;
int number_groups;
pfo_head=pfnew(0);
pfput_tbl(pfo_head,"ensemble_keys",ensemble_keys);
if(grouping_on) pfput_tbl(pfo_head,"group_keys",group_keys);
dbquery(dbge,dbRECORD_COUNT,&number_ensembles);
if(DB2PFS_verbose) elog_log(0,"database has %d ensembles\n",
number_ensembles);
if(grouping_on)
{
dbgg.record=0;
dbquery(dbgg,dbRECORD_COUNT,&number_groups);
if(DB2PFS_verbose)
elog_log(0,"database has %d subgroups\n",
number_groups);
}
for(dbge.record=0;dbge.record<number_ensembles;
++dbge.record)
{
Pf_ensemble *pfe;
int nmembers;
char *grp_records;
Tbl *grplist;
dbgetv(dbge,0,"bundle",&db_bundle_1,0);
dbget_range(db_bundle_1,&is_ensemble,&ie_ensemble);
nmembers = ie_ensemble-is_ensemble;
/* pfe does not need to hold the group records
for this application so the ngroups variable is
passed as 0*/
pfe=create_Pf_ensemble(nmembers,0);
/*Now loop through and load the array of pf's
with parameters defined by the attribute maps*/
for(i=0,dbv.record=is_ensemble;i<nmembers;
++i,++dbv.record)
{
pfe->pf[i]=pfnew(PFARR);
error_list=db2pf(dbv,require,pfe->pf[i]);
if(maxtbl(error_list)>0)
{
if(dryrun)
{
elog_log(0,"Ensemble %d at input database view record %d lacks required attributes\n",
dbge.record,dbv.record);
log_error_list(error_list);
}
else
{
fprintf(fp,"%s\n",END_OF_DATA_SENTINEL);
fflush(fp);
elog_log(0,"FATAL ERROR: ensemble %d at input database view record %d lacks required attributes\nOUTPUT DATA STREAM TRUNCATED\n",
i,dbv.record);
log_error_list(error_list);
exit(-1);
}
}
freetbl(error_list,free);
error_list=db2pf(dbv,passthrough,pfe->pf[i]);
if(DB2PFS_verbose)
{
elog_log(0,"Warning: null passthrough attributes for ensemble %d at row %d\n",
dbge.record,dbv.record);
log_error_list(error_list);
}
freetbl(error_list,free);
pfput_boolean(pfe->pf[i],"data_valid",1);
}
if(grouping_on)
{
grplist=newtbl(0);
do {
dbgetv(dbgg,0,"bundle",&db_bundle_2,0);
dbget_range(db_bundle_2,&isg,&ieg);
grp_records=malloc(30);
sprintf(grp_records,"%d %d",
isg-is_ensemble,ieg-is_ensemble-1);
pushtbl(grplist,grp_records);
++dbgg.record;
}
while (ieg<ie_ensemble);
pfput_tbl(pfo_head,"group_records",grplist);
}
pfo_total=build_ensemble(1,tag,pfo_head,pfe);
free_Pf_ensemble(pfe);
if(!dryrun)
{
pfout(fp,pfo_total);
fprintf(fp,"%s\n",ENDPF_SENTINEL);
fflush(fp);
}
pffree(pfo_total);
if(grouping_on)freetbl(grplist,free);
}
}
else
{
/*This is the simpler, single block mode */
int nrecords;
Pf *pfo;
dbquery(dbv,dbRECORD_COUNT,&nrecords);
pfo=pfnew(PFARR);
for(dbv.record=0;dbv.record<nrecords;++dbv.record)
{
error_list=db2pf(dbv,require,pfo);
if(maxtbl(error_list)>0)
{
if(dryrun)
{
elog_log(0,"Input database view at row %d lacks required parameters\n",
dbv.record);
log_error_list(error_list);
}
else
{
fprintf(fp,"%s\n",END_OF_DATA_SENTINEL);
fflush(fp);
elog_log(0,"FATAL: input database view at row %d lacks required parameters\n",
dbv.record);
log_error_list(error_list);
exit(-1);
}
}
freetbl(error_list,free);
error_list=db2pf(dbv,passthrough,pfo);
pfput_boolean(pfo,"data_valid",1);
if(DB2PFS_verbose)
{
elog_log(0,"Warning: null passthrough attributes for row %d of input database view\n",
dbv.record);
}
if(!dryrun)
{
pfout(fp,pfo);
fprintf(fp,"%s\n",ENDPF_SENTINEL);
}
}
}
if(!dryrun)
{
fprintf(fp,"%s\n",END_OF_DATA_SENTINEL);
fflush(fp);
sleep(sleep_time);
fclose(fp);
}
exit(0);
}
int main(int argc, char **argv) {
ROUTE err, saveroute;
int i;
TABLE tab;
char *str;
route_init(NULL, 0);
route_register(&rt_filea_method);
route_register(&rt_fileov_method);
route_register(&rt_stdin_method);
route_register(&rt_stdout_method);
route_register(&rt_stderr_method);
route_register(&rt_rs_method);
rs_init();
if ( ! elog_init(1, argv[0], NULL))
elog_die(FATAL, "Didn't initialise elog\n");
err = route_open("stderr", NULL, NULL, 0);
/* first lot of messages sent to the default places */
elog_send(INFO, "This is an eventlog test");
elog_send(INFO, NULL);
elog_send(INFO, "");
elog_send(INFO, "Event!!");
elog_send(DEBUG, "Event!!");
elog_send(WARNING, "Event!!");
elog_send(ERROR, "Event!!");
elog_send(INFO, "Event!!");
/* change origin */
elog_setorigin("etest");
elog_send(INFO, "test of set origin");
/* set one new purl route */
elog_setsevpurl(DEBUG, FILE1);
elog_send(INFO, "on screen");
elog_send(DEBUG, "in file");
elog_send(WARNING, "on screen");
/* set second identical purl route to reuse the previous one */
elog_setsevpurl(ERROR, FILE1);
if (elog_opendest[DEBUG].route !=
elog_opendest[ERROR].route)
route_die(err, "[13] didnt reuse already open DEBUG route\n");
elog_send(ERROR, "in file");
/* set identical below purl route */
if ( !elog_setbelowpurl(INFO, FILE1))
route_die(err, "[14] unable to setbelowpurl() file\n");
if (elog_opendest[DEBUG].route !=
elog_opendest[ERROR].route ||
elog_opendest[INFO].route !=
elog_opendest[ERROR].route)
route_die(err, "[14] didnt reuse already open ERROR route\n");
elog_send(DEBUG, "in file");
elog_send(INFO, "in file");
elog_send(WARNING, "on screen");
elog_send(ERROR, "in file");
elog_send(FATAL, "on screen");
/* set identical above purl route */
if ( !elog_setabovepurl(ERROR, FILE1))
route_die(err, "[19] unable to setabovepurl() file\n");
if (elog_opendest[ERROR].route !=
elog_opendest[INFO].route ||
elog_opendest[FATAL].route !=
elog_opendest[INFO].route)
route_die(err, "[19] didnt reuse already open INFO route\n");
elog_send(DEBUG, "in file");
elog_send(INFO, "in file");
elog_send(WARNING, "on screen");
elog_send(ERROR, "in file");
elog_send(FATAL, "in file");
/* set identical all purl route */
saveroute = elog_opendest[DEBUG].route;
if ( !elog_setallpurl(FILE1))
route_die(err, "[24] unable to setallpurl() file\n");
for (i=0; i < ELOG_NSEVERITIES; i++)
if (elog_opendest[i].route != saveroute)
route_die(err, "[24] didnt reuse already open %s route\n",
elog_sevstring[i]);
elog_send(DEBUG, "in file");
elog_send(INFO, "in file");
elog_send(WARNING, "in file");
elog_send(ERROR, "in file");
elog_send(FATAL, "in file");
/* set one different purl - timestore that we currently have to set up
* ourselves */
saveroute = route_open(RS1, "event log test", NULL, 10);
if ( ! saveroute)
route_die(err, "[29] unable to create/open timestore\n");
route_close(saveroute);
if ( ! elog_setsevpurl(INFO, RS1))
route_die(err, "[29] unable to setsevpurl() timestore\n");
if (elog_opendest[INFO].route ==
elog_opendest[WARNING].route)
route_die(err, "[29] different route same as WARNING\n");
elog_send(DEBUG, "in file");
elog_send(INFO, "in timestore");
elog_send(WARNING, "in file");
elog_send(ERROR, "in file");
elog_send(FATAL, "in file");
/* set one different route */
#if 0
elog_send(INFO, "");
elog_send(INFO, "Event!!");
elog_send(DEBUG, "Event!!");
elog_send(WARNING, "Event!!");
elog_send(ERROR, "Event!!");
elog_send(INFO, "Event!!");
elog_send(INFO, "Event!!");
elog_send(INFO, "Event!!");
elog_send(INFO, "Event!!");
elog_send(INFO, "Event!!");
elog_send(INFO, "Event!!");
elog_send(INFO, "Event!!");
elog_send(INFO, "Event!!");
#endif
/* change format */
elog_setsevroute(WARNING, err);
elog_setformat(WARNING, "%s %s");
elog_send(WARNING, "still works??");
/* safe logging */
elog_safeprintf(INFO, "This is an eventlog test 35");
elog_safeprintf(INFO, NULL);
elog_safeprintf(INFO, "");
elog_safeprintf(INFO, "Event!! 38");
elog_safeprintf(DEBUG, "Event!! 39");
elog_safeprintf(WARNING, "Event!! 40");
elog_safeprintf(ERROR, "Event!! 41");
elog_safeprintf(INFO, "Event!!");
/* print the status out */
tab = elog_getstatus();
str = table_printcols_a(tab, elog_colnames);
printf("%s\n", str);
nfree(str);
table_destroy(tab);
rs_fini();
elog_fini();
route_close(err);
route_fini();
exit(0);
}
/*
* Initialise standard routes, logging, configuration, interpret
* command line and change directory.
*
* A standard set of rules is followed to setup the correct
* configuration from central places local files and the command line.
* All the information is then available in the global CF_VALS: iiab_cf.
* The command line config is available in iiab_cmdarg on its own and also
* placed in iiab_cf.
* There are some standard options implemented by this routine:-
* -c Configuration file (arg expected)
* -C Configuration option (arg expected)
* -d Diagnostic debug mode
* -D Developer debug mode
* -e 'off the shelf' error format (int arg expected 1-7)
* -h Help
* -v Version print and exit
* Note:-
* 1. If the symbol defined by NM_CFNAME (nmalloc) is not defined or
* set to 0, nmalloc leak checks are disabled
*/
void iiab_start(char *opts, /* Command line option string as getopts(3) */
int argc, /* Number of arguments in command line */
char **argv, /* Array of argument strings */
char *usage, /* String describing usage */
char *appcf /* Application configuration string */ )
{
int r;
char *appcf_expanded;
int elogfmt;
if ( !(opts && usage) )
elog_die(FATAL, "opts or usage not set");
/* save our launch directory & work out the standard places */
iiab_dir_locations(argv[0]);
/* consolidated command line options and usage */
/* -- setup global variables -- */
iiab_cmdopts = util_strjoin(IIAB_DEFOPTS, opts, NULL);
iiab_cmdusage = util_strjoin(IIAB_DEFUSAGE, usage, usage?"\n":"",
IIAB_DEFWHERE, NULL);
iiab_cmdarg = cf_create();
iiab_cf = cf_create();
/* initialise common IIAB classes: callbacks, error logging,
* i/o and old storage routes */
callback_init();
iiab_init_routes(); /* initialise new route mechanism */
elog_init(1, argv[0], NULL);
rs_init();
/* collect command line arguments and place in special config list
* which is use for generating the main config list
*/
r = cf_cmd(iiab_cmdarg, iiab_cmdopts, argc, argv, iiab_cmdusage);
if ( ! r ) {
nm_deactivate();
elog_send(FATAL, "incorrect command line, can't continue further");
exit(1);
}
/* help! print out help before we do anything else and send it
* to stderr as the user needs to read it */
if (cf_defined(iiab_cmdarg, "h")) {
nm_deactivate();
fprintf(stderr, "usage %s %s",
cf_getstr(iiab_cmdarg,"argv0"), iiab_cmdusage);
exit(1);
}
/* load app's dir locations into config, expand the application config
* string (which needs the dir locations in iiab_cf), then do the
* fullconfig load */
iiab_dir_setcf(iiab_cf);
appcf_expanded = nmalloc(strlen(appcf) * 2);
route_expand(appcf_expanded, appcf, NULL, 0);
iiab_cf_load(iiab_cf, iiab_cmdarg, iiab_cmdusage, appcf_expanded);
nfree(appcf_expanded);
/***********************************************
* (d) Carry out common configuration actions
* 1. configure event logging
* 2. memory checking
* 3. version switch
* 4. adapt logging for -d and -D special debug cases
* 5. adapt logging format for -e
* 6. final initialisation for subsystems needing configuration
* 7. license checking: go/no-go
***********************************************/
/* configure event logging */
elog_configure(iiab_cf);
/*
* nmalloc deactivation check.
* Deactivate nmalloc checking if NM_CFNAME is set to 0 in config
*/
if ( !cf_defined(iiab_cf, NM_CFNAME) ||
cf_getint(iiab_cf, NM_CFNAME) == 0 )
nm_deactivate();
/* command line switches (excluding -c and -C) */
/* -v flag: version print and exit */
if (cf_defined(iiab_cmdarg, "v")) {
fprintf(stderr, "Version of %s is %s\n",
cf_getstr(iiab_cmdarg,"argv0"), VERSION);
exit(0);
}
/* if -d diag flag specified, override supplied event
* configuration and instead route DIAG and above to stderr */
if (cf_defined(iiab_cmdarg, "d")) {
elog_setallpurl("none:");
elog_setabovepurl(DIAG, "stderr:");
elog_printf(DIAG, "event configuration overidden: diagnosis "
"to stderr");
}
/* -D debug flag: as above but route everything to stderr */
if (cf_defined(iiab_cmdarg, "D")) {
elog_setabovepurl(DEBUG, "stderr:");
elog_printf(DEBUG, "event configuration overidden: debug "
"to stderr");
}
/* -e flag: use precanned elog formats */
if (cf_defined(iiab_cmdarg, "e")) {
elogfmt = cf_getint(iiab_cmdarg, "e");
if (elogfmt < 0 || elogfmt > ELOG_MAXFMT)
elog_printf(ERROR, "standard error format out of range "
"(0-%d), using default", ELOG_MAXFMT);
else
elog_setallformat(elog_stdfmt[elogfmt]);
}
/* diagnostics: config and dirs */
cf_dump(iiab_cf); /* dump config to diag */
iiab_dir_dump(); /* dump dir locations to diag */
/* final set of initialisations that require configurations */
http_init();
#if 0
/* self destruction due to snapshot time out, licenses etc
* disabled, but kept here just in case we want to do it again */
if ( ! cf_defined(iiab_cf, IIAB_LICNAME) )
if (time(NULL) > IIAB_EXPIRE)
elog_printf(FATAL, "This is development software "
"and almost certainly out of date.\n"
"You should arrange an update from system garden "
"by e-mailing [email protected]\n"
"or checking the web site "
"http://www.systemgarden.com.\n"
"This software will run unaffected in its current "
"form but you will be nagged from now on");
#endif
#if 0
/* return to the launch dir */
chdir(iiab_dir_launch);
#endif
}
int
main (int argc, char **argv)
{
int c;
int errflg = 0;
Dbptr db;
char *database;
int verbose = 0;
int primary = 0;
Pf pf;
char *xmlstring = 0;
char *rootname = 0;
char *rowname = 0;
Tbl *fields = 0;
Tbl *expressions = 0;
elog_init( argc, argv ) ;
while ((c = getopt (argc, argv, "pd:r:v")) != -1) {
switch (c) {
case 'v':
verbose++;
break;
case 'd':
rootname = strdup( optarg );
break;
case 'p':
primary++;
break;
case 'r':
rowname = strdup( optarg );
break;
default:
errflg++;
break ;
}
}
if( errflg || argc - optind < 1 || (((argc-optind) % 2) != 1)) {
usage ();
}
database = argv[optind++];
if( dbopen_table( database, "r+", &db ) < 0 ) {
die( 0, "Can't open database %s\n", database );
}
if( argc - optind > 0 ) {
fields = newtbl( 20 );
expressions = newtbl( 20 );
while( argc - optind > 0 ) {
pushtbl( fields, argv[optind++] );
pushtbl( expressions, argv[optind++] );
}
if( primary ) {
complain( 1,
"Useless use of '-p' with specified expressions\n" );
}
} else if( primary ) {
dbquery( db, dbPRIMARY_KEY, (Dbvalue *) &fields );
}
db2ptolemy( db, fields, expressions, (void **) &xmlstring, 0 );
if( xmlstring != NULL ) {
fwrite( xmlstring, sizeof(char), strlen( xmlstring ), stdout );
free( xmlstring );
}
return 0;
}
/*
* Main program loop
*/
int main(int iArgCount, char *aArgList[]) {
uint8_t *aBBAPkt; /* Buffer to hold a bba packet read from the wire */
struct stBBAPacketInfo oPktInfo; /* Struct to hold information from the packet header */
double dPrevTime;
int bOKToSend;
char *sOutPkt; /* Packet to put onto the orb */
int iOutPktLen; /* Length of sOutPkt */
elog_init(iArgCount, aArgList);
/* Parse out command line options */
if (parseCommandLineOptions(iArgCount, aArgList) == RESULT_SUCCESS) {
/* Read in the parameter file */
if (paramFileRead() == RESULT_FAILURE) {
elog_complain(1,
"main(): Error encountered during paramFileRead() operation.");
dcbbaCleanup(-1);
}
/* Exit if bPFValidateFlag is set */
if (oConfig.bPFValidateFlag == TRUE) {
elog_notify(
0,
"main(): Parameter File %s validated successfully. Exiting.",
oConfig.sParamFileName);
dcbbaCleanup(0);
}
/* Allocate memory for our packet */
allot (uint8_t *, aBBAPkt, oConfig.iBBAPktBufSz);
/* Set up a signal handler to re-read the parameter file on SIGUSR1*/
signal(SIGUSR1, sig_hdlr);
/* Connect to the ORB */
if ((orbfd = orbopen(oConfig.sOrbName, "w&")) < 0) {
elog_complain(1, "orbopen: unable to connect to ORB \"%s\".",
oConfig.sOrbName);
dcbbaCleanup(-1);
}
/* Connect to Data Concentrator's Data read port */
if (dcDataConnect(oConfig.iConnectionType, oConfig.sDCConnectionParams)
== RESULT_SUCCESS) {
dPrevTime = now();
/*** BEGIN MAIN LOOP ***/
while (readFromDC(&oPktInfo, aBBAPkt) == RESULT_SUCCESS) {
bOKToSend = TRUE;
/* Check the packet age */
/*if (fabs(oPktInfo.dPktTime - dPrevTime) > 86400.0) {
dPrevTime = now();
if (fabs(oPktInfo.dPktTime - dPrevTime) > 86400.0) {
elog_complain(
0,
"%s packet has bad time - %s (epoch:%lf). Will discard packet.\n",
oPktInfo.sSrcname, sTimeStamp = strtime(
oPktInfo.dPktTime), oPktInfo.dPktTime);
free(sTimeStamp);
bOKToSend = FALSE;
} else
dPrevTime = oPktInfo.dPktTime;
} else
dPrevTime = oPktInfo.dPktTime;*/
if (bOKToSend == TRUE) {
/* Add orb header to Packet */
iOutPktLen = (int) stuffBBAPkt(&oPktInfo, aBBAPkt, &sOutPkt);
if (iOutPktLen == 0) {
/* There was an error stuffing the packet*/
elog_complain(
1,
"An error occurred while adding the ORB header to the raw packet. Not submitting to the orb.");
} else if (sOutPkt == 0) {
elog_die(1,
"Output packet length was non-zero but pointer to Output packet is null");
} else {
/* put it into the orb */
if (oConfig.bVerboseModeFlag == TRUE) {
showPkt(0, oPktInfo.sSrcname, oPktInfo.dPktTime,
sOutPkt, iOutPktLen, stderr, PKT_UNSTUFF);
showPkt(0, oPktInfo.sSrcname, oPktInfo.dPktTime,
sOutPkt, iOutPktLen, stderr, PKT_DUMP);
}
if (orbput(orbfd, oPktInfo.sSrcname, oPktInfo.dPktTime,
sOutPkt, iOutPktLen)) {
elog_complain(0, "orbput() failed in main()\n");
dcbbaCleanup(-1);
}
if (oConfig.bVerboseModeFlag == TRUE)
elog_notify(0, "packet submitted under %s\n",
oPktInfo.sSrcname);
/* Free the packet */
free(sOutPkt);
}
}
}
/*
* If we get here, it means readFromDC failed to get a packet from oDCDataBNS.
* This could be either that an EOF was reached if we were reading from a file,
* or that the socket died unexpectedly.
*/
dcbbaCleanup(-1);
}
/* Else unable to connect, cleanup with failure (-1) exit code */
else
dcbbaCleanup(-1);
} else {
int main(int argc, char **argv)
{
char *dbin; /* Input db name */
char *dbout; /* output db name */
Dbptr db; /* input db pointer */
Dbptr dbo; /* base output db pointer */
Dbptr dbv; /* set to view formed by join */
char *pfin=NULL; /* input parameter file */
char *sift_exp; /* sift expression for subset */
int sift = 0; /* default is no sift. */
Tbl *sortkeys;
Tbl *joinkey1, *joinkey2;
/*Pointers to views returned by dbgroup (keyed to origin and event
respectively */
Dbptr dborigin_group;
Tbl *origin_group; /* relation keys used in grouping*/
long nevents;
/* db row variables */
long evid;
long nrows, nrows_raw;
int useold=0;
Pf *pf;
Tbl *ta,*tu;
Tbl *reason_converged, *residual;
Location_options o;
Arr *arr_phase;
int i;
Tbl *converge_history;
Hypocenter h0;
Hypocenter *hypos;
long niterations;
char *vmodel;
int ret_code; /* ggnloc return code */
double **C; /* covariance matrix*/
float emodel[4];
/* entries for S-P feature */
long nbcs;
Arr *badclocks;
/* need global setting of this to handle fixed depth solutions*/
int global_fix_depth;
C=dmatrix(0,3,0,3);
if(argc < 3) usage();
dbin = argv[1];
dbout = argv[2];
for(i=3;i<argc;++i)
{
if(!strcmp(argv[i],"-pf"))
{
++i;
if(i>=argc) usage();
pfin = argv[i];
}
else if(!strcmp(argv[i],"-sift"))
{
++i;
if(i>=argc) usage();
sift_exp = argv[i];
sift = 1;
}
else if(!strcmp(argv[i],"-useold"))
useold = 1;
else
usage();
}
/* set default this way*/
if(pfin == NULL) pfin = strdup("relocate");
/* Initialize the error log and write a version notice */
elog_init (argc, argv) ;
cbanner("Version $Revision$ $Date$\n",
"relocate inputdb outputdb [-pf pf -sift expression -useold]\n",
"Gary Pavlis",
"Indiana University",
"*****@*****.**");
/* Alway join assoc, arrival, and site. We join site
to make sure station table is properly dynamic to account for
time changes. With this setup, the stations can even move
around and this should still work.*/
if(dbopen(dbin,"r",&db) == dbINVALID)
elog_die(1,"Unable to open input database %s\n",dbin);
if(dbopen(dbout,"r+",&dbo) == dbINVALID)
elog_die(1,"Unable to open output database %s\n",dbout);
dbv = dbjoin ( dblookup(db,0,"event",0,0),
dblookup(db,0,"origin",0,0),
0,0,0,0,0);
if(dbv.table == dbINVALID)
elog_die(1,"event->origin join failed\n");
dbv = dbjoin ( dbv, dblookup(db,0,"assoc",0,0),
0,0,0,0,0);
if(dbv.table == dbINVALID)
elog_die(1,"event->origin->assoc join failed\n");
dbv = dbjoin ( dbv, dblookup(db,0,"arrival",0,0),
0,0,0,0,0);
if(dbv.table == dbINVALID)
elog_die(1,"event->origin->assoc->arrival join failed\n");
/* We will explicitly set the keys for this join because it
was found to fail sometimes */
joinkey1 = newtbl(0);
joinkey2 = newtbl(0);
pushtbl(joinkey1,"arrival.sta");
pushtbl(joinkey1,"arrival.time");
pushtbl(joinkey2,"sta");
pushtbl(joinkey2,"ondate::offdate");
dbv = dbjoin ( dbv, dblookup(db,0,"site",0,0),
&joinkey1,&joinkey2,0,0,0);
if(dbv.table == dbINVALID)
elog_die(1,"event->origin->assoc->arrival->site join failed\n");
/* Subset using sift_key if requested */
if(sift)
{
dbv = dbsubset(dbv,sift_exp,0);
if(dbv.record == dbINVALID)
elog_die(1,"dbsubset of %s with expression %s failed\n",
dbin, sift_exp);
}
/* This keeps only the prefered origin records intact */
dbv = dbsubset(dbv,"orid == prefor", 0);
if(dbv.record == dbINVALID)
elog_die(1,"Subset to preferred origin records failed\n");
/* First we have to run a unique key sort in the following order
to remove redundant picks made on multiple channels. We will
issue a warning if the record count changes. */
dbquery(dbv, dbRECORD_COUNT, &nrows_raw);
sortkeys = newtbl(0);
pushtbl(sortkeys,"evid");
pushtbl(sortkeys,"sta");
pushtbl(sortkeys,"phase");
dbv = dbsort(dbv,sortkeys,UNIQUE,0);
dbquery(dbv, dbRECORD_COUNT, &nrows);
if(nrows != nrows_raw)
elog_complain(0,"Input database has duplicate picks of one or more phases on multiple channels\n\
Which picks will be used here is unpredictable\n\
%ld total picks, %ld unique\nContinuing\n", nrows_raw, nrows);
/* This sort is the required one for the grouping that follows*/
sortkeys = newtbl(3);
pushtbl(sortkeys,"evid");
pushtbl(sortkeys,"orid");
pushtbl(sortkeys,"arrival.time");
dbv = dbsort(dbv,sortkeys,0,0);
if(dbv.record == dbINVALID)
elog_die(1,"dbsort on evid,orid,arrival.time failed\n");
/* Set up grouping by events */
origin_group = newtbl(0);
pushtbl(origin_group, "evid");
dborigin_group = dbgroup(dbv, origin_group, "origin_group",1);
if(dborigin_group.record == dbINVALID)
elog_die(1,"dbgroup by origin failed\n");
dbquery(dborigin_group,dbRECORD_COUNT,&nevents);
elog_notify(0,"Attempting to relocate %ld events in subsetted database\n",
nevents);
/* DB is now set up correctly, now we turn to the parameter files */
i = pfread(pfin,&pf);
if(i != 0) elog_die(1,"Pfread error\n");
o = parse_options_pf (pf);
global_fix_depth=o.fix[2];
arr_phase = parse_phase_parameter_file(pf);
vmodel = pfget_string(pf,"velocity_model_name");
/* set up minus phase for bad clock problems */
badclocks = newarr(0);
if(db_badclock_definition(db,pf,badclocks))
elog_complain(0,"Warning: problems in database definitions of bad clock time periods\n");
pfget_badclocks(pf,badclocks);
nbcs = cntarr(badclocks);
if(nbcs>0) fprintf(stdout,"relocate: bad clock feature enabled\n\n");
/* Change by JN to output evid and orid. */
/* fprintf(stdout,"lat lon depth time rms wrms interquartile ndata ndgf iterations\n"); */
fprintf(stdout,"evid orid lat lon depth time rms wrms interquartile ndata ndgf iterations\n");
/* Main loop. We utilize the group views and loop through by
events */
for(dborigin_group.record=0;
dborigin_group.record< nevents;++dborigin_group.record)
{
Dbptr db_bundle; /* db pointer returned from bundle field
of dborigin_group for current event */
Arr *station_table;
Arr *array_table;
long is, ie;
long orid; /* orid assigned relocated event in output db */
if(dbgetv(dborigin_group,0,"evid", &evid,
"bundle", &db_bundle,NULL ) == dbINVALID)
elog_complain(1,"dbgetv error for row %ld of event group\n",
dborigin_group.record);
dbget_range(db_bundle,&is,&ie);
station_table = dbload_station_table(dbv,
is,ie,pf);
array_table = dbload_array_table(dbv,
is,ie,pf);
ta = dbload_arrival_table(dbv,
is,ie,station_table, arr_phase);
tu = dbload_slowness_table(dbv,
is,ie,array_table, arr_phase);
/* this actually sets up the minus phase feature for bad clocks*/
if(nbcs)
{
if(minus_phases_arrival_edit(ta,arr_phase,badclocks))
elog_complain(0,"Warning(relocate): problems in minus_phase_arrival_edit function\n");
}
if(useold)
{
char dtype[2];
h0 = db_load_initial(dbv,is);
/* keep fixed depth if done before.
setting dbv.record here is a bit of
a potential maintenance problem */
dbv.record=is;
dbgetv(dbv,0,"dtype",dtype,NULL );
if( (!strcmp(dtype,"g")) || (!strcmp(dtype,"r")) )
o.fix[2]=1;
}
else
h0 = initial_locate(ta, tu, o, pf);
ret_code = ggnloc(h0,ta,tu,o,
&converge_history,&reason_converged,&residual);
if(ret_code < 0)
{
elog_complain(1,"ggnloc failed to produce a solution\n");
}
else
{
if(ret_code > 0)
elog_complain(1,"%d travel time calculator failures in ggnloc\nSolution ok\n",
ret_code);
niterations = maxtbl(converge_history);
hypos = (Hypocenter *)gettbl(converge_history,
niterations-1);
predicted_errors(*hypos,ta,tu,o,C,emodel);
/* Next 3 calls changed by JN to output evid, orid and number_data */
orid = save_origin(dbv,is,ie,o.fix[3],*hypos,dbo);
evid = save_event(dbv,is,ie,orid,dbo);
fprintf(stdout,"%ld %ld %lf %lf %lf %lf %g %g %g %d %d %ld\n",
evid,
orid,
hypos->lat,hypos->lon,hypos->z,hypos->time,
hypos->rms_raw, hypos->rms_weighted,
hypos->interquartile,
hypos->number_data,
hypos->degrees_of_freedom,
niterations);
save_origerr(orid,*hypos,C,dbo);
save_assoc(dbv,is,ie,orid,vmodel,residual,*hypos,dbo);
/* These save genloc add on tables */
save_emodel(orid,emodel,dbo);
save_predarr(dbo,ta,tu,*hypos,orid,vmodel);
}
o.fix[2]=global_fix_depth;
if(maxtbl(converge_history)>0)freetbl(converge_history,free);
if(maxtbl(reason_converged)>0)freetbl(reason_converged,free);
if(maxtbl(residual)>0)freetbl(residual,free);
destroy_data_tables(tu, ta);
destroy_network_geometry_tables(station_table,array_table);
}
return(0);
}
int test_elog_main (unformat_input_t * input)
{
clib_error_t * error = 0;
u32 i, n_iter, seed, max_events;
elog_main_t _em, * em = &_em;
u32 verbose;
f64 min_sample_time;
char * dump_file, * load_file, * merge_file, ** merge_files;
u8 * tag, ** tags;
n_iter = 100;
max_events = 100000;
seed = 1;
verbose = 0;
dump_file = 0;
load_file = 0;
merge_files = 0;
tags = 0;
min_sample_time = 2;
while (unformat_check_input (input) != UNFORMAT_END_OF_INPUT)
{
if (unformat (input, "iter %d", &n_iter))
;
else if (unformat (input, "seed %d", &seed))
;
else if (unformat (input, "dump %s", &dump_file))
;
else if (unformat (input, "load %s", &load_file))
;
else if (unformat (input, "tag %s", &tag))
vec_add1 (tags, tag);
else if (unformat (input, "merge %s", &merge_file))
vec_add1 (merge_files, merge_file);
else if (unformat (input, "verbose %=", &verbose, 1))
;
else if (unformat (input, "max-events %d", &max_events))
;
else if (unformat (input, "sample-time %f", &min_sample_time))
;
else
{
error = clib_error_create ("unknown input `%U'\n",
format_unformat_error, input);
goto done;
}
}
#ifdef CLIB_UNIX
if (load_file)
{
if ((error = elog_read_file (em, load_file)))
goto done;
}
else if (merge_files)
{
uword i;
elog_main_t * ems;
vec_clone (ems, merge_files);
elog_init (em, max_events);
for (i = 0; i < vec_len (ems); i++)
{
if ((error = elog_read_file (i == 0 ? em : &ems[i], merge_files[i])))
goto done;
if (i > 0)
{
elog_merge (em, tags[0], &ems[i], tags[i]);
tags[0] = 0;
}
}
}
else
#endif /* CLIB_UNIX */
{
f64 t[2];
elog_init (em, max_events);
elog_enable_disable (em, 1);
t[0] = unix_time_now ();
for (i = 0; i < n_iter; i++)
{
u32 j, n, sum;
n = 1 + (random_u32 (&seed) % 128);
sum = 0;
for (j = 0; j < n; j++)
sum += random_u32 (&seed);
{
ELOG_TYPE_XF (e);
ELOG (em, e, sum);
}
{
ELOG_TYPE_XF (e);
ELOG (em, e, sum + 1);
}
{
struct { u32 string_index; f32 f; } * d;
ELOG_TYPE_DECLARE (e) = {
.format = "fumble %s %.9f",
.format_args = "t4f4",
.n_enum_strings = 4,
.enum_strings = {
"string0",
"string1",
"string2",
"string3",
},
};
d = ELOG_DATA (em, e);
d->string_index = sum & 3;
d->f = (sum & 0xff) / 128.;
}
{
ELOG_TYPE_DECLARE (e) = {
.format = "bar %d.%d.%d.%d",
.format_args = "i1i1i1i1",
};
ELOG_TRACK (my_track);
u8 * d = ELOG_TRACK_DATA (em, e, my_track);
d[0] = i + 0;
d[1] = i + 1;
d[2] = i + 2;
d[3] = i + 3;
}
{
ELOG_TYPE_DECLARE (e) = {
.format = "bar `%s'",
.format_args = "s20",
};
struct { char s[20]; } * d;
u8 * v;
d = ELOG_DATA (em, e);
v = format (0, "foo %d%c", i, 0);
memcpy (d->s, v, clib_min (vec_len (v), sizeof (d->s)));
}
{
ELOG_TYPE_DECLARE (e) = {
.format = "bar `%s'",
.format_args = "T4",
};
struct { u32 offset; } * d;
d = ELOG_DATA (em, e);
d->offset = elog_string (em, "string table %d", i);
}
}
do {
t[1] = unix_time_now ();
} while (t[1] - t[0] < min_sample_time);
}
#ifdef CLIB_UNIX
if (dump_file)
{
if ((error = elog_write_file (em, dump_file)))
goto done;
}
#endif
if (verbose)
{
elog_event_t * e, * es;
es = elog_get_events (em);
vec_foreach (e, es)
{
clib_warning ("%18.9f: %12U %U\n", e->time,
format_elog_track, em, e,
format_elog_event, em, e);
}
}
done:
if (error)
clib_error_report (error);
return 0;
}
#ifdef CLIB_UNIX
int main (int argc, char * argv [])
{
unformat_input_t i;
int r;
unformat_init_command_line (&i, argv);
r = test_elog_main (&i);
unformat_free (&i);
return r;
}
int
main (int argc, char **argv)
{
int c,
verbose = 0,
errflg = 0;
char *dbinname=malloc(1024);
char *dboutname=malloc(1024);
Point *poly;
double lat,lon;
char *subset_expr=NULL;
char *name=malloc(100);
long nregions, nvertices;
Tbl *sortkeys;
Dbptr dbin,dbout,dbi,dbo,dbs;
long i,from,to,nv;
long vertex;
elog_init ( argc, argv ) ;
while ((c = getopt (argc, argv, "s:vV")) != -1) {
switch (c) {
case 's':
subset_expr=optarg;
break;
case 'v':
verbose++ ;
break;
case 'V':
usage ();
break;
case '?':
errflg++;
break ;
}
}
if ((errflg) || argc < 3)
usage ();
dbinname = argv[optind++];
dboutname= argv[optind++];
if (dbopen(dbinname,"r",&dbin)) {
elog_die(1,"cannot open database %s",dbinname);
}
dbi=dblookup(dbin,0,"polygon",0,0);
if (subset_expr) {
dbi=dbsubset(dbi,subset_expr,NULL);
}
sortkeys=newtbl(1);
pushtbl(sortkeys,"pname");
dbs=dbsort(dbi,sortkeys,0,"sorted");
dbquery(dbs,dbRECORD_COUNT,&nregions);
if (nregions <1) {
elog_die(0,"table regions seems to be empty (or not present)");
}
if (verbose) elog_notify(0,"creating database descriptor %s",dboutname);
if (dbcreate(dboutname,"places1.2",0,0,0)) {
elog_die(1,"cannot create database %s",dboutname);
}
dbopen(dboutname,"r+",&dbout);
dbo=dblookup(dbout,0,"regions",0,0);
for (i=0; i< nregions; i++) {
dbs.record=i;
dbgetv(dbs,0,"pname",name,NULL );
nvertices=readPolygon(dbs,&poly);
for (nv=0;nv < nvertices;nv++) {
lat=poly[nv].lat;
lon=poly[nv].lon;
dbaddv(dbo,0,
"regname",name,
"vertex",nv,
"lat",lat,"lon",lon,
NULL );
}
free(poly);
}
dbclose(dbo);
/*
*/
return 0;
}
int main(int argc, char **argv) {
time_t now;
/* Initialise route, runq and job classes */
now = time(NULL);
route_init(NULL, 0);
route_register(&rt_filea_method);
route_register(&rt_fileov_method);
route_register(&rt_stdin_method);
route_register(&rt_stdout_method);
route_register(&rt_stderr_method);
if ( ! elog_init(1, "job test", NULL))
elog_die(FATAL, "didn't initialise elog\n");
sig_init();
callback_init();
runq_init(now);
meth_init();
job_init();
/* Test should fail due to incorrect method */
elog_printf(DEBUG, "Expect a complaint! -> ");
if (job_add(5, 5, 0, 1, "test1a1", "internal_test", "stdout",
"stderr", 100, NULL, "echo \"Hello, world\"") != -1)
{
elog_die(FATAL, "[1a] Shouldn't be able to add\n");
}
/* Single test in five seconds, never to run */
if (job_add(5, 5, 0, 1, "test1a2", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1a] Can't add\n");
}
/* Attention: some white box testing */
itree_first(runq_event);
if (itree_getkey(runq_event) != now+5) {
elog_die(FATAL, "[1a] Queued at an incorrect time\n");
}
job_clear();
if (!itree_empty(runq_event) || !itree_empty(runq_tab)) {
elog_die(FATAL,
"[1a] Trees not emptied. runq_events=%d, runq_tab=%d\n",
itree_n(runq_event), itree_n(runq_tab));
}
now = time(NULL);
/* Two tests both in five seconds, never to run */
if (job_add(5, 5, 0, 1, "test1b1", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1b] Can't add first\n");
}
if (job_add(5, 5, 0, 1, "test1b2", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1b] Can't add second\n");
}
itree_first(runq_event);
if (itree_getkey(runq_event) != now+5) {
elog_die(FATAL, "[1b] First queued at an incorrect time\n");
}
itree_next(runq_event);
if (itree_getkey(runq_event) != now+5) {
elog_die(FATAL, "[1b] Second queued at an incorrect time\n");
}
job_clear();
if (!itree_empty(runq_event) || !itree_empty(runq_tab)) {
elog_die(FATAL,
"[1b] Trees not emptied. runq_events=%d, runq_tab=%d\n",
itree_n(runq_event), itree_n(runq_tab));
}
now = time(NULL);
/* Two tests one in five seconds, the other in six, never to run */
if (job_add(6, 6, 0, 1, "test1c1", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1c] Can't add first\n");
}
if (job_add(now+5, 5, 0, 1, "test1c2", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1c] Can't add second\n");
}
itree_first(runq_event);
if (itree_getkey(runq_event) != now+5) {
elog_die(FATAL, "[1c] First queued at an incorrect time\n");
}
itree_next(runq_event);
if (itree_getkey(runq_event) != now+6) {
elog_die(FATAL, "[1c] Second queued at an incorrect time\n");
}
job_clear();
if (!itree_empty(runq_event) || !itree_empty(runq_tab)) {
elog_die(FATAL,
"[1c] Trees not emptied. runq_events=%d, runq_tab=%d\n",
itree_n(runq_event), itree_n(runq_tab));
}
now = time(NULL);
/* Continuous single test supposed to start two seconds ago,
* next run in three; never to run */
if (job_add(-2, 5, 0, 0, "test1d1", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1d] Can't add\n");
}
itree_first(runq_event);
if (itree_getkey(runq_event) != now+3) {
elog_die(FATAL,
"[1d] Event queued at an incorrect time: bad=%d good=%ld\n",
itree_getkey(runq_event), now+3);
}
job_clear();
if (runq_nsched() > 0) {
elog_die(FATAL, "[1d] Still active work scheduled. runq_events=%d, "
"runq_tab=%d runq_nsched()=%d\n",
itree_n(runq_event), itree_n(runq_tab), runq_nsched());
runq_dump();
}
now = time(NULL);
/* Two continous tests, starting two seconds ago, next next run in four;
* never to run */
if (job_add(-2, 6, 0, 0, "test1e1", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1e] Can't add first\n");
}
if (job_add(-3, 5, 0, 0, "test1e2", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1e] Can't add second\n");
}
itree_first(runq_event);
while (((struct runq_work*) itree_get(runq_event))->expired)
itree_next(runq_event);
if (itree_getkey(runq_event) != now+2) {
elog_die(FATAL, "[1e] First queued at an incorrect time\n");
}
itree_next(runq_event);
while (((struct runq_work*) itree_get(runq_event))->expired)
itree_next(runq_event);
if (itree_getkey(runq_event) != now+4) {
elog_die(FATAL, "[1e] Second queued at an incorrect time\n");
}
job_clear();
if (runq_nsched() > 0) {
elog_die(FATAL, "[1e] Still active work scheduled. runq_events=%d, "
"runq_tab=%d runq_nsched()=%d\n",
itree_n(runq_event), itree_n(runq_tab), runq_nsched());
runq_dump();
}
now = time(NULL);
/* Two 5 run jobs, scheduled to start 10 seconds ago, with periods
* of 5 and 6 seconds; never to run */
if (job_add(-10, 6, 0, 5, "test1f1", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1f] Can't add first\n");
}
if (job_add(-10, 5, 0, 5, "test1f2", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1f] Can't add second\n");
}
itree_first(runq_event);
while (((struct runq_work*) itree_get(runq_event))->expired)
itree_next(runq_event);
if (itree_getkey(runq_event) != now+2) {
elog_die(FATAL, "[1f] First queued at an incorrect time\n");
}
itree_next(runq_event);
while (((struct runq_work*) itree_get(runq_event))->expired)
itree_next(runq_event);
if (itree_getkey(runq_event) != now+5) {
elog_die(FATAL, "[1f] Second queued at an incorrect time\n");
}
job_clear();
if (runq_nsched() > 0) {
elog_die(FATAL, "[1f] Still active work scheduled. runq_events=%d, "
"runq_tab=%d runq_nsched()=%d\n",
itree_n(runq_event), itree_n(runq_tab), runq_nsched());
runq_dump();
}
now = time(NULL);
/* Two 5 run jobs, scheduled to start 100 seconds ago, with periods
* of 5 and 6 seconds; they should never be scheduled */
if (job_add(-100, 6, 0, 5, "test1g1", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1g] Can't add first\n");
}
if (job_add(-100, 5, 0, 5, "test1g2", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1g] Can't add second\n");
}
if (runq_nsched() > 0) {
elog_die(FATAL, "[1g] Still active work scheduled. runq_events=%d, "
"runq_tab=%d runq_nsched()=%d\n",
itree_n(runq_event), itree_n(runq_tab), runq_nsched());
runq_dump();
}
job_clear();
now = time(NULL);
/* Two five run tests, starting at different times in the past,
* five runs each wittth different periods; they should both
* run now */
if (job_add(-24, 6, 0, 5, "test1h1", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1h] Can't add first\n");
}
if (job_add(-20, 5, 0, 5, "test1h2", "internal_test", "stdout",
"stderr", 100, "exec", "echo \"Hello, world\"") == -1)
{
elog_die(FATAL, "[1h] Can't add second\n");
}
if (runq_nsched() != 2) {
elog_die(FATAL, "[1h] Two jobs should be scheduled not %d\n",
runq_nsched());
runq_dump();
}
sig_on();
sleep(6); /* let it run */
sleep(1); /* let it run */
sleep(1); /* let it run */
sleep(1); /* let it run */
sig_off();
if (runq_nsched() > 0) {
elog_die(FATAL, "[1h] Still active work scheduled. runq_events=%d, "
"runq_tab=%d runq_nsched()=%d\n",
itree_n(runq_event), itree_n(runq_tab), runq_nsched());
runq_dump();
}
job_clear();
#if 0
/* check all tables/lists are empty */
if (!itree_empty(runq_event) || !itree_empty(runq_tab)) {
elog_die(FATAL, "[1i] Still entries in tables. runq_events=%d, "
"runq_tab=%d runq_nsched()=%d\n",
itree_n(runq_event), itree_n(runq_tab), runq_nsched());
runq_dump();
}
#endif
job_fini();
meth_fini();
runq_fini();
elog_fini();
route_fini();
callback_fini();
printf("%s: tests finished\n", argv[0]);
exit(0);
}
int
main (int argc, char **argv)
{
int c,
verbose = 0,
errflg = 0;
char *dbinname=malloc(1024);
char *dboutname=malloc(1024);
Point *poly;
double lat,lon;
char *auth=strdup("regions2polygon");
char *ptype= strdup("rp");
char *dir=strdup(".");
char *dfile=strdup("polygons");
int ftype=polyFLOAT;
char *name;
int nregions, nvertices;
Tbl *sortkeys, *groupkeys;
Dbptr dbin,dbout,dbi,dbo,dbg,dbb;
int i,from,to,nv;
int vertex;
elog_init ( argc, argv ) ;
while ((c = getopt (argc, argv, "vV")) != -1) {
switch (c) {
case 'v':
verbose++ ;
break;
case 'V':
usage ();
break;
case '?':
errflg++;
break ;
}
}
if ((errflg) || argc < 3)
usage ();
dbinname = argv[optind++];
dboutname= argv[optind++];
if (dbopen(dbinname,"r",&dbin)) {
elog_die(1,"cannot open database %s",dbinname);
}
dbi=dblookup(dbin,0,"regions",0,0);
sortkeys=newtbl(2);
pushtbl(sortkeys,"regname");
pushtbl(sortkeys,"vertex");
groupkeys=newtbl(1);
pushtbl(groupkeys,"regname");
dbi=dbsort(dbi,sortkeys,0,"regions.sorted");
dbg=dbgroup(dbi,groupkeys,0,0);
dbquery(dbg,dbRECORD_COUNT,&nregions);
if (nregions <1) {
elog_die(0,"table regions seems to be empty (or not present)");
}
if (verbose) elog_notify(0,"creating database descriptor %s",dboutname);
if (dbcreate(dboutname,"polygon1.2",0,0,0)) {
elog_die(1,"cannot create database %s",dboutname);
}
dbopen(dboutname,"r+",&dbout);
dbo=dblookup(dbout,0,"polygon",0,0);
for (i=0; i< nregions; i++) {
dbg.record=i;
dbgetv(dbg,0,"regname",name,"bundle",&dbb,0);
dbget_range(dbb,&from,&to);
nvertices= to - from;
if (verbose) elog_notify(0,"%s (%i nvertices)",name,nvertices);
poly=malloc(2 * nvertices * sizeof(double));
nv=0;
for (dbi.record=from; dbi.record<to; dbi.record++) {
dbgetv(dbi,0,
"regname",name,
"vertex",&vertex,
"lat",&lat,"lon",&lon,
0);
poly[nv].lat=lat;
poly[nv].lon=lon;
nv++;
}
writePolygonData(dbo,poly,nv,name,1,0,ptype,auth,dir,dfile,ftype);
free(poly);
}
/*
*/
return 0;
}
void kelog_init (elog_main_t * em, char * kernel_tracer, u32 n_events)
{
int enable_fd, current_tracer_fd, data_fd;
int len;
struct timespec ts, ts2;
char *trace_enable = "/debug/tracing/tracing_enabled";
char *current_tracer = "/debug/tracing/current_tracer";
char *trace_data = "/debug/tracing/trace";
f64 realtime, monotonic;
f64 freq, secs_per_clock;
ASSERT (kernel_tracer);
/*$$$$ fixme */
n_events = 1<<18;
/* init first so we won't hurt ourselves if we bail */
elog_init (em, n_events);
enable_fd = open (trace_enable, O_RDWR);
if (enable_fd < 0)
{
clib_warning ("Couldn't open %s", trace_enable);
return;
}
/* disable kernel tracing */
if (write (enable_fd, "0\n", 2) != 2)
{
clib_unix_warning ("disable tracing");
close(enable_fd);
return;
}
/*
* open + clear the data buffer.
* see .../linux/kernel/trace/trace.c:tracing_open()
*/
data_fd = open (trace_data, O_RDWR | O_TRUNC);
if (data_fd < 0)
{
clib_warning ("Couldn't open+clear %s", trace_data);
return;
}
close(data_fd);
/* configure tracing */
current_tracer_fd = open (current_tracer, O_RDWR);
if (current_tracer_fd < 0)
{
clib_warning ("Couldn't open %s", current_tracer);
close(enable_fd);
return;
}
len = strlen(kernel_tracer);
if (write (current_tracer_fd, kernel_tracer, len) != len)
{
clib_unix_warning ("configure trace");
close(current_tracer_fd);
close(enable_fd);
return;
}
close(current_tracer_fd);
/*
* The kernel event log uses CLOCK_MONOTONIC timestamps,
* not CLOCK_REALTIME timestamps. These differ by a constant
* but the constant is not available in user mode.
* This estimate will be off by one syscall round-trip.
*/
clib_time_init (&em->cpu_timer);
em->init_time.cpu = em->cpu_timer.init_cpu_time;
syscall (SYS_clock_gettime, CLOCK_MONOTONIC, &ts);
/* enable kernel tracing */
if (write (enable_fd, "1\n", 2) != 2)
{
clib_unix_warning ("enable tracing");
close(enable_fd);
return;
}
close(enable_fd);
}
