Changeset 106


Ignore:
Timestamp:
03/03/2009 11:50:00 AM (14 years ago)
Author:
marcus
Message:
  • removed abandoned code (formerly commented out by "#IFDEF XXX" and similar)
Location:
SH_SHM/branches/marcus/source
Files:
35 edited

Legend:

Unmodified
Added
Removed
  • SH_SHM/branches/marcus/source/cpar.c

    r105 r106  
    5050                                      /* parameters and qualifiers */ 
    5151                                      /* are numbered from 1 to N */ 
    52  
    53  
    54 #ifdef XXXYYY 
    55 int main( int argc, char *argv[] ) 
    56 { 
    57         /* local variables */ 
    58         int      i;        /* counter */ 
    59         char     *ptr;     /* string pointer */ 
    60         char     str[BC_LINELTH+1]; 
    61  
    62         /* executable code */ 
    63  
    64         pa_init( argc, argv ); 
    65  
    66         printf( "parameters\n" ); 
    67         for  (i=1; i<=pa_pnumber(); i++) 
    68                 printf( "%2d: %s\n", i, pa_pvalue(i) ); 
    69  
    70         printf( "\n%d qualifiers\n", pa_qnumber() ); 
    71  
    72         if  (pa_qspecified("-x"))  { 
    73                 ptr = pa_qvalue( "-x" ); 
    74                 if  (ptr == NULL)  { 
    75                         printf( "\n   -x (no value)\n" ); 
    76                 } else { 
    77                         printf( "\n   -x value >%s<\n", ptr ); 
    78                 } /*endif*/ 
    79         } else { 
    80                 printf( "\n   -x not specified\n" ); 
    81         } /*endif*/ 
    82  
    83         if  (pa_qspecified("-test"))  { 
    84                 ptr = pa_qvalue( "-test" ); 
    85                 if  (ptr == NULL)  { 
    86                         printf( "\n   -test (no value)\n" ); 
    87                 } else { 
    88                         printf( "\n   -test value >%s<\n", ptr ); 
    89                 } /*endif*/ 
    90         } else { 
    91                 printf( "\n   -test not specified\n" ); 
    92         } /*endif*/ 
    93  
    94         if  (pa_qunchecked(str) > 0) 
    95                 printf( "\n   %d unchecked qualifers.   first: %s\n", 
    96                         pa_qunchecked(str), str ); 
    97  
    98         return 0; 
    99  
    100 } /* end of main */ 
    101 #endif 
    102  
    10352 
    10453 
  • SH_SHM/branches/marcus/source/earthloc.c

    r16 r106  
    7373 
    7474 
    75 /* test main module */ 
    76  
    77  
    78 #ifdef XXX 
    79 int main( int argc, char *argv[] ) 
    80 { 
    81         /* local variables */ 
    82         double   slat, slon;             /* station coordinates */ 
    83         double   elat, elon;             /* epicentre coordinates */ 
    84         double   dist, azim, bazim;      /* results */ 
    85         int      feridx;                 /* FER index */ 
    86         STATUS   status;                 /* return status */ 
    87         char     fername[BC_LINELTH+1];  /* FER name */ 
    88  
    89         /* executable code */ 
    90  
    91         status = BC_NOERROR; 
    92  
    93         if  (argc != 5)  { 
    94                 printf( "*** Usage: mbdis <slat> <slon> <elat> <elon> ***\n" ); 
    95                 return 0; 
    96         } /*endif*/ 
    97  
    98         sscanf( argv[1], "%lf", &slat ); 
    99         sscanf( argv[2], "%lf", &slon ); 
    100         sscanf( argv[3], "%lf", &elat ); 
    101         sscanf( argv[4], "%lf", &elon ); 
    102  
    103         mb_locdiff( slat, slon, elat, elon, &dist, &azim, &bazim ); 
    104  
    105         printf( "   distance:     %6.2f deg\n", dist ); 
    106         printf( "   azimuth:      %6.2f deg\n", azim ); 
    107         printf( "   back-azimuth: %6.2f deg\n", bazim ); 
    108  
    109         mb_ferindex( elat, elon, &feridx, &status ); 
    110         printf( "   FER index: %d\n", feridx ); 
    111         mb_fername( feridx, BC_LINELTH, fername, &status ); 
    112         printf( "   FER name: %s\n", fername ); 
    113         return 0; 
    114  
    115 } /* end of main */ 
    116 #endif /* XXX */ 
    117  
    118 #ifdef YYY 
    119 /* second test main module */ 
    120 int main( int argc, char *argv[] ) 
    121 { 
    122         /* local variables */ 
    123         float    slo_in, az_in; 
    124         float    slo_out, az_out; 
    125         float    slo_dist, az_dist; 
    126         STATUS   status; 
    127  
    128         /* executable code */ 
    129  
    130         status = BC_NOERROR; 
    131         if  (argc != 3)  { 
    132                 printf( "*** Usage: earthloc <slo> <az> ***\n" ); 
    133                 return 0; 
    134         } /*endif*/ 
    135  
    136         sscanf( argv[1], "%f", &slo_in ); 
    137         sscanf( argv[2], "%f", &az_in ); 
    138         mb_statcorr( slo_in, az_in, &slo_out, &az_out, &slo_dist, 
    139                 &az_dist, &status ); 
    140  
    141         if  (Severe(&status))  { 
    142                 printf( "*** status code %d ***\n", status ); 
    143         } else { 
    144                 printf( "   corr: slo %5.2f,  az %6.3f\n", slo_out, az_out ); 
    145                 printf( "   dist: slo %5.2f,  az %6.3f\n", slo_dist, az_dist ); 
    146         } /*endif*/ 
    147  
    148         return 0; 
    149  
    150 } /* end of main */ 
    151 #endif /* YYY */ 
    152  
    153  
    154  
    155 /*---------------------------------------------------------------------*/ 
    156  
    157  
    158  
    15975void mb_locdiff( double slat, double slon, double elat, double elon, 
    16076        double *distance, double *azim, double *bazim ) 
     
    326242/*---------------------------------------------------------------------*/ 
    327243 
    328 #ifdef XXX 
    329  
    330 /* this is old version with old names */ 
    331  
    332 void mb_ferindex( float lat, float lon, int *feridx, STATUS *status ) 
    333  
    334 /* returns FER index from given location (lat,lon) in degrees 
    335  * 
    336  * parameters of routine 
    337  * float      lat, lon;     input; location in degrees 
    338  */ 
    339 { 
    340         /* local variables */ 
    341         int      in, ie, i, j; 
    342         float    zu, eloni, re; 
    343         FILE     *reg; 
    344         int      ferrec[IDXRECLTH]; 
    345         char     line[BC_LINELTH]; 
    346  
    347         /* executable code */ 
    348  
    349         if  (lat < -90.0 || lat > 90.0)  { 
    350                 *feridx = -1; 
    351                 *status = MBE_ILLLAT; 
    352                 return; 
    353         } else if  (lon < -180.0 || lon > 180.0)  { 
    354                 *feridx = -1; 
    355                 *status = MBE_ILLLON; 
    356                 return; 
    357         } /*endif*/ 
    358  
    359         ie = in = 0; 
    360         if  (lat < 0.0)  in = 180; 
    361         if  (lon < 0.0)  ie = 90; 
    362         lat = fabs( lat ); 
    363         lon = fabs( lon ); 
    364         zu = (float)ie + (float)in + lat + 0.0001; 
    365         i = (int)zu + 1; 
    366  
    367         eloni = lon + 0.0001; 
    368  
    369         reg = sy_fopen( mbv_indexfile, "r" ); 
    370         if  (reg == NULL)  { 
    371                 *status = MBE_OPNIDX; 
    372                 return; 
    373         } /*endif*/ 
    374         j = 1; 
    375         while  (j < i)  { 
    376                 if  (fgets( line, BC_LINELTH, reg ) == NULL)  { 
    377                         *status = MBE_EOF; 
    378                         fclose( reg ); 
    379                         return; 
    380                 } /*endif*/ 
    381                 if  (*line == '\n')  j++; 
    382         } /*endwhile*/ 
    383         fscanf( reg, "%d\n", ferrec ); 
    384         for  (j=1; j<=ferrec[0]; j++) 
    385                 fscanf( reg, "%d\n", ferrec+j ); 
    386         /* fseek( reg, (i-1)*IDXRECLTH*sizeof(int), 0 ); */ 
    387         /* fread( ferrec, sizeof(int), IDXRECLTH, reg ); */ 
    388         fclose( reg ); 
    389  
    390         j = ferrec[0]; 
    391         for  (i=2; i<j; i += 3)  { 
    392                 re = (float)(ferrec[i]) + (float)(ferrec[i+1])*0.001; 
    393                 if  (eloni < re)  { 
    394                         *feridx = ferrec[i-1]; 
    395                         break; 
    396                 } /*endif*/ 
    397         } /*endfor*/ 
    398  
    399 } /* end of mb_ferindex */ 
    400  
    401 #endif 
    402  
    403 /*---------------------------------------------------------------------*/ 
    404  
    405  
    406244 
    407245void mb_ferindex( float lat, float lon, int *feridx, STATUS *status ) 
     
    425263 
    426264/*---------------------------------------------------------------------*/ 
    427  
    428 #ifdef XXX 
    429  
    430 /* this is old version with old names */ 
    431  
    432 void mb_fername( int ferindex, int maxlth, char fername[], STATUS *status ) 
    433  
    434 /* returns name of FER 
    435  * 
    436  * parameters of routine 
    437  * int        ferindex;       input; FER index 
    438  * char       fername[];      output; FER name 
    439  * STATUS     *status;        output; return status 
    440  */ 
    441 { 
    442         /* local variables */ 
    443         FILE     *fn;      /* file pointer */ 
    444         int      slth;     /* string length */ 
    445  
    446         /* executable code */ 
    447  
    448         if  (maxlth < 79)  { 
    449                 *status = MBE_SHORTSTR; 
    450                 return; 
    451         } /*endif*/ 
    452  
    453         fn = sy_fopen( mbv_namefile, "r" ); 
    454         if  (fn == NULL)  { 
    455                 *status = MBE_OPNNAM; 
    456                 return; 
    457         } /*endif*/ 
    458  
    459         while  (ferindex-- > 0) 
    460                 fgets( fername, maxlth, fn ); 
    461  
    462         sy_fclose( fn ); 
    463  
    464         slth = (int)strlen( fername ) - 1; 
    465         if  (fername[slth] == '\n') 
    466                 fername[slth] = '\0'; 
    467  
    468 } /* end of mb_fername */ 
    469  
    470 #endif 
    471  
    472 /*---------------------------------------------------------------------*/ 
    473  
    474265 
    475266 
  • SH_SHM/branches/marcus/source/fctxmn5.h

    r16 r106  
    194194/*--------------------------------------------------------------------*/ 
    195195 
    196 #ifdef XXX 
    197 void mn5_set_shmsetup_pointer( SHT_GLOBAL_SET *ptr ); 
    198 #endif 
    199  
    200 /* special routine to set pointer to global variable of motif modules 
    201  * 
    202  * parameters of routine 
    203  * SHT_GLOBAL_SET *ptr;      input; specifies address of global paramters 
    204  */ 
    205  
    206  
    207 /*--------------------------------------------------------------------*/ 
    208  
    209196 
    210197void mn5_shmsetup( PARAM *par, STATUS *status ); 
     
    255242void mn5_fixgap( PARAM *par, STATUS *status ); 
    256243 
    257 /* removes  zeros from traces introducing a straight line  
     244/* removes  zeros from traces introducing a straight line 
    258245        connecting non-zero values 
    259246 * par 1:    trace list 
  • SH_SHM/branches/marcus/source/fctxmt.h

    r16 r106  
    297297 */ 
    298298 
    299  
    300 /*--------------------------------------------------------------------------*/ 
    301  
    302 #ifdef XXX 
    303 void mt_fft( long lx, COMPLEX cx[], REAL signi ); 
    304  
    305 /* fast fourier transformation of array "cx" of length "lx" 
    306  * Source code was transferred directly from an old-fashioned 
    307  * FORTRAN routine. 
    308  * 
    309  * parameters of routine 
    310  * long       lx;    input; length of complex array 
    311  * COMPLEX    cx[];  modify; array to be fourier transformed 
    312  * REAL       signi; input; sign of transformation 
    313  */ 
    314 #endif /* XXX */ 
    315299 
    316300/*--------------------------------------------------------------------------*/ 
     
    641625        int maxiter, REAL *pos, REAL *width, int *iter, STATUS *status ); 
    642626 
    643 /* fits a gauss function of position "*pos" and width "*width" to  
     627/* fits a gauss function of position "*pos" and width "*width" to 
    644628 * the data given in x[0..ndata-1] and y[0..ndata-]. 
    645629 * 
     
    711695 
    712696 
    713 void mt_fix_gap( SAMPLE dat[], long lth, REAL const_value, BOOLEAN konst,  
     697void mt_fix_gap( SAMPLE dat[], long lth, REAL const_value, BOOLEAN konst, 
    714698               BOOLEAN one); 
    715699 
  • SH_SHM/branches/marcus/source/fftfiltr.c

    r16 r106  
    264264 
    265265/* reads complex coefficients from file 
    266  *  
     266 * 
    267267 * parameters of routine 
    268268 * FILE       *f;       input; file pointer 
     
    13791379/*-------------------------------------------------------------------------*/ 
    13801380 
    1381 #ifdef XXX 
    1382  
    1383 static void ff_lintaper( float taper, long lth, COMPLEX dat[] ) 
    1384  
    1385 /* tapers the end of data array (linear taper) 
    1386  * 
    1387  * parameters of routine 
    1388  * float      taper;       input; taper start [0..1] 
    1389  * long       lth;         input; length of data array 
    1390  * COMPLEX    dat[];       modify; data array to be tapered 
    1391  */ 
    1392 { 
    1393         /* local variables */ 
    1394         long     start;    /* start index */ 
    1395         long     i;        /* index counter */ 
    1396         float    step;     /*  */ 
    1397         float    r;        /* scratch */ 
    1398  
    1399         /* executable code */ 
    1400  
    1401         start = Nlong( (float)lth * taper ); 
    1402         if  (start >= (lth-1))  return; 
    1403         step = 1.0 / (float)(lth-start-1); 
    1404  
    1405         for  (i=start+1; i<lth-1; i++)  { 
    1406                 r = 1.0 - (float)(i-start) * step; 
    1407                 dat[i+1].re *= r; 
    1408                 dat[i+1].im *= r; 
    1409         } /*endfor*/ 
    1410         dat[0].im = 0.0; 
    1411  
    1412 } /* end of ff_lintaper */ 
    1413  
    1414 #endif /* XXX */ 
    1415  
    1416 /*-------------------------------------------------------------------------*/ 
    1417  
    1418  
    1419  
    14201381static void ff_costaper( float taper, long lth, COMPLEX dat[] ) 
    14211382 
  • SH_SHM/branches/marcus/source/fileopen.c

    r105 r106  
    6262 
    6363 
    64  
    6564/*----------------------------------------------------------------------*/ 
    66  
    67 #ifdef XXX 
    68 int main( void ) 
    69 { 
    70         STATUS s; 
    71         char   str[200]; 
    72         int    i; 
    73  
    74         fo_readtable( "shpaths.lnt", &s ); 
    75         fo_translate( "SHC_INPUTS:s.shc", TRUE, 199, str, &i ); 
    76         while  (i == FOC_ANOTHER) 
    77                 fo_translate( "x", FALSE, 199, str, &i ); 
    78         return 0; 
    79 } 
    80 #endif 
    81  
    82  
    83 /*----------------------------------------------------------------------*/ 
    84  
    8565 
    8666 
  • SH_SHM/branches/marcus/source/foreign/sh_gse.c

    r16 r106  
    353353 
    354354        /* read date and other info from this line */ 
    355 #       ifdef XXX 
    356         strncpy( str, line+5, 4 ); 
    357         str[4] = '\0'; 
    358         sscanf( str, "%d", &(nstart.year) ); 
    359         strncpy( str, line+9, 3 ); 
    360         str[3] = '\0'; 
    361         sscanf( str, "%d", &julday ); 
    362         tc_dayofmn( nstart.year, julday, &(nstart.month), &(nstart.day), status ); 
    363         if  (Severe(status))  return; 
    364         sscanf( line+14, "%d\n%d\n%d\n%d\n%ld\n%s", 
    365                 &(nstart.hour), &(nstart.min), &(nstart.sec), &(nstart.ms), 
    366                 gsv_length+trcno, str ); 
    367 #       endif 
    368355        s = 4; 
    369356        while  (line[s] == ' ')  s++; 
  • SH_SHM/branches/marcus/source/gcf/gcflib.c

    r16 r106  
    342342/* skips data block (jumps to next header or EOF) after a raw header has been 
    343343 * read 
    344  *  
     344 * 
    345345 * parameters of routine 
    346346 * FILE          *gcf; input; GCF data input file 
     
    807807                fd->pos -= 2; 
    808808                if  (fd->pos < 0)  { 
    809 #ifdef XXX 
    810                         if  ((tdiff_start > ((-1.5)*(float)(gcfv_blk->timecorr)/TIMECORRUNIT)) 
    811                                 && gcfv_use_timecorr)  { 
    812                                 /* This may happen if the gfdfile does not contain possible time  */ 
    813                                 /* corrections of the data.  Try to fix this by positioning to    */ 
    814                                 /* a time shifted by the correction.  The samples before this time*/ 
    815                                 /* are not read.  Call this routine recursively.                  */ 
    816                                 { 
    817                                         char  newtime[cBcTimeLth+1];    /* new time position */ 
    818                                         tc_tadd( req_start, (float)(gcfv_blk->timecorr)/TIMECORRUNIT, 
    819                                                 newtime, status ); 
    820                                         if  (SySevere(status))  { 
    821                                                 fprintf( stderr, 
    822                                                         "*** GcfSearchPosition: error in time calc\n"); 
    823                                                 *status = GcfERR_BUG; 
    824                                                 return; 
    825                                         } /*endif*/ 
    826                                         fprintf( stderr, 
    827                                                 "GcfSearchPosition: try to fix time correction bug\n" ); 
    828                                         GcfSearchPosition( chan, gfdfile, stream_str, newtime, 
    829                                                 act_start, status ); 
    830                                         return; 
    831                                 } 
    832                         } else { 
    833 #endif 
    834809                                fprintf( stderr, "*** GcfSearchPosition: check gfdfile\n" ); 
    835810                                *status = GcfERR_BUG; 
    836811                                return; 
    837 #ifdef XXX 
    838                         } /*endif*/ 
    839 #endif 
    840812                } /*endif*/ 
    841813                seek_pos = (INT32)(fd->pos) * (INT32)(fd->blklth); 
     
    11251097                        GcfDecodeBlock( &rhdr, blk, blksmp, &actblksmp, status ); 
    11261098                        ON_ERROR_RETURN 
    1127 #ifdef XXX 
    1128                         if  (actblksmp != gcfv_blk->no_of_samples)  { 
    1129                                 fprintf( stderr, 
    1130                                         "*** GCF block samples: expected %d, actual: %d\n", 
    1131                                         gcfv_blk->no_of_samples, actblksmp ); 
    1132                                 if  (gcfv_decerr_abort)  { 
    1133                                         sy_deallocmem( *ldat ); 
    1134                                         *ldat = NULL; 
    1135                                         GcfFreeMem( blksmp ); 
    1136                                         GcfFreeMem( blk ); 
    1137                                         *status = SeedERR_DECODE_ERR; 
    1138                                         return; 
    1139                                 } else { 
    1140                                         INT32    zeronum;       /* number of sample to zero */ 
    1141                                         zeronum = gcfv_blk->no_of_samples; 
    1142                                         if  (zeronum > maxblksmp)  zeronum = maxblksmp; 
    1143                                         fprintf( stderr, "   zero %d samples and continue\n", zeronum ); 
    1144                                         for  (i=0; i<zeronum; i++) 
    1145                                                 blksmp[i] = 0; 
    1146                                 } /*endif*/ 
    1147                                 actblksmp = gcfv_blk->no_of_samples; 
    1148                         } /*endif*/ 
    1149 #endif 
    11501099                        lsrc = blksmp + fd->sample; 
    11511100                        actblksmp -= fd->sample; 
     
    11741123                        GcfDecodeBlock( &rhdr, blk, blksmp, &actblksmp, status ); 
    11751124                        ON_ERROR_RETURN 
    1176 #ifdef XXX 
    1177                         if  (actblksmp != gcfv_blk->no_of_samples)  { 
    1178                                 fprintf( stderr, 
    1179                                         "*** GCF block samples: expected %d, actual: %d\n", 
    1180                                         gcfv_blk->no_of_samples, actblksmp ); 
    1181                                 if  (gcfv_decerr_abort)  { 
    1182                                         sy_deallocmem( *ldat ); 
    1183                                         *ldat = NULL; 
    1184                                         GcfFreeMem( blksmp ); 
    1185                                         GcfFreeMem( blk ); 
    1186                                         *status = GcfERR_DECODE_ERR; 
    1187                                         return; 
    1188                                 } else { 
    1189                                         INT32    zeronum;       /* number of sample to zero */ 
    1190                                         zeronum = gcfv_blk->no_of_samples; 
    1191                                         if  (zeronum > maxblksmp)  zeronum = maxblksmp; 
    1192                                         fprintf( stderr, "   zero %d samples and continue\n", zeronum ); 
    1193                                         for  (i=0; i<zeronum; i++) 
    1194                                                 blksmp[i] = 0; 
    1195                                 } /*endif*/ 
    1196                                 actblksmp = gcfv_blk->no_of_samples; 
    1197                         } /*endif*/ 
    1198 #endif 
    11991125                        lsrc = blksmp; 
    12001126 
     
    12431169                                                GcfFreeMem( blksmp ); 
    12441170                                                GcfFreeMem( blk ); 
    1245                                                 fprintf( stderr,  
     1171                                                fprintf( stderr, 
    12461172                                                        "   padding aborted, %ld zeroes remaining\n", padcnt ); 
    12471173                                                return; 
  • SH_SHM/branches/marcus/source/gcf/gcftest.c

    r16 r106  
    4242 
    4343 
    44 #ifdef XXX 
    45  
    46         /* test GcfFindFileInGfd */ 
    47  
    48         GcfFindFileInGfd( stream_str, start, gfdfile, 
    49                 &fdescr, &status ); 
    50  
    51         printf( "stream %s\n", fdescr.stream ); 
    52         printf( "t_start %s\n", fdescr.t_start ); 
    53         printf( "t_end %s\n", fdescr.t_end ); 
    54         printf( "name %s\n", fdescr.name ); 
    55         printf( "gfdfile %s\n", fdescr.gfdfile ); 
    56         printf( "recno %d\n", fdescr.recno ); 
    57         printf( "pos %s\n", fdescr.pos ); 
    58         printf( "sample %s\n", fdescr.sample ); 
    59         printf( "calib %g\n", fdescr.calib ); 
    60  
    61  
    62 #endif 
    63  
    6444        /* test GcfSearchPosition */ 
    6545 
     
    7050        printf( "act_start %s\n", act_start ); 
    7151        printf( "status %d\n", status ); 
    72  
    73  
    74  
    75 #ifdef XXX 
    76  
    77         /* test GcfReadStream */ 
    78  
    79         printf( "\n" ); 
    80  
    81         GcfReadStream( 0, gfdfile, stream_str, FALSE, start, 300.0, &ldat, 
    82                 &smplth, act_start, &dt, &calib, &status ); 
    83  
    84         printf( "\n" ); 
    85         printf( "smplth %d\n", smplth ); 
    86         printf( "dt %g\n", dt ); 
    87         printf( "calib %g\n", calib ); 
    88         printf( "act_start %s\n", act_start ); 
    89         printf( "status %d\n", status ); 
    90         printf( "\n" ); 
    91         printf( "%d %d %d %d %d ...\n", ldat[0], ldat[1], ldat[2], ldat[3], ldat[4] ); 
    92  
    93 #endif 
    94  
    95  
    9652} /* end of main */ 
  • SH_SHM/branches/marcus/source/infoidx.h

    r16 r106  
    4747 
    4848/* infos stored in memory */ 
    49 #ifdef XXX 
    50 /* old values up to 15-Mar-2006 */ 
    51 #define EMAX_LONG  5 
    52 #define EMAX_INT   6 
    53 #define EMAX_BYTE  2 
    54 #define EMAX_REAL  12 
    55 #define EMAX_STR   4 
    56 #define EMAX_CHAR  4 
    57 #define EMAX_TIME  3 
    58 #define EMAX_PTR   8 
    59 #define EMAX_FLAG  16 
    60 #endif 
    61  
    6249#define EMAX_LONG  30 
    6350#define EMAX_INT   30 
     
    7158 
    7259/* info not read from file */ 
    73 #ifdef XXX 
    74 /* old values up to 15-Mar-2006 */ 
    75 #define ENF_LONG   2 
    76 #define ENF_INT    2 
    77 #define ENF_BYTE   0 
    78 #define ENF_REAL   5 
    79 #define ENF_STR    3 
    80 #define ENF_CHAR   3 
    81 #define ENF_TIME   3 
    82 #define ENF_PTR    0 
    83 #define ENF_FLAG   6 
    84 #endif 
    85  
    8660#define ENF_LONG   27 
    8761#define ENF_INT    26 
     
    348322 
    349323/* parameters of routine */ 
    350 /* MEMBLC   *ptr;           input; info block pointer */  
     324/* MEMBLC   *ptr;           input; info block pointer */ 
    351325/* unsigned ientry;         input; info entry */ 
    352326/* int      *status;        output; return status */ 
     
    361335 
    362336/* parameters of routine */ 
    363 /* MEMBLC   *ptr;           input; info block pointer */  
     337/* MEMBLC   *ptr;           input; info block pointer */ 
    364338/* unsigned ientry;         input; info entry */ 
    365339/* int      *status;        output; return status */ 
     
    374348 
    375349/* parameters of routine */ 
    376 /* MEMBLC   *ptr;           input; info block pointer */  
     350/* MEMBLC   *ptr;           input; info block pointer */ 
    377351/* unsigned ientry;         input; info entry */ 
    378352/* int      *status;        output; return status */ 
     
    387361 
    388362/* parameters of routine */ 
    389 /* MEMBLC   *ptr;           input; info block pointer */  
     363/* MEMBLC   *ptr;           input; info block pointer */ 
    390364/* unsigned ientry;         input; info entry */ 
    391365/* int      *status;        output; return status */ 
     
    400374 
    401375/* parameters of routine */ 
    402 /* MEMBLC   *ptr;           input; info block pointer */  
     376/* MEMBLC   *ptr;           input; info block pointer */ 
    403377/* unsigned ientry;         input; info entry */ 
    404378/* int          maxlth;                  input; maximum length of output string */ 
     
    415389 
    416390/* parameters of routine */ 
    417 /* MEMBLC   *ptr;           input; info block pointer */  
     391/* MEMBLC   *ptr;           input; info block pointer */ 
    418392/* unsigned ientry;         input; info entry */ 
    419393/* int      *status;        output; return status */ 
     
    428402 
    429403/* parameters of routine */ 
    430 /* MEMBLC   *ptr;           input; info block pointer */  
     404/* MEMBLC   *ptr;           input; info block pointer */ 
    431405/* unsigned ientry;         input; info entry */ 
    432406/* TIME         *time;                   output; time returned */ 
     
    442416 
    443417/* parameters of routine */ 
    444 /* MEMBLC   *ptr;           input; info block pointer */  
     418/* MEMBLC   *ptr;           input; info block pointer */ 
    445419/* unsigned ientry;         input; info entry */ 
    446420/* int      *status;        output; return status */ 
     
    455429 
    456430/* parameters of routine */ 
    457 /* MEMBLC   *ptr;           input; info block pointer */  
     431/* MEMBLC   *ptr;           input; info block pointer */ 
    458432/* unsigned ientry;         input; info entry */ 
    459433/* int      *status;        output; return status */ 
  • SH_SHM/branches/marcus/source/newgraph/memfile.c

    r16 r106  
    357357                sy_fbwrite( &r, (int)sizeof(MFC_REAL), 1L, mfv_file[id] ); 
    358358        } else { 
    359 #ifdef XXX 
    360                 mf_open( id, mfv_defswitch, "a", status ); 
    361                 if  (*status != MFE_NOERROR)  return; 
    362                 mf_writereal( id, r, status ); 
    363 #endif 
    364359                /* fprintf( stderr, "mf_writereal: ignored output for chan %d\n", id ); */ 
    365360        } /*endif*/ 
     
    403398                sy_fbwrite( &i, (int)sizeof(int), 1L, mfv_file[id] ); 
    404399        } else { 
    405 #ifdef XXX 
    406                 mf_open( id, mfv_defswitch, "a", status ); 
    407                 if  (*status != MFE_NOERROR)  return; 
    408                 mf_writeint( id, i, status ); 
    409 #endif 
    410400                /* fprintf( stderr, "mf_writeint: ignored output for chan %d\n", id ); */ 
    411401        } /*endif*/ 
     
    449439                sy_fbwrite( &l, (int)sizeof(long), 1L, mfv_file[id] ); 
    450440        } else { 
    451 #ifdef XXX 
    452                 mf_open( id, mfv_defswitch, "a", status ); 
    453                 if  (*status != MFE_NOERROR)  return; 
    454                 mf_writelong( id, l, status ); 
    455 #endif 
    456441                /* fprintf( stderr, "mf_writelong: ignored output for chan %d\n", id ); */ 
    457442        } /*endif*/ 
  • SH_SHM/branches/marcus/source/newgraph/psch.c

    r16 r106  
    7373static int     psv_strokenum=5000; /* max number of lineto's between stroke's */ 
    7474static char    psv_headerfile[BC_FILELTH+1]=PSHEADER; /* PS header file */ 
    75 #ifdef XXX 
    76 static char    psv_printfmt[BC_LINELTH+1]=  /* print command */ 
    77                                         {"lpr -P lj %s"}; 
    78 #endif 
    7975 
    8076/* prototypes of local routines */ 
     
    641637        if  (outf != NULL)  strcpy( outf, str ); 
    642638 
    643 #   ifdef XXX 
    644         /* send it to the printer */ 
    645         if  (*psv_printfmt != '\0')  { 
    646                 sprintf( cmd, psv_printfmt, str ); 
    647                 sy_system( cmd, status ); 
    648         } /*endif*/ 
    649 #   endif 
    650  
    651639        /* open PostScript file */ 
    652640        psv_pf = sy_fopen( psv_currpsf, "w" ); 
  • SH_SHM/branches/marcus/source/newgraph/psusrdef.h

    r16 r106  
    222222 
    223223#define ps_charsize(s,x,t) 
    224 #ifdef XXX 
    225 void ps_charsize( int style, float size, STATUS *status ); 
    226  
    227 /* sets character size in units of display height 
    228  * 
    229  * parameters of routine 
    230  * int        style;     input; style number 
    231  * float      size;      input; size of character in units of display height 
    232  * STATUS     *status;   output; return status 
    233  */ 
    234 #endif 
    235  
    236 /*----------------------------------------------------------------------------*/ 
    237  
    238224 
    239225#define ps_linestyle(s,l,t) 
    240 #ifdef XXX 
    241 void ps_linestyle( int style, int linestyle, STATUS *status ); 
    242  
    243 /* sets line linestyle in style block number "style" 
    244  * 
    245  * parameters of routine 
    246  * int        style;      input; style block number 
    247  * int        linestyle;  input; number of line style 
    248  * STATUS     *status;    output; return status 
    249  */ 
    250 #endif 
    251226 
    252227#define ps_linewidth(s,l,t) 
    253228 
    254 /*----------------------------------------------------------------------------*/ 
    255  
    256  
    257229#define ps_color(s,r,g,b,t) 
    258 #ifdef XXX 
    259 void ps_color( int style, float red, float green, float blue, STATUS *status ); 
    260  
    261 /* sets color of style block "style" 
    262  * 
    263  * parameters of routine 
    264  * int        style;            input; style block number 
    265  * float      red, green, blue; input; red, green and blue intensities (0..1) 
    266  * STATUS     *status;          output; return status 
    267  */ 
    268 #endif 
    269230 
    270231/*----------------------------------------------------------------------------*/ 
     
    286247 
    287248#define ps_aspectratio() 1.0 
    288 #ifdef XXX 
    289 float ps_aspectratio(); 
    290  
    291 /* returns ratio of width to height of output 
    292  * no parameters 
    293  */ 
    294 #endif 
    295  
    296 /*----------------------------------------------------------------------------*/ 
    297249 
    298250 
  • SH_SHM/branches/marcus/source/newgraph/xwch.c

    r105 r106  
    17891789                        &exact_color ); 
    17901790        } /*endif*/ 
    1791 #ifdef XXX 
    1792         if  (xstatus == 0)  { 
    1793                 *status = XWE_COLALLOC; 
    1794                 return; 
    1795         } /*endif*/ 
    1796 #endif 
    17971791        XSetForeground( xwv_dsp, xwv_gc[style], screen_color.pixel ); 
    17981792 
  • SH_SHM/branches/marcus/source/qfileio.c

    r16 r106  
    8484#define POSIDX (QFCL_POS&IDXMASK)  /* index number of position */ 
    8585#define LTHIDX (QFCL_LTH&IDXMASK)  /* index number of length */ 
    86 #ifdef XXX 
    87 /* this was not portable, K.S. 17-Mar-2006 */ 
    88 #define R_EMPTY 0xffffffffL 
    89 #endif 
    9086#define R_EMPTY     5.37531e-38 
    9187#define R_EMPTY_MIN 5.375e-38 
     
    21702166                *b++ = *(b+1); 
    21712167                *b++ = tmp; 
    2172         } /*endwhile*/  
     2168        } /*endwhile*/ 
    21732169 
    21742170} /* end of qf_dobyteswap */ 
  • SH_SHM/branches/marcus/source/qfusrdef.h

    r16 r106  
    3535#ifndef __QFUSRDEF 
    3636#define __QFUSRDEF 
    37  
    38 /* old values up to 15-Mar-2006 */ 
    39 #ifdef XXX 
    40 #define QFC_IENTRY 50   /* number of integer entries */ 
    41 #define QFC_LENTRY 20   /* number of long entries */ 
    42 #define QFC_RENTRY 50   /* number of float entries */ 
    43 #define QFC_SENTRY 30   /* number of string entries */ 
    44 #define QFC_CENTRY 16   /* number of character entries */ 
    45 #endif 
    4637 
    4738#define QFC_IENTRY 500   /* number of integer entries */ 
  • SH_SHM/branches/marcus/source/readgrn.c

    r102 r106  
    884884                if  (fstat != 0)  {*status = GRNE_TOOSHORT; return;} 
    885885        } /*endif*/ 
    886 #       ifdef XXX 
    887         if  (fstat != 0)  { /*{*status = GRNE_TOOSHORT; return;}*/ 
    888                 grn_warning( "\n--- jump: file too short" ); 
    889                 do  { 
    890                         setpos -= GRN_RECLTH; 
    891                         if  (setpos < 0)  { 
    892                                 *status = GRNE_TOOSHORT; 
    893                                 return; 
    894                         } /*endif*/ 
    895                         grn_readlog( "-" ); 
    896                         fstat = fseek( grn, setpos, 0 ); 
    897                 }  while (fstat != 0); 
    898                 grn_warning( "    jump: now found last record" ); 
    899         } /*endif*/ 
    900 #       endif 
    901886 
    902887        /* try this record */ 
     
    12421227                        diff[(*lth)++] = si; 
    12431228                        frame += 2; 
    1244 #                       ifdef XXX 
    1245                         diff[(*lth)++] = (int)grn_get2bytes( frame, swap ); 
    1246                         frame += 2; 
    1247                         diff[(*lth)++] = (int)grn_get2bytes( frame, swap ); 
    1248                         frame += 2; 
    1249 #                       endif 
    12501229                        break; 
    12511230                case 3: 
     
    12841263 
    12851264        /* executable code */ 
    1286  
    1287 #       ifdef XXX 
    1288         if  (strncmp(grnname,"gr",2) == 0 || strncmp(grnname,"GR",2) == 0)  { 
    1289                 grnname += 4; 
    1290         } else { 
    1291                 while  (isalpha(*grnname)) 
    1292                         grnname++; 
    1293         } /*endif*/ 
    1294 #       endif 
    12951265 
    12961266        slen = (int)strlen( station ); 
  • SH_SHM/branches/marcus/source/seed_io/fir_resample.c

    r16 r106  
    453453{ 
    454454        /* local variables */ 
    455 #ifdef XXX 
    456         /*------------------------------------------*/ 
    457         FILE     *fp;            /* pointer to output file */ 
    458         /*------------------------------------------*/ 
    459 #endif 
    460455        static TSyBoolean first_call=TRUE;/* first call to routine */ 
    461456        static TSyBoolean new_hdr=TRUE;   /* new header required */ 
     
    515510        /* return if this is final call */ 
    516511        if  (dat == NULL)  return; 
    517  
    518 #ifdef XXX 
    519         /*------------------------------------------*/ 
    520         /* this will be removed after testing */ 
    521         fp = fopen( "resample.dat", "a" ); 
    522         if  (fp == NULL)  { 
    523                 fprintf( stderr, "error opening test file\n" ); 
    524                 exit( 1 ); 
    525         } /*endif*/ 
    526         fprintf( fp, "LENGTH: %d\n", dat[stageno-1].lth ); 
    527         fprintf( fp, "DELTA: %e\n", stage_dt ); 
    528         fprintf( fp, "START: %s\n", outtime ); 
    529         for  (i=0; i<dat[stageno-1].lth; i++) 
    530                 fprintf( fp, "%d\n", dat[stageno-1].ptr[i] ); 
    531         fclose( fp ); 
    532         /*------------------------------------------*/ 
    533 #endif 
    534512 
    535513        /* initialize header and open output file if not yet done */ 
  • SH_SHM/branches/marcus/source/seed_io/seed_lib.c

    r105 r106  
    849849/*---------------------------------------------------------------------*/ 
    850850 
    851 #ifdef XXX 
    852  
    853 static void SeedFindFileInDatabase( char stream_str[], char start[], 
    854         char dbfile[], SeedFileDescrT *fdescr, STATUS *status ) 
    855  
    856 /* Finds SEED file in sfdb database. If no file is found the file with the 
    857  * next possible time is returned 
    858  * 
    859  * parameters of routine 
    860  * char       stream_str[];      input; stream string like "bfo-vbb-z" 
    861  * char       start[];           input; start time 
    862  * char       dbfile[];          input; DB output file 
    863  * SeedFileDescrT *fdescr;       output; SEED file descriptor 
    864  * STATUS     *status;           output; return status 
    865  */ 
    866 { 
    867         /* local variables */ 
    868         static char last_start[cBcTimeLth+1]="";  /* last start time */ 
    869         char     shellcmd[cBcVeryLongStrLth+1];   /* shell command */ 
    870         char     tmpfileb[cBcFileLth+1];          /* scratch file 2 */ 
    871         FILE     *fp;                             /* pointer to file */ 
    872         char     tmpstr[cBcShortStrLth+1];        /* scratch string */ 
    873         char     station[cBcShortStrLth+1];       /* passed station name */ 
    874         char     chan[cBcShortStrLth+1];          /* passed channel name */ 
    875         char     comp;                            /* passed component name */ 
    876         char     tstation[cBcShortStrLth+1];      /* current station name */ 
    877         char     tchan[cBcShortStrLth+1];         /* current channel name */ 
    878         char     tcomp;                           /* current component name */ 
    879         int      i;                               /* counter */ 
    880         NTIME    ntime, ntimeb;                   /* numeric read time */ 
    881         char     line[cBcLineLth+1];              /* current line of file */ 
    882         int      pathid, pathidx;                 /* path ID */ 
    883         char     relpath[cBcLineLth+1];           /* relative pathname */ 
    884         SeedFileDescrT descr, descrx;             /* Seed file descr */ 
    885         float    tdiff;                           /* time difference */ 
    886         char     *rootpath;                       /* pointer to root path */ 
    887         int      pri, prix;                       /* priority of entry */ 
    888         int      dataformat;                      /* data format (not used yet) */ 
    889         int      datea, dateb;                    /* dates of seed entry */ 
    890         double   timea, timeb;                    /* times of entry */ 
    891         int      rddate;                          /* read date as integer */ 
    892         double   rdtime;                          /* read time as double */ 
    893  
    894         /* executable code */ 
    895  
    896         /* parse stream string */ 
    897         if  (strlen(stream_str) > cBcShortStrLth)  { 
    898                 *status = SeedERR_STROVFL; 
    899                 return; 
    900         } /*endif*/ 
    901         strcpy( tmpstr, stream_str ); 
    902         ut_uncap( tmpstr ); 
    903         for  (i=0; tmpstr[i] != '\0'; i++) 
    904                 if  (tmpstr[i] == '-')  tmpstr[i] = ' '; 
    905         i = sscanf( tmpstr, "%s %s %c", station, chan, &comp ); 
    906         if  (i < 3)  comp = ' '; 
    907         if  (i < 2)  strcpy( chan , "  " ); 
    908         if  (i < 1)  strcpy( station , "   " ); 
    909  
    910         fp = fopen( dbfile, "r" ); 
    911         if  (fp == NULL)  { 
    912                 *status = SeedERR_BUG; 
    913                 err_setcontext( " ## error opening database file " ); 
    914                 err_setcontext( dbfile ); 
    915                 return; 
    916         } /*endif*/ 
    917         /* read off header */ 
    918         fgets( line, cBcLineLth, fp ); 
    919  
    920         /* read through all entries (shouldn't be more than 2) */ 
    921         descr.ufd = Seed_C_ILLEGAL; 
    922         descr.pos = 0; 
    923         descr.sample = 0; 
    924         strcpy( descr.addinf, Seed_C_EmptyAddinfStr ); 
    925         descr.sfdfile[0] = descrx.sfdfile[0] = '\0'; 
    926         descr.calib = 0.0; 
    927         pri = prix = 0; 
    928         while  (fgets(line,cBcLineLth,fp) != NULL)  { 
    929                 /* parse line read */ 
    930                 if  (sscanf(line,"%s %s %c %d %s %d %lf %d %lf %d %d %d %d %d %d %d", 
    931                         tstation,tchan,&tcomp,&pathid,relpath,&datea,&timea,&dateb,&timeb, 
    932                         &descr.recno,&descr.swap_hdr,&descr.reclth,&descr.byteoff, 
    933                         &descr.dataflags,&pri,&dataformat) != 16)  { 
    934                         *status = SeedERR_DBREAD; 
    935                         fclose( fp ); 
    936                         return; 
    937                 } /*endif*/ 
    938                 if  (strcmp(station,tstation) != 0)  continue; 
    939                 if  (strcmp(chan,tchan) != 0)  continue; 
    940                 if  (comp != tcomp )  continue; 
    941                 if  (GpGetInt(cGpI_debug_level) > 5) 
    942                         printf( "SHM-dbg6: got line %sSHM-dbg6: read times %d,%lf %d,%lf\n", 
    943                                 line, datea, timea, dateb, timeb ); 
    944                 ntime.year = datea / 10000; 
    945                 ntime.month = (datea % 10000) / 100; 
    946                 ntime.day = datea % 100; 
    947                 ntime.hour = Nint( timea / 10000.0 - 0.499 ); 
    948                 timea -= (double)ntime.hour*10000.0; 
    949                 ntime.min = Nint( timea / 100.0 - 0.499 ); 
    950                 timea -= (double)ntime.min*100.0; 
    951                 ntime.sec = Nint( timea - 0.499 ); 
    952                 timea -= (double)ntime.sec; 
    953                 ntime.ms = Nint( timea*1000.0 ); 
    954                 if  (GpGetInt(cGpI_debug_level) > 5) 
    955                         printf( "SHM-dbg6: start ntime: %d,%d,%d,%d,%d,%d,%d\n", ntime.year, 
    956                                 ntime.month, ntime.day, ntime.hour, ntime.min, ntime.sec, ntime.ms); 
    957                 tc_n2t( &ntime, descr.t_start, status ); 
    958                 if  (SySevere(status))  {fclose(fp); return;} 
    959                 ntime.year = dateb / 10000; 
    960                 ntime.month = (dateb % 10000) / 100; 
    961                 ntime.day = dateb % 100; 
    962                 ntime.hour = Nint( timeb / 10000.0 - 0.499 ); 
    963                 timeb -= (double)ntime.hour*10000.0; 
    964                 ntime.min = Nint( timeb / 100.0 - 0.499 ); 
    965                 timeb -= (double)ntime.min*100.0; 
    966                 ntime.sec = Nint( timeb - 0.499 ); 
    967                 timeb -= (double)ntime.sec; 
    968                 ntime.ms = Nint( timeb*1000.0 ); 
    969                 if  (GpGetInt(cGpI_debug_level) > 5) 
    970                         printf( "SHM-dbg6: start ntime: %d,%d,%d,%d,%d,%d,%d\n", ntime.year, 
    971                                 ntime.month, ntime.day, ntime.hour, ntime.min, ntime.sec, ntime.ms); 
    972                 tc_n2t( &ntime, descr.t_end, status ); 
    973                 if  (SySevere(status))  {fclose(fp); return;} 
    974                 if  (strlen(station)+strlen(chan)+3 > cBcShortStrLth)  { 
    975                         *status = SeedERR_STROVFL; 
    976                         return; 
    977                 } /*endif*/ 
    978                 /* database list may contain files which do not match the requested time */ 
    979                 /* if priority is lower than the one we have, ignore entry */ 
    980                 if  (pri < prix)  continue; 
    981                 /* if we already have a matching entry, compare with this here */ 
    982                 if  (descrx.sfdfile[0] != '\0')  { 
    983                         /* take the one with earlier start time */ 
    984                         tdiff = tc_tdiff( descr.t_start, descrx.t_start, status ); 
    985                         if  (SySevere(status))  return; 
    986                         if  (tdiff > 0.0)  continue; 
    987                 } /*endif*/ 
    988                 sprintf( descr.stream, "%s-%s-%c", station, chan, comp ); 
    989                 strcpy( descr.name, relpath ); 
    990                 strcpy( descr.sfdfile, "db:" ); 
    991                 descrx = descr; 
    992                 prix = pri; 
    993                 pathidx = pathid; 
    994         } /*endfor*/ 
    995  
    996         fclose( fp ); 
    997  
    998         if  (descrx.sfdfile[0] == '\0')  { 
    999                 *status = SeedERR_SFD_NOTFOUND; 
    1000                 return; 
    1001         } /*endif*/ 
    1002         descr = descrx; 
    1003         strcpy( relpath, descr.name ); 
    1004         pathid = pathidx; 
    1005  
    1006         /* now find absolute path, first look in cache */ 
    1007         rootpath = SeedGetRootPath( pathid ); 
    1008         if  (rootpath == NULL)  { 
    1009                 /* second temporary file */ 
    1010                 i = 1; 
    1011                 FOREVER  { 
    1012                         sprintf( tmpfileb, "/tmp/sfdb_read_b_%d.000", i++ ); 
    1013                         fp = fopen( tmpfileb, "r" ); 
    1014                         if  (fp == NULL)  break; 
    1015                         fclose( fp ); 
    1016                 } /*endfor*/ 
    1017                 /* create empty file to reserve name */ 
    1018                 fp = fopen( tmpfileb, "w" ); 
    1019                 fclose( fp ); 
    1020                 /* not in cache, get it from database */ 
    1021                 sprintf( shellcmd, 
    1022                         "\\rm %s; %s %s \"select rootpath from pathtab where id = \'%d\'\" >%s", 
    1023                         tmpfileb, GpGetString(cGpS_sfdb_command), 
    1024                         GpGetString(cGpS_sfdb_exec_qual), pathid, tmpfileb ); 
    1025                 /*printf( "--> executing %s\n", shellcmd );*/ 
    1026                 system( shellcmd ); 
    1027  
    1028                 /* read output file */ 
    1029                 fp = fopen( tmpfileb, "r" ); 
    1030                 if  (fp == NULL)  { 
    1031                         *status = SeedERR_BUG; 
    1032                         err_setcontext( " ## error opening scratch file" ); 
    1033                         return; 
    1034                 } /*endif*/ 
    1035                 /* read off header */ 
    1036                 fgets( line, cBcLineLth, fp ); 
    1037                 fgets( descr.name, cBcFileLth, fp ); 
    1038                 i = strlen( descr.name ); 
    1039                 if  (i > 0 && descr.name[i-1] == '\n')  descr.name[i-1] = '\0'; 
    1040                 fclose( fp ); 
    1041                 /* put it to cache */ 
    1042                 SeedCacheRootPath( pathid, descr.name, status ); 
    1043                 sy_fdelete( tmpfileb ); 
    1044         } else { 
    1045                 strcpy( descr.name, rootpath ); 
    1046         } /*endif*/ 
    1047  
    1048         strcat( descr.name, "/" ); 
    1049         strcat( descr.name, relpath ); 
    1050  
    1051         if  (strlen(start) > cBcTimeLth)  { 
    1052                 *status = SeedERR_BUG; 
    1053                 err_setcontext( " ## time tring too long" ); 
    1054                 return; 
    1055         } /*endif*/ 
    1056  
    1057         descr.calib = SeedFindStreamCalibration( descr.stream, start, status ); 
    1058         if  (*status == SeedERR_NOCALIB)  { 
    1059                 *status = cBcNoError; 
    1060                 descr.dataflags |= Seed_F_QUAL_NOCALIB; 
    1061         } /*endif*/ 
    1062         if  (seedv_invert_swap_hdr)  descr.swap_hdr = ! descr.swap_hdr; 
    1063         *fdescr = descr; 
    1064  
    1065 } /* end of SeedFindFileInDatabase */ 
    1066  
    1067 #endif 
    1068  
    1069 /*---------------------------------------------------------------------*/ 
    1070  
    1071 #ifdef XXX 
    1072  
    1073 static void SeedFindFileInDatabaseOld( char stream_str[], char start[], 
    1074         SeedFileDescrT *fdescr, STATUS *status ) 
    1075  
    1076 /* Finds SEED file in sfdb database. If no file is found the file with the 
    1077  * next possible time is returned 
    1078  * 
    1079  * parameters of routine 
    1080  * char       stream_str[];      input; stream string like "bfo-vbb-z" 
    1081  * char       start[];           input; start time 
    1082  * char       sfdfile[];         input; SEED file directory 
    1083  * SeedFileDescrT *fdescr;       output; SEED file descriptor 
    1084  * STATUS     *status;           output; return status 
    1085  */ 
    1086 { 
    1087         /* local variables */ 
    1088         static char last_start[cBcTimeLth+1]="";  /* last start time */ 
    1089         char     shellcmd[cBcVeryLongStrLth+1];   /* shell command */ 
    1090         char     tmpfileb[cBcFileLth+1];          /* scratch file 2 */ 
    1091         FILE     *fp;                             /* pointer to file */ 
    1092         char     tmpstr[cBcShortStrLth+1];        /* scratch string */ 
    1093         char     station[cBcShortStrLth+1];       /* passed station name */ 
    1094         char     chan[cBcShortStrLth+1];          /* passed channel name */ 
    1095         char     comp;                            /* passed component name */ 
    1096         char     tstation[cBcShortStrLth+1];      /* current station name */ 
    1097         char     tchan[cBcShortStrLth+1];         /* current channel name */ 
    1098         char     tcomp;                           /* current component name */ 
    1099         int      i;                               /* counter */ 
    1100         NTIME    ntime, ntimeb;                   /* numeric read time */ 
    1101         char     line[cBcLineLth+1];              /* current line of file */ 
    1102         int      pathid, pathidx;                 /* path ID */ 
    1103         char     relpath[cBcLineLth+1];           /* relative pathname */ 
    1104         SeedFileDescrT descr, descrx;             /* Seed file descr */ 
    1105         float    tdiff;                           /* time difference */ 
    1106         char     *rootpath;                       /* pointer to root path */ 
    1107         int      pri, prix;                       /* priority of entry */ 
    1108         int      dataformat;                      /* data format (not used yet) */ 
    1109 #ifdef USE_DATETIME 
    1110         char     datea[cBcShortStrLth+1];         /* date 1 */ 
    1111         char     timea[cBcShortStrLth+1];         /* time 1 */ 
    1112         int      msa;                             /* millisecs 1 */ 
    1113         char     dateb[cBcShortStrLth+1];         /* date 2 */ 
    1114         char     timeb[cBcShortStrLth+1];         /* time 2 */ 
    1115         int      msb;                             /* millisecs 2 */ 
    1116 #else 
    1117         int      datea, dateb;                    /* dates of seed entry */ 
    1118         double   timea, timeb;                    /* times of entry */ 
    1119         int      rddate;                          /* read date as integer */ 
    1120         double   rdtime;                          /* read time as double */ 
    1121 #endif 
    1122  
    1123         /* executable code */ 
    1124  
    1125         /* parse stream string */ 
    1126         if  (strlen(stream_str) > cBcShortStrLth)  { 
    1127                 *status = SeedERR_STROVFL; 
    1128                 return; 
    1129         } /*endif*/ 
    1130         strcpy( tmpstr, stream_str ); 
    1131         ut_uncap( tmpstr ); 
    1132         for  (i=0; tmpstr[i] != '\0'; i++) 
    1133                 if  (tmpstr[i] == '-')  tmpstr[i] = ' '; 
    1134         i = sscanf( tmpstr, "%s %s %c", station, chan, &comp ); 
    1135         if  (i < 3)  comp = ' '; 
    1136         if  (i < 2)  strcpy( chan , "  " ); 
    1137         if  (i < 1)  strcpy( station , "   " ); 
    1138  
    1139         /* static temporary file, create if no call to db before */ 
    1140         if  (last_start[0] == '\0')  { 
    1141                 i = 1; 
    1142                 FOREVER  { 
    1143                         sprintf( seedv_sfdb_tmp, "/tmp/sfdb_read_a_%d.000", i++ ); 
    1144                         fp = fopen( seedv_sfdb_tmp, "r" ); 
    1145                         if  (fp == NULL)  break; 
    1146                         fclose( fp ); 
    1147                 } /*endfor*/ 
    1148                 /* create empty file to reserve name */ 
    1149                 fp = fopen( seedv_sfdb_tmp, "w" ); 
    1150                 fclose( fp ); 
    1151         } /*endif*/ 
    1152  
    1153         /* convert time to numeric format */ 
    1154         tc_t2n( start, &ntime, status ); 
    1155         if  (SySevere(status))  return; 
    1156         tc_nadd( &ntime, 1.0, &ntimeb, status ); 
    1157         if  (SySevere(status))  return; 
    1158  
    1159         if  (strcmp(start,last_start) != 0)  { 
    1160                 /* call to db if new start time given */ 
    1161 #ifdef USE_DATETIME 
    1162                 sprintf( shellcmd, 
    1163                         "\\rm %s; %s %s \"select * from sftab where stime <= \'%4d-%02d-%02d %02d:%02d:%02d\' and etime >= \'%4d-%02d-%02d %02d:%02d:%02d\'\" >%s", 
    1164                         seedv_sfdb_tmp, GpGetString(cGpS_sfdb_command), GpGetString(cGpS_sfdb_exec_qual), 
    1165                         ntime.year, ntime.month, ntime.day, 
    1166                         ntime.hour, ntime.min, ntime.sec, ntimeb.year, ntimeb.month, ntimeb.day, 
    1167                         ntimeb.hour, ntimeb.min, ntimeb.sec, seedv_sfdb_tmp ); 
    1168 #else 
    1169                 rddate = ntime.year*10000 + ntime.month*100 + ntime.day; 
    1170                 rdtime = (double)ntime.hour*10000.0 + (double)ntime.min*100.0 
    1171                         + (double)ntime.sec + (double)ntime.ms/1000.0; 
    1172                 sprintf( shellcmd, 
    1173                         "\\rm %s; %s %s \"select * from sftab where ((sdate < %d) OR (sdate = %d AND stime <= %10.3f)) AND ((%d < edate) OR (%d = edate AND %10.3f <= etime))\" >%s", 
    1174                         seedv_sfdb_tmp, GpGetString(cGpS_sfdb_command), 
    1175                         GpGetString(cGpS_sfdb_exec_qual), rddate, rddate, rdtime, rddate, 
    1176                         rddate, rdtime, seedv_sfdb_tmp ); 
    1177 #endif 
    1178                 if  (GpGetInt(cGpI_debug_level) > 3) 
    1179                         printf( "SH-dbg4: executing %s\n", shellcmd ); 
    1180                 system( shellcmd ); 
    1181                 strcpy( last_start, start ); 
    1182         } /*endif*/ 
    1183  
    1184         fp = fopen( seedv_sfdb_tmp, "r" ); 
    1185         if  (fp == NULL)  { 
    1186                 *status = SeedERR_BUG; 
    1187                 err_setcontext( " ## error opening scratch file " ); 
    1188                 err_setcontext( seedv_sfdb_tmp ); 
    1189                 return; 
    1190         } /*endif*/ 
    1191         /* read off header */ 
    1192         fgets( line, cBcLineLth, fp ); 
    1193  
    1194         /* read through all entries (shouldn't be more than 2) */ 
    1195         descr.ufd = Seed_C_ILLEGAL; 
    1196         descr.pos = 0; 
    1197         descr.sample = 0; 
    1198         strcpy( descr.addinf, Seed_C_EmptyAddinfStr ); 
    1199         descr.sfdfile[0] = descrx.sfdfile[0] = '\0'; 
    1200         descr.calib = 0.0; 
    1201         pri = prix = 0; 
    1202         while  (fgets(line,cBcLineLth,fp) != NULL)  { 
    1203                 /* parse line read */ 
    1204 #ifdef USE_DATETIME 
    1205                 if  (sscanf(line,"%s %s %c %d %s %s %s %d %s %s %d %d %d %d %d %d %d", 
    1206                         tstation,tchan,&tcomp,&pathid,relpath,datea,timea,&msa,dateb,timeb, 
    1207                         &msb,&descr.recno,&descr.swap_hdr,&descr.reclth,&descr.byteoff, 
    1208                         &descr.dataflags,&pri) != 17)  { 
    1209                         *status = SeedERR_DBREAD; 
    1210                         fclose( fp ); 
    1211                         return; 
    1212                 } /*endif*/ 
    1213 #else 
    1214                 if  (sscanf(line,"%s %s %c %d %s %d %lf %d %lf %d %d %d %d %d %d %d", 
    1215                         tstation,tchan,&tcomp,&pathid,relpath,&datea,&timea,&dateb,&timeb, 
    1216                         &descr.recno,&descr.swap_hdr,&descr.reclth,&descr.byteoff, 
    1217                         &descr.dataflags,&pri,&dataformat) != 16)  { 
    1218                         *status = SeedERR_DBREAD; 
    1219                         fclose( fp ); 
    1220                         return; 
    1221                 } /*endif*/ 
    1222 #endif 
    1223                 if  (strcmp(station,tstation) != 0)  continue; 
    1224                 if  (strcmp(chan,tchan) != 0)  continue; 
    1225                 if  (comp != tcomp )  continue; 
    1226                 if  (GpGetInt(cGpI_debug_level) > 5) 
    1227                         printf( "SHM-dbg6: got line %sSHM-dbg6: read times %d,%lf %d,%lf\n", 
    1228                                 line, datea, timea, dateb, timeb ); 
    1229 #ifdef USE_DATETIME 
    1230                 /* change '-'s to '/'s in dates, so that tc_... routines can read it */ 
    1231                 for  (i=0; datea[i] != '\0'; i++) 
    1232                         if  (datea[i] == '-')  datea[i] = '/'; 
    1233                 for  (i=0; dateb[i] != '\0'; i++) 
    1234                         if  (dateb[i] == '-')  dateb[i] = '/'; 
    1235                 sprintf( descr.t_start, "%s_%s", datea, timea ); 
    1236                 sprintf( descr.t_end, "%s_%s", dateb, timeb ); 
    1237                 /* add the milliseconds, which were not used in DB search */ 
    1238                 tc_tadd( descr.t_start, (float)msa/1000.0, descr.t_start, status ); 
    1239                 if  (SySevere(status))  {fclose(fp); return;} 
    1240                 tc_tadd( descr.t_end, (float)msb/1000.0, descr.t_end, status ); 
    1241                 if  (SySevere(status))  {fclose(fp); return;} 
    1242                 tdiff = tc_tdiff( start, descr.t_start, status ); 
    1243                 if  (SySevere(status))  {fclose(fp); return;} 
    1244                 if  (tdiff < 0.0)  continue;  /* then the milliseconds didn't match */ 
    1245                 tdiff = tc_tdiff( descr.t_end, start, status ); 
    1246                 if  (SySevere(status))  {fclose(fp); return;} 
    1247                 if  (tdiff < 0.0)  continue;  /* then the milliseconds didn't match */ 
    1248 #else 
    1249                 ntime.year = datea / 10000; 
    1250                 ntime.month = (datea % 10000) / 100; 
    1251                 ntime.day = datea % 100; 
    1252                 ntime.hour = Nint( timea / 10000.0 - 0.499 ); 
    1253                 timea -= (double)ntime.hour*10000.0; 
    1254                 ntime.min = Nint( timea / 100.0 - 0.499 ); 
    1255                 timea -= (double)ntime.min*100.0; 
    1256                 ntime.sec = Nint( timea - 0.499 ); 
    1257                 timea -= (double)ntime.sec; 
    1258                 ntime.ms = Nint( timea*1000.0 ); 
    1259                 if  (GpGetInt(cGpI_debug_level) > 5) 
    1260                         printf( "SHM-dbg6: start ntime: %d,%d,%d,%d,%d,%d,%d\n", ntime.year, 
    1261                                 ntime.month, ntime.day, ntime.hour, ntime.min, ntime.sec, ntime.ms); 
    1262                 tc_n2t( &ntime, descr.t_start, status ); 
    1263                 if  (SySevere(status))  {fclose(fp); return;} 
    1264                 ntime.year = dateb / 10000; 
    1265                 ntime.month = (dateb % 10000) / 100; 
    1266                 ntime.day = dateb % 100; 
    1267                 ntime.hour = Nint( timeb / 10000.0 - 0.499 ); 
    1268                 timeb -= (double)ntime.hour*10000.0; 
    1269                 ntime.min = Nint( timeb / 100.0 - 0.499 ); 
    1270                 timeb -= (double)ntime.min*100.0; 
    1271                 ntime.sec = Nint( timeb - 0.499 ); 
    1272                 timeb -= (double)ntime.sec; 
    1273                 ntime.ms = Nint( timeb*1000.0 ); 
    1274                 if  (GpGetInt(cGpI_debug_level) > 5) 
    1275                         printf( "SHM-dbg6: start ntime: %d,%d,%d,%d,%d,%d,%d\n", ntime.year, 
    1276                                 ntime.month, ntime.day, ntime.hour, ntime.min, ntime.sec, ntime.ms); 
    1277                 tc_n2t( &ntime, descr.t_end, status ); 
    1278                 if  (SySevere(status))  {fclose(fp); return;} 
    1279 #endif 
    1280                 if  (strlen(station)+strlen(chan)+3 > cBcShortStrLth)  { 
    1281                         *status = SeedERR_STROVFL; 
    1282                         return; 
    1283                 } /*endif*/ 
    1284                 /* if priority is lower than the one we have, ignore entry */ 
    1285                 if  (pri < prix)  continue; 
    1286                 /* if we already have a matching entry, compare with this here */ 
    1287                 if  (descrx.sfdfile[0] != '\0')  { 
    1288                         /* take the one with earlier start time */ 
    1289                         tdiff = tc_tdiff( descr.t_start, descrx.t_start, status ); 
    1290                         if  (SySevere(status))  return; 
    1291                         if  (tdiff > 0.0)  continue; 
    1292                 } /*endif*/ 
    1293                 sprintf( descr.stream, "%s-%s-%c", station, chan, comp ); 
    1294                 strcpy( descr.name, relpath ); 
    1295                 strcpy( descr.sfdfile, "db:" ); 
    1296                 descrx = descr; 
    1297                 prix = pri; 
    1298                 pathidx = pathid; 
    1299         } /*endfor*/ 
    1300  
    1301         fclose( fp ); 
    1302  
    1303         if  (descrx.sfdfile[0] == '\0')  { 
    1304                 *status = SeedERR_SFD_NOTFOUND; 
    1305                 return; 
    1306         } /*endif*/ 
    1307         descr = descrx; 
    1308         strcpy( relpath, descr.name ); 
    1309         pathid = pathidx; 
    1310  
    1311         /* now find absolute path, first look in cache */ 
    1312         rootpath = SeedGetRootPath( pathid ); 
    1313         if  (rootpath == NULL)  { 
    1314                 /* second temporary file */ 
    1315                 i = 1; 
    1316                 FOREVER  { 
    1317                         sprintf( tmpfileb, "/tmp/sfdb_read_b_%d.000", i++ ); 
    1318                         fp = fopen( tmpfileb, "r" ); 
    1319                         if  (fp == NULL)  break; 
    1320                         fclose( fp ); 
    1321                 } /*endfor*/ 
    1322                 /* create empty file to reserve name */ 
    1323                 fp = fopen( tmpfileb, "w" ); 
    1324                 fclose( fp ); 
    1325                 /* not in cache, get it from database */ 
    1326                 sprintf( shellcmd, 
    1327                         "\\rm %s; %s %s \"select rootpath from pathtab where id = \'%d\'\" >%s", 
    1328                         tmpfileb, GpGetString(cGpS_sfdb_command), 
    1329                         GpGetString(cGpS_sfdb_exec_qual), pathid, tmpfileb ); 
    1330                 /*printf( "--> executing %s\n", shellcmd );*/ 
    1331                 system( shellcmd ); 
    1332  
    1333                 /* read output file */ 
    1334                 fp = fopen( tmpfileb, "r" ); 
    1335                 if  (fp == NULL)  { 
    1336                         *status = SeedERR_BUG; 
    1337                         err_setcontext( " ## error opening scratch file" ); 
    1338                         return; 
    1339                 } /*endif*/ 
    1340                 /* read off header */ 
    1341                 fgets( line, cBcLineLth, fp ); 
    1342                 fgets( descr.name, cBcFileLth, fp ); 
    1343                 i = strlen( descr.name ); 
    1344                 if  (i > 0 && descr.name[i-1] == '\n')  descr.name[i-1] = '\0'; 
    1345                 fclose( fp ); 
    1346                 /* put it to cache */ 
    1347                 SeedCacheRootPath( pathid, descr.name, status ); 
    1348                 sy_fdelete( tmpfileb ); 
    1349         } else { 
    1350                 strcpy( descr.name, rootpath ); 
    1351         } /*endif*/ 
    1352  
    1353         strcat( descr.name, "/" ); 
    1354         strcat( descr.name, relpath ); 
    1355  
    1356         if  (strlen(start) > cBcTimeLth)  { 
    1357                 *status = SeedERR_BUG; 
    1358                 err_setcontext( " ## time tring too long" ); 
    1359                 return; 
    1360         } /*endif*/ 
    1361  
    1362         descr.calib = SeedFindStreamCalibration( descr.stream, start, status ); 
    1363         if  (*status == SeedERR_NOCALIB)  { 
    1364                 *status = cBcNoError; 
    1365                 descr.dataflags |= Seed_F_QUAL_NOCALIB; 
    1366         } /*endif*/ 
    1367         if  (seedv_invert_swap_hdr)  descr.swap_hdr = ! descr.swap_hdr; 
    1368         *fdescr = descr; 
    1369  
    1370 } /* end of SeedFindFileInDatabaseOld */ 
    1371  
    1372 #endif 
    1373  
    1374 /*---------------------------------------------------------------------*/ 
    1375  
    1376  
    1377851 
    1378852void SeedSearchPosition( int chan, char sfdfile[], char stream_str[], 
     
    21231597 
    21241598 
    2125 /* #ifdef XXX */ 
    2126  
    21271599#define BUFLTH 4096 
    21281600/* should be enough for decoding one record */ 
     
    23061778#undef FREE_AND_RETURN 
    23071779 
    2308 /* #endif */ 
    23091780 
    23101781/*---------------------------------------------------------------------*/ 
     
    25522023                                                recsmp[i] = 0; 
    25532024                                } /*endif*/ 
    2554 #                               ifdef XXX 
    2555                                 /* excluded this on 1-Jul-98, K.S. */ 
    2556                                 fd->sample = 0; 
    2557                                 fprintf( stderr, 
    2558                                         "   read position within zeroed record set to zero\n" ); 
    2559 #                               endif 
    25602025                                actrecsmp = seedv_rec->no_of_samples; 
    25612026                        } /*endif*/ 
     
    33412806        if  (!seedv_warnings)  return; 
    33422807 
    3343 #ifdef XXX 
    3344         i = 0; 
    3345         while  (i < cBcLineLth && text[i] != '\0')  { 
    3346                 if  ((text[i] >= ' ' && text[i] <= 'z') || text[i] == '\n')  { 
    3347                         str[i] = text[i]; 
    3348                 } else { 
    3349                         str[i] = '.'; 
    3350                 } /*endif*/ 
    3351                 i++; 
    3352         } /*endwhile*/ 
    3353         str[i] = '\0'; 
    3354  
    3355         fprintf( stderr, "%s", str ); 
    3356 #endif 
    33572808        fprintf( stderr, "%s", text ); 
    33582809 
  • SH_SHM/branches/marcus/source/seed_io/seed_tidy.c

    r105 r106  
    397397        qsort( dsc, dsclth, sizeof(SeedFileDescrT), &TdQsortCompare ); 
    398398 
    399 #ifdef XXX 
    400  
    401         do  { 
    402                 again = FALSE; 
    403                 for  (i=1; i<dsclth; i++)  { 
    404                         tdiff = tc_tdiff( dsc[i].t_start, dsc[i-1].t_start, status ); 
    405                         if  (Severe(status))  return; 
    406                         if  (tdiff < 0.0)  { 
    407                                 /* exchange i and i-1 and set again */ 
    408                                 xdsc = dsc[i-1]; 
    409                                 dsc[i-1] = dsc[i]; 
    410                                 dsc[i] = xdsc; 
    411                                 again = TRUE; 
    412                         } /*endif*/ 
    413                 } /*endfor*/ 
    414         }  while  (again); 
    415  
    416 #endif 
    417  
    418399} /* end of TdSortSfdList */ 
    419400 
     
    676657                } /*endif*/ 
    677658                SeedStoreReclth( (SeedDataHeaderT *)tdv_seedrec, dsc->reclth ); 
    678 #ifdef XXX 
    679                 if  (F_LINUXDATA & flags)  { 
    680                         SeedSwapHeader( (SeedDataHeaderT *)tdv_seedrec ); 
    681                 } /*endif*/ 
    682 #endif 
    683659                TdPutRecord( tdv_seedrec, flags ); 
    684660        } /*endif*/ 
  • SH_SHM/branches/marcus/source/seed_io/seedquickdump.c

    r47 r106  
    237237                if  (seedhdr->first != 0)  { 
    238238                        donly = (SeedDataOnlyBlocketteT *)(seedrec+(seedhdr->first)); 
    239 #ifdef XXX 
    240                         /* this is done in SeedSwapHeader now */ 
    241                         if  (sfd_swap_hdr)  { 
    242                                 tmp = (UWORD)(donly->block_id); 
    243                                 donly->block_id = (tmp & 0xff) * 0x100; 
    244                                 donly->block_id += (UWORD)(tmp & 0xff00) / (UWORD)0x100; 
    245                                 tmp = (UWORD)(donly->next_block); 
    246                                 donly->next_block = (tmp & 0xff) * 0x100; 
    247                                 donly->next_block += (UWORD)(tmp & 0xff00) / (UWORD)0x100; 
    248                         } /*endif*/ 
    249 #endif 
    250239                        b1000found = (donly->block_id == 1000); 
    251240                        if  (b1000found && donly->next_block > 0)  { 
    252241                                dext = (SeedDataExtBlocketteT *)(seedrec+(donly->next_block)); 
    253 #ifdef XXX 
    254                                 /* this is done in SeedSwapHeader now */ 
    255                                 if  (sfd_swap_hdr)  { 
    256                                         tmp = (UWORD)(dext->block_id); 
    257                                         dext->block_id = (tmp & 0xff) * 0x100; 
    258                                         dext->block_id += (UWORD)(tmp & 0xff00) / (UWORD)0x100; 
    259                                 } /*endif*/ 
    260 #endif 
    261242                                if  (dext->block_id == 1001)  { 
    262243                                        time_quality = dext->timequal; 
     
    334315        fclose( fp ); 
    335316        return 0; 
    336  
    337 #ifdef XXX 
    338  
    339  
    340         /* get length of file */ 
    341         fseek( fp, 0, 2 ); 
    342         fsize = ftell( fp ) - byteoff; 
    343         if  (fsize % recsize != 0)  { 
    344                 fprintf( stderr, "*** %s: illegal size %ld bytes of SEED file %s\n", 
    345                         pa_progname(), fsize, seedfile ); 
    346                 fclose( fp ); 
    347                 fclose( out ); 
    348                 return 1 ; 
    349         } /*endif*/ 
    350         sfd_recno = (int)(fsize / (long)recsize); 
    351  
    352         /* get last record */ 
    353         fseek( fp, 
    354                 (long)(sfd_recno-1)*(long)recsize + (long)byteoff, 0 ); 
    355         read_ret = (int)fread( (char *)seedrec, recsize, 1, fp ); 
    356         if  (read_ret != 1)  { 
    357                 fprintf( stderr, "*** %s: read error on file %s (end)\n", 
    358                         pa_progname(), seedfile ); 
    359                 fclose( fp ); 
    360                 fclose( out ); 
    361                 return 1; 
    362         } /*endif*/ 
    363         seedhdr = (SeedDataHeaderT *)seedrec; 
    364         if  (SeedSwapNecessary(seedhdr))  SeedSwapHeader(seedhdr); 
    365         errcnt = 0; 
    366         SeedBtimeToNtime( &(seedhdr->starttime), &ntime, &status ); 
    367         while  (Severe(&status))  { 
    368                 errcnt++; 
    369                 fprintf( stderr, 
    370                         "%s: unreadable last record, take %d before in file %s\n", 
    371                         pa_progname(), errcnt, seedfile ); 
    372                 status = BC_NOERROR; 
    373                 /* get previous record */ 
    374                 sfd_recno--; 
    375                 fseek( fp, 
    376                         (long)(sfd_recno-1)*(long)recsize + (long)byteoff, 
    377                         0 ); 
    378                 read_ret = (int)fread( (char *)seedrec, recsize, 1, fp); 
    379                 if  (read_ret != 1)  { 
    380                         fprintf( stderr, "%s: read error on file %s (end)\n", 
    381                                 pa_progname(), seedfile ); 
    382                         fclose( fp ); 
    383                         fclose( out ); 
    384                         return 1; 
    385                 } /*endif*/ 
    386                 seedhdr = (SeedDataHeaderT *)seedrec; 
    387                 if  (SeedSwapNecessary(seedhdr))  SeedSwapHeader(seedhdr); 
    388                 SeedBtimeToNtime( &(seedhdr->starttime), &ntime, &status ); 
    389                 if  (Severe(&status) && errcnt > 10)  { 
    390                         fprintf( stderr, 
    391                                 "%s: couldn't read start time of last record in file %s\n", 
    392                                 pa_progname(), seedfile ); 
    393                         fclose( fp ); 
    394                         fclose( out ); 
    395                         return 1; 
    396                 } /*endif*/ 
    397         } /*endwhile*/ 
    398         tc_nadd( &ntime, (float)(seedhdr->no_of_samples)*dt, &ntime, &status ); 
    399         if  (Severe(&status))  { 
    400                 fprintf( stderr, "%s: couldn't compute end time in file\n", 
    401                         pa_progname(), seedfile ); 
    402                 fclose( fp ); 
    403                 fclose( out ); 
    404                 return 1; 
    405         } /*endif*/ 
    406         tc_n2t( &ntime, sfd_t_end, &status ); 
    407         if  (Severe(&status))  { 
    408                 fprintf( stderr, "%s: couldn't convert end time in file %s\n", 
    409                         pa_progname(), seedfile ); 
    410                 fclose( fp ); 
    411                 fclose( out ); 
    412                 return 1; 
    413         } /*endif*/ 
    414  
    415         fclose( fp ); 
    416  
    417         fprintf( out, "%c>%s %c>%s %c>%s %c>%s %c>%d %c>%d %c>%d %c>%d\n", 
    418                 Seed_C_SfdStream, sfd_stream, Seed_C_SfdName, seedfile, 
    419                 Seed_C_SfdTStart, sfd_t_start, Seed_C_SfdTEnd, sfd_t_end, 
    420                 Seed_C_SfdRecno, sfd_recno, Seed_C_SfdSwapH, sfd_swap_hdr, 
    421                 Seed_C_SfdReclth, recsize, Seed_C_SfdOffset, byteoff ); 
    422  
    423         if  (out != stdout)  fclose( out ); 
    424  
    425         return 0; 
    426  
    427 #endif 
    428  
    429317} /* end of main */ 
  • SH_SHM/branches/marcus/source/seed_io/sfdline.c

    r16 r106  
    204204        if  (chanstr[1] <= ' ' || chanstr[1] > 'z')  chanstr[1] = '\0'; 
    205205        ut_uncap( chanstr ); 
    206 #ifdef XXX 
    207         if  (strcmp(chanstr,"bh") == 0)  {         strcat( sfd_stream, "vbb-" ); 
    208         } else if  (strcmp(chanstr,"hh") == 0)  {  strcat( sfd_stream, "vsp-" ); 
    209         } else if  (strcmp(chanstr,"lh") == 0)  {  strcat( sfd_stream, "lp-" ); 
    210         } else { 
    211                 strcat( sfd_stream, chanstr ); 
    212                 strcat( sfd_stream, "-" ); 
    213         } /*endif*/ 
    214 #endif 
    215206        strcat( sfd_stream, chanstr ); 
    216207        strcat( sfd_stream, "-" ); 
  • SH_SHM/branches/marcus/source/shconst.h

    r105 r106  
    172172 
    173173 
    174  
    175 /* ---------------------------------------------------- */ 
    176 /* the following type is used in the motif version only */ 
    177 /* ---------------------------------------------------- */ 
    178  
    179  
    180 #ifdef XXX 
    181  
    182 typedef struct { 
    183         float     red;       /* red fraction */ 
    184         float     green;     /* green fraction */ 
    185         float     blue;      /* blue fraction,  all fractions are between 0 and 1 */ 
    186 } SHT_COLOR; 
    187  
    188  
    189 /* definition of structure for global parameter set */ 
    190 typedef struct { 
    191         char      depth_phase_list[BC_LINELTH+1];   /* list of depth phases */ 
    192         char      theo_phase_list[BC_LINELTH+1];    /* list of theo. phases */ 
    193         char      diff_phase_list[BC_LINELTH+1];    /* list of diff. phases */ 
    194         float     close_phase_resol;     /* close phase resolution in pixel */ 
    195         int       min_drag_box_width; /* minimum width of drag box in pixel */ 
    196         char      defpath_filter[BC_FILELTH+1]; /* default path for filters */ 
    197         char      defpath_events[BC_FILELTH+1]; /* def.path for event files */ 
    198         char      defpath_gse[BC_FILELTH+1];     /* def. path for GSE files */ 
    199         char      defpath_gse2[BC_FILELTH+1];   /* def. path for GSE2 files */ 
    200         char      defpath_ah[BC_FILELTH+1];       /* def. path for AH files */ 
    201         char      defpath_q[BC_FILELTH+1];         /* def. path for Q files */ 
    202         char      defpath_evid[BC_FILELTH+1];    /* path for event ID files */ 
    203         char      defpath_evtout[BC_FILELTH+1];   /* event info output path */ 
    204         char      defpath_data[BC_FILELTH+1];     /* def.path for SEED data */ 
    205    BOOLEAN   top_down_order;       /* arrange trace from top to bottom */ 
    206         long      double_click_time;  /* maximum time diff. of clicks in ms */ 
    207         float     trace_zoom_base;            /* base of trace zoom formula */ 
    208         float     trace_zoom_exp;  /* exponent factor of trace zoom formula */ 
    209         SHT_COLOR color_mark;                               /* marker color */ 
    210         SHT_COLOR color_theo;                  /* theoretical phase markers */ 
    211         SHT_COLOR color_auto;           /* automatically picked phase color */ 
    212         SHT_COLOR color_crsr;                               /* cursor color */ 
    213         char      refstation[BC_SHORTSTRLTH+1];        /* reference station */ 
    214         BOOLEAN   autopick_first;         /* take first or bigger amplitude */ 
    215         char      edit_cmd[BC_LINELTH+1];     /* call to system text editor */ 
    216         float     calib_wdw_width;           /* width of calibration window */ 
    217         float     calib_wdw_height;         /* height of calibration window */ 
    218         float     calib_azimuth_grid;      /* azimuth grid in calib diagram */ 
    219         float     calib_slowness_grid;    /* slowness grid in calib diagram */ 
    220         BOOLEAN   auto_scaling;    /* scale traces on display automatically */ 
    221         BOOLEAN   use_rec_filters;  /* use recursive filters instead of FFT */ 
    222         char      analyst[BC_SHORTSTRLTH+1];      /* analyst's abbreviation */ 
    223         BOOLEAN   prompt_analyst;              /* prompt for analyst's name */ 
    224         char      motif_log[BC_FILELTH+1];         /* motif action log file */ 
    225         float     phase_ampl_diff;  /* max. seconds between phase and ampl. */ 
    226         BOOLEAN   reverse_xors;         /* reverse back/foreground on XOR's */ 
    227         int       x_max_drawlth;    /* max. no of samples in one XDrawLines */ 
    228         int       default_quality;           /* default phase quality value */ 
    229         int       drag_box_rubber_val; /* no of pixels to enable rubber box */ 
    230         char      default_filter[BC_FILELTH+1];   /* def. filter after read */ 
    231         int       default_phase_type;      /* default phase type, like tele */ 
    232         int       default_phase_flags;               /* default phase flags */ 
    233         int       default_depth_type;                 /* default depth type */ 
    234         float     default_depth;                     /* default depth in km */ 
    235         int       default_loc_quality;          /* default location quality */ 
    236         int       max_cursor_form;                /* maximum cursor form ID */ 
    237         char      event_check_proc[BC_FILELTH+1]; /* routine to check event */ 
    238         char      screendump_proc[BC_FILELTH+1];      /* screendump routine */ 
    239         char      evtview_proc[BC_FILELTH+1];  /* evt result view prcoedure */ 
    240         char      remreqhost[BC_SHORTSTRLTH+1];      /* request remote host */ 
    241         BOOLEAN   full_phase_names;             /* display full phase names */ 
    242         char      default_source[BC_SHORTSTRLTH+1];  /* default info source */ 
    243         float     move_wdw_step;        /* step size of move window command */ 
    244         int       top_margin;             /* top margin of display in pixel */ 
    245         char      auto_phase[cBcShortStrLth+1];   /* name of autopick phase */ 
    246         int       draw_area_height;      /* height of drawing area in pixel */ 
    247         int       draw_area_width;        /* width of drawing area in pixel */ 
    248         float     area_zoom_base;              /* drawing area resize, base */ 
    249         float     area_zoom_exp;           /* drawing area resize, exponent */ 
    250         char      reformat_proc[cBcFileLth+1];  /* routine to reformat data */ 
    251         char      final_proc[cBcFileLth+1];/* postprocessing 'final params' */ 
    252         BOOLEAN   own_accelerators;             /* use own accelerator code */ 
    253         char      filter_type;     /* filter type, replaces use_rec_filters */ 
    254 } SHT_GLOBAL_SET; 
    255  
    256 #endif 
    257  
    258  
    259174#endif /* __SHCONST */ 
  • SH_SHM/branches/marcus/source/shexec.c

    r105 r106  
    387387                        mn4_int( cmd, status ); 
    388388                        *redraw = TRUE; 
    389 #               ifdef XXX 
    390                 } else if  (cp_cmdverb(cmd,"INVERSE"))  { 
    391                         mngrf_inverse( cmd, status ); 
    392                         *redraw = TRUE; 
    393 #               endif /* XXX */ 
    394389                } else { 
    395390                        mn0_callproc( cmd, status ); 
     
    499494                        mni_readf( cmd, status ); 
    500495                        *redraw = TRUE; 
    501 #ifdef XXX 
    502                 } else if  (cp_cmdverb(cmd,"READG"))  { 
    503                         mn5_readg( cmd, status ); 
    504                         *redraw = TRUE; 
    505 #endif 
    506496                } else if  (cp_cmdverb(cmd,"READS"))  { 
    507497                        mni_reads( cmd, status ); 
  • SH_SHM/branches/marcus/source/shlib.c

    r102 r106  
    859859 
    860860        if  (nomean)  { 
    861 #ifdef XXX 
    862                 /* this is the plain decimation, is not recommended */ 
    863                 ocnt = 0; 
    864                 for  (ncnt=0; ncnt<new_lth; ncnt++)  { 
    865                         new[ncnt] = old[ocnt]; 
    866                         ocnt += decimation; 
    867                         if  (ocnt >= old_lth)  ocnt -= decimation; 
    868                 } /*endfor*/ 
    869 #endif 
    870861                /* take here the maximum value out of the decimation window */ 
    871862                ocnt = 0; 
  • SH_SHM/branches/marcus/source/shmath.c

    r16 r106  
    422422                aez = 0.0;          aen =  sina;          aee = -cosa; 
    423423        } else if  (type == SHC_ROT_ZNE_TO_UVW)  { 
    424 #               ifdef XXX 
    425                 if  (sina != 0.0)   sina = 1.0 / sina; 
    426                 if  (cosa != 0.0)   cosa = 1.0 / cosa; 
    427                 azz = cosa/3.0;     anz = cosa/3.0;       aez = cosa/3.0; 
    428                 azn = 0.;           ann = sina/SQRT3;     aen = -sina/SQRT3; 
    429                 aze = -sina*2.0/3.0;ane = sina/3.0;       aee = sina/3.0; 
    430 #               endif 
    431424                azz = SQRT1_3;      anz = SQRT1_3;        aez = SQRT1_3; 
    432425                azn = 0.0;          ann = SQRT1_2;        aen = -SQRT1_2; 
    433426                aze = -SQRT2_3;     ane = 0.5*SQRT2_3;    aee = 0.5*SQRT2_3; 
    434427        } else if  (type == SHC_ROT_UVW_TO_ZNE)  { 
    435 #               ifdef XXX 
    436                 azz = cosa;         anz = cosa;           aez = cosa; 
    437                 azn = 0.;           ann = sina*SQRT3_2;   aen = -sina*SQRT3_2; 
    438                 aze = -sina;        ane = sina*0.5;       aee = sina*0.5; 
    439 #               endif 
    440428                azz = SQRT1_3;      azn = SQRT1_3;        aze = SQRT1_3; 
    441429                anz = 0.0;          ann = SQRT1_2;        ane = -SQRT1_2; 
     
    733721/*--------------------------------------------------------------------------*/ 
    734722 
    735 #ifdef XXX 
    736  
    737 void mt_fft( long lx, COMPLEX cx[], REAL signi ) 
    738  
    739 /* fast fourier transformation of array "cx" of length "lx" 
    740  * Source code was transferred directly from an old-fashioned 
    741  * FORTRAN routine. 
    742  * 
    743  * parameters of routine 
    744  * long       lx;    input; length of complex array 
    745  * COMPLEX    cx[];  modify; array to be fourier transformed 
    746  * REAL       signi; input; sign of transformation 
    747  */ 
    748 { 
    749         /* local variables */ 
    750         long     i, j, m, l;   /* counters */ 
    751         long     istep; 
    752         REAL     sc; 
    753         COMPLEX  cw, ctemp; 
    754  
    755         /* executable code */ 
    756  
    757         cx--;   /* fortan array start with 1 */ 
    758  
    759         j = 1; 
    760         sc = sqrt( 1.0 / (float)lx ); 
    761         for  (i=1; i<=lx; i++)  { 
    762                 if  (i > j)  goto m2; 
    763                 mt_rmulcmplx( &ctemp, cx+j, sc ); 
    764                 mt_rmulcmplx( cx+j, cx+i, sc ); 
    765                 cx[i] = ctemp; 
    766 m2:   m = lx/2; 
    767 m3:   if  (j <= m)  goto m5; 
    768                 j -= m; 
    769                 m /= 2; 
    770                 if  (m >= 1)  goto m3; 
    771 m5:   j += m; 
    772         } /*endfor*/ 
    773         l = 1; 
    774 m6: istep = 2*l; 
    775         for  (m=1; m<=l; m++)  { 
    776                 mt_imexp( &cw, (SHC_PI * signi * (float)(m-1) / (float)l) ); 
    777                 for  (i=m; i<=lx; i += istep)  { 
    778                         mt_mulcmplx( &ctemp, &cw, cx+i+l ); 
    779                         cx[i+l].re = cx[i].re - ctemp.re; 
    780                         cx[i+l].im = cx[i].im - ctemp.im; 
    781                         cx[i].re += ctemp.re; 
    782                         cx[i].im += ctemp.im; 
    783                 } /*endfor*/ 
    784         } /*endfor*/ 
    785         l = istep; 
    786         if  (l < lx)  goto m6; 
    787  
    788 } /* end of mt_fft */ 
    789  
    790 #endif /* XXX */ 
    791  
    792 /*--------------------------------------------------------------------------*/ 
    793  
    794  
    795723 
    796724void mt_deg_to_km( int listlth, STATLOC lat[], STATLOC lon[], 
     
    814742        /* executable code */ 
    815743 
    816 #ifdef XXX 
    817         /* this was changed at 20-Dec-2004 */ 
    818         /* reference location is first element */ 
    819         ref_lat = *lat; 
    820         ref_lon = *lon; 
    821 #endif 
    822744        /* reference location is last element */ 
    823745        ref_lat = lat[listlth-1]; 
     
    825747 
    826748        while  (listlth-- > 0)  { 
    827                 *x++ = (REAL)((*lon++ - ref_lon) *  
     749                *x++ = (REAL)((*lon++ - ref_lon) * 
    828750                        SHC_DEG_TO_KM * cos((*lat)/SHC_RAD_TO_DEG)); 
    829751                *y++ = (REAL)((*lat++ - ref_lat) * SHC_DEG_TO_KM); 
     
    924846                y[i] -= ymean; 
    925847        } /*endfor*/ 
    926  
    927 #       ifdef SH_DEBUGXXX 
    928         for  (i=0; i<listlth; i++) 
    929                 printf( "--sh-debug->  %f %f %f\n", x[i], y[i], time[i] ); 
    930 #       endif 
    931848 
    932849        tx = ty = tq = 0.0; 
     
    12831200        printf( "--sh-debug-> (err) sx,sy: %f,%f\n", sx, sy ); 
    12841201#       endif 
    1285          
     1202 
    12861203        /* compute center */ 
    12871204        xc = yc = 0.0; 
     
    13061223                xc -= refx; 
    13071224                yc -= refy; 
    1308          
     1225 
    13091226                tx = ty = 0.0; 
    13101227                axx = axy = ayx = ayy = 0.0; 
    1311          
     1228 
    13121229                if  (listlth == 3)  { 
    13131230                        tx = time[1]; 
     
    13271244                        ayx = axy; 
    13281245                } /*endif */ 
    1329          
     1246 
    13301247                /* compute determinant, Cramer's rule */ 
    13311248                det = axx*ayy - axy*ayx; 
     
    13461263 
    13471264                if  (resid != NULL)  *resid++ = dkx; 
    1348          
     1265 
    13491266#               ifdef SH_DEBUG 
    13501267                printf( "--sh-debug-> (ref%02d) dkx: %f, dky: %f\n", refstat, dkx, dky ); 
     
    18181735/*----------------------------------------------------------------------------*/ 
    18191736 
    1820 #ifdef XXX 
    1821  
    1822 void mt_locdiff( REAL lat1, REAL lon1, REAL lat2, REAL lon2, 
    1823         REAL *dist, REAL *azim ) 
    1824  
    1825 /* returns distance in degrees and azimuth of two locations given 
    1826  * by (lat1,lon1) and (lat2,lon2) 
    1827  * 
    1828  * parameters of routine 
    1829  * REAL       lat1, lon1;    input; first location in degrees 
    1830  * REAL       lat2, lon2;    input; second location in degrees 
    1831  * REAL       *dist;         output; distance in degrees 
    1832  * REAL       *azim;         output; azimuth from loc1 to loc2 (in deg) 
    1833  */ 
    1834 { 
    1835         /* local variables */ 
    1836         double     b1, b2, dl, d, alpha; 
    1837  
    1838         /* executable code */ 
    1839  
    1840         b1 = (double)lat1 / SHC_RAD_TO_DEG; 
    1841         b2 = (double)lat2 / SHC_RAD_TO_DEG; 
    1842  
    1843         b1 = BC_PI/2.0 - b1; 
    1844         b2 = BC_PI/2.0 - b2; 
    1845         dl = Abs((double)lon1-(double)lon2) / SHC_RAD_TO_DEG; 
    1846         if  (dl > BC_PI)  dl = 2.0*BC_PI - dl; 
    1847         d = acos( cos(b1)*cos(b2) + sin(b1)*sin(b2)*cos(dl) ); 
    1848         if  (Abs(b1) < SHC_EPSILON  ||  Abs(dl) < SHC_EPSILON)  { 
    1849                 alpha = 0.0; 
    1850         } else { 
    1851                 alpha = acos( (cos(b2)-cos(b1)*cos(d)) / (sin(b1)*sin(d)) ); 
    1852         } /*endif*/ 
    1853  
    1854         *dist = (REAL)(d*SHC_RAD_TO_DEG); 
    1855         *azim = (REAL)((BC_PI/2.0 - alpha)*SHC_RAD_TO_DEG); 
    1856  
    1857 } /* end of mt_locdiff */ 
    1858  
    1859  
    1860  
    1861 /*----------------------------------------------------------------------------*/ 
    1862  
    1863  
    1864  
    1865 void mt_locadd( REAL lat, REAL lon, REAL dist, REAL azim, 
    1866         REAL *latx, REAL *lonx ) 
    1867  
    1868 /* computes location (*latx,*lonx) from point (lat,lon) and 
    1869  * a distance "dist" in direction "azim" 
    1870  * 
    1871  * parameters of routine 
    1872  * REAL       lat, lon;      input; input location in degrees 
    1873  * REAL       dist;          input; distance in degrees 
    1874  * REAL       azim;          input; direction 
    1875  * REAL       *latx, *lonx;  output; output location 
    1876  */ 
    1877 { 
    1878         /* local variables */ 
    1879         double   b, d, bx, cosbx, alpha, sinbx, sinb, dl; 
    1880  
    1881         /* executable code */ 
    1882  
    1883         b = BC_PI/2.0 - (double)lat/SHC_RAD_TO_DEG; 
    1884         d = (double)dist / SHC_RAD_TO_DEG; 
    1885         alpha = BC_PI/2.0 - (double)azim/SHC_RAD_TO_DEG; 
    1886  
    1887         sinb = sin(b); 
    1888         cosbx = cos(b)*cos(d) + sinb*sin(d)*cos(alpha); 
    1889         sinbx = sqrt( 1.0 - cosbx*cosbx ); 
    1890  
    1891         if  (Abs(sinbx) < SHC_EPSILON)  { 
    1892                 bx = 0.0; 
    1893                 dl = 0.0; 
    1894         } else if  (Abs(sinb) < SHC_EPSILON)  { 
    1895                 bx = d; 
    1896                 dl = 0.0; 
    1897         } else { 
    1898                 dl = acos( (cos(d) - cos(b)*cosbx) / (sinbx*sinb) ); 
    1899                 bx = acos( cosbx ); 
    1900         } /*endif*/ 
    1901  
    1902         bx = BC_PI/2.0 - bx; 
    1903         dl += (double)lon/SHC_RAD_TO_DEG; 
    1904  
    1905         *latx = (REAL)(bx*SHC_RAD_TO_DEG); 
    1906         *lonx = (REAL)(dl*SHC_RAD_TO_DEG); 
    1907  
    1908 } /* end of mt_locadd */ 
    1909  
    1910 #endif 
    1911  
    1912 /*----------------------------------------------------------------------------*/ 
    1913  
    1914  
    19151737 
    19161738void mt_fit_gauss( REAL x[], SAMPLE y[], int ndata, REAL ampl, 
    19171739        int maxiter, REAL *pos, REAL *width, int *iter, STATUS *status ) 
    19181740 
    1919 /* fits a gauss function of position "*pos" and width "*width" to  
     1741/* fits a gauss function of position "*pos" and width "*width" to 
    19201742 * the data given in x[0..ndata-1] and y[0..ndata-]. 
    19211743 * 
     
    22612083 
    22622084 
    2263 void mt_fix_gap( SAMPLE dat[], long lth, REAL const_value, BOOLEAN konst,  
     2085void mt_fix_gap( SAMPLE dat[], long lth, REAL const_value, BOOLEAN konst, 
    22642086               BOOLEAN one) 
    22652087 
     
    23062128                                next_value = dat[s]; 
    23072129                                if (start_cnt==0) last_value=next_value; 
    2308                                 slope=(next_value - last_value)/(REAL)(value_counter+1);  
     2130                                slope=(next_value - last_value)/(REAL)(value_counter+1); 
    23092131                                if (konst) { 
    23102132                                        slope=0.0; 
    2311                                         last_value=(next_value + last_value)/2.0;  
     2133                                        last_value=(next_value + last_value)/2.0; 
    23122134                                }  /*endif*/ 
    23132135            if (value_counter> (int) !one) 
    2314                                         for (i=0; i<value_counter; i++)  
     2136                                        for (i=0; i<value_counter; i++) 
    23152137                                                dat[start_cnt++] = last_value + (REAL)(i+1)*slope; 
    23162138                                value_counter = 0; 
     
    23362158                if (konst) { 
    23372159                        slope=0.0; 
    2338                         last_value=(next_value + last_value)/2.0;  
     2160                        last_value=(next_value + last_value)/2.0; 
    23392161                }  /*endif*/ 
    23402162      if (value_counter> (int) !one) 
  • SH_SHM/branches/marcus/source/shmenu0.c

    r105 r106  
    537537                sl_setsymbol( str2, str, &locstat );  /* save output if possible */ 
    538538        } else { 
    539 #ifdef XXX 
    540                 *status = SHE_UKFCT; 
    541                 err_setcontext( " ## subfct " ); err_setcontext( str ); 
    542 #endif 
    543539                printf( "*SH: illegal fct item %s\n", str ); 
    544540        } /*endif*/ 
  • SH_SHM/branches/marcus/source/shmenu3.c

    r16 r106  
    470470                sprintf( str, "%e", res ); 
    471471                sl_setsymbol( symbol, str, status ); 
    472                 if  (Severe(status))  return;            
     472                if  (Severe(status))  return; 
    473473        } else { 
    474474                *status = SHE_UKKEY; 
     
    639639 
    640640                /* perform filtering */ 
    641                 mt_fold( itrclth, (SAMPLE *)db_getp(trc[t],EP_DATA,NULL)+loidx,  
     641                mt_fold( itrclth, (SAMPLE *)db_getp(trc[t],EP_DATA,NULL)+loidx, 
    642642                        flth, db_getp(fil,EP_DATA,NULL), datptr ); 
    643643 
     
    10991099        start -= loff; 
    11001100        trclth += roff+loff; 
    1101         mt_mend( start, trclth, loff, roff, widening,  
     1101        mt_mend( start, trclth, loff, roff, widening, 
    11021102                db_getr(trc,ER_DELTA,NULL), pol, status ); 
    11031103 
     
    12571257                *mov++ = 0.; 
    12581258 
    1259 #       ifdef XXX 
    1260         for  (i=0; i<outlth; ccr[i++] = 0.) {} 
    1261         ccr[t0] = 1.0; 
    1262 #       endif 
    1263  
    12641259        mt_levinson( ac, ccr, f, outlth, status ); 
    12651260        if  (Severe(status))  { 
  • SH_SHM/branches/marcus/source/shmenu4.c

    r70 r106  
    441441 
    442442 
    443   
     443 
    444444/*--------------------------------------------------------------------*/ 
    445445 
     
    12151215                /* compute FFT */ 
    12161216                nr_spctrm( smp-1, datptr-1, m, k, overlap ); 
    1217                 /*         ^--- this is ok, I made it compatible to other     */  
     1217                /*         ^--- this is ok, I made it compatible to other     */ 
    12181218                /*              array arguments                               */ 
    12191219                /*              originally this data array was read from file */ 
    12201220 
    1221 #ifdef XXX 
    1222                 /* normalization */ 
    1223                 tmp = (float)trclth; 
    1224                 for  (i=0; i<m; i++)  { 
    1225                         datptr[i] *= tmp; 
    1226                         if  (datptr[i] >= 0)  { 
    1227                                 datptr[i] = sqrt( datptr[i] ) * dt; 
    1228                         } else { 
    1229                                 datptr[i] = 0.0; 
    1230                         } /*endif*/ 
    1231                 } /*endfor*/ 
    1232 #endif 
    12331221 
    12341222                /* initialise trace parameters */ 
  • SH_SHM/branches/marcus/source/shmenu5.c

    r105 r106  
    6161 
    6262/* global variables */ 
    63 #ifdef XXX 
    64 SHT_GLOBAL_SET *mn5v_global=NULL;      /* for use in motif version only */ 
    65 #endif 
    6663void (*mn5v_external_routine)( char cmd[], STATUS *status)=NULL; 
    6764        /* external routine */ 
     
    410407/*----------------------------------------------------------------------------*/ 
    411408 
    412 #ifdef XXX 
    413  
    414 void mn5_readg( PARAM *par, STATUS *status ) 
    415  
    416 /* reads traces from GRN files 
    417  * par 1:  device 
    418  * par 2:  start time 
    419  * par 3:  length in seconds 
    420  * par 4:  station list 
    421  * par 5:  component list 
    422  * par 6:  sample rate 
    423  * 
    424  * parameters of routine 
    425  * PARAM    *par;           input; command parameter 
    426  * int      *status;        output; return status 
    427  */ 
    428 { 
    429         /* local variables */ 
    430         char     device[BC_FILELTH+1];     /* device name */ 
    431         char     tstart[BC_LINELTH+1];     /* start time */ 
    432         REAL     seclength;                /* length in seconds */ 
    433         char     statlist[BC_LINELTH+1];   /* station list */ 
    434         char     cmpl[BC_SHORTSTRLTH+1];   /* component list */ 
    435         int      smprate;                  /* sample rate */ 
    436         char     stations[GRNC_MAXSTATION][GRNC_STATNAMELTH+1]; /*station list*/ 
    437         int      statno;                   /* number of stations */ 
    438         int      cmpno;                    /* number of components */ 
    439         int      s, c;                     /* station and component counters */ 
    440         char     label[BC_FILELTH+1];      /* volume label */ 
    441         long     length;                   /* length of trace in samples */ 
    442         long     *ldatptr;                 /* pointer to data array */ 
    443         GRN_TRCINFO inf;                   /* trace info */ 
    444         float    *fdat;                    /* floating array pointer */ 
    445         long     i, j;                     /* counters */ 
    446         TRACE    *trc;                     /* trace pointer */ 
    447         TIME     atime;                    /* absolute start time */ 
    448         char     msg[BC_LINELTH+1];        /* error message */ 
    449         BOOLEAN  swap;                     /* swap data bytes */ 
    450         int      firstrec;                 /* first records */ 
    451         char     grnfile[BC_FILELTH+1];    /* specified file name */ 
    452  
    453         /* executable code */ 
    454  
    455         /* get parameters */ 
    456         if  (cp_pnexc(par,6,status))  return; 
    457         cp_getstr( par, 1, tc, "  device: ", BC_FILELTH, device, status ); 
    458         if  (Severe(status))  return; 
    459         cp_getstr( par, 2, tc, "  start time: ", BC_LINELTH, tstart, status ); 
    460         if  (Severe(status))  return; 
    461         cp_getfloat( par, 3, tc, "  length in seconds: ", &seclength, status ); 
    462         if  (Severe(status))  return; 
    463         cp_getstr( par, 4, tc, "  station list: ", BC_LINELTH, statlist, status ); 
    464         if  (Severe(status))  return; 
    465         cp_getstr( par, 5, tc, "  comp list: ", BC_SHORTSTRLTH, cmpl, status ); 
    466         if  (Severe(status))  return; 
    467         cp_getint( par, 6, tc, "  sample rate: ", &smprate, status ); 
    468         if  (Severe(status))  return; 
    469  
    470         swap = TRUE;   /* default */ 
    471         if  (cp_qexist(par,"NOSWAP"))  swap = FALSE; 
    472         if  (cp_qexist(par,"SWAP"))  swap = TRUE; 
    473         if  (!sl_quals(par,"FILE",BC_FILELTH,grnfile,status)) 
    474                 *grnfile = '\0'; 
    475         if  (Severe(status))  return; 
    476         if  (!sl_quali(par,"FIRST",&firstrec,status)) 
    477                 firstrec = -1; 
    478         if  (Severe(status))  return; 
    479  
    480         if  (cp_qexist(par,"CURRENT") || *grnfile != '\0')  { 
    481                 *label = '\0'; 
    482         } else if  (!sl_quals(par,"LABEL",BC_FILELTH,label,status))  { 
    483                 if  (Severe(status))  return; 
    484                 grn_getlabel( tstart, BC_FILELTH, label, status ); 
    485                 if  (*status == GRNE_LABNOTIME)  { 
    486                         if  (SHF_CHATTY & shflags_shv) 
    487                                 printf( "%s no WORM available, try disk %s\n", 
    488                                         SHC_CHATTXT, device ); 
    489                         *label = '\0'; 
    490                         *status = BC_NOERROR; 
    491                 } else { 
    492                         *status = BC_NOERROR; 
    493                         if  (SHF_CHATTY & shflags_shv) 
    494                                 printf( "%s label is %s\n", SHC_CHATTXT, label ); 
    495                 } /*endif*/ 
    496         } /*endif*/ 
    497  
    498         grn_parse_stations( statlist, stations, &statno ); 
    499         ut_cap( cmpl ); 
    500         cmpno = (int)strlen( cmpl ); 
    501         db_newlist(); 
    502  
    503         /* remove commas from component list */ 
    504         j = 0; 
    505         for  (i=0; i<cmpno; i++)  { 
    506                 if  (cmpl[i] != ',') 
    507                         if  (i == j)  { 
    508                                 j++; 
    509                         } else { 
    510                                 cmpl[j++] = cmpl[i]; 
    511                         } /*endif*/ 
    512         } /*endfor*/ 
    513         cmpl[j] = '\0'; 
    514         cmpno = (int)j; 
    515  
    516         if  (*grnfile != '\0' && (statno != 1 || cmpno != 1))  { 
    517                 gc_write( cc, "*** only 1 station and 1 component makes sense ***\n" ); 
    518                 return; 
    519         } /*endif*/ 
    520  
    521         for  (s=0; s<statno; s++)  { 
    522                 for  (c=0; c<cmpno; c++)  { 
    523                         if  (cmpl[c] == 'N' || cmpl[c] == 'E')  { 
    524                                 if  (strcmp(stations[s],"GRA2") == 0)  continue; 
    525                                 if  (strcmp(stations[s],"GRA3") == 0)  continue; 
    526                                 if  (strcmp(stations[s],"GRA4") == 0)  continue; 
    527                                 /*if  (strcmp(stations[s],"GRB2") == 0)  continue;*/ 
    528                                 if  (strcmp(stations[s],"GRB3") == 0)  continue; 
    529                                 if  (strcmp(stations[s],"GRB4") == 0)  continue; 
    530                                 if  (strcmp(stations[s],"GRB5") == 0)  continue; 
    531                                 /*if  (strcmp(stations[s],"GRC2") == 0)  continue;*/ 
    532                                 if  (strcmp(stations[s],"GRC3") == 0)  continue; 
    533                                 if  (strcmp(stations[s],"GRC4") == 0)  continue; 
    534                         } /*endif*/ 
    535                         if  (SHF_CHATTY & shflags_shv) 
    536                                 printf( "%s reading %s-%c ",  /* no cr/lf */ 
    537                                         SHC_CHATTXT, stations[s], cmpl[c] ); 
    538                         if  (*grnfile == '\0')  { 
    539                                 grn_read( device, label, tstart, seclength, stations[s], 
    540                                         cmpl[c], smprate, swap, &length, &ldatptr, 
    541                                         &inf, status ); 
    542                         } else { 
    543                                 grn_readfile( grnfile, tstart, seclength, swap, 
    544                                         firstrec, &length, &ldatptr, &inf, status ); 
    545                         } /*endif*/ 
    546                         if  (Severe(status))  { 
    547                                 err_msg( *status, msg ); gc_write( cc, "\n" ); 
    548                                 gc_write( cc, msg ); gc_write( cc, "\n" ); 
    549                                 length = 0; 
    550                                 *status = BC_NOERROR; 
    551                         } /*endif*/ 
    552                         if  (length > 0)  { 
    553                                 /* copy to real array */ 
    554                                 fdat = (float *)ldatptr; 
    555                                 for  (i=0; i<length; i++) 
    556                                         fdat[i] = (float)ldatptr[i] * inf.calib; 
    557                                 trc = db_create( status ); 
    558                                 if  (Severe(status))  return; 
    559                                 ml_inittrc( trc, fdat, length, inf.dt ); 
    560                                 ut_cap( inf.station ); 
    561                                 db_sets( trc, ES_STATION, inf.station, NULL ); 
    562                                 db_setc( trc, EC_COMP, cmpl[c], NULL ); 
    563                                 tc_t2a( inf.tstart, &atime, status ); 
    564                                 if  (Severe(status))  return; 
    565                                 db_sett( trc, ET_START, &atime, status ); 
    566                                 if  (Severe(status))  return; 
    567                                 db_setr( trc, ER_TORIG, 0.0, NULL ); 
    568                                 db_sets( trc, ES_FILE, "FROM-GRN-FILE", NULL ); 
    569                                 db_seti( trc, EI_RECNO, 0, NULL ); 
    570                                 db_setf( trc, EF_MODIF, FALSE, NULL ); 
    571                                 db_setf( trc, EF_FROMQ, FALSE, NULL ); 
    572                                 db_setr( trc, ER_CALIB, inf.calib, status ); 
    573                                 if  (Severe(status))  return; 
    574                                 sprintf( msg, "%f", inf.calib ); 
    575                                 db_sets( trc, ES_OPINFO, msg, status ); 
    576                                 if  (Severe(status))  return; 
    577                         } /*endif*/ 
    578                 } /*endfor*/ 
    579         } /*endfor*/ 
    580  
    581 } /* end of mn5_readg */ 
    582  
    583 #endif 
    584  
    585 /*----------------------------------------------------------------------------*/ 
    586  
    587  
    588  
    589409void mn5_decimate( PARAM *par, STATUS *status ) 
    590410 
     
    945765/*--------------------------------------------------------------------*/ 
    946766 
    947 #ifdef XXX 
    948  
    949 void mn5_set_shmsetup_pointer( SHT_GLOBAL_SET *ptr ) 
    950  
    951 /* special routine to set pointer to global variable of motif modules 
    952  * 
    953  * parameters of routine 
    954  * SHT_GLOBAL_SET *ptr;      input; specifies address of global paramters 
    955  */ 
    956 { 
    957         /* executable code */ 
    958  
    959         mn5v_global = ptr; 
    960  
    961 } /* end of mn5_shmsetup_pointer */ 
    962  
    963 #endif 
    964  
    965 /*--------------------------------------------------------------------*/ 
    966  
    967  
    968  
    969767void mn5_shmsetup( PARAM *par, STATUS *status ) 
    970768 
     
    978776 */ 
    979777{ 
    980         /* local variables */ 
    981 #ifdef XXX 
    982         char     item[BC_LINELTH+1];    /* item name */ 
    983         char     str[BC_LINELTH+1];     /* scratch string */ 
    984         char     path[BC_FILELTH+1];    /* path name */ 
    985         int      itmp;                  /* scratch */ 
    986 #endif 
    987  
    988778        /* executable code */ 
    989779 
    990780        printf( "*SHM: command SHMSETUP obsolete, please use 'Configure' instead\n" ); 
    991781        return; 
    992  
    993 #ifdef XXX 
    994         if  (mn5v_global == NULL)  { 
    995                 *status = SHE_NOTIMPL; 
    996                 return; 
    997         } /*endif*/ 
    998  
    999         if  (cp_pnexc(par,2,status))  return; 
    1000         cp_getstr( par, 1, tc, "   item name :", BC_LINELTH, item, status ); 
    1001         if  (Severe(status))  return; 
    1002  
    1003         if  (strcmp(item,"DEPTH_PHASE_LIST") == 0)  { 
    1004                 cp_getstr( par, 2, tc, "   phase list: ", BC_LINELTH, str, status ); 
    1005                 if  (Severe(status))  return; 
    1006                 if  (strchr(str,' ') != NULL)  { 
    1007                         *status = SHE_ILPAR; 
    1008                         return; 
    1009                 } /*endif*/ 
    1010                 strcpy( mn5v_global->depth_phase_list, str ); 
    1011         } else if  (strcmp(item,"THEO_PHASE_LIST") == 0)  { 
    1012                 cp_getstr( par, 2, tc, "   phase list: ", BC_LINELTH, str, status ); 
    1013                 if  (Severe(status))  return; 
    1014                 if  (strchr(str,' ') != NULL)  { 
    1015                         *status = SHE_ILPAR; 
    1016                         return; 
    1017                 } /*endif*/ 
    1018                 strcpy( mn5v_global->theo_phase_list, str ); 
    1019         } else if  (strcmp(item,"DIFF_PHASE_LIST") == 0)  { 
    1020                 cp_getstr( par, 2, tc, "   phase list: ", BC_LINELTH, str, status ); 
    1021                 if  (Severe(status))  return; 
    1022                 if  (strchr(str,' ') != NULL)  { 
    1023                         *status = SHE_ILPAR; 
    1024                         return; 
    1025                 } /*endif*/ 
    1026                 strcpy( mn5v_global->diff_phase_list, str ); 
    1027         } else if  (strcmp(item,"CLOSE_PHASE_RESOL") == 0)  { 
    1028                 cp_getfloat( par, 2, tc, "   resol. in pixels: ", 
    1029                         &(mn5v_global->close_phase_resol), status ); 
    1030         } else if  (strcmp(item,"MIN_DRAG_BOX_WIDTH") == 0)  { 
    1031                 cp_getint( par, 2, tc, "   width in pixels: ", 
    1032                         &(mn5v_global->min_drag_box_width), status ); 
    1033         } else if  (strcmp(item,"DEFPATH_FILTER") == 0)  { 
    1034                 cp_getstr( par, 2, tc, "   path name: ", BC_FILELTH, path, status ); 
    1035                 if  (Severe(status))  return; 
    1036                 strcpy( mn5v_global->defpath_filter, path ); 
    1037         } else if  (strcmp(item,"DEFPATH_EVENTS") == 0)  { 
    1038                 cp_getstr( par, 2, tc, "   path name: ", BC_FILELTH, path, status ); 
    1039                 if  (Severe(status))  return; 
    1040                 strcpy( mn5v_global->defpath_events, path ); 
    1041         } else if  (strcmp(item,"DEFPATH_GSE") == 0)  { 
    1042                 cp_getstr( par, 2, tc, "   path name: ", BC_FILELTH, path, status ); 
    1043                 if  (Severe(status))  return; 
    1044                 strcpy( mn5v_global->defpath_gse, path ); 
    1045         } else if  (strcmp(item,"DEFPATH_GSE2") == 0)  { 
    1046                 cp_getstr( par, 2, tc, "   path name: ", BC_FILELTH, path, status ); 
    1047                 if  (Severe(status))  return; 
    1048                 strcpy( mn5v_global->defpath_gse2, path ); 
    1049         } else if  (strcmp(item,"DEFPATH_AH") == 0)  { 
    1050                 cp_getstr( par, 2, tc, "   path name: ", BC_FILELTH, path, status ); 
    1051                 if  (Severe(status))  return; 
    1052                 strcpy( mn5v_global->defpath_ah, path ); 
    1053         } else if  (strcmp(item,"DEFPATH_Q") == 0)  { 
    1054                 cp_getstr( par, 2, tc, "   path name: ", BC_FILELTH, path, status ); 
    1055                 if  (Severe(status))  return; 
    1056                 strcpy( mn5v_global->defpath_q, path ); 
    1057         } else if  (strcmp(item,"DEFPATH_EVID") == 0)  { 
    1058                 cp_getstr( par, 2, tc, "   path name: ", BC_FILELTH, path, status ); 
    1059                 if  (Severe(status))  return; 
    1060                 strcpy( mn5v_global->defpath_evid, path ); 
    1061         } else if  (strcmp(item,"DEFPATH_EVTOUT") == 0)  { 
    1062                 cp_getstr( par, 2, tc, "   path name: ", BC_FILELTH, path, status ); 
    1063                 if  (Severe(status))  return; 
    1064                 strcpy( mn5v_global->defpath_evtout, path ); 
    1065         } else if  (strcmp(item,"DEFPATH_DATA") == 0)  { 
    1066                 cp_getstr( par, 2, tc, "   path name: ", BC_FILELTH, path, status ); 
    1067                 if  (Severe(status))  return; 
    1068                 strcpy( mn5v_global->defpath_data, path ); 
    1069         } else if  (strcmp(item,"TOP_DOWN_ORDER") == 0)  { 
    1070                 cp_getstr( par, 2, tc, "   TRUE/FALSE: ", BC_LINELTH, str, status ); 
    1071                 if  (Severe(status))  return; 
    1072                 if  (strcmp(str,"TRUE") == 0)  { 
    1073                         mn5v_global->top_down_order = TRUE; 
    1074                 } else if  (strcmp(str,"FALSE") == 0)  { 
    1075                         mn5v_global->top_down_order = FALSE; 
    1076                 } else { 
    1077                         *status = SHE_ILPAR; 
    1078                         return; 
    1079                 } /*endif*/ 
    1080         } else if  (strcmp(item,"DOUBLE_CLICK_TIME") == 0)  { 
    1081                 cp_getint( par, 2, tc, "   time in ms: ", &itmp, status ); 
    1082                 mn5v_global->double_click_time = (long)itmp; 
    1083         } else if  (strcmp(item,"TRACE_ZOOM_BASE") == 0)  { 
    1084                 cp_getfloat( par, 2, tc, "   base: ", 
    1085                         &(mn5v_global->trace_zoom_base), status ); 
    1086         } else if  (strcmp(item,"TRACE_ZOOM_EXP") == 0)  { 
    1087                 cp_getfloat( par, 2, tc, "   exponent: ", 
    1088                         &(mn5v_global->trace_zoom_exp), status ); 
    1089         } else if  (strcmp(item,"COLOR_MARK") == 0)  { 
    1090                 cp_getstr( par, 2, tc, "   color values: ", BC_LINELTH, str, status ); 
    1091                 if  (Severe(status))  return; 
    1092                 if  (strchr(str,' ') != NULL)  { 
    1093                         *status = SHE_ILPAR; 
    1094                         return; 
    1095                 } /*endif*/ 
    1096                 if  (sscanf(str,"%f,%f,%f",&(mn5v_global->color_mark.red), 
    1097                         &(mn5v_global->color_mark.green),&(mn5v_global->color_mark.blue)) != 3) 
    1098                         *status = SHE_REALCNV; 
    1099         } else if  (strcmp(item,"COLOR_THEO") == 0)  { 
    1100                 cp_getstr( par, 2, tc, "   color values: ", BC_LINELTH, str, status ); 
    1101                 if  (Severe(status))  return; 
    1102                 if  (strchr(str,' ') != NULL)  { 
    1103                         *status = SHE_ILPAR; 
    1104                         return; 
    1105                 } /*endif*/ 
    1106                 if  (sscanf(str,"%f,%f,%f",&(mn5v_global->color_theo.red), 
    1107                         &(mn5v_global->color_theo.green),&(mn5v_global->color_theo.blue)) != 3) 
    1108                         *status = SHE_REALCNV; 
    1109         } else if  (strcmp(item,"COLOR_AUTO") == 0)  { 
    1110                 cp_getstr( par, 2, tc, "   color values: ", BC_LINELTH, str, status ); 
    1111                 if  (Severe(status))  return; 
    1112                 if  (strchr(str,' ') != NULL)  { 
    1113                         *status = SHE_ILPAR; 
    1114                         return; 
    1115                 } /*endif*/ 
    1116                 if  (sscanf(str,"%f,%f,%f",&(mn5v_global->color_auto.red), 
    1117                         &(mn5v_global->color_auto.green),&(mn5v_global->color_auto.blue)) != 3) 
    1118                         *status = SHE_REALCNV; 
    1119         } else if  (strcmp(item,"COLOR_CRSR") == 0)  { 
    1120                 cp_getstr( par, 2, tc, "   color values: ", BC_LINELTH, str, status ); 
    1121                 if  (Severe(status))  return; 
    1122                 if  (strchr(str,' ') != NULL)  { 
    1123                         *status = SHE_ILPAR; 
    1124                         return; 
    1125                 } /*endif*/ 
    1126                 if  (sscanf(str,"%f,%f,%f",&(mn5v_global->color_crsr.red), 
    1127                         &(mn5v_global->color_crsr.green),&(mn5v_global->color_crsr.blue)) != 3) 
    1128                         *status = SHE_REALCNV; 
    1129         } else if  (strcmp(item,"REFSTATION") == 0)  { 
    1130                 cp_getstr( par, 2, tc, "   reference station: ", BC_LINELTH, str, status); 
    1131                 if  (Severe(status))  return; 
    1132                 if  (strlen(str) > BC_SHORTSTRLTH)  { 
    1133                         *status = SHE_STROVFL; 
    1134                         return; 
    1135                 } /*endif*/ 
    1136                 strcpy( mn5v_global->refstation, str ); 
    1137         } else if  (strcmp(item,"AUTOPICK_FIRST") == 0)  { 
    1138                 cp_getstr( par, 2, tc, "   TRUE/FALSE: ", BC_LINELTH, str, status ); 
    1139                 if  (Severe(status))  return; 
    1140                 if  (strcmp(str,"TRUE") == 0)  { 
    1141                         mn5v_global->autopick_first = TRUE; 
    1142                 } else if  (strcmp(str,"FALSE") == 0)  { 
    1143                         mn5v_global->autopick_first = FALSE; 
    1144                 } else { 
    1145                         *status = SHE_ILPAR; 
    1146                         return; 
    1147                 } /*endif*/ 
    1148         } else if  (strcmp(item,"CALIB_WDW_WIDTH") == 0)  { 
    1149                 cp_getfloat( par, 2, tc, "   calib wdw width: ", 
    1150                         &(mn5v_global->calib_wdw_width), status ); 
    1151         } else if  (strcmp(item,"CALIB_WDW_HEIGHT") == 0)  { 
    1152                 cp_getfloat( par, 2, tc, "   calib wdw height: ", 
    1153                         &(mn5v_global->calib_wdw_height), status ); 
    1154         } else if  (strcmp(item,"CALIB_SLOWNESS_GRID") == 0)  { 
    1155                 cp_getfloat( par, 2, tc, "   calib slowness grid: ", 
    1156                         &(mn5v_global->calib_slowness_grid), status ); 
    1157         } else if  (strcmp(item,"CALIB_AZIMUTH_GRID") == 0)  { 
    1158                 cp_getfloat( par, 2, tc, "   calib azimuth grid: ", 
    1159                         &(mn5v_global->calib_azimuth_grid), status ); 
    1160         } else if  (strcmp(item,"AUTO_SCALING") == 0)  { 
    1161                 cp_getstr( par, 2, tc, "   TRUE/FALSE: ", BC_LINELTH, str, status ); 
    1162                 if  (Severe(status))  return; 
    1163                 if  (strcmp(str,"TRUE") == 0)  { 
    1164                         mn5v_global->auto_scaling = TRUE; 
    1165                 } else if  (strcmp(str,"FALSE") == 0)  { 
    1166                         mn5v_global->auto_scaling = FALSE; 
    1167                 } else { 
    1168                         *status = SHE_ILPAR; 
    1169                         return; 
    1170                 } /*endif*/ 
    1171         } else if  (strcmp(item,"USE_REC_FILTERS") == 0)  { 
    1172                 cp_getstr( par, 2, tc, "   TRUE/FALSE: ", BC_LINELTH, str, status ); 
    1173                 if  (Severe(status))  return; 
    1174                 if  (strcmp(str,"TRUE") == 0)  { 
    1175                         mn5v_global->use_rec_filters = TRUE; 
    1176                 } else if  (strcmp(str,"FALSE") == 0)  { 
    1177                         mn5v_global->use_rec_filters = FALSE; 
    1178                 } else { 
    1179                         *status = SHE_ILPAR; 
    1180                         return; 
    1181                 } /*endif*/ 
    1182         } else if  (strcmp(item,"ANALYST") == 0)  { 
    1183                 cp_getstr( par, 2, tc, "   analyst: ", BC_LINELTH, str, status); 
    1184                 if  (Severe(status))  return; 
    1185                 if  (strlen(str) > BC_SHORTSTRLTH)  { 
    1186                         *status = SHE_STROVFL; 
    1187                         return; 
    1188                 } /*endif*/ 
    1189                 strcpy( mn5v_global->analyst, str ); 
    1190         } else if  (strcmp(item,"EDIT_CMD") == 0)  { 
    1191                 cp_getstr( par, 2, tc, "   edit_cmd: ", BC_LINELTH, str, status); 
    1192                 if  (Severe(status))  return; 
    1193                 strcpy( mn5v_global->edit_cmd, str ); 
    1194                 if  (strncmp(mn5v_global->edit_cmd,"DEFAULT",7) == 0 
    1195                         || strncmp(mn5v_global->edit_cmd,"default",7) == 0)  { 
    1196                         /* local variables */ 
    1197                         char *env;      /* pointer to environment variable */ 
    1198                         /* executable code */ 
    1199                         env = getenv( "SH_TEXTEDIT" ); 
    1200                         if  (env != NULL && strlen(env) < cBcLineLth-3) 
    1201                                 sprintf( mn5v_global->edit_cmd, "%s %%s", env ); 
    1202                 } /*endif*/ 
    1203         } else if  (strcmp(item,"PROMPT_ANALYST") == 0)  { 
    1204                 cp_getstr( par, 2, tc, "   TRUE/FALSE: ", BC_LINELTH, str, status ); 
    1205                 if  (Severe(status))  return; 
    1206                 if  (strcmp(str,"TRUE") == 0)  { 
    1207                         mn5v_global->prompt_analyst = TRUE; 
    1208                 } else if  (strcmp(str,"FALSE") == 0)  { 
    1209                         mn5v_global->prompt_analyst = FALSE; 
    1210                 } else { 
    1211                         *status = SHE_ILPAR; 
    1212                         return; 
    1213                 } /*endif*/ 
    1214         } else if  (strcmp(item,"MOTIF_LOG") == 0)  { 
    1215                 cp_getstr( par, 2, tc, "   motif log: ", BC_LINELTH, str, status); 
    1216                 if  (Severe(status))  return; 
    1217                 if  (strlen(str) > BC_FILELTH)  { 
    1218                         *status = SHE_STROVFL; 
    1219                         return; 
    1220                 } /*endif*/ 
    1221                 strcpy( mn5v_global->motif_log, str ); 
    1222         } else if  (strcmp(item,"PHASE_AMPL_DIFF") == 0)  { 
    1223                 cp_getfloat( par, 2, tc, "   phase-ampl diff (sec): ", 
    1224                         &(mn5v_global->phase_ampl_diff), status ); 
    1225         } else if  (strcmp(item,"REVERSE_XORS") == 0)  { 
    1226                 cp_getstr( par, 2, tc, "   TRUE/FALSE: ", BC_LINELTH, str, status ); 
    1227                 if  (Severe(status))  return; 
    1228                 if  (strcmp(str,"TRUE") == 0)  { 
    1229                         mn5v_global->reverse_xors = TRUE; 
    1230                 } else if  (strcmp(str,"FALSE") == 0)  { 
    1231                         mn5v_global->reverse_xors = FALSE; 
    1232                 } else { 
    1233                         *status = SHE_ILPAR; 
    1234                         return; 
    1235                 } /*endif*/ 
    1236         } else if  (strcmp(item,"X_MAX_DRAWLTH") == 0)  { 
    1237                 cp_getint( par, 2, tc, "   max draw length: ", 
    1238                         &(mn5v_global->x_max_drawlth), status ); 
    1239         } else if  (strcmp(item,"DEFAULT_QUALITY") == 0)  { 
    1240                 cp_getint( par, 2, tc, "   default quality: ", 
    1241                         &(mn5v_global->default_quality), status ); 
    1242                 if  (mn5v_global->default_quality < 1)  mn5v_global->default_quality = 1; 
    1243                 if  (mn5v_global->default_quality > 9)  mn5v_global->default_quality = 9; 
    1244         } else if  (strcmp(item,"DRAG_BOX_RUBBER_VAL") == 0)  { 
    1245                 cp_getint( par, 2, tc, "   drag box rubber val: ", 
    1246                         &(mn5v_global->drag_box_rubber_val), status ); 
    1247         } else if  (strcmp(item,"DEFAULT_FILTER") == 0)  { 
    1248                 cp_getstr( par, 2, tc, "   default_filter: ", BC_LINELTH, str, status); 
    1249                 if  (Severe(status))  return; 
    1250                 if  (strlen(str) > BC_FILELTH)  { 
    1251                         *status = SHE_STROVFL; 
    1252                         return; 
    1253                 } /*endif*/ 
    1254                 strcpy( mn5v_global->default_filter, str ); 
    1255         } else if  (strcmp(item,"DEFAULT_PHASE_TYPE") == 0)  { 
    1256                 cp_getstr( par, 2, tc, "   def. phase type: ", BC_LINELTH, str, status); 
    1257                 if  (Severe(status))  return; 
    1258                 if  (strcmp(str,"OTHER") == 0)  { 
    1259                         mn5v_global->default_phase_type = 0;  /* PIC_TYPE_OTHER */ 
    1260                 } else if  (strcmp(str,"TELE_QUAKE") == 0)  { 
    1261                         mn5v_global->default_phase_type = 1;  /* PIC_TYPE_TELE_QUAKE */ 
    1262                 } else if  (strcmp(str,"NUCLEAR") == 0)  { 
    1263                         mn5v_global->default_phase_type = 2;  /* PIC_TYPE_NUCLEAR */ 
    1264                 } else if  (strcmp(str,"REGIO_QUAKE") == 0)  { 
    1265                         mn5v_global->default_phase_type = 3;  /* PIC_TYPE_REGIO_QUAKE */ 
    1266                 } else if  (strcmp(str,"LOCAL_QUAKE") == 0)  { 
    1267                         mn5v_global->default_phase_type = 4;  /* PIC_TYPE_LOCAL_QUAKE */ 
    1268                 } else if  (strcmp(str,"BLAST") == 0)  { 
    1269                         mn5v_global->default_phase_type = 5;  /* PIC_TYPE_BLAST */ 
    1270                 } else if  (strcmp(str,"MINING") == 0)  { 
    1271                         mn5v_global->default_phase_type = 6;  /* PIC_TYPE_MINING */ 
    1272                 } else { 
    1273                         *status = SHE_ILPAR; 
    1274                         return; 
    1275                 } /*endif*/ 
    1276         } else if  (strcmp(item,"DEFAULT_PHASE_FLAGS") == 0)  { 
    1277                 cp_getstr( par, 2, tc, "   def. phase flags: ", BC_LINELTH, str, status); 
    1278                 if  (Severe(status))  return; 
    1279                 if  (strcmp(str,"CLEAR") == 0)  { 
    1280                         mn5v_global->default_phase_flags = 0; 
    1281                 } else if  (strcmp(str,"CALIB") == 0)  { 
    1282                         mn5v_global->default_phase_flags |= 0x01; /* CUC_F_EVENT_CALIB */ 
    1283                 } else if  (strcmp(str,"IGNORE") == 0)  { 
    1284                         mn5v_global->default_phase_flags |= 0x02; /* CUC_F_EVENT_IGNORE */ 
    1285                 } else if  (strcmp(str,"TELEX_ALL") == 0)  { 
    1286                         mn5v_global->default_phase_flags |= 0x04; /* CUC_F_EVENT_TELEX_ALL */ 
    1287                 } else { 
    1288                         *status = SHE_ILPAR; 
    1289                         return; 
    1290                 } /*endif*/ 
    1291         } else if  (strcmp(item,"DEFAULT_DEPTH_TYPE") == 0)  { 
    1292                 cp_getstr( par, 2, tc, "   def. depth type: ", BC_LINELTH, str, status); 
    1293                 if  (Severe(status))  return; 
    1294                 if  (strcmp(str,"UNDEFINED") == 0)  { 
    1295                         mn5v_global->default_depth_type = 0;  /* CUC_DEPTH_UNDEFINED */ 
    1296                 } else if  (strcmp(str,"PRESET") == 0)  { 
    1297                         mn5v_global->default_depth_type = 1;  /* CUC_DEPTH_PRESET */ 
    1298                 } else if  (strcmp(str,"ESTIMATED") == 0)  { 
    1299                         mn5v_global->default_depth_type = 2;  /* CUC_DEPTH_ESTIMATED */ 
    1300                 } else if  (strcmp(str,"FREE") == 0)  { 
    1301                         mn5v_global->default_depth_type = 3;  /* CUC_DEPTH_FREE */ 
    1302                 } else if  (strcmp(str,"POOR") == 0)  { 
    1303                         mn5v_global->default_depth_type = 4;  /* CUC_DEPTH_POOR */ 
    1304                 } else if  (strcmp(str,"LESSWELL") == 0)  { 
    1305                         mn5v_global->default_depth_type = 5;  /* CUC_DEPTH_LESSWELL */ 
    1306                 } else if  (strcmp(str,"RELIABLE") == 0)  { 
    1307                         mn5v_global->default_depth_type = 6;  /* CUC_DEPTH_RELIABLE */ 
    1308                 } else if  (strcmp(str,"EXTERNAL") == 0)  { 
    1309                         mn5v_global->default_depth_type = 7;  /* CUC_DEPTH_EXTERNAL */ 
    1310                 } else { 
    1311                         *status = SHE_ILPAR; 
    1312                         return; 
    1313                 } /*endif*/ 
    1314         } else if  (strcmp(item,"DEFAULT_DEPTH") == 0)  { 
    1315                 cp_getfloat( par, 2, tc, "   default depth (km): ", 
    1316                         &(mn5v_global->default_depth), status ); 
    1317         } else if  (strcmp(item,"DEFAULT_LOC_QUALITY") == 0)  { 
    1318                 cp_getstr( par, 2, tc, "   def. loc qual.: ", BC_LINELTH, str, status); 
    1319                 if  (Severe(status))  return; 
    1320                 if  (strcmp(str,"UNDEFINED") == 0)  { 
    1321                         mn5v_global->default_loc_quality = 0;  /* CUC_LOCQ_UNDEFINED */ 
    1322                 } else if  (strcmp(str,"TOOWEAK") == 0)  { 
    1323                         mn5v_global->default_loc_quality = 1;  /* CUC_LOCQ_TOOWEAK */ 
    1324                 } else if  (strcmp(str,"INCOHERENT") == 0)  { 
    1325                         mn5v_global->default_loc_quality = 2;  /* CUC_LOCQ_INCOHERENT */ 
    1326                 } else if  (strcmp(str,"NOBEARING") == 0)  { 
    1327                         mn5v_global->default_loc_quality = 3;  /* CUC_LOCQ_NOBEARING */ 
    1328                 } else if  (strcmp(str,"REGION") == 0)  { 
    1329                         mn5v_global->default_loc_quality = 4;  /* CUC_LOCQ_REGION */ 
    1330                 } else if  (strcmp(str,"RELIABLE") == 0)  { 
    1331                         mn5v_global->default_loc_quality = 5;  /* CUC_LOCQ_RELIABLE */ 
    1332                 } else { 
    1333                         *status = SHE_ILPAR; 
    1334                         return; 
    1335                 } /*endif*/ 
    1336         } else if  (strcmp(item,"MAX_CURSOR_FORM") == 0)  { 
    1337                 cp_getstr( par, 2, tc, "   max crsr form: ", BC_LINELTH, str, status); 
    1338                 if  (Severe(status))  return; 
    1339                 if  (strcmp(str,"CROSSHAIR") == 0)  { 
    1340                         mn5v_global->max_cursor_form = 2;  /* MGC_CRSR_CROSSHAIR */ 
    1341                 } else if  (strcmp(str,"WAVEFORM") == 0)  { 
    1342                         mn5v_global->max_cursor_form = 3;  /* MGC_CRSR_WAVEFORM */ 
    1343                 } else if  (strcmp(str,"WAVEFORM_NEG") == 0)  { 
    1344                         mn5v_global->max_cursor_form = 4;  /* MGC_CRSR_WAVEFORM_NEG */ 
    1345                 } else if  (strcmp(str,"WAVEFORM_HILB") == 0)  { 
    1346                         mn5v_global->max_cursor_form = 5;  /* MGC_CRSR_WAVEFORM_HILB */ 
    1347                 } else if  (strcmp(str,"WAVEFORM_NEGHILB") == 0)  { 
    1348                         mn5v_global->max_cursor_form = 6;  /* MGC_CRSR_WAVEFORM_NEGHILB */ 
    1349                 } else { 
    1350                         *status = SHE_ILPAR; 
    1351                         return; 
    1352                 } /*endif*/ 
    1353         } else if  (strcmp(item,"EVENT_CHECK_PROC") == 0)  { 
    1354                 cp_getstr( par, 2, tc, "   event check proc: ", BC_FILELTH, str, status ); 
    1355                 if  (Severe(status))  return; 
    1356                 strcpy( mn5v_global->event_check_proc, str ); 
    1357         } else if  (strcmp(item,"SCREENDUMP_PROC") == 0)  { 
    1358                 cp_getstr( par, 2, tc, "   screendump proc: ", BC_FILELTH, str, status ); 
    1359                 if  (Severe(status))  return; 
    1360                 strcpy( mn5v_global->screendump_proc, str ); 
    1361         } else if  (strcmp(item,"EVTVIEW_PROC") == 0)  { 
    1362                 cp_getstr( par, 2, tc, "   evtview proc: ", BC_FILELTH, str, status ); 
    1363                 if  (Severe(status))  return; 
    1364                 strcpy( mn5v_global->evtview_proc, str ); 
    1365         } else if  (strcmp(item,"REFORMAT_PROC") == 0)  { 
    1366                 cp_getstr( par, 2, tc, "   reformat proc: ", BC_FILELTH, str, status ); 
    1367                 if  (Severe(status))  return; 
    1368                 strcpy( mn5v_global->reformat_proc, str ); 
    1369         } else if  (strcmp(item,"FINAL_PROC") == 0)  { 
    1370                 cp_getstr( par, 2, tc, "   postprocessing proc: ", BC_FILELTH, str, status ); 
    1371                 if  (Severe(status))  return; 
    1372                 strcpy( mn5v_global->final_proc, str ); 
    1373         } else if  (strcmp(item,"REMREQHOST") == 0)  { 
    1374                 cp_getstr( par, 2, tc, "   remreqhost: ", BC_SHORTSTRLTH, str, status ); 
    1375                 if  (Severe(status))  return; 
    1376                 strcpy( mn5v_global->remreqhost, str ); 
    1377         } else if  (strcmp(item,"FULL_PHASE_NAMES") == 0)  { 
    1378                 cp_getstr( par, 2, tc, "   TRUE/FALSE: ", BC_LINELTH, str, status ); 
    1379                 if  (Severe(status))  return; 
    1380                 if  (strcmp(str,"TRUE") == 0)  { 
    1381                         mn5v_global->full_phase_names = TRUE; 
    1382                 } else if  (strcmp(str,"FALSE") == 0)  { 
    1383                         mn5v_global->full_phase_names = FALSE; 
    1384                 } else { 
    1385                         *status = SHE_ILPAR; 
    1386                         return; 
    1387                 } /*endif*/ 
    1388         } else if  (strcmp(item,"DEFAULT_SOURCE") == 0)  { 
    1389                 cp_getstr( par, 2, tc, "   default source: ", BC_SHORTSTRLTH, 
    1390                         str, status ); 
    1391                 if  (Severe(status))  return; 
    1392                 strcpy( mn5v_global->default_source, str ); 
    1393         } else if  (strcmp(item,"AUTO_PHASE") == 0)  { 
    1394                 cp_getstr( par, 2, tc, "   auto phase: ", cBcShortStrLth, str, status ); 
    1395                 if  (Severe(status))  return; 
    1396                 strcpy( mn5v_global->auto_phase, str ); 
    1397         } else if  (strcmp(item,"MOVE_WDW_STEP") == 0)  { 
    1398                 cp_getfloat( par, 2, tc, "   move wdw step: ", 
    1399                         &(mn5v_global->move_wdw_step), status ); 
    1400         } else if  (strcmp(item,"TOP_MARGIN") == 0)  { 
    1401                 cp_getint( par, 2, tc, "   top margin: ", 
    1402                         &(mn5v_global->top_margin), status ); 
    1403         } else if  (strcmp(item,"DRAW_AREA_HEIGHT") == 0)  { 
    1404                 cp_getint( par, 2, tc, "   draw area height: ", 
    1405                         &(mn5v_global->draw_area_height), status ); 
    1406         } else if  (strcmp(item,"DRAW_AREA_WIDTH") == 0)  { 
    1407                 cp_getint( par, 2, tc, "   draw area width: ", 
    1408                         &(mn5v_global->draw_area_width), status ); 
    1409         } else if  (strcmp(item,"AREA_ZOOM_BASE") == 0)  { 
    1410                 cp_getfloat( par, 2, tc, "   area zoom base: ", 
    1411                         &(mn5v_global->area_zoom_base), status ); 
    1412         } else if  (strcmp(item,"AREA_ZOOM_EXP") == 0)  { 
    1413                 cp_getfloat( par, 2, tc, "   area zoom exponent: ", 
    1414                         &(mn5v_global->area_zoom_exp), status ); 
    1415         } else if  (strcmp(item,"OWN_ACCELERATORS") == 0)  { 
    1416                 cp_getstr( par, 2, tc, "   TRUE/FALSE: ", BC_LINELTH, str, status ); 
    1417                 if  (Severe(status))  return; 
    1418                 if  (strcmp(str,"TRUE") == 0)  { 
    1419                         mn5v_global->own_accelerators = TRUE; 
    1420                 } else if  (strcmp(str,"FALSE") == 0)  { 
    1421                         mn5v_global->own_accelerators = FALSE; 
    1422                 } else { 
    1423                         *status = SHE_ILPAR; 
    1424                         return; 
    1425                 } /*endif*/ 
    1426         } else if  (strcmp(item,"FILTER_TYPE") == 0)  { 
    1427                 cp_getstr( par, 2, tc, "   filter type: ", BC_LINELTH, str, status ); 
    1428                 if  (Severe(status))  return; 
    1429                 mn5v_global->filter_type = *str; 
    1430         } else { 
    1431                 /* *status = SHE_UKKEY; */ 
    1432                 printf( "SH: SHMSETUP item %s unknown.  Command ignored.\n", item ); 
    1433                 return; 
    1434         } /*endif*/ 
    1435 #endif 
    1436782 
    1437783} /* end of mn5_shmsetup */ 
  • SH_SHM/branches/marcus/source/shmenuio.c

    r69 r106  
    262262                        datlth = qf_getl( QFCL_LTH, NULL ); 
    263263                } /*endif*/ 
    264          
     264 
    265265                ml_inittrc( blcptr, sdatptr, datlth, dt ); 
    266266 
     
    13191319        FILE     *flagf;                   /* pointer to flag file */ 
    13201320        int      flags;                    /* data flags */ 
    1321 #ifdef XXX 
    1322         BOOLEAN  no_bugfix;                /* do not call jukebox bugfix */ 
    1323 #endif 
    13241321 
    13251322        /* executable code */ 
     
    16901687                } /*endif*/ 
    16911688                if  (Severe(status))  {if (ef != NULL) sy_fclose(ef); return;} 
    1692          
     1689 
    16931690                db_newlist(); 
    16941691                trc = db_create( status ); 
    16951692                if  (Severe(status))  {if (ef != NULL) sy_fclose(ef); return;} 
    1696          
     1693 
    16971694                if  (ef != NULL)  { 
    16981695                        while  (fgets(entstr,BC_LINELTH,ef) != NULL)  { 
     
    17551752                        fseek( ef, 0, 0 ); 
    17561753                } /*endif*/ 
    1757          
     1754 
    17581755                sh_frgn_geti( "LENGTH", &trclth, status ); 
    17591756                if  (Severe(status))  {db_delete(trc); return;} 
    17601757                sh_frgn_getr( "DELTA", &dt, status ); 
    17611758                if  (Severe(status))  {db_delete(trc); return;} 
    1762          
     1759 
    17631760                datptr = (SAMPLE *)sy_allocmem( trclth, (int)sizeof(SAMPLE), status ); 
    17641761                if  (Severe(status))  {db_delete(trc); return;} 
    17651762                sh_frgn_read( datptr ); 
    1766          
     1763 
    17671764                ml_inittrc( trc, datptr, trclth, dt ); 
    17681765                db_setr( trc, ER_TORIG, 0.0, NULL ); 
  • SH_SHM/branches/marcus/source/shmidlev.c

    r16 r106  
    179179                } /*endfor*/ 
    180180                return; 
    181 #  ifdef XXX 
    182         } else if  (*liststr == 'H')  { 
    183                 if  (liststr[1] == ':')  { 
    184                         map = SHC_HIDDENLIST; 
    185                         liststr += 2; 
    186                         prevtrc = EP_PREV; 
    187                         nexttrc = EP_NEXT; 
    188                 } else { 
    189                         prevtrc = EP_DSPP; 
    190                         nexttrc = EP_DSPN; 
    191                         map = gc; 
    192                 } /*endif*/ 
    193 #  endif  /* XXX */ 
    194181        } else { 
    195182                map = gc; 
     
    361348 * 
    362349 * parameters of routine 
    363  * PARAM      *par;            input; menu parameter  
     350 * PARAM      *par;            input; menu parameter 
    364351 * int        pos;             input; parameter number 
    365352 * int        wdw;             input; window number for prompting 
  • SH_SHM/branches/marcus/source/shtransl.c

    r16 r106  
    367367                        return; 
    368368                } /*endif*/ 
    369 #  ifdef XXX 
    370         } else if  (*idxstr == 'H')  { 
    371                 if  (idxstr[1] == ':')  { 
    372                         dln = SHC_HIDDENLIST; 
    373                         idxstr += 2; 
    374                 } else { 
    375                         dln = gc; 
    376                 } /*endif*/ 
    377 #  endif  /* XXX */ 
    378369        } else { 
    379370                dln = gc; /* (gc == 0) ? SHC_HIDDENLIST : gc; */ 
     
    469460        STATUS *status ) 
    470461 
    471 /* returns internal variable  
     462/* returns internal variable 
    472463 * 
    473464 * parameters of routine 
  • SH_SHM/branches/marcus/source/syscall.c

    r105 r106  
    254254        /* executable code */ 
    255255 
    256 #ifdef XXX 
    257         if  (ampl == 0.0)  { 
    258                 srand( (unsigned)clock() ); 
    259                 return 0.0; 
    260         } else { 
    261                 rdm = rand(); 
    262                 return  ( (((double)rdm * 2.0) / MAXRAND - 1.0) * ampl ); 
    263         } /*endif*/ 
    264 #endif 
    265  
    266256        return (drand48()*ampl); 
    267257 
  • SH_SHM/branches/marcus/source/travtime.c

    r16 r106  
    8484static float tt_mantle_psdiff( float convdepth, float slowness, STATUS *status ); 
    8585static float tt_mantle_p_ppp( float convdepth, float slowness, STATUS *status ); 
    86 static float tt_mantle_x( float convdepth, float slowness,  
     86static float tt_mantle_x( float convdepth, float slowness, 
    8787        DIFFPROC diffproc, STATUS *status ); 
    8888static void tth_snellius( float *phi, float vin, float vout ); 
     
    952952/*-------------------------------------------------------------------*/ 
    953953 
    954 #ifdef XXX 
    955  
    956 float tt_travel( int phase, float distance, float depth, 
    957         STATUS *status ) 
    958  
    959 /* returns travel time in seconds for different phases 
    960  * 
    961  * parameters of routine 
    962  * int        phase;       input; phase ID 
    963  * float      distance;    input; distance of source in degrees 
    964  * float      depth;       input; depth of source in km 
    965  * STATUS     *status;     output; return status 
    966  *                         returns travel time of phase in sec 
    967  */ 
    968 { 
    969         /* local variables */ 
    970         FILE     *tf;                    /* table file */ 
    971         int      cmtlines;               /* number of comment lines */ 
    972         float    dep[TTC_DEPTH_STEPS];   /* depths given in table */ 
    973         int      tt_ln[TTC_DEPTH_STEPS]; /* travel times of current line */ 
    974         float    tt_ip[TTC_IP_ORDER];    /* tt interpolation array */ 
    975         float    dst_ip[TTC_IP_ORDER];   /* distance interpolation array */ 
    976         int      i;                      /* counter */ 
    977         char     str[BC_LINELTH+1];      /* scratch */ 
    978         float    currdist;               /* current distance */ 
    979         int      depidx;                 /* depth index */ 
    980         int      dstidx;                 /* distance index to compare */ 
    981         float    depthstep;              /* depth step size */ 
    982         float    ttime;                  /* travel time returned */ 
    983         float    err;                    /* interpolation deviation */ 
    984         STATUS   locstat=BC_NOERROR;     /* local status */ 
    985  
    986         /* executable code */ 
    987  
    988         cmtlines = tth_get_comment_lines( phase, status ); 
    989         if  (Severe(status))  return 0.0; 
    990  
    991         tth_get_depth_steps( dep ); 
    992  
    993         /* check bounds */ 
    994         if  ((depth < *dep) || (depth > dep[TTC_DEPTH_STEPS-1]))  { 
    995                 *status = TTE_DEPTHOOR; 
    996                 return 0.0; 
    997         } /*endif*/ 
    998         if  ((distance < 0.0) || (distance > TTC_MAXDIST))  { 
    999                 *status = TTE_DISTOOR; 
    1000                 return 0.0; 
    1001         } /*endif*/ 
    1002  
    1003         /* open table file */ 
    1004         tf = sy_fopen( ttv_tablename, "r" ); 
    1005         if  (tf == NULL)  { 
    1006                 *status = TTE_FOPNRD; 
    1007                 err_setcontext( " ## file " ); err_setcontext( ttv_tablename ); 
    1008                 return 0.0; 
    1009         } /*endif*/ 
    1010  
    1011         /* skip comment lines */ 
    1012         for  (i=0; i<cmtlines; i++) 
    1013                 if  (fgets(str,BC_LINELTH,tf) == NULL)  { 
    1014                         *status = TTE_FREAD; 
    1015                         return 0.0; 
    1016                 } /*endif*/ 
    1017  
    1018         /* find depth index */ 
    1019         depidx = 1; 
    1020         while  (dep[depidx] < depth) 
    1021                 depidx++; 
    1022         depthstep = dep[depidx] - dep[depidx-1]; 
    1023         dstidx = TTC_IP_ORDER/2; 
    1024  
    1025         /* read at least TTC_IP_ORDER depths */ 
    1026         for  (i=0; i<TTC_IP_ORDER; i++)  { 
    1027                 tth_readline( tf, dst_ip+i, tt_ln, status ); 
    1028                 /* depth interpolation */ 
    1029                 tt_ip[i] = tt_ln[depidx-1] + (dep[depidx-1]-depth) 
    1030                         * (tt_ln[depidx]-tt_ln[depidx-1]) / depthstep; 
    1031                 if  (Severe(status))  return 0.0; 
    1032         } /*endfor*/ 
    1033  
    1034         FOREVER  { 
    1035                 if  (dst_ip[dstidx] > distance)  break; 
    1036                 tth_readline( tf, &currdist, tt_ln, &locstat ); 
    1037                 if  (Severe(&locstat))  break; 
    1038                 /* shift arrays */ 
    1039                 for  (i=0; i<TTC_IP_ORDER-1; i++)  { 
    1040                         tt_ip[i] = tt_ip[i+1]; 
    1041                         dst_ip[i] = dst_ip[i+1]; 
    1042                 } /*endfor*/ 
    1043                 dst_ip[TTC_IP_ORDER-1] = currdist; 
    1044                 tt_ip[TTC_IP_ORDER-1] = (float)(tt_ln[depidx-1]) + (dep[depidx-1]-depth) 
    1045                         * (float)(tt_ln[depidx]-tt_ln[depidx-1]) / depthstep; 
    1046         } /*endfor*/ 
    1047  
    1048         fclose( tf ); 
    1049  
    1050         /* polynomial interpolation */ 
    1051         nr_polint( dst_ip, tt_ip, TTC_IP_ORDER, distance, &ttime, &err ); 
    1052  
    1053         ttv_delta_dist = dst_ip[dstidx] - dst_ip[dstidx-1]; /* store distance step */ 
    1054  
    1055         return (ttime / 10.0);  /* values in table are tenths of seconds */ 
    1056  
    1057 } /* end of tt_travel */ 
    1058  
    1059 #endif /* XXX */ 
    1060  
    1061 /*-------------------------------------------------------------------*/ 
    1062  
    1063  
    1064954 
    1065955float tt_slowness( int phase, float distance, float depth, 
     
    1088978        return  ((tt_travel(phase,lo_dist+curr_delta_dist,depth,status) - 
    1089979                tt_travel(phase,lo_dist,depth,status)) / curr_delta_dist); 
    1090          
     980 
    1091981 
    1092982} /* end of tt_slowness */ 
     
    11981088        /* executable code */ 
    11991089 
    1200 #       ifdef XXX  /* old version */ 
    1201         if  (fscanf( tf, "%f ", dist ) != 1)  { 
    1202                 *status = TTE_FREAD; 
    1203                 return; 
    1204         } /*endif*/ 
    1205  
    1206         for  (i=0; i<14; i++) 
    1207                 if  (fscanf(tf,"%d ",tt+i) != 1)  { 
    1208                         *status = TTE_FREAD; 
    1209                         return; 
    1210                 } /*endif*/ 
    1211 #       endif 
    1212  
    12131090        if  (fscanf( tf, "%5f ", dist ) != 1)  { 
    12141091                *status = TTE_FREAD; 
Note: See TracChangeset for help on using the changeset viewer.