/* Recursively traverses a Pf object and frees its nested pf-consistent * members. */ void recurse_free_pf ( Pf * pf ) { Arr * currarr; Tbl * currtbl; void * key; void * value; int i; int size; if ( pf == NULL ) return; switch ( pf->type ) { case PFARR: clrarr( pf->value.arr, recurse_free_pf ); break; case PFTBL: clrtbl( pf->value.tbl, recurse_free_pf ); break; default: free( pf->value.s ); break; } pffree( pf ); pf = NULL; }
/* Simple little function to define the 3D reference model used to compute bias components of solution. It simply uses the same mechanism used in dbgenloc to access a set of standard models. */ Arr *parse_3D_phase(Pf *pf) { Arr *a; Pf *pf3d; char *vmodel; vmodel = pfget_string(pf,"3Dreference_model"); if(pfload("GENLOC_MODELS","tables/genloc",vmodel,&pf3d) != 0) elog_die(0,"pfload failed on 3Dreference model %s\n",vmodel); a = parse_phase_parameter_file(pf3d); pffree(pf3d); return(a); }
/* This is the routine that uses data pushed onto the queue by the read thread. All it does is call pmtfifo and handle error conditions. pfh is the control structure returned by the read thread we use to access the data contained in the fifo. Returns a NULL to signal end of data. This can happen one of two ways. If there is an error in pmtfifo_pop, complain is called and we return NULL. This was done to allow a graceful exit from the caller. The warning message may be too subtle, but I see now simple way to do this with plain C. This is a case where I can see reasons for C++'s throw having a big advantage. The function will also return NULL when it sees the end of data. That is caught here by the FINISHED boolean in the pf. */ Pf *pfstream_get_next_ensemble(Pfstream_handle *pfh) { Pf *pf; /* Pf popped from Pmtfifo */ if(pmtfifo_pop(pfh->mtf,(void **)(&pf)) < 0) { elog_complain(1,"pfstream_get_next_ensemble: Attempt to fetch data from input fifo failed\nData stream was probably trunctated\nTrying to clean up before exit\n"); return(NULL); } if(pfget_boolean(pf,"FINISHED")) { pffree(pf); return(NULL); } return(pf); }
/* This is the opposite of the previous */ void *pfstream_write_data(void *arg) { Pfstream_control *pfsc=(Pfstream_control *)arg; Pf *pf,*pftest; int fini; int itest; while(1) { pmtfifo_pop(pfsc->mtf,(void **)(&pf)); /* this is a safe test if FINISHED is not set. Should not require user to have to do this */ itest = pfget(pf,"FINISHED",(void **)&pftest); if(itest==PFINVALID) { fini=0; pfput_boolean(pf,"FINISHED",0); } else fini=pfget_boolean(pf,"FINISHED"); if(fini) { fprintf(pfsc->fp,"%s\n",END_OF_DATA_SENTINEL); fflush(pfsc->fp); sleep(20); fclose(pfsc->fp); break; } pfout(pfsc->fp,pf); fprintf(pfsc->fp,"%s\n", ENDPF_SENTINEL); fflush(pfsc->fp); /* We have release the memory for pf here as the caller is pushing this away a forgetting about it */ pffree(pf); } return(NULL); }
Pf * pforbstat( int orbfd, int flags ) { Pf *pf = 0; Pf *pfans; Orbstat *orbstatus = 0; Orbsrc *sources = 0; Orbclient *clients = 0; double atime; int orbversion; int nsources = 0; int nclients = 0; char *s; if( orbfd <= 0 ) { return (Pf *) NULL; } if( flags & PFORBSTAT_CONNECTIONS ) { flags |= PFORBSTAT_CLIENTS; } if( flags & PFORBSTAT_DATABASES ) { flags |= PFORBSTAT_CLIENTS; } orbping( orbfd, &orbversion ); pf = pfnew( PFFILE ); pfput_double( pf, "pforbstat_version", PFORBSTAT_VERSION ); if( flags & PFORBSTAT_SERVER ) { orbstat( orbfd, &orbstatus ); pfans = orbstat2pf( orbstatus, orbversion ); pfput( pf, "server", pfans, PFPF ); } if( flags & PFORBSTAT_SOURCES ) { orbsources( orbfd, &atime, &sources, &nsources ); pfans = orbsources2pf( atime, sources, nsources ); pfcompile( s = pf2string( pfans ), &pf ); free( s ); pffree( pfans ); } if( flags & PFORBSTAT_CLIENTS ) { orbclients( orbfd, &atime, &clients, &nclients ); pfans = orbclients2pf( atime, clients, nclients ); pfcompile( s = pf2string( pfans ), &pf ); free( s ); id_clients( pf ); pffree( pfans ); } if( flags & PFORBSTAT_CONNECTIONS ) { pfans = orbconnections2pf( pf ); pfcompile( s = pf2string( pfans ), &pf ); free( s ); pffree( pfans ); } if( flags & PFORBSTAT_DATABASES ) { pfans = orbdatabases2pf( pf ); pfcompile( s = pf2string( pfans ), &pf ); free( s ); pffree( pfans ); } return pf; }
static Pf * orbconnections2pf( Pf *pfanalyze ) { Pf *pf; Pf *pfserver; Pf *pfconnections; Pf *pfclients; Pf *pfclient; Pf *pfconnection; Tbl *client_keys; int ikey; char *client_key; char *clientid; char *what; char *perm; char *clientaddress; char *serveraddress; char clientaddress_ipc[STRSZ]; char serveraddress_ipc[STRSZ]; int serverport; double atime; regex_t preg_findclient; char closeorb[STRSZ]; char o2omachine[STRSZ]; char farorb[STRSZ]; int closeport; int farport; char orbstat_machine_hostname[STRSZ]; char orbstat_machine_ipc[STRSZ]; int orbstat_machine_ip; char cmdline_fromorb[STRSZ]; char cmdline_toorb[STRSZ]; char cmdline_fromip[STRSZ]; char cmdline_fromipc[STRSZ]; char cmdline_toip[STRSZ]; char cmdline_toipc[STRSZ]; char formal_name[STRSZ]; int formal_count = 0; int cmdline_fromport; int cmdline_toport; struct in_addr addr; regcomp( &preg_findclient, "^orb2orb ", 0 ); pf = pfnew( PFFILE ); atime = pfget_time( pfanalyze, "client_when" ); pfput_time( pf, "connections_when", atime ); my_ip( orbstat_machine_hostname, orbstat_machine_ipc, &orbstat_machine_ip ); if( is_localhost( orbstat_machine_ipc ) ) { elog_complain( 0, "libpforbstat: orbstat machine is localhost; giving up on connection analysis\n" ); regfree( &preg_findclient ); return pf; } else { pfput_string( pf, "orbstat_machine", orbstat_machine_ipc ); } pfget( pfanalyze, "server", (void **) &pfserver ); serveraddress = pfget_string( pfserver, "address" ); serverport = pfget_int( pfserver, "port" ); if( is_nonroutable( serveraddress ) && report_nonroutable( serveraddress ) ) { elog_complain( 0, "libpforbstat: warning: monitored server %s is nonroutable\n", serveraddress ); } if( name2ip( serveraddress, &addr, serveraddress_ipc ) < 0 ) { elog_complain( 0, "libpforbstat: warning: name translation failed for %s\n", serveraddress ); strcpy( serveraddress_ipc, serveraddress ); } if( is_localhost( serveraddress ) ) { strcpy( closeorb, orbstat_machine_ipc ); } else { strcpy( closeorb, serveraddress_ipc ); } closeport = serverport; /* SCAFFOLD: this causes memory problems. Leave untranslated for now: pfput_string( pfserver, "address", closeorb ); Record the translated server address */ pfget( pfanalyze, "clients", (void **) &pfclients ); client_keys = pfkeys( pfclients ); pfconnections = pfnew( PFTBL ); for( ikey = 0; ikey < maxtbl( client_keys ); ikey++ ) { client_key = gettbl( client_keys, ikey ); pfget( pfclients, client_key, (void **) &pfclient ); what = pfget_string( pfclient, "what" ); if( ! regexec( &preg_findclient, what, 0, 0, 0 ) ) { pfconnection = pfnew( PFARR ); /* Easy things: */ pfput_string( pfconnection, "what", what ); if( ( clientid = pfget_string( pfclient, "clientid") ) != NULL ) { pfput_string( pfconnection, "clientid", clientid ); } /* Preparatory raw-information acquisition: */ extract_orb2orb_orbargs( what, cmdline_fromorb, cmdline_toorb ); parse_orbname( cmdline_fromorb, cmdline_fromip, &cmdline_fromport ); if( name2ip( cmdline_fromip, &addr, cmdline_fromipc ) < 0 ) { elog_complain( 0, "libpforbstat: warning: name translation failed for %s\n", cmdline_fromipc ); strcpy( cmdline_fromipc, cmdline_fromip ); } parse_orbname( cmdline_toorb, cmdline_toip, &cmdline_toport ); if( name2ip( cmdline_toip, &addr, cmdline_toipc ) < 0 ) { elog_complain( 0, "libpforbstat: warning: name translation failed for %s\n", cmdline_toipc ); strcpy( cmdline_toipc, cmdline_toip ); } perm = pfget_string( pfclient, "perm" ); clientaddress = pfget_string( pfclient, "address" ); if( name2ip( clientaddress, &addr, clientaddress_ipc ) < 0 ) { elog_complain( 0, "libpforbstat: warning: name translation failed for %s\n", clientaddress ); strcpy( clientaddress_ipc, clientaddress ); } /* Analysis */ if( is_nonroutable( clientaddress ) && report_nonroutable( clientaddress ) ) { elog_complain( 0, "libpforbstat: warning: clientaddress %s is nonroutable\n", clientaddress ); } if( is_localhost( clientaddress ) ) { strcpy( o2omachine, serveraddress_ipc ); } else { strcpy( o2omachine, clientaddress_ipc ); } pfput_string( pfconnection, "o2omachine", o2omachine ); if( STREQ( perm, "w" ) ) { strcpy( farorb, cmdline_fromipc ); farport = cmdline_fromport; } else if( STREQ( perm, "r" ) ) { strcpy( farorb, cmdline_toipc ); farport = cmdline_toport; } else { elog_complain( 0, "libpforbstat: unexpected perm '%s' in client info; giving up on client\n", perm ); pffree( pfconnection ); continue; } if(is_localhost(farorb)) { strcpy( farorb, o2omachine ); } if( STREQ( perm, "w" ) ) { pfput_string( pfconnection, "fromaddress", farorb ); pfput_int( pfconnection, "fromport", farport ); pfput_string( pfconnection, "toaddress", closeorb ); pfput_int( pfconnection, "toport", closeport ); pfput_string( pfconnection, "closeorb", "toaddress" ); } else { /* perm == "r" */ pfput_string( pfconnection, "fromaddress", closeorb ); pfput_int( pfconnection, "fromport", closeport ); pfput_string( pfconnection, "toaddress", farorb ); pfput_int( pfconnection, "toport", farport ); pfput_string( pfconnection, "closeorb", "fromaddress" ); } sprintf( formal_name, "client%03d", ++formal_count ); pfput( pfconnections, formal_name, pfconnection, PFPF ); } } pfput( pf, "connections", pfconnections, PFPF ); regfree( &preg_findclient ); return pf; }
/* This little routine dumps the parameter space of pf and the output tbls of ggnloc to a log file tagged by orid. Note, however, that if ggnloc failed for some reason, it is assumed that orid will be set to a NEGATIVE number. When this occurs, the results are written to a "failures" directory defined in rtopts. IMPORTANT: multiple instances of orbgenloc should arrange to write in seperate failure directories or they can collide. */ int write_to_logfile(RTlocate_Options rtopts, int orid, int evid, Pf *pf, Tbl *converge_history, Tbl *reason_converged,Tbl *residual) { char fname[256]; FILE *fp; /* We write the logfile output as a pf object copying code from sgnloc */ Pf *pflog; Tbl *t; /* formatted output tbl of hypo convergence history */ char *line; int i; Hypocenter *hypos; /* This can fail for very long directory entries, but it isn't worth messing with in my mind. Note switch for orid */ if(orid > 0) { sprintf(fname,"%s/orid%d.pf",rtopts.logdir,orid); } else { sprintf(fname,"%s/%s/evid%d.pf",rtopts.logdir, rtopts.failure_sdir,evid); } pfwrite(fname,pf); /* Here we encapsulate the convergence history information into a second pf object, and write this onto the same pf file */ t = newtbl(maxtbl(converge_history)); for(i=0;i<maxtbl(converge_history);++i) { hypos = (Hypocenter *)gettbl(converge_history,i); line = format_hypo(hypos); pushtbl(t,line); } pflog = pfnew(PFFILE); pfput_tbl(pflog,"convergence_history",t); printf("Reasons for convergence:\n"); for(i=0;i<maxtbl(reason_converged);++i) printf("%s\n",gettbl(reason_converged,i)); pfput_tbl(pflog,"convergence_criteria",reason_converged); pfput_tbl(pflog,"residuals",residual); /* We use pf2string rather than pfwrite since I'm not sure what pfwrite will do when the file already exists. Here we just append the new pf info to the end of the stuff written above. */ if((fp=fopen(fname,"a")) == NULL) { elog_complain(1,"Cannot open log file %s\n",fname); return(1); } fseek(fp,0L,SEEK_END); line = pf2string(pflog); fwrite(line,1,strlen(line),fp); fclose(fp); free(line); pffree(pflog); freetbl(t,free); return(0); }
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 pfput_mxArray( Pf *pf, char *name, const mxArray *array ) { Pf *sub_pf; double number; char *string; mxArray *in[2], *out[1]; char warning[STRSZ]; char *fieldname; mxArray *mxfield; mxArray *mxcell; int M,N; int rc; int i; if( mxIsClass( array, "dbpf" ) ) { if( ! get_pf( array, &sub_pf ) ) { return PFINVALID; } if( sub_pf->type == PFFILE) { /* Don't embed a PFFILE in something else */ sub_pf->type = PFARR; } switch (pf->type) { case PFFILE: case PFARR: setarr ( pf->value.arr, name, sub_pf ) ; break ; case PFTBL: settbl ( pf->value.tbl, (int) name, sub_pf ) ; break ; default : return PFINVALID; } antelope_mex_clear_register( 1 ); } else if( mxIsDouble( array ) ) { if( ! get_scalar( array, &number ) ) { return PFINVALID; } in[0] = (mxArray *) array; /* Input scalar */ mexCallMATLAB( 1, out, 1, in, "floor" ); in[1] = out[0]; /* floor( Input scalar ) */ mexCallMATLAB( 1, out, 2, in, "eq" ); mxDestroyArray( in[1] ); if( mxIsLogicalScalarTrue( out[0] ) ) { pfput_int( pf, name, (int) number ); } else { pfput_double( pf, name, number ); } antelope_mex_clear_register( 1 ); mxDestroyArray( out[0] ); } else if( mxIsChar( array ) ) { if( ! mtlb_get_string( array, &string ) ) { sprintf( warning, "failed to extract string for parameter %s\n", name ); mexWarnMsgTxt( warning ); return PFINVALID; } pfput_string( pf, name, string ); antelope_mex_clear_register( 1 ); mxFree( string ); } else if( mxIsStruct( array ) ) { if( mxGetNumberOfDimensions( array ) > 2 ) { sprintf( warning, "structure has too many dimensions for parameter %s\n", name ); mexWarnMsgTxt( warning ); return PFINVALID; } else if( mxGetM( array ) != 1 || mxGetN( array ) != 1 ) { sprintf( warning, "structure has too many elements for parameter %s\n", name ); mexWarnMsgTxt( warning ); return PFINVALID; } N = mxGetNumberOfFields( array ); sub_pf = pfnew( PFARR ); for( i = 0; i < N; i++ ) { fieldname = (char *) mxGetFieldNameByNumber( array, i ); mxfield = mxGetFieldByNumber( array, 0, i ); rc = pfput_mxArray( sub_pf, fieldname, mxfield ); if( rc == PFINVALID ) { pffree( sub_pf ); return PFINVALID; } } switch (pf->type) { case PFFILE: case PFARR: setarr ( pf->value.arr, name, sub_pf ) ; break ; case PFTBL: settbl ( pf->value.tbl, (int) name, sub_pf ) ; break ; default : pffree( sub_pf ); return PFINVALID; } antelope_mex_clear_register( 1 ); } else if( mxIsCell( array ) ) { if( mxGetNumberOfDimensions( array ) > 2 ) { sprintf( warning, "cell array has too many dimensions for parameter %s\n", name ); mexWarnMsgTxt( warning ); return PFINVALID; } M = mxGetM( array ); N = mxGetN( array ); sub_pf = pfnew( PFTBL ); for( i = 0; i < M * N; i++ ) { mxcell = mxGetCell( array, i ); rc = pfput_mxArray( sub_pf, (char *) i, mxcell ); if( rc == PFINVALID ) { pffree( sub_pf ); return PFINVALID; } } switch (pf->type) { case PFFILE: case PFARR: setarr ( pf->value.arr, name, sub_pf ) ; break ; case PFTBL: settbl ( pf->value.tbl, (int) name, sub_pf ) ; break ; default : pffree( sub_pf ); return PFINVALID; } antelope_mex_clear_register( 1 ); } else { return PFINVALID; } return 0; }
/* This is the main processing function for this program. Arguments: dbv - db pointer to a complex view of the database to be processed. That is, it has these properties: 1. It is a join of: event->origin->assoc->arrival 2. subset to single arrival name AND orid==prefor 3. sorted by evid/sta pf - input parameter space The main processing loop here keys on the grouping defined in the view passed as dbgrp. That is, seismograms for each event group are processed as a complete gather. After that, are nested loops to do the multiwavelet processing as described in Bear and Pavlis (1999a,b). Author: Gary Pavlis Date: March 1999+ */ #define LAG_ERROR -100000 /* Computed lags smaller than this returned by compute_optimal_lag are treated as an error condition. Should probably be in an include file*/ void mwap_process(Dbptr dbv,char *phase, Pf *pf) { int nevents; /* number of events=number of groups in dbgrp */ MWbasis *mw; /* Multiwavelet basis functions */ Tbl **decimators; /* List of loaded decimators used to construct multiwavelet transforms in lower bands */ Tbl **dec_objects; /*Actual decimation filter objects */ /* Note: mw and dec_objects define the multiwavelet transform */ int nwavelets,nbands; /* sets coherence mode used to determine optimal lag */ int coherence_type; Arr *stations; /* This associative array holds MWstation objects that contain header like data that is station dependent */ Arr *badclocks; /* associative array keyed by sta name holding list of time intervals with bad timing */ char *refsta; /* Name of reference station */ double refelev; /* reference elevation from parameter file */ int nsta; /* number of stations */ int ntest; Dbptr db; /* generic db lookup parameter */ Dbptr dbgrp; /* evid group db pointer */ Dbptr tr; /* trace database */ Dbptr dbmps; /* mwpredslow table */ Tbl *sortkeys,*sortkeys2; /* used because different tr routines require different sort orders */ int *pad; /* vector of length nbands holding computed time padding lengths for each band in samples */ int tpad; /*time pad actually used (max of *pad) */ Time_Window *swin, *nwin; /* arrays defining time windows for signal and noise respectively (relative to arrival)*/ Time_Window swinall, nwinall; /*define read time intervals (extracted from swin and nwin arrays */ int *decfac; /* array of decimation factors needed at times */ Arr *mwarr; /* Holds indexed multiwavelet transformed trace objects*/ /* We keep three copies of arrival time information. arrival0 = original times read from db (never altered) arrivals = current working copy arrival_new = new estimate obtained from "arrivals" */ Arr *arrival0,*arrivals,*arrival_new; Arr *static_result; /* Holds error statistics for static estimates */ MWSlowness_vector u0,u; int i,j; double avgamp, amperr; int ampndgf; int iterations; double ucovariance[9]; char *array_name; int accumulate; /* These are channel code names used in trace library rotation functions rotate_to_standard and trrotate. */ char *stdchans[3]={ EW, NS , VERTICAL }; char *pcchans[3]={"R","T","ZL"}; Arr *mwsig_arr,*mwnoise_arr; /* these index pointers to mw transformed signal and noise series */ Arr **sn_ratios; /* vector of Arr pointers of length nbands indexing signal to noise ratio estimates (stored in a structure) for every station */ Spherical_Coordinate polarization0,polarization; Spherical_Coordinate polarz={1.0,0.0,0.0}; Arr *model_times=NULL; MWSlowness_vector model_slow; double rctm[9]; /*ray coordinate transformation matrix*/ double timeref; /* time reference at reference station */ double time; double t0,twin; double si; double fc,fwin; int evid; int lag; /* optimal lab computed by coherence measure */ double peakcm; /*Peak value of coherence measure */ /* For a given gather we set moveout computed moveout time in seconds relative to the reference station. This time includes the combined current static estimates. This is a vector workspace that is recycled for every gather. It is alloced soon as we know the number of stations in the site table. */ double *moveout; MWgather **gathers; Particle_Motion_Ellipse *avgpm; Particle_Motion_Error *avgerr; char *pmtype_to_use; /* type of particle motion estimate to use for polarization */ Arr *pm_arr,*pmerr_arr; Arr *pmarray,*errarray; /* This vector defines the "up" direction. For P waves this initialization is correct. For S it may not be appropriate, but this is something to repair later */ double up[3]={0.0,0.0,1.0}; int bankid; /* mutliwavelet group id */ int band_exit = 0; /* name of parameter file produced by GUI to control this program */ char *guipf; int stack_alignment; Pf *pfcontrol; int loopback; int numberpasses=0; /* These define the relative time window used for stack and particle motion. s denotes stack, ts0 etc are pm */ double sts0,ste0; /* we don't need the equivalent of ts1 and te1 */ double ts0,ts1,te1,te0; /* This is essential or copy_arrival_array can produce garbage */ arrival0=NULL; arrivals = NULL; arrival_new=NULL; pm_arr = NULL; pmerr_arr = NULL; pmarray = NULL; errarray = NULL; si = pfget_double(pf,"sample_interval"); /* First we need to load the multiwavelet functions and the associated decimators for the transform. Each of these routines will die if serious problems occur and have no error returns. Wavelet functions can be loaded from a parameter file or a db. */ if(pfget_boolean(pf,"get_wavelets_from_database")) { mw = load_multiwavelets_db(dbv,pf,&nwavelets,&bankid); } else { mw = load_multiwavelets_pf(pf,&nwavelets); bankid = pfget_int(pf,"bankid"); } decimators = define_decimation(pf,&nbands); allot(int *,decfac,nbands); dec_objects = build_decimation_objects(decimators,nbands,decfac); print_band_info(mw,decfac,pf); /* This creates the station objects. The time extracted here is needed to sort out the ontime:endtime key in the site table. This is done is a less than bombproof fashion by randomly grabbing the time in the first record view. Because of the way the site table works this will always work in some fashion. It will only matter if a station ever moves and then we have a bad problem anyway. */ dbv.record = 0; dbgetv(dbv,0,"time",&time,0); stations = build_station_objects(dbv,pf,time); refsta = get_refsta(stations); array_name = pfget_string(pf,"array_name"); if(array_name == NULL) { elog_complain(0,"WARNING: array_name not defined in parameter file. Set to default of ARRAY\n"); array_name = strdup("ARRAY"); } refelev = pfget_double(pf,"reference_elevation"); /* This loads a definition of bad clocks from an extension table called timing. This comes from libgenloc where it is used to handle automatic switching to S-P times. */ badclocks=newarr(0); if(db_badclock_definition(dbv,pf,badclocks)) { elog_notify(0,"Problems in setting up table of stations with timing problems\n"); } /* This function can define stations as always having bad timing based on a parameter Tbl list of station names keyed by bad_clock.*/ pfget_badclocks(pf,badclocks); pmtype_to_use = pfget_string(pf,"array_particle_motion_to_use"); if(pmtype_to_use==NULL) pmtype_to_use=strdup(PMOTION_BEAM); /* this used to be a variable, but we no longer have a choice.*/ coherence_type=USE_COHERENCE; /* This variable sets if we should reset the arrival estimates to starting values for each band. When true the results accumulate from band to band. That is we keep adding corrections from previous band to progressively higher frequency.*/ accumulate = pfget_boolean(pf,"accumulate_statics"); /* compute time pad lengths for each band of the mw transforms */ pad = compute_tpad(dec_objects, mw, stations,pf); /* These routine parses the parameter file for noise and analysis time window information respectively returning arrays of Time_Window structures of length nbands*/ decfac = get_decimation_factors(dec_objects, pf); swin = get_signal_windows(decfac,pad,pf); nwin = get_noise_windows(decfac,pad,pf); print_window_data(decfac,nbands,swin,nwin,pf); /* This gets time windows for signal and noise needed for reading data (i.e. largest time ranges needed) */ swinall = compute_time_window(swin,decfac,nbands); nwinall = compute_time_window(nwin,decfac,nbands); guipf = pfget_string(pf,"mwapcontrol"); /* better safe than sorry */ if(guipf==NULL) { elog_die(0,"Missing required parameter mwapcontrol"); } /* We can create these works spaces now for efficiency so we don't have to constantly recreate them dynamically below */ allot(double *,moveout,cntarr(stations)); allot(MWgather **,gathers,nwavelets); /* This associative array holds indexed pointers to multiwavelet transformed traces. We create it here, but it is repeatedly freed and cleared below */ mwarr = newarr(0); /* This one has to be initialized*/ static_result=newarr(0); /* We need this table repeatedly below so we avoid constant lookups */ dbmps = dblookup(dbv,0,"mwpredslow",0,0); if(dbmps.record == dbINVALID) elog_die(0,"db lookup failed for mwpredslow table\nMWavelet schema extensions are required\n"); /* Now we loop through the outer loop event by event. This is structured here by using a dbgroup defined db pointer that is passed through the argument list. The db pointer is incremented and then the bundle is taken apart to crack apart each group of traces (the gather). Note we use a defined name to look up the evid grouped table. */ dbgrp = dblookup(dbv,0,EVIDBDLNAME,0,0); if (dbgrp.record == dbINVALID) elog_die(0,"Error in dblookup for named evid group table = %s\n", EVIDBDLNAME); dbquery(dbgrp,dbRECORD_COUNT,&nevents); fprintf(stdout,"Processing begins for %d events\n",nevents); sortkeys = newtbl(0); pushtbl(sortkeys,"sta"); pushtbl(sortkeys,"chan"); pushtbl(sortkeys,"time"); sortkeys2 = newtbl(0); pushtbl(sortkeys2,"time"); pushtbl(sortkeys2,"sta"); pushtbl(sortkeys2,"chan"); for(dbgrp.record=0;dbgrp.record<nevents;++dbgrp.record) { Dbptr db_bundle; int evid; int is, ie; int ierr; double modaz; if(dbgetv(dbgrp,0,"evid", &evid, "bundle", &db_bundle,0) == dbINVALID) { elog_complain(1,"dbgetv error for row %d of event group\nAttempting to continue by skipping to next event\n", dbgrp.record); continue; } dbget_range(db_bundle,&is,&ie); if(ie-is<3) { elog_complain(0,"Insufficient data to process for evid %d\nNeed at least three station -- found only %d\n", evid,ie-is); continue; } /* We utilize what we call plane wave statics here to approximately correct for wavefront curvature. We set the record number to is so we can access the correct origin information from the db. Because we used a join allrows of this group should have the same origin data. */ ierr = set_pwstatics(stations,refsta,phase,db_bundle,pf); if(ierr)elog_complain(0,"%d errors computing %d plane wave statics for evid %d\n", ierr,ie-is,evid); /* This routine loads an Arr of arrival times from the input db to be used to compute initial slowness vector and initial statics. */ arrival0 = get_arrivals(db_bundle); /* We edit the MWstation array to flag stations with bad timing in this function */ MWcheck_timing(arrival0,stations,badclocks); /* Save these times */ copy_arrival_array(arrival0,&arrivals); /* Initialize slowness vector to 0 and then estimate it from data using current arrival times */ u0.ux = 0.0; u0.uy = 0.0; u0.refsta = refsta; timeref = compute_time_reference(stations,arrivals,refsta,u0); /* for the first pass we use weights defined for the lowest frequency band. This is done because it asssumed that if frequency dependent weighting is actually used the lowest band would have the widest effective aperture. */ ierr = estimate_slowness_vector(u0,arrivals,stations, refsta, refelev, timeref, phase, nbands-1,&u); /* It is necessary to reset the time reference to handle the case correctly when the reference station does not actually record this event. This function uses a moveout correction that depends upon the slowness vector, so it can float about a bit in that situation */ if(ierr>0) elog_notify(0,"%d nonfatal errors in estimate_slowness_vetor for evid %d\n",ierr,evid); else if(ierr < 0) { elog_complain(0,"estimate_slowness_vector failed for initial slowness estimate for evid %d\nData for this event will be skipped\n", evid); continue; } /* This routine returns the slowness vector and an arr of estimated arrival times. The slowness vector is saved in the mwpredslow table immediately below. Arrival times are used to compute residuals later. */ ierr = MWget_model_tt_slow(stations, refsta, phase, db_bundle, pf, &model_times, &model_slow); timeref = compute_time_reference(stations,arrivals,refsta,u); polarization0=estimate_initial_polarization(model_slow,stations, refsta,phase); modaz = atan2(model_slow.ux,model_slow.uy); if(dbaddv(dbmps,0,"sta",array_name, "evid",evid, "phase",phase, "time",timeref, "slo",hypot(model_slow.ux,model_slow.uy), "azimuth",deg(modaz), "majoraz",deg(polarization0.phi), "majorema",deg(polarization0.theta), "vmodel",pfget_string(pf,"TTmodel"),0) == dbINVALID) { elog_complain(0,"dbaddv error for evid %d on mwpredslow table\n", evid); } /* This function reads in the trace data for this event using time windows defined above */ tr = mwap_readdata(dbgrp,arrivals,swinall, nwinall); if(tr.record == dbINVALID) { elog_complain(0,"Serious problems reading data for evid %d -- no data processed for this event\n",evid); continue; } tr = dblookup(tr,0,"trace",0,0); /* We first glue together any possible recording break generated entries -- common with continuous data. This also seems to require a resort because of the way data was read in. */ /* tr = dbsort(tr,sortkeys,0,0); */ trsplice(tr,0.1,0,0); /* We run trsplit to break up waveform segments at real gaps. I'm not sure later code will work correctly if it isn't an all or nothing situations (e.g. gap in Z component, but not in N or E). In any case, we have to deal with potential multiple segments later. */ trsplit(tr,0,0); trapply_calib(tr); trdemean_seg(tr); /* Now we have reorder the traces or this will not work correctly*/ tr = dbsort(tr,sortkeys2,0,0); ierr = rotate_to_standard(tr,stdchans); if(ierr<0) { elog_complain(0,"rotate_to_standard failed processing evid %d -- no data processed for this event\n", evid); continue; } if(ierr>0)elog_complain(0,"rotate_to_standard failed for %d stations\n", ierr); /* This releases the space held by the raw data traces keeping only the rotate_to_standard outputs */ free_noncardinal_traces(tr); elog_log(0,"Computing multiwavelet transform: be\ patient as this can take a while with many channels\n"); /* This function computes the multiwavelet transform of all traces currently in tr for signals around arrival*/ mwsig_arr = tr_mwtransform(tr,arrivals,swin,decfac,dec_objects, nbands,mw,nwavelets); /* We repeat the same thing for noise windows */ mwnoise_arr = tr_mwtransform(tr,arrivals,nwin,decfac, dec_objects,nbands,mw,nwavelets); /* Now compute signal to noise ratio figures for all nbands storing the structures that define the results in an Arr keyed by station. Note this is actually a vector of Arr pointers of length nbands. Further note the following function creates this complicated object, and it must be freed after each event is processed. */ sn_ratios=compute_signal_to_noise(mwsig_arr,mwnoise_arr, stations,arrivals,swin,nwin, nbands,nwavelets); /* Now we get to the heart of this program. This is the outer loop over frequency. Note the loop goes backward because the lowest frequencies are the final row of the mw transform matrices of pointers */ copy_MWslowness_vector(&u,&u0); if(numberpasses>0) { fprintf(MWpout,"NEWEVENT %d\n",evid); } for(i=nbands-1;i>=0;--i) { if(!accumulate) copy_arrival_array(arrival0,&arrivals); copy_arrival_array(arrivals,&arrival_new); fc = (mw[i].f0)/(2.0*si*decfac[i]); fwin = (mw[i].fw)/(2.0*si*decfac[i]); fprintf(stdout,"Processing begins on band %d with center frequency %lf\nWait for -Hit Accept button when ready- prompt\n", i,fc); /* This builds the basic working gathers for each wavelet and builds a shortcut of pointers to MWtraces that are related */ for(j=0;j<nwavelets;++j) { gathers[j] = build_MWgather(i,j, mwsig_arr,stations, sn_ratios[i],pf); } fprintf(stdout,"Working gather for this band has %d stations\n", gathers[0]->nsta); /* Testing band 0 should be sufficient. The signal-to-noise is averaged overall wavelets so the same stations should be deleted in all wavelet of the group */ if(gathers[0]->nsta < 3) { elog_notify(0,"Insufficient data in band %d to passed signal-to-noise cutoff defined for this band for evid %d\nSkipping to next frequency band\n", i,evid); continue; } /* This may not be necessary, but it is certainly important for debugging. We check that all the gathers in the group have the same length. If they aren't, we are in trouble because we use a single vector to hold moveout information */ check_gather_consistency(gathers,nwavelets); /* Now we compute the moveout information assuming stations are in the same order in the gather for each wavelet */ if(compute_total_moveout(*gathers,stations,refsta, u,refelev,phase,moveout)) { elog_die(0,"Cannot find reference station to compute moveout: Should not happen unless program overwrites itself\n"); } if(numberpasses>0) { fprintf(MWpout,"NEWBAND %d\n",i); fflush(MWpout); } else { char ctmp[40]; fprintf(stdout,"Starting processing of first event\nSelect and options and press the Start button when ready\n"); fprintf(MWpout,"STARTUP %d %d\n", evid,i); fflush(MWpout); fgets(ctmp,40,MWpin); } ++numberpasses; /* This is placed here to allow changing the alignment options on the fly. Choice may depend on data. */ pfread(guipf,&pfcontrol); stack_alignment=get_stack_align_mode(pfcontrol); pffree(pfcontrol); /* kind of a odd loop construct here made necessary by differences in stackalignment options. If we align with theoretical value or use the vertical we do not need to repeat this loop and we fall out the bottom. If we use the pm estimate, however, we have to realign the stack rotated to the new major ellipse estimate. In that case we have to repeat the whole procedure.*/ loopback=2; do { MWstack *stack; switch(stack_alignment) { case PMTHEORY: copy_polarization(&polarization0,&polarization); loopback=0; break; case PMZ: copy_polarization(&polarz,&polarization); loopback=0; break; case PMESTIMATE: default: /* This uses theoretical version for the first pass then the estimate on the second */ if(loopback==2) copy_polarization(&polarization0, &polarization); } stack=MWcompute_arrival_times(gathers, nwavelets,timeref,moveout, polarization,swin[i], sn_ratios[i],guipf, &arrival_new,&static_result, &avgamp, &err, &ndgf); if(stack==NULL) { /* I use a flag to avoid an evil goto here */ band_exit = 1; /* This is strange but necessary to stop string of bogus errors from copy_arrival_array function when this loops back */ if(arrival_new!=NULL) freearr(arrival_new,free); arrival_new = NULL; break; } /* Note this routine updates residual static values to new values relative to the new slowness vector estimate */ ierr = estimate_slowness_vector(u0, arrival_new,stations, refsta, refelev, timeref, phase, i, &u); /* We need to recompute the moveout to now be relative to the new slowness vector estimate. We then use this for particle motion analysis which can change the polarization vector */ compute_total_moveout(*gathers,stations,refsta, u,refelev,phase,moveout); /* This segment converts particle motions for 3-c arrays. */ if(gathers[0]->ncomponents==3) { MWstack *spm; Time_Window pmtwindow; double *timeweight; /* We extract the time window from a control parameter file which is assumed to be created by a GUI with tcl/tk */ pfread(guipf,&pfcontrol); ts0=pfget_double(pfcontrol,"pm_ts0"); ts1=pfget_double(pfcontrol,"pm_ts1"); te1=pfget_double(pfcontrol,"pm_te1"); te0=pfget_double(pfcontrol,"pm_te0"); /* we need these below, not here */ sts0=pfget_double(pfcontrol,"stack_ts0"); ste0=pfget_double(pfcontrol,"stack_te0"); twin = ste0-sts0; pffree(pfcontrol); pmtwindow.tstart = nint(ts0/(stack->dt)); pmtwindow.tend = nint(te0/(stack->dt)); spm = MWextract_stack_window(stack, &pmtwindow); if(spm==NULL) elog_die(0, "Fatal error in MWextract_stack_window\n"); /* Sets time weight function for a trapezoidal window */ timeweight=MWstack_set_trapezoidal_window(spm->tstart, spm->dt,spm->nt, ts0,ts1,te1,te0); dcopy(spm->nt,timeweight,1,spm->timeweight,1); free(timeweight); MWstack_apply_timeweight(spm); if(MWcompute_array_particle_motion(gathers, nwavelets,spm,timeref,moveout, up,&pmarray,&errarray, &pm_arr,&pmerr_arr) ) { elog_complain(0,"Errors in MWcompute_array_particle_motion\n"); } avgpm = (Particle_Motion_Ellipse *)getarr(pmarray,pmtype_to_use); avgerr = (Particle_Motion_Error *)getarr(pmarray,pmtype_to_use); polarization =unit_vector_to_spherical(avgpm->major); destroy_MWstack(spm); } peakcm=stack->coherence[idamax( stack->nt, stack->coherence,1)]; copy_arrival_array(arrival_new,&arrivals); freearr(arrival_new,free); arrival_new = NULL; destroy_MWstack(stack); if(stack_alignment==PMESTIMATE) --loopback; }while(loopback>0); if(band_exit) { band_exit = 0; continue; } /* This routine computes the covariance of the estimated slowness vector */ if(compute_slowness_covariance(stations,static_result, ucovariance) ) elog_complain(0,"Problems computing slowness vector covariance estimate for evid %d and band %d\n", evid, i); /* routines below save a time window. We compute the lag corrected start time at the reference station here as t0 to simplify this in functions that need this.*/ t0 = timeref + sts0; /* This series of functions save results in a set of css3.0 extension tables. */ /* ampndgf+1 here is a cheap solution to the number of stations used in a solution. This confusion is necessary because autoediting reduces the data set. Poor planning caused me to not force this to be saved explicitly, but ampndgf is an exact surrogate. The +1 is needed because the calculation uses number_used - 1 since the average amplitude is extracted as a free parameter. */ if(MWdb_save_slowness_vector(phase,&u,t0,twin, array_name,evid,bankid,fc,fwin, ucovariance,ampndgf+1,3, coherence_type,peakcm,dbv)) dbsave_error("mwslow",evid,i); if(MWdb_save_avgamp(array_name, evid, bankid, phase, fc, t0, twin, avgamp,amperr,ampndgf, dbv) ) dbsave_error("mwavgamp",evid,i); if(MWdb_save_statics(evid, bankid, phase, fc, t0, twin,refelev,*gathers,moveout,static_result, stations,sn_ratios[i], arrivals, model_times,dbv)) dbsave_error("mwtstatic:mwastatic:mwsnr",evid,i); t0=timeref+ts0; twin = te0-ts0; if(MWdb_save_pm(array_name,evid,bankid,phase,fc,t0, twin,*gathers,moveout,pm_arr,pmerr_arr, avgpm,avgerr,dbv) ) dbsave_error("mwpm",evid,i); /* We have to release the memory held in these associative arrays. In the earlier loop the function that creates them always clears them before continuing when they are not null. The explicit NULL set after the free is done to make sure in looping back the particle motion routine clears these correctly. */ freearr(pm_arr,free); pm_arr = NULL; freearr(pmerr_arr,free); pmerr_arr = NULL; /* same for static arr */ freearr(static_result,free); static_result = NULL; } /*release main work spaces with this series of complicated free routines. Here is where you really wish C had garbage collection */ free_sn_ratios_arr(sn_ratios,nbands); free_MWtransform_arr(mwsig_arr,nbands,nwavelets); free_MWtransform_arr(mwnoise_arr,nbands,nwavelets); trdestroy(&tr); freearr(arrival0,free); freearr(arrivals,free); /* This may not be necessary, but better safe than sorry */ arrivals = NULL; arrival0 = NULL; arrival_new = NULL; } free(moveout); free(swin); free(nwin); free(refsta); }
int main (int argc, char **argv) { int c, errflg = 0; Dbptr db, tr; char *database,*outfile, *pfname=0; Flags flags ; Pf *pf,*pf_def,*pf_sta=NULL,*pf_stas; Tbl *input; char *start, *stop, *triggertimestring=NULL ; char *subset=0 ; long nrecords,nsamp1 ; int duration,nframes,sampsperframe; double tstart, tstop, triggertime=0; char sta[STA_LEN],sta1[STA_LEN]; char chan[STA_LEN],chan1[STA_LEN]; double samprate,samprate1,t1,t2; FILE *fout; size_t nw; unsigned char *hdrbuf=malloc(2040); unsigned char *framebuf=malloc(32); unsigned char *tagbuf=malloc(16); unsigned short cksum; unsigned char wfarr[3 * 12 * 100]; /*1000sps * 0.1 sec * 12 chan * 3bytes*/ int sampindex=0; K2EvtFile *myhdr=malloc(2040); K2EvtTag *mytag=malloc(sizeof(K2EvtTag)); K2EvtFrame *myframe=malloc(sizeof(K2EvtFrame)); float *data[12] ; unsigned short channelBitmap=0; int pf_serialno,pf_sensortype; double pf_sensitivity, pf_fullscale, pf_lat, pf_lon, pf_elev; memset ( &flags, 0, sizeof(flags)); elog_init ( argc, argv ) ; while ((c = getopt (argc, argv, "do:p:s:t:v")) != -1) { switch (c) { case 'd': flags.display = 1 ; break ; case 'p': pfname= optarg ; break; case 's': subset = optarg ; break ; case 't': triggertimestring = optarg ; break ; case 'v': flags.verbose++ ; break; default: errflg++; break ; } } if (errflg || argc-optind != 4) usage (); if (pfname==NULL) { pfname=Program_Name; } if (pfread (pfname, &pf) != 0) die (0, "Can't read parameter file %s\n",pfname); database = argv[optind++]; outfile = argv[optind++]; start = argv[optind++]; stop = argv[optind++]; tstart=str2epoch(start); tstop=str2epoch(stop); tstart=ceil(tstart); /* make sure we have second boundaries, this also makes sure we have a integer number of frames */ tstop=floor(tstop); duration=tstop - tstart; if ( dbopen(database, "r", &db) ) { die ( 0, "Can't open database %s", database ) ; } input = pfget_tbl (pf, "view" ) ; db = dbprocess ( db, input, 0 ) ; if (subset) { db=dbsubset(db,subset,0); } tr = dbinvalid() ; if ( trload_css ( db, start, stop, &tr, 0, 0 ) ) { die ( 1, "trload_css failed" ) ; } if ( trsplit(tr, 0, 0) ) { complain ( 0, "trsplit failed" ) ; } if ( trsplice(tr, 0, 0, 0) ) { complain ( 0, "trsplice failed" ) ; } if ( flags.display ) { trdisp (tr, "will try to convert this stuff to evt") ; } tr.record=0; dbgetv(tr,0,"time",&t1,"endtime",&t2,"sta",sta1,"chan",chan1,"samprate",&samprate1,"nsamp",&nsamp1,NULL); samprate1=round(samprate1); dbquery ( tr, dbRECORD_COUNT, &nrecords ) ; if (nrecords > 12) { printf("will only use the first 12 channels, consider modifying the subset..."); nrecords=12; } for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) { double ts,te; dbgetv(tr,0,"time",&ts,"endtime",&te,"samprate",&samprate,"sta",sta,"chan",chan,NULL); samprate=round(samprate); if (t1 != ts || t2 != te) { die ( 0, "this simplistic version only works with 101% correct times and/or subsets, sorry..." ) ; } if (strcmp(sta,sta1) !=0) { die ( 0, "%s <=> %s this simplistic version only works with ONE station, but the subset left more",sta,sta1 ) ; } if (samprate != samprate1) { die ( 0, "all channels in a K2-EVT File MUST have the same samplerate!" ); } } newFileHeader(&myhdr, pf, sta); if (parse_param (pf, "sta_defaults", P_ARRPF, 1, &pf_def) < 0) { elog_die (0, "error parsing array sta_defaults.\n"); } if (parse_param (pf, "sta_params", P_ARRPF, 1, &pf_stas) < 0) { elog_die (0, "error parsing array sta_params.\n"); } if (parse_param (pf_stas, sta, P_ARRPF, 0, &pf_sta) < 0) { elog_die (0, "error parsing sta_params{%s}\n.",sta); } if (parse_param(pf_def,"sensortype",P_LINT,1,&pf_sensortype)< 0 ) { elog_die (0, "error parsing default sensortype.\n"); } if (parse_param(pf_def,"serialno",P_LINT,1,&pf_serialno)< 0 ) { elog_die (0, "error parsing default serialno.\n"); } if (parse_param(pf_def,"sensitivity",P_DBL,1,&pf_sensitivity)< 0 ) { elog_die (0, "error parsing default sensitivity.\n"); } if (parse_param(pf_def,"fullscale",P_DBL,1,&pf_fullscale)< 0 ) { elog_die (0, "error parsing default fullscale.\n"); } if (parse_param(pf_def,"lat",P_DBL,1,&pf_lat)< 0 ) { elog_die (0, "error parsing default lat.\n"); } if (parse_param(pf_def,"lon",P_DBL,1,&pf_lon)< 0 ) { elog_die (0, "error parsing default lon.\n"); } if (parse_param(pf_def,"elev",P_DBL,1,&pf_elev)< 0 ) { elog_die (0, "error parsing default elev.\n"); } if (pf_sta==NULL) { elog_notify (0, "can't parse array sta_params{%s}, will use defaults\n.",sta); pf_sta=pf_def; } else { if (parse_param(pf_def,"sensortype",P_LINT,0,&pf_sensortype)< 0 ) { elog_die (0, "error parsing sensortype.\n"); } if (parse_param(pf_sta,"serialno",P_LINT,0,&pf_serialno)< 0 ) { elog_die (0, "error parsing serialno.\n"); } if (parse_param(pf_sta,"sensitivity",P_DBL,0,&pf_sensitivity)< 0 ) { elog_die (0, "error parsing sensitivity.\n"); } if (parse_param(pf_sta,"fullscale",P_DBL,0,&pf_fullscale)< 0 ) { elog_die (0, "error parsing fullscale.\n"); } if (parse_param(pf_sta,"lat",P_DBL,0,&pf_lat)< 0 ) { elog_die (0, "error parsing lat.\n"); } if (parse_param(pf_sta,"lon",P_DBL,0,&pf_lon)< 0 ) { elog_die (0, "error parsing lon.\n"); } if (parse_param(pf_sta,"elev",P_DBL,0,&pf_elev)< 0 ) { elog_die (0, "error parsing elev.\n"); } } myhdr->rw_stream.sps=samprate; /* sampling rate */ myhdr->rw_stream.preEvent=1; /* in seconds */ myhdr->rw_stream.postEvent=5; /* in seconds */ myhdr->rw_stream.minRunTime=6; /* in seconds */ myhdr->ro_stream.duration=duration; myhdr->ro_stream.nscans=duration* 10; myhdr->ro_stream.startTime=epoch2k2time(t1); myhdr->ro_stream.startTimeMsec=0; int ttms=0; if (triggertimestring) { triggertime=str2epoch(triggertimestring); ttms=remainder(triggertime,1.0 ) * 1000.0; triggertime=epoch2k2time(triggertime); } else { triggertime=epoch2k2time(t1)+5; ttms=0; } myhdr->ro_stream.triggerTime=triggertime; myhdr->ro_stream.triggerTimeMsec=ttms; myhdr->rw_misc.nchannels=nrecords; for (int channo=0;channo< nrecords;channo++) { myhdr->rw_channel[channo].sensitivity=pf_sensitivity; myhdr->rw_channel[channo].sensitivity=pf_fullscale; } myhdr->rw_misc.elevation=pf_elev; /* meters above sea level */ myhdr->rw_misc.latitude=pf_lat; /* degrees north */ myhdr->rw_misc.longitude=pf_lon; /* degrees east */ nframes=duration * 10; myhdr->ro_stream.duration=nframes; myhdr->ro_stream.nscans=duration*samprate; channelBitmap=chanbitmap(nrecords); for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) { unsigned long i ; int nsamp; char chan[7]; unsigned long minoffset=0; unsigned long maxoffset=0; int max=INT_MIN; int min=INT_MAX; dbgetv(tr, 0, "chan",chan,"data", &data[tr.record], "nsamp", &nsamp, NULL ) ; for ( i=0 ; i<nsamp ; i++ ) { if (data[tr.record][i] > max) { max=data[tr.record][i]; maxoffset=i; } if (data[tr.record][i] < min) { min=data[tr.record][i]; minoffset=i; } } myhdr->ro_channel[tr.record].maxPeak=max; myhdr->ro_channel[tr.record].maxPeakOffset=maxoffset; myhdr->ro_channel[tr.record].minPeak=min; myhdr->ro_channel[tr.record].minPeakOffset=minoffset; memcpy(myhdr->rw_channel[tr.record].id,chan,K2EVT_CHANNEL_ID_LENGTH); } for ( tr.record = 0 ; tr.record < nrecords ; tr.record++ ) { } newTag(&mytag,0, 2040, 0, 128,1234); encodek2header(hdrbuf,myhdr); cksum=k2_checksum(hdrbuf,2040); mytag->length=2040;/*header size*/ mytag->dataLength=0; mytag->checksum=cksum; encodek2tag(tagbuf,mytag); fout=fopen(outfile,"w+"); nw=fwrite(tagbuf,16,1,fout); nw=fwrite(hdrbuf,2040,1,fout); double t=t1 ; double k2t=round(epoch2k2time(t)); newFrameHeader(&myframe,128,(sampsperframe*3*nrecords)+32, k2t); sampsperframe=TIME2SAMP(0,samprate,0.1);/*samples per frame*/ for (int fn=0;fn < nframes;fn++) { cksum=0; sampindex=0; for (int s=0;s<sampsperframe;s++) { long val; unsigned char buf[4]; for ( int channo = 0 ; channo < nrecords ; channo++ ) { int index=((fn*sampsperframe) + s); val=round(data[channo][index]); /*debugging...*/ //val=66051;/*0x010203*/ memcpy(&buf,&val,4); val <<=8; #ifdef WORDS_BIGENDIAN cksum+=buf[1]; cksum+=buf[2]; cksum+=buf[3]; wfarr[sampindex++]=buf[1]; wfarr[sampindex++]=buf[2]; wfarr[sampindex++]=buf[3]; #else cksum+=buf[2]; cksum+=buf[1]; cksum+=buf[0]; wfarr[sampindex++]=buf[2]; wfarr[sampindex++]=buf[1]; wfarr[sampindex++]=buf[0]; #endif } } mytag->checksum=cksum; mytag->length=32;/*header size*/ mytag->dataLength=sampsperframe * nrecords * 3; myframe->frameSize=(sampsperframe*3*nrecords)+32; myframe->blockTime=round(k2t); myframe->msec=fmod(k2t,1.0) * 1000; myframe->channelBitMap=channelBitmap; encodek2Frame(framebuf,myframe); mytag->checksum+=k2_checksum(framebuf,32); encodek2tag(tagbuf,mytag); k2t+=0.1; //k2t=round((k2t+0.1)*10.0)/10.0; nw=fwrite(tagbuf,1,16,fout); if (nw!= 16) { die(0,"could not write file tag, wrote %d bytes instead of 16",nw); } nw=fwrite(framebuf,32,1,fout); nw=fwrite(&wfarr, 1,sampsperframe * 3 * nrecords, fout); } fclose(fout); tr.table = dbALL ; trfree(tr) ; pffree(pf) ; return 0; }