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;
}
}
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 dbpmel_process(Dbptr db, Tbl *gridlist,Pf *pf)
{
Pf *vpf;
Arr *arr_phase;
char *vmodel;
/* Holds indexed list of stations with bad clocks problems
that should be used only with S-P type timing */
Arr *badclocks;
Location_options o;
/* Hold station table. We make the array table empty always. */
Arr *stations;
int nbcs;
int i,j,k;
Tbl *grptbl;
Tbl *grdidtbl;
Dbptr dbevid_grp; /* dbgroup pointers */
/* Used by dbmatches */
static Hook *hook=NULL;
Tbl *reclist;
Dbptr dbgs;
Dbptr dbbundle;
Dbptr dbcs;
Tbl **ta; /* We use an array of Tbls for arrival times to
allow a simple loop through an event group.*/
Hypocenter *h0;
int *evid; /* parallel array to h0 of event ids for each h0[i]*/
Hypocenter hypocentroid;
/* The associative array here is loaded from the pf and contains
information on which events are to be treated as calibration events.
The fixlist array of character strings is passed to pmel as a
parallel of vectors defining events with fixed coordinates */
Arr *events_to_fix;
/* This is the structure that encapsulates all the station
correction elements. WARNING: it is built up in pieces below,
and later modifications most handle this carefully.*/
SCMatrix *smatrix;
Tbl *converge=NULL,*pmelhistory=NULL;
Arr *arr_phase_3D;
/* needed for output db tables */
char *runname, *gridname;
int pmelfail;
Tbl *phaselist;
initialize_hypocenter(&hypocentroid);
runname = pfget_string(pf,"pmel_run_name");
gridname = pfget_string(pf,"gridname");
/* This genloc routine defines location parameters. These
are set globally here for the entire run.*/
o = parse_options_pf(pf);
/* Pmel is know to fail if this option is turned on */
if(((o.generalized_inverse)==PSEUDO_RECENTERED)
|| ((o.generalized_inverse)==DAMPED_RECENTERED) )
{
elog_notify(0,"parameter file specifies recenter\
option which is know to cause problems\nrecenter set off\n");
if((o.generalized_inverse)==PSEUDO_RECENTERED)
o.generalized_inverse = PSEUDOINVERSE;
if((o.generalized_inverse)==DAMPED_RECENTERED)
o.generalized_inverse = DAMPED_INVERSE;
}
