source: SH_SHM/trunk/source/motif/cbutil.c @ 44

Revision 44, 90.4 KB checked in by marcus, 14 years ago (diff)

r29 | svn | 2008-02-23 23:02:22 +0100 (Sa, 23 Feb 2008) | 1 line

implemented trailer string in sfdb requests necessary for ingres

Line 
1
2/* file cbutil.c
3 *      ========
4 *
5 * $Revision: 29 $, $Date: 2008-02-23 23:02:22 +0100 (Sa, 23 Feb 2008) $
6 *
7 * utility routines for callbacks
8 * K. Stammler, 3-Mar-93
9 */
10
11
12/*
13 *
14 *  SeismicHandler, seismic analysis software
15 *  Copyright (C) 1996,  Klaus Stammler, Federal Institute for Geosciences
16 *                                       and Natural Resources (BGR), Germany
17 *
18 *  This program is free software; you can redistribute it and/or modify
19 *  it under the terms of the GNU General Public License as published by
20 *  the Free Software Foundation; either version 2 of the License, or
21 *  (at your option) any later version.
22 *
23 *  This program is distributed in the hope that it will be useful,
24 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
25 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
26 *  GNU General Public License for more details.
27 *
28 *  You should have received a copy of the GNU General Public License
29 *  along with this program; if not, write to the Free Software
30 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
31 *
32 */
33
34
35#include <stdio.h>
36#include <string.h>
37#include "basecnst.h"
38#ifdef BC_INC_STDLIB
39#include BC_INC_STDLIB
40#endif
41#include <Xm/Xm.h>
42#include <Xm/ToggleB.h>
43#include <Xm/Text.h>  /* because XmTextSetString is not defined in Xm.h */
44#include <time.h>
45#include <math.h>
46#undef BC_DEFINE_TRUE_FALSE
47#include BC_SYSBASE
48#include BC_TCUSRDEF
49#include "infoidx.h"
50#include "glusrdef.h"
51#include "fctxmt.h"
52#include "sherrors.h"
53#include "earthloc.h"
54#include "ptusrdef.h"
55#include "ffusrdef.h"
56#include "erusrdef.h"
57#include "utusrdef.h"
58#include "motifgraph.h"
59#include "seismics.h"
60#include "cbutil.h"
61#include "phaseinf.h"
62#include "phasemgr.h"
63#include "shvars.h"
64#include "shm_widgets.h"
65#include "globalparams.h"
66
67
68#define WAIT_UNIT 10000
69
70
71
72/* global variables */
73static Widget  cuv_alert_widget;      /* widget ID of alert box */
74static Widget  cuv_multipli_value;    /* widget ID for multiplic. box (value) */
75static Widget  cuv_multipli_box;      /* widget ID for multiplic. box */
76static Widget  cuv_multipli_edit;     /* widget ID for multiplic. box (edit) */
77static TPiPhase *cuv_multipli_phase=NULL; /* pointer to multiplication value */
78static TPiPhase *cuv_multipli_trc=NULL;   /* pointer to multiplication value */
79static int     cuv_execflags=0;       /* execution flag memory */
80
81
82
83
84/* prototype of get_geo */
85void xxx_get_geo(float *elat, float *elon, int *num_id, char *qnam);
86
87/* prototypes of local routines */
88static void cuh_strip_blanks( char str[] );
89static void cuh_wait( int cnt );
90static void cuh_phase_onset( char phase[], void *trc, char **onset,
91        float *residcorr );
92static GLT_STATINF *cu_get_statinf( TPmTrace *trc, TSyStatus *status );
93
94
95
96/*---------------------------------------------------------------------------*/
97
98
99
100void cu_reset_phase( TPiPhase *phase )
101
102/* resets phase info to default values
103 *
104 * parameters of routine
105 * TPiPhase   *phase;      output; structure to reset
106 */
107{
108        /* executable code */
109
110        phase->onset[0] = '\0';
111        phase->onset_acc_l = cPiAccEmpty;
112        phase->onset_acc_r = cPiAccEmpty;
113        phase->spec = cPiSpecEmergent;
114        phase->sign = 0;
115        phase->source = cPiSourceUndefined;
116        phase->quality = GpGetInt( cGpI_default_quality );
117        phase->weight = cu_quality2weight( phase->quality );
118        phase->ampl = 0.0;
119        phase->ampl_time = 0.0;
120        phase->ampl_veloc = 0.0;
121        phase->ampl_displ = 0.0;
122        phase->period = 0.0;
123        phase->magnitude = 0.0;
124        phase->magn_source = cPiMagnUndefined;
125        phase->ap_source = cPiApsrcUndefined;
126        phase->bb.bbampl = 0.0;
127        phase->bb.bbperiod = 0.0;
128        phase->bb.bbampl_time = 0.0;
129        phase->bb.mbb = 0.0;
130        phase->signoise = 0.0;
131        phase->resid = 0.0;
132        phase->resid_type = cPiResidUndefined;
133        phase->resid_corr = cPiResidCorrEmpty;
134        phase->flags = 0;
135        phase->filter[0] = '\0';
136        phase->comment[0] = '\0';
137        phase->reliable = TRUE;
138
139} /* end of cu_reset_phase */
140
141
142
143/*---------------------------------------------------------------------------*/
144
145
146
147void cu_reset_parameters( CUT_PARAMS *par )
148
149/* resets parameters to default values
150 *
151 * parameters of routine
152 * CUT_PARAMS    *par;     parameters to be reset
153 */
154{
155        /* executable code */
156
157        par->distance = 0.0;
158        par->dist_unit = CUC_DIST_UNIT_DEG;
159        par->b_slowness = 0.0;
160        par->b_slowness_err = 0.0;
161        par->b_azimuth = 0.0;
162        par->b_azimuth_err = 0.0;
163        par->l_slowness = 0.0;
164        par->l_azimuth = 0.0;
165        par->depth = GpGetFloat( cGpF_default_depth );
166        par->depth_type = GpGetInt( cGpI_default_depth_type );
167        par->origin[0] = '\0';
168        par->source_lat = 0.0;
169        par->source_lon = 0.0;
170        par->source_type = GpGetInt( cGpI_default_event_type );
171        par->center_lat = 0.0;
172        par->center_lon = 0.0;
173        par->ref_lat = 0;
174        par->ref_lon = 0;
175        par->reg_id = 0;
176        par->regname[0] = '\0';
177        par->loc_meth = CUC_LOCMETH_UNDEFINED;
178        par->loc_quality = GpGetInt( cGpI_default_loc_quality );
179        par->loc_addpar[0] = '\0';
180        par->velmod[0] = '\0';
181        par->momten[0] = '\0';
182        par->momten_descr[0] = '\0';
183        par->fps_angles[0] = '\0';
184        par->fps_descr[0] = '\0';
185        par->mu_descr[0] = '\0';
186        par->cornerfreq = 0.0;
187        par->lowfreqlevel = 0.0;
188        par->m0 = 0.0;
189        par->stations_used = 0;
190        par->phase[0] = '\0';
191        if  (par->comment != NULL)
192                sy_deallocmem( par->comment );
193        par->comment = NULL;
194        par->source[0] = '\0';
195        par->soft_change = FALSE;
196        par->flags = GpGetInt( cGpI_default_phase_flags );
197        par->err.lat = 0.0;
198        par->err.lon = 0.0;
199        par->err.dep = 0.0;
200        par->err.orig = 0.0;
201        par->err.smajor = 0.0;
202        par->err.sminor = 0.0;
203        par->err.majstrike = 0.0;
204        par->err.dist_unit = CUC_DIST_UNIT_DEG;
205
206        PiSbClearAll( &(par->slowbox) );
207
208        cu_clear_exec_flags();
209
210} /* end of cu_reset_parameters */
211
212
213
214/*--------------------------------------------------------------------------*/
215
216
217
218void cu_reset_paramsets( CUT_PARAMSETS *parset )
219
220/* resets all parameter sets
221 *
222 * parameters of routine
223 * CUT_PARAMSETS *parset;        output; parameter to be reset
224 */
225{
226        /* local variables */
227        int      i;         /* counter */
228
229        /* executable code */
230
231        /* parset->state = CUC_PARSTATE_PROCESS; */
232        parset->evid = 0;
233        parset->parno = 0;
234        for  (i=0; i<CUC_MAXPARSET; i++)
235                cu_reset_parameters( parset->par+i );
236
237} /* end of cu_reset_paramsets */
238
239
240
241/*--------------------------------------------------------------------------*/
242
243
244
245void cu_set_read_time( Widget date, Widget time, float incr, TSyStatus *status )
246
247/* increments read time by "incr" seconds
248 *
249 * parameters of routine
250 * Widget     date, time;    input; Widget ID's for date and time text
251 * float      incr;          input; time increment in seconds
252 * TSyStatus  *status;       output; return status
253 */
254{
255        /* local variables */
256        char     *str;                   /* string pointer */
257        char     timestr[BC_LINELTH+1];  /* time string */
258        NTIME    ntime;                  /* numeric time */
259        int      loopcnt;                /* loop counter */
260        static int last_timestamp=0;     /* last timestamp */
261        /* QueryPointer returns */
262        Window   root, child;
263        int      root_x, root_y;
264        int      win_x, win_y;
265        unsigned mask;
266
267        /* executable code */
268
269        loopcnt = 0;
270
271        do  {
272
273                str = cu_get_string( date );
274                strcpy( timestr, str );
275                cuh_strip_blanks( timestr );
276                strcat( timestr, "_" );
277                str = cu_get_string( time );
278                strcat( timestr, str );
279                cuh_strip_blanks( timestr );
280                if  (incr == CUC_MONTH_INC)  {
281                        tc_t2n( timestr, &ntime, status );
282                        if  (Severe(status))  return;
283                        if  (++(ntime.month) > 12)  {
284                                ntime.month = 1;
285                                (ntime.year)++;
286                        } /*endif*/
287                        tc_n2t( &ntime, timestr, status );
288                } else if  (incr == CUC_MONTH_DEC)  {
289                        tc_t2n( timestr, &ntime, status );
290                        if  (Severe(status))  return;
291                        if  (--(ntime.month) <= 0)  {
292                                ntime.month = 12;
293                                (ntime.year)--;
294                        } /*endif*/
295                        tc_n2t( &ntime, timestr, status );
296                } else if  (incr == CUC_YEAR_INC)  {
297                        tc_t2n( timestr, &ntime, status );
298                        if  (Severe(status))  return;
299                        (ntime.year)++;
300                        tc_n2t( &ntime, timestr, status );
301                } else if  (incr == CUC_YEAR_DEC)  {
302                        tc_t2n( timestr, &ntime, status );
303                        if  (Severe(status))  return;
304                        (ntime.year)--;
305                        tc_n2t( &ntime, timestr, status );
306                } else {
307                        tc_tadd( timestr, incr, timestr, status );
308                } /*endif*/
309                if  (Severe(status))  return;
310                timestr[11] = '\0';
311                timestr[20] = '\0';
312                cu_set_string( date, timestr );
313                cu_set_string( time, timestr+12 );
314
315                XQueryPointer( XtDisplay(date), XtWindow(date), &root, &child,
316                        &root_x, &root_y, &win_x, &win_y, &mask );
317                if  (!(Button1Mask & mask))  break;
318
319                if  (loopcnt == 0)  {
320                        cuh_wait( 5*WAIT_UNIT );
321                } else if  (loopcnt >= 1)  {
322                        cuh_wait( WAIT_UNIT );
323                } /*endif*/
324
325                XQueryPointer( XtDisplay(date), XtWindow(date), &root, &child,
326                        &root_x, &root_y, &win_x, &win_y, &mask );
327
328                loopcnt++;
329
330        }  while  (Button1Mask & mask);
331
332} /* end of cu_set_read_time */
333
334
335
336/*-----------------------------------------------------------------------*/
337
338
339
340void cu_set_read_time_file( Widget w[], int mode, char autoevt[],
341        TSyStatus *status )
342
343/* reads next/previous time from file
344 *
345 * parameters of routine
346 * Widget     w[];        input; widget array
347 * int        mode;       input; search mode
348 * char       autoevt[];  output; name of evt-file
349 * TSyStatus  *status;    output; return status
350 */
351{
352        /* local variables */
353        static int curr_line=0;         /* current line count */
354        FILE     *fp;                   /* file pointer */
355        char     line[cBcLongStrLth+1]; /* current line */
356        char     *c, *cp, *cc;          /* pointers to char */
357        int      i;                     /* line counter */
358        char     timestr[BC_TIMELTH+1]; /* time string */
359        char     file[BC_FILELTH+1];    /* input file */
360        int      slen;                  /* string length */
361        int      loopcnt;               /* loop counter */
362        /* QueryPointer returns */
363        Window   root, child;
364        int      root_x, root_y;
365        int      win_x, win_y;
366        unsigned mask;
367
368        /* executable code */
369
370        /* build filename */
371        c = cu_get_string( w[k_widget_read_grsn_eventfile_text] );
372        if  (strlen(c) > BC_FILELTH)  {
373                *status = CUE_STROVFL;
374                return;
375        } /*endif*/
376
377        /* check whether filename is complete */
378        fp = sy_fopen( c, "r" );
379        if  (fp == NULL)  {
380                /* no directory specified, take default directory */
381                slen = (int)strlen( GpGetString(cGpS_defpath_events) );
382                if  (slen+strlen(c)+1 > BC_FILELTH)  {
383                        *status = CUE_STROVFL;
384                        return;
385                } /*endif*/
386                strcpy( file, GpGetString(cGpS_defpath_events) );
387                if  (file[slen-1] != '/')
388                        strcat( file, "/" );
389                strcat( file, c );
390                /* open file */
391                fp = sy_fopen( file, "r" );
392                if  (fp == NULL)  {
393                        printf( "*SHM: file %s not found\n", c );
394                        return;
395                } /*endif*/
396        } else {
397                /* directory is there, take it as it is */
398                strcpy( file, c );
399        } /*endif*/
400
401        loopcnt = 0;
402        do  {
403
404                fseek( fp, 0, 0 );
405
406                if  (mode == CUC_LIST_NEXT)  {
407                        curr_line++;
408                } else {
409                        curr_line--;
410                } /*endif*/
411                if  (curr_line <= 0)  curr_line = 1;
412
413                i = 0;
414                *line = '\0';
415                while  (i < curr_line)  {
416                        if  (fgets(line,cBcLongStrLth,fp) == NULL)
417                                curr_line--;
418                        if  (*line != '!')  i++;
419                } /*endwhile*/
420
421                sprintf( timestr, "%d", curr_line );
422                cu_set_string( w[k_widget_read_grsn_eventno_text], timestr );
423
424                /* read and then remove remainder of line (after time string) */
425                *autoevt = '\0';
426                if  (*line == '\0')  {sy_fclose( fp ); return;}
427                i = (int)strlen( line ) - 1;
428                if  (line[i] == '\n')  line[i] = '\0';
429                c = line;
430                while  (*c != '\0' && *c == ' ')
431                        c++;
432                cp = c;
433                while  (*cp != '\0' && *cp != ' ')
434                        cp++;
435                /* remove remainder and put it to autoevt */
436                if  (*cp != '\0')  {
437                        *cp++ = '\0';
438                        while  (*cp != '\0' && *cp == ' ')  cp++;
439                        cc = cp;
440                        while  (*cc != ' ' && *cc != '\0')  cc++;
441                        if  (*cp != '\0')   {
442                                if  ((cc-cp) > BC_FILELTH)  {
443                                        *status = CUE_STROVFL;
444                                        sy_fclose( fp );
445                                        return;
446                                } /*endif*/
447                                sscanf( cp, "%s", autoevt );
448                        } /*endif*/
449                } /*endif*/
450
451                /* reformat time string */
452                tc_tadd( c, 0.0, timestr, status );
453                if  (Severe(status)) {sy_fclose( fp ); return;}
454
455                timestr[11] = '\0';
456                timestr[20] = '\0';
457                cu_set_string( w[k_widget_read_grsn_date], timestr );
458                cu_set_string( w[k_widget_read_grsn_time], timestr+12 );
459
460                if  (loopcnt == 0)  {
461                        cuh_wait( 5*WAIT_UNIT );
462                } else if  (loopcnt >= 1)  {
463                        cuh_wait( WAIT_UNIT );
464                } /*endif*/
465
466                XQueryPointer( XtDisplay(w[k_widget_read_grsn_date]),
467                        XtWindow(w[k_widget_read_grsn_date]), &root, &child,
468                        &root_x, &root_y, &win_x, &win_y, &mask );
469
470                loopcnt++;
471
472        }  while  (Button1Mask & mask);
473
474        sy_fclose( fp );
475
476} /* end of cu_set_read_time_file */
477
478
479
480/*-----------------------------------------------------------------------*/
481
482
483
484void cu_current_time( char str[] )
485
486/* returns current time.  Minimum length of str is 21
487 *
488 * parameter of routine
489 * char      str[];      output; time string
490 */
491{
492        /* local variable */
493        char     s[81];
494        time_t   ct;
495
496        /* executable code */
497
498        ct = time( NULL );
499        strcpy( s, ctime(&ct) );
500        strncpy( str, s+8, 2 );     /* dd */
501        str[2] = '-';               /* dd- */
502        strncpy( str+3, s+4, 3 );   /* dd-mmm */
503        str[6] = '-';               /* dd-mmm- */
504        strncpy( str+7, s+20, 4 );  /* dd-mmm-yyyy */
505        str[11] = '_';              /* dd-mmm-yyyy_ */
506        strncpy( str+12, s+11, 8 ); /* dd-mmm-yyyy_hh:mm:ss */
507        str[20] = '\0';
508
509} /* end of cu_current_time */
510
511
512
513/*--------------------------------------------------------------------------*/
514
515
516
517static void cuh_strip_blanks( char str[] )
518
519/* removes blanks at beginning and end of string
520 *
521 * parameters of routine
522 * char       str[];    modify; string to remove blanks
523 */
524{
525        /* local variables */
526        int     slen;      /* string length */
527
528        /* executable code */
529
530        while  (*str == ' ')
531                strcpy( str, str+1 );
532
533        slen = strlen( str ) - 1;
534        while  (str[slen] == ' ')
535                str[slen--] = '\0';
536
537} /* end of cuh_strip_blanks */
538
539
540
541/*--------------------------------------------------------------------------*/
542
543
544
545static void cuh_wait( int cnt )
546
547/* wait loop
548 *
549 * parameters of routine
550 * int        cnt;     input; loop counter
551 */
552{
553        /* local variables */
554        float    dmy;
555
556        /* executable code */
557
558#ifdef XXX
559        dmy = 1000.0;
560        while  (cnt-- > 0)  {
561                dmy = sqrt( dmy );
562                dmy = pow( dmy, 2.0 );
563        } /*endwhile*/
564#endif
565
566        usleep( 3*cnt );
567
568} /* end of cuh_wait */
569
570
571
572/*--------------------------------------------------------------------------*/
573
574
575
576void cu_accept_phase( Widget wm, Widget ws, TPiPhase *phase, TPmTrace *phtrc,
577        TSyBoolean acc, TSyStatus *status )
578
579/* accepts a phase from dialog box
580 *
581 * parameters of routine
582 * Widget     wm;      input; main window
583 * Widget     ws;      input; single trace window
584 * TPiPhase   *phase;  input; pointer to phase info
585 * TPmTrace   *phtrc;  input; pointer to trace
586 * TSyBoolean acc;     input; show accuracies of phases
587 * TSyStatus  *status; output; returns status if no NULL
588 */
589{
590        /* local variables */
591        TSyStatus    locstat=BC_NOERROR;  /* local status */
592
593        /* executable code */
594
595        PmAddPhase( phtrc, phase, status );
596        if  (SySevere(status))  return;
597
598        mg_do_phase( (Widget)0, MGC_WDW_LAST, MGC_PHASE_CLEAR,
599                0, 0, NULL, NULL, NULL );
600        mg_mark_one_phase( wm, ws, phase, phtrc, acc );
601
602} /* end of cu_accept_phase */
603
604
605
606/*--------------------------------------------------------------------------*/
607
608
609
610void cu_phase_box_defaults( Widget w[], TPiPhase *phase )
611
612/* sets button states of phase box
613 *
614 * parameters of routine
615 * Widget     w[];        input; widget array
616 * TPiPhase   *phase;     input; phase info
617 */
618{
619        /* local variables */
620        Arg      al[1];       /* argument list */
621        int      qual_widget; /* quality button */
622
623        /* executable code */
624
625        cu_set_string( w[k_widget_phase_name_text], phase->name );
626        XmToggleButtonSetState( w[k_widget_phase_spec_e],
627                (phase->spec == cPiSpecEmergent), FALSE );
628        XmToggleButtonSetState( w[k_widget_phase_spec_i],
629                (phase->spec == cPiSpecImpulsive), FALSE );
630        XmToggleButtonSetState( w[k_widget_phase_sign_p],
631                (phase->sign > 0), FALSE );
632        XmToggleButtonSetState( w[k_widget_phase_sign_m],
633                (phase->sign < 0), FALSE );
634        XmToggleButtonSetState( w[k_widget_phase_sign_0],
635                (phase->sign == 0), FALSE );
636        XmToggleButtonSetState( w[k_widget_phase_reliab_yes],
637                phase->reliable, FALSE );
638        XmToggleButtonSetState( w[k_widget_phase_reliab_no],
639                !(phase->reliable), FALSE );
640
641        if  (phase->quality < 1)  phase->quality = 1;
642        if  (phase->quality > 9)  phase->quality = 9;
643        qual_widget = k_widget_phase_qual_0 + phase->quality;
644        XtSetArg( al[0], XmNmenuHistory, w[qual_widget] );
645        XtSetValues( w[k_widget_phase_weight_option], al, 1 );
646
647} /* end of cu_phase_box_defaults */
648
649
650
651/*--------------------------------------------------------------------------*/
652
653
654
655#define SH_DEBUG
656
657#define CLEAR_AND_RETURN \
658        sy_deallocmem( delay ); \
659        sy_deallocmem( lat ); \
660        sy_deallocmem( xcp ); \
661        sy_deallocmem( code ); \
662        return;
663
664#define CODELTH 7
665
666
667
668void cu_localization( char phasename[], int do_flags, CUT_PARAMS *par,
669        TSyStatus *status )
670
671/* performs localization of event, using marked phases of type "phasename".
672 * If CUF_DOLOC_SLOAZ is specified in "do_flags" than slowness and azimuth
673 * is determined from a plane wave approximation.  If CUF_DOLOC_DISTANCE
674 * is specified the distance in degrees for the given phase and the current
675 * slowness value is computed using the appropriate travel time table.
676 *
677 * parameters of routine
678 * char       phasename[];  input; name of phase to be used
679 * int        do_flags;     input; CUF_DOLOC_SLOAZ and/or CUF_DOLOC_DISTANCE
680 * CUT_PARAMS *par;         input/output; analysis parameters
681 * TSyStatus  *status;      output; return status
682 */
683{
684        /* local variables */
685        int      alloclth;                /* array length to allocate */
686        float    *delay;                  /* pointer to time delays */
687        float    *x, *y;                  /* pointer to relative coordinate */
688        float    *shift;                  /* time shifts */
689        float    *resid;                  /* station residuals to plane wave */
690        STATLOC  *lat, *lon;              /* pointer to station locations */
691        char     *code;                   /* station codes */
692        int      codepos;                 /* code string position */
693        TSyBoolean same_array;            /* use relative or absolute locations */
694        int      listlth;                 /* number of phases found */
695        int      t;                       /* trace counter */
696        void     *trc;                    /* current trace pointer */
697        char     station[BC_LINELTH+1];   /* name of current station */
698        GLT_STATINF *statinf;             /* pointer to station info */
699        int      arrcode;                 /* array code */
700        char     *onset;                  /* pointer to onset time */
701        char     firsttime[BC_TIMELTH+1]; /* onset time of first trace */
702        char     reftime[BC_TIMELTH+1];   /* reference time */
703        float    dt;                      /* sample distance in sec */
704        TSyBoolean same_dt;               /* same sample distance */
705        float    travtime;                /* trave time */
706        int      loc_method;              /* location method */
707        TSyBoolean german_event;          /* this is a german event (roughly) */
708        float    ref_shift;               /* time shift betw. first and ref. trace */
709        STATLOC  clat, clon;              /* location of center */
710        float    u_azim;                  /* used azimuth */
711        double   dbl_dist, dbl_azim, dbl_bazim;  /* double results of locdiff */
712        float    *xcp, *ycp, *tcp;        /* backup values */
713        float    residcorr;               /* residual correction */
714        int      ii;                      /* counter */
715        TPiPhaseRoot *proot;              /* pointer to phase root */
716        TPiPhaseList *plist;              /* pointer to phase list */
717        TPiPhase *resphase;               /* pointer to phase */
718        TSyStatus locstat;                /* local status */
719        float    residrms;                /* root mean square residual */
720
721        /* executable code */
722
723        alloclth = mg_dsptrcs();
724        if  (alloclth == 0)  {
725                *status = CUE_NOTRACES;
726                return;
727        } /*endif*/
728
729        /* allocate memory */
730        delay = (float *)sy_allocmem( (alloclth+1)*5, (int)sizeof(float), status );
731        if  (Severe(status))  return;
732        lat = (STATLOC *)sy_allocmem( (alloclth+1)*2, (int)sizeof(STATLOC), status );
733        if  (Severe(status))  {sy_deallocmem(delay); return;}
734        x = delay + alloclth+1;
735        y = x + alloclth+1;
736        shift = y + alloclth+1;
737        resid = shift + alloclth+1;
738        lon = lat + alloclth+1;
739        xcp = (float *)sy_allocmem( (alloclth+1)*3, (int)sizeof(float), status );
740        if  (Severe(status))  {sy_deallocmem(delay); sy_deallocmem(lat); return;}
741        ycp = xcp + alloclth+1;
742        tcp = ycp + alloclth+1;
743        code = (char *)sy_allocmem( (alloclth+1)*(CODELTH+1),
744                (int)sizeof(char), status );
745        if  (Severe(status))  {sy_deallocmem(delay); sy_deallocmem(lat);
746                sy_deallocmem(xcp); return;}
747
748        /* get delays and positions */
749        listlth = 0;
750        same_array = TRUE;
751        *firsttime = *reftime = '\0';
752        dt = 0.0;
753        same_dt = TRUE;
754        arrcode = -1;
755        clat = clon = 0.0;
756        codepos = 0;
757        trc = NULL;
758        for  (t=0; t<alloclth; t++)  {
759                trc = db_getp( trc, EP_DSPN, status );
760                if  (SySevere(status))  {CLEAR_AND_RETURN}
761                /* get name of station */
762                db_gets( trc, ES_STATION, BC_LINELTH, station, status );
763                if  (Severe(status))  {CLEAR_AND_RETURN}
764                strncpy( code+codepos, station, CODELTH );
765                codepos += CODELTH+1;
766                /* check for phase onset on BEAM if reference station is CENTRE */
767                if  (strcmp(station,"BEAM") == 0 || strcmp(station,"ALIGN") == 0)  {
768                        if  (strcmp(GpGetString(cGpS_refstation),"CENTRE") != 0
769                                && strcmp(GpGetString(cGpS_refstation),"CENTER") != 0)
770                                continue;
771                        cuh_phase_onset( phasename, trc, &onset, &residcorr );
772                        if  (onset == NULL)  continue;
773                        strcpy( reftime, onset );
774                        continue;
775                } /*endif*/
776                /* retrieve station info */
777                statinf = (GLT_STATINF *)db_getp( trc, EP_STAT, status );
778                if  (statinf == NULL)  {
779                        *status = BC_NOERROR;
780                        statinf = gl_store_station( station, TRUE, status );
781                        if  (Severe(status))  {CLEAR_AND_RETURN}
782                        db_setp( trc, EP_STAT, statinf, status );
783                        if  (Severe(status))  {CLEAR_AND_RETURN}
784                } /*endif*/
785                /* get phase onset time */
786                cuh_phase_onset( phasename, trc, &onset, &residcorr );
787                if  (onset == NULL)  continue;
788                /* if reference station is in selected list, store onset */
789                if  (strcmp(station,GpGetString(cGpS_refstation)) == 0)
790                        strcpy( reftime, onset );
791                /* store station location */
792                lat[listlth] = statinf->lat;
793                lon[listlth] = statinf->lon;
794                x[listlth] = statinf->xrel;
795                y[listlth] = statinf->yrel;
796                clat += statinf->lat;
797                clon += statinf->lon;
798                /* check whether to use relative or absolute location */
799                if  (arrcode < 0)  arrcode = statinf->arr_id;
800                if  (statinf->arr_id != arrcode) same_array = FALSE;
801                /* store onset time on first trace and relative delays */
802                if  (*firsttime == '\0')  {
803                        strcpy( firsttime, onset );
804                        delay[listlth] = 0.0;
805                } else {
806                        delay[listlth] = tc_tdiff( onset, firsttime, status );
807                        if  (Severe(status))  {CLEAR_AND_RETURN}
808                } /*endif*/
809                if  (par->loc_meth == CUC_LOCMETH_RESIDCORR)  {
810                        delay[listlth] -= residcorr;
811                        /* printf( "*SHM: apply residual correction\n" ); */
812                } /*endif*/
813                /* check for the sample rate */
814                if  (dt == 0.0)  {
815                        dt = db_getr( trc, ER_DELTA, NULL );
816                } else {
817                        if  (db_getr(trc,ER_DELTA,NULL) != dt)
818                                same_dt = FALSE;
819                } /*endif*/
820                listlth++;
821        } /*endfor*/
822
823        if  (arrcode == 0)
824                same_array = FALSE;
825
826        /* get position of reference station */
827        cu_reference_location( lat+listlth, lon+listlth, x+listlth,
828                y+listlth, &arrcode, status );
829        if  (Severe(status))  {CLEAR_AND_RETURN}
830
831#ifdef XXX
832        if  (!same_array)  {
833                if  (GpGetInt(cGpI_debug_level) > 2)
834                        printf( "SHM-dbg3: rel. location from (lat,lon) recomputed.\n" );
835                mt_deg_to_km( listlth+1, lat, lon, x, y );
836        } /*endif*/
837#endif
838        mb_deg_to_km( listlth+1, lat, lon, x, y );
839
840        for  (t=0; t<=listlth; t++)
841                printf( "%lf %lf %f %f\n", lat[t], lon[t], x[t], y[t] );
842
843
844        if  (listlth < 3 && (CUF_DOLOC_SLOAZ & do_flags))  {
845
846                *status = CUE_TOOLESS;
847                CLEAR_AND_RETURN
848
849        } else if  (CUF_DOLOC_SLOAZ & do_flags)  {
850
851                /* check delta-t if only three traces */
852                if  (listlth == 3 && !same_dt)  {
853                        *status = SHE_DIFFSAMP;
854                        CLEAR_AND_RETURN
855                } /*endif*/
856 
857                /* perform location */
858                /* it does not matter that "delay" is relative to */
859                /* "firsttime" instead of "reftime" */
860                /* save values */
861                for  (ii=0; ii<listlth; ii++)  {
862                        tcp[ii] = delay[ii];
863                        xcp[ii] = x[ii];
864                        ycp[ii] = y[ii];
865                } /*endfor*/
866#               ifdef SH_DEBUG
867                mt_locate_old( listlth, delay, x, y, dt,
868                        &(par->b_azimuth), &(par->b_azimuth_err), &(par->b_slowness),
869                        &(par->b_slowness_err), status );
870                /* restore values */
871                for  (ii=0; ii<listlth; ii++)  {
872                        delay[ii] = tcp[ii];
873                        x[ii] = xcp[ii];
874                        y[ii] = ycp[ii];
875                } /*endfor*/
876                mt_locate_svd( listlth, delay, x, y, dt,
877                        &(par->b_azimuth), &(par->b_azimuth_err), &(par->b_slowness),
878                        &(par->b_slowness_err), status );
879                /* restore values */
880                for  (ii=0; ii<listlth; ii++)  {
881                        delay[ii] = tcp[ii];
882                        x[ii] = xcp[ii];
883                        y[ii] = ycp[ii];
884                } /*endfor*/
885#               endif
886                par->l_slowness = par->l_azimuth = 0.0;
887                mt_locate( listlth, delay, x, y, dt,
888                        &(par->b_azimuth), &(par->b_azimuth_err), &(par->b_slowness),
889                        &(par->b_slowness_err), status );
890                if  (Severe(status))  {CLEAR_AND_RETURN}
891                /* restore values */
892                for  (ii=0; ii<listlth; ii++)  {
893                        delay[ii] = tcp[ii];
894                        x[ii] = xcp[ii];
895                        y[ii] = ycp[ii];
896                } /*endfor*/
897                mt_locate_old_error( listlth, delay, x, y,
898                        par->b_azimuth, par->b_slowness, resid );
899                /* par->b_azimuth -= 180.0; */
900                /* if  (par->b_azimuth < 0.0)  par->b_azimuth += 360.0; */
901                par->l_slowness = 0.0;
902                par->l_azimuth = 0.0;
903                par->stations_used = listlth;
904                clat /= (STATLOC)listlth;
905                clon /= (STATLOC)listlth;
906                par->center_lat = clat;
907                par->center_lon = clon;
908
909                /* insert residuals, loop all phases */
910                codepos = 0;
911                proot = NULL;
912                residrms = 0.0;
913                ii = 0;
914                FOREVER  {
915                        proot = PiNextPhaseRoot( proot );
916                        if  (proot == NULL)  break;
917                        plist = PiPhaseListOfRoot( proot );
918                        if  (plist == NULL)  continue;
919                        strcpy( station, PiStationOfRoot(proot) );
920                        codepos = 0;
921                        for  (t=0; t<alloclth; t++)  {
922                                if  (strcmp(code+codepos,station) == 0)  {
923                                        resphase = PiFindPhase( plist, phasename );
924                                        if  (resphase == NULL)  break;
925                                        resphase->resid = resid[t];
926                                        resphase->resid_type = cPiResidPlaneWave;
927                                        residrms += (resid[t])*(resid[t]);
928                                        ii++;
929                                        break;
930                                } /*endif*/
931                                codepos += CODELTH+1;
932                        } /*endfor*/
933                } /*endfor*/
934                residrms = sqrt( residrms / (float)ii );
935                printf( "*SHM: mean root square residual: %5.2f\n", residrms );
936
937        } else {
938
939        } /*endif*/
940
941        /* store phase in parameter block */
942        strcpy( par->phase, phasename );
943
944        if  (!(CUF_DOLOC_DISTANCE & do_flags))  {CLEAR_AND_RETURN}
945
946        if  (*phasename == 'b')  {
947                /* the following doesn't make sense for beam selections */
948                *status = CUE_DUMMY_PHASE;
949                err_setcontext( " ## phase "); err_setcontext( phasename );
950                CLEAR_AND_RETURN
951        } /*endif*/
952
953        /* compute distance */
954        if  (par->loc_meth == CUC_LOCMETH_RESIDCORR)  {
955                loc_method = CUC_LOCMETH_RESIDCORR;
956        } else {
957                loc_method = (par->l_slowness == 0.0 && par->l_azimuth == 0.0) ?
958                        CUC_LOCMETH_BEAMUNCORR : CUC_LOCMETH_BEAMCORR;
959        } /*endif*/
960        if  (loc_method == CUC_LOCMETH_BEAMUNCORR
961                || loc_method == CUC_LOCMETH_RESIDCORR)  {
962                par->distance = pt_distance( phasename, par->b_slowness,
963                        par->depth, status );
964                if  (*reftime == '\0')
965                        mt_beamshift( listlth+1, x,y, par->b_azimuth, par->b_slowness, shift );
966        } else {
967                par->distance = pt_distance( phasename, par->l_slowness,
968                        par->depth, status );
969                if  (*reftime == '\0')
970                        mt_beamshift( listlth+1, x,y, par->l_azimuth, par->l_slowness, shift );
971        } /*endif*/
972        par->dist_unit = CUC_DIST_UNIT_DEG;
973        if  (Severe(status))  {par->distance = 0.0; CLEAR_AND_RETURN}
974        par->loc_meth = loc_method;
975        if  (*reftime == '\0')  ref_shift = *shift - shift[listlth];
976
977        /* get location of reference station */
978        par->ref_lat = lat[listlth];
979        par->ref_lon = lon[listlth];
980 
981        sy_deallocmem( delay );
982        sy_deallocmem( lat );
983        sy_deallocmem( xcp );
984        sy_deallocmem( code );
985
986        /* get coordinates of source */
987        if  (GpGetInt(cGpI_debug_level) > 2)
988                printf( "SHM-dbg3: source region computed on sphere !\n" );
989        if  (par->loc_meth == CUC_LOCMETH_BEAMUNCORR
990                || par->loc_meth == CUC_LOCMETH_RESIDCORR)  {
991                mb_sphereadd( par->ref_lat, par->ref_lon, par->distance,
992                        par->b_azimuth, &(par->source_lat), &(par->source_lon) );
993        } else {
994                mb_sphereadd( par->ref_lat, par->ref_lon, par->distance,
995                        par->l_azimuth, &(par->source_lat), &(par->source_lon) );
996        } /*endif*/
997#ifdef XXXNEW
998        if  (par->center_lat == 0.0 && par->center_lon == 0.0)  {
999                *status = CUE_NOCENTER;
1000                return;
1001        } /*endif*/
1002        u_azim = (par->loc_meth == CUC_LOCMETH_BEAMUNCORR
1003                || par->loc_meth == CUC_LOCMETH_RESIDCORR) ?
1004                par->b_azimuth : par->l_azimuth;
1005        mb_sphereadd( par->center_lat, par->center_lon, par->distance,
1006                u_azim, &(par->source_lat), &(par->source_lon) );
1007        mb_locdiff( par->ref_lat, par->ref_lon, par->source_lat, par->source_lon,
1008                &dbl_dist, &dbl_azim, &dbl_bazim );
1009        if  (GpGetInt(cGpI_debug_level) > 1)
1010                printf( "SHM-dbg2: center (%5.2f,%5.2f)  ref (%5.2lf,%5.2lf)\n",
1011                        par->distance, u_azim, dbl_dist, dbl_bazim ):
1012        /* distance & azimuth in 'par' setzen */
1013#endif
1014
1015        /* get name of source region */
1016        german_event = cu_german_event( par->source_lat, par->source_lon );
1017        if  (german_event)  {
1018                xxx_get_geo( &(par->source_lat), &(par->source_lon),
1019                        &(par->reg_id), par->regname );
1020                if  (par->reg_id < 0)  {
1021                        *status = CUE_NOGETGEO;
1022                        err_setcontext( " ## getgeo error " );
1023                        err_setcontext_l( par->reg_id );
1024                        return;
1025                } /*endif*/
1026                par->table_number = CUC_REGTABLE_GERGEO;
1027        } else {
1028                mb_ferindex( par->source_lat, par->source_lon, &(par->reg_id), status );
1029                if  (Severe(status))  return;
1030                mb_fername( par->reg_id, BC_LINELTH, par->regname, status );
1031                if  (Severe(status))  return;
1032                par->table_number = CUC_REGTABLE_FLINNENG;
1033        } /*endif*/
1034        par->loc_quality = CUC_LOCQ_RELIABLE;
1035
1036        /* reset source of information */
1037        par->source[0] = '\0';
1038
1039        if  (!(CUF_DOLOC_ORIGIN & do_flags))  return;
1040
1041        /* get origin time, onset time on reference station is in reftime */
1042        travtime = pt_travel( phasename, par->distance, par->depth, status );
1043        if  (Severe(status))  return;
1044        if  (*reftime == '\0')  {
1045                tc_tadd( firsttime, ref_shift, reftime, status );
1046        } /*endif*/
1047        tc_tadd( reftime, -travtime, par->origin, status );
1048        if  (Severe(status))  return;
1049
1050} /* end of cu_localization */
1051
1052
1053
1054#undef CLEAR_AND_RETURN
1055
1056
1057
1058/*--------------------------------------------------------------------------*/
1059
1060
1061
1062static void cuh_phase_onset( char phase[], TPmTrace *trc, char **onset,
1063        float *residcorr )
1064
1065/* checks whether phase is marked in trc, returns onset time or NULL
1066 *
1067 * parameters of routine
1068 * char       phase[];        input; phase name
1069 * TPmTrace   *trc;           input; pointer to trace info
1070 * char       **onset;        output; pointer to onset time
1071 * float      *residcorr;     output; residual correction (or cPiResidCorrEmpty)
1072 */
1073{
1074        /* local variables */
1075        TPiPhaseList    *phaselist;         /* pointer to phase list */
1076        TPiPhase        *c_phase;           /* pointer to current phase */
1077        TSyStatus       locstat=BC_NOERROR; /* local status */
1078        int             p;                  /* phase counter */
1079
1080        /* executable code */
1081
1082        phaselist = PmGetPhaseList( trc );
1083        if  (phaselist == NULL)  {
1084                *onset = NULL;
1085                return;
1086        } /*endif*/
1087        for  (p=0; p<PiPhaseListLength(phaselist); p++)  {
1088                c_phase = PiGetPhase( phaselist, p, NULL );
1089                if  (strcmp(c_phase->name,phase) == 0
1090                        && c_phase->source != cPiSourceTheo)  {
1091                        *onset = c_phase->onset;
1092                        *residcorr = c_phase->resid_corr;
1093                        return;
1094                } /*endif*/
1095        } /*endfor*/
1096        *onset = NULL;
1097        return;
1098
1099} /* end of cuh_phase_onset */
1100
1101
1102
1103/*--------------------------------------------------------------------------*/
1104
1105
1106
1107void cu_set_param_values( Widget w[], CUT_PARAMS *par, int parno )
1108
1109/* sets values of parameter block to dialog box.  If distance in deg is
1110 * smaller than 5 it is recomputed into km.
1111 *
1112 * parameters of routine
1113 * Widget     w[];       input; widget array
1114 * CUT_PARAMS *par;      input/modify; parameter values
1115 * int        parno;     input; number of parameter set
1116 */
1117{
1118        /* local variables */
1119        Arg      al[1];                  /* argument list */
1120        int      w_locq;                 /* location quality widget */
1121        char     str[BC_LINELTH+1];      /* scratch string */
1122        int      i;                      /* counter */
1123
1124        /* executable code */
1125
1126        /* check distance */
1127        if  (par->dist_unit == CUC_DIST_UNIT_DEG && par->distance < 5.0)  {
1128                par->dist_unit = CUC_DIST_UNIT_KM;
1129                par->distance *= CUC_DEG_TO_KM;
1130        } /*endif*/
1131
1132        sprintf( str, "%5.1f", par->b_azimuth );
1133        cu_set_string( w[k_widget_param_azimuth_text], str );
1134        sprintf( str, "%5.1f", par->distance );
1135        if  (par->dist_unit == CUC_DIST_UNIT_KM)
1136                strcat( str, "km" );
1137        cu_set_string( w[k_widget_param_distance_text], str );
1138        sprintf( str, "%5.1f", par->depth );
1139        cu_set_string( w[k_widget_param_depth_text], str );
1140        sprintf( str, "%5.2f", par->b_slowness );
1141        cu_set_string( w[k_widget_param_slowness_text], str );
1142        sprintf( str, "%6.3f", par->source_lat );
1143        cu_set_string( w[k_widget_param_lat_text], str );
1144        sprintf( str, "%6.3f", par->source_lon );
1145        cu_set_string( w[k_widget_param_lon_text], str );
1146
1147        /* set time string */
1148        if  (par->origin[0] == '\0')  {
1149                /* writing an empty string "" to the edit strings when dialog box
1150                 * was unmapped crashed the program (Bad Pixmap) on mapping the
1151                 * dialog box afterwards
1152                 */
1153                cu_set_string( w[k_widget_param_origin_d_text], " " );
1154                cu_set_string( w[k_widget_param_origin_t_text], " " );
1155        } else {
1156                i = 0;
1157                while  (par->origin[i] != '_')  {
1158                        i++;
1159                        if  (par->origin[i] == '\0' || i > BC_TIMELTH)  {
1160                                cu_set_string( w[k_widget_param_origin_d_text], " " );
1161                                cu_set_string( w[k_widget_param_origin_t_text], " " );
1162                                printf( "*SHM: cu_set_param_values: error in time string\n" );
1163                                return;
1164                        } /*endif*/
1165                } /*endwhile*/
1166                strncpy( str, par->origin, i );  str[i] = '\0';
1167                cu_set_string( w[k_widget_param_origin_d_text], str );
1168                strcpy( str, (par->origin)+i+1 );
1169                cu_set_string( w[k_widget_param_origin_t_text], str );
1170        } /*endif*/
1171
1172        /* set quality option menu */
1173        switch  (par->loc_quality)  {
1174        case CUC_LOCQ_INCOHERENT: w_locq = k_widget_param_locq_incoherent; break;
1175        case CUC_LOCQ_NOBEARING:  w_locq = k_widget_param_locq_nobearing; break;
1176        case CUC_LOCQ_REGION:     w_locq = k_widget_param_locq_region; break;
1177        case CUC_LOCQ_RELIABLE:   w_locq = k_widget_param_locq_reliable; break;
1178        case CUC_LOCQ_UNDEFINED:  w_locq = k_widget_param_locq_undefined; break;
1179        default:                  w_locq = k_widget_param_locq_undefined; break;
1180        } /*endswitch*/
1181        XtSetArg( al[0], XmNmenuHistory, w[w_locq] );
1182        XtSetValues( w[k_widget_param_locq_option], al, 1 );
1183
1184        /* set event type option menu */
1185        switch  (par->source_type)  {
1186        case CUC_TYPE_LOCAL_QUAKE: w_locq = k_widget_phase_type_local; break;
1187        case CUC_TYPE_REGIO_QUAKE: w_locq = k_widget_phase_type_regio; break;
1188        case CUC_TYPE_TELE_QUAKE:  w_locq = k_widget_phase_type_tele;  break;
1189        case CUC_TYPE_NUCLEAR:     w_locq = k_widget_phase_type_nuclear; break;
1190        case CUC_TYPE_BLAST:       w_locq = k_widget_phase_type_blast; break;
1191        case CUC_TYPE_MINING:      w_locq = k_widget_phase_type_mining; break;
1192        default:                   w_locq = k_widget_phase_type_other; break;
1193        } /*endswitch*/
1194        XtSetArg( al[0], XmNmenuHistory, w[w_locq] );
1195        XtSetValues( w[k_widget_phase_type_option], al, 1 );
1196
1197        /* set parameter set option menu */
1198        XtSetArg( al[0], XmNmenuHistory, w[k_widget_param_set_1+parno] );
1199        XtSetValues( w[k_widget_param_set_option], al, 1 );
1200
1201} /* end of cu_set_param_values */
1202
1203
1204
1205/*--------------------------------------------------------------------------*/
1206
1207
1208
1209void cu_print_param_values( CUT_PARAMS *par )
1210
1211/* prints out parameters
1212 *
1213 * parameters of routine
1214 * CUT_PARAMS *par;        input; analysis parameters
1215 */
1216{
1217        /* executable code */
1218
1219        if  (par->distance == 0.0)  {
1220                printf( "   distance     : not specified\n" );
1221        } else {
1222                printf( "   distance     : %5.1f\n", par->distance );
1223        } /*endif*/
1224        if  (par->b_slowness == 0.0 && par->b_azimuth == 0.0)  {
1225                printf( "   beam-slowness: not specified\n" );
1226                printf( "   beam-azimuth : not specified\n" );
1227        } else {
1228                printf( "   beam-slowness: %5.1f +/- %5.1f  (%s)\n",
1229                        par->b_slowness, par->b_slowness_err, par->phase );
1230                printf( "   beam-azimuth : %5.1f +/- %5.1f  (%s)\n",
1231                        par->b_azimuth, par->b_azimuth_err, par->phase );
1232        } /*endif*/
1233        if  (par->l_slowness == 0.0 && par->l_azimuth == 0.0)  {
1234                printf( "   epi-slowness : not specified\n" );
1235                printf( "   epi-azimuth  : not specified\n" );
1236        } else {
1237                printf( "   epi-slowness : %5.1f  (%s)\n",
1238                        par->l_slowness, par->phase );
1239                printf( "   epi-azimuth  : %5.1f  (%s)\n",
1240                        par->l_azimuth, par->phase );
1241        } /*endif*/
1242        printf( "   depth        : %5.1f +/- %5.1f\n",
1243                par->depth, par->err.dep );
1244        if  (par->ref_lat == 0.0 && par->ref_lon == 0.0)  {
1245                printf( "   reference    : %s\n", GpGetString(cGpS_refstation) );
1246        } else {
1247                printf( "   reference    : %s, %7.2f lat  %7.2f lon\n",
1248                        GpGetString(cGpS_refstation), par->ref_lat, par->ref_lon );
1249        } /*endif*/
1250        if  (par->loc_meth == CUC_LOCMETH_BEAMUNCORR)  {
1251                printf( "   location determined from beam\n" );
1252        } else if  (par->loc_meth == CUC_LOCMETH_BEAMCORR)  {
1253                printf( "   location determined from corrected slowness & azimuth\n" );
1254        } else if  (par->loc_meth == CUC_LOCMETH_HYPO)  {
1255                printf( "   location determined by Hypoellipse\n" );
1256        } /*endif*/
1257        if  (par->origin[0] == '\0')  {
1258                printf( "   origin time  : not specified\n" );
1259        } else {
1260                printf( "   origin time  : %s\n", par->origin );
1261        } /*endif*/
1262        if  (par->source_lat == 0.0 && par->source_lon == 0.0)  {
1263                printf( "   epicenter    : not specified\n" );
1264        } else {
1265                printf( "   epicenter    : %7.2f lat  %7.2f lon\n",
1266                        par->source_lat, par->source_lon );
1267        } /*endif*/
1268        if  (par->regname[0] == '\0')  {
1269                printf( "   FE region    : not specified\n" );
1270        } else {
1271                printf( "   FE region    : %s\n", par->regname );
1272        } /*endif*/
1273#ifdef XXX
1274        if  (par->evid == 0)  {
1275                printf( "   Event ID     : not specified\n" );
1276        } else {
1277                printf( "   Event ID     : %09ld\n", par->evid );
1278        } /*endif*/
1279#endif
1280
1281} /* end of cu_print_param_values */
1282
1283
1284
1285/*--------------------------------------------------------------------------*/
1286
1287
1288
1289void cu_get_param_values( Widget w[], CUT_PARAMS *par )
1290
1291/* copies values from dialog box to parameter block
1292 *
1293 * parameters of routine
1294 * Widget     w[];         input; widget array
1295 * CUT_PARAMS *par;        output; parameter values
1296 */
1297{
1298        /* local variables */
1299        char     *str1, *str2;     /* pointers to strings */
1300        int      slen1, slen2;     /* string lengths */
1301        STATUS   locstat;          /* local status */
1302        char        *txt;          /* text pointer */
1303        int         slen;          /* string length */
1304
1305        /* executable code */
1306
1307        if  (sscanf( cu_get_string(w[k_widget_param_azimuth_text]), "%f",
1308                &(par->b_azimuth) ) != 1)  {
1309                par->b_azimuth = 0.0;
1310                if  (GpGetInt(cGpI_debug_level) > 0)
1311                        printf( "SHM-dbg1: cu_get_param_values: couldn't read azimuth\n" );
1312        } /*endif*/
1313        txt = cu_get_string( w[k_widget_param_distance_text] );
1314        if  (sscanf( txt, "%f", &(par->distance) ) != 1)  {
1315                par->distance = 0.0;
1316                if  (GpGetInt(cGpI_debug_level) > 0)
1317                        printf( "SHM-dbg1: cu_get_param_values: couldn't read distance\n" );
1318        } /*endif*/
1319        par->dist_unit = CUC_DIST_UNIT_DEG;
1320        slen = strlen( txt );
1321        if  (slen > 2 && txt[slen-2] == 'k' && txt[slen-1] == 'm')
1322                par->dist_unit = CUC_DIST_UNIT_KM;
1323        if  (sscanf( cu_get_string(w[k_widget_param_depth_text]), "%f",
1324                &(par->depth) ) != 1)  {
1325                par->depth = 0.0;
1326                if  (GpGetInt(cGpI_debug_level) > 0)
1327                        printf( "SHM-dbg1: cu_get_param_values: couldn't read depth\n" );
1328        } /*endif*/
1329        if  (sscanf( cu_get_string(w[k_widget_param_slowness_text]), "%f",
1330                &(par->b_slowness) ) != 1)  {
1331                par->b_slowness = 0.0;
1332                if  (GpGetInt(cGpI_debug_level) > 0)
1333                        printf( "SHM-dbg1: cu_get_param_values: couldn't read slowness\n" );
1334        } /*endif*/
1335        str1 = cu_get_string( w[k_widget_param_origin_d_text] );
1336        str2 = cu_get_string( w[k_widget_param_origin_t_text] );
1337        slen1 = strlen( str1 );
1338        slen2 = strlen( str2 );
1339        if  (slen1 > 6 && slen2 > 0)  {
1340                if  (slen1+slen2+1 <= BC_TIMELTH)  {
1341                        sprintf( par->origin, "%s_%s", str1, str2 );
1342                        /* check time */
1343                        locstat = BC_NOERROR;
1344                        tc_tadd( par->origin, 0.0, par->origin, &locstat );
1345                        if  (Severe(&locstat))  {
1346                                if  (GpGetInt(cGpI_debug_level) > 0)
1347                                        printf( "SHM-dbg1: cu_get_param_values: couldn't read origin time\n" );
1348                                par->origin[0] = '\0';
1349                        } /*endif*/
1350                } /*endif*/
1351        } else {
1352                par->origin[0] = '\0';
1353        } /*endif*/
1354        if  (sscanf( cu_get_string(w[k_widget_param_lat_text]), "%f",
1355                &(par->source_lat) ) != 1)  {
1356                par->source_lat = 0.0;
1357                if  (GpGetInt(cGpI_debug_level) > 0)
1358                        printf( "SHM-dbg1: cu_get_param_values: couldn't read source lat\n" );
1359        } /*endif*/
1360        if  (sscanf( cu_get_string(w[k_widget_param_lon_text]), "%f",
1361                &(par->source_lon) ) != 1)  {
1362                par->source_lon = 0.0;
1363                if  (GpGetInt(cGpI_debug_level) > 0)
1364                        printf( "SHM-dbg1: cu_get_param_values: couldn't read source lon\n" );
1365        } /*endif*/
1366
1367} /* end of cu_get_param_values */
1368
1369
1370
1371/*--------------------------------------------------------------------------*/
1372
1373
1374
1375void cu_get_display_control( Widget w[], MGT_DSPCTRL *ctrl )
1376
1377/* puts display controls values from dialog box to control structure
1378 *
1379 * parameters of routine
1380 * Widget        w[];     input; Widget array of dialog box elements
1381 * MGT_DSPCTRL   *ctrl;   output; values retrieved
1382 */
1383{
1384        /* local variables */
1385
1386        /* executable code */
1387/*
1388        sscanf( cu_get_string(w[k_widget_ctrl_zoom_text]),
1389                "%f", &(ctrl->zoom) );
1390*/
1391} /* end of cu_get_display_control */
1392
1393
1394
1395/*--------------------------------------------------------------------------*/
1396
1397
1398
1399void cu_theo_arrivals( Widget wm, Widget ws, CUT_PARAMS *par, STATUS *status )
1400
1401/* marks theoretical arrivals on all traces on display
1402 *
1403 * parameters of routine
1404 * Widget     wm;               input; widget ID of main window
1405 * Widget     ws;               input; widget ID of single trace window
1406 * CUT_PARAMS *par;             input; analysis parameters
1407 * STATUS     *status;          output; return status
1408 */
1409{
1410        /* local variables */
1411        TPmTrace *trc;                      /* pointer to trace */
1412        char     curr_phase[BC_LINELTH+1];  /* current theo phase */
1413        GLT_STATINF *statinf;               /* pointer to station info */
1414        float    distance;                  /* distance in deg */
1415        float    azimuth;                   /* back azimuth in deg */
1416        float    travtime;                  /* trave time in sec */
1417        TPiPhase theo_phase;                /* theoretical phase */
1418        int      slen;                      /* string length */
1419        TSyStatus locstat;                  /* local status */
1420        char     *sc, *dc;                  /* moving pointers */
1421        TSyBoolean quit;                    /* quit loop */
1422
1423        /* executable code */
1424
1425        if  (par->distance == 0.0)  {
1426                *status = CUE_NODISTANCE;
1427                return;
1428        } /*endif*/
1429
1430        /* delete all theoretical phases from all traces */
1431        cu_delete_all_phases( wm, ws, "--theo--", TRUE );
1432
1433        /* compute and mark new phases */
1434        sc = GpGetString( cGpS_theo_phase_list );
1435        dc = curr_phase;
1436        quit = FALSE;
1437        while  (!quit)  {
1438
1439                if  (*sc != ',' && *sc != '\0')  {
1440                        *dc++ = *sc++;
1441                        continue;
1442                } /*endif*/
1443                if  (*sc++ == '\0')  quit = TRUE;
1444                *dc = '\0';
1445                dc = curr_phase;
1446
1447                /* if comment line or depth phase at depth 0, do nothing */
1448                if  (par->depth == 0.0 &&
1449                        (*curr_phase == 'p' || *curr_phase == 's'))  continue;
1450
1451                /* process current phase for each trace */
1452                if  (GpGetInt(cGpI_debug_level) > 1)
1453                        printf( "SHM-dbg2: phase %s\n", curr_phase );
1454                trc = NULL;
1455                FOREVER  {
1456                        locstat = cBcNoError;
1457                        trc = db_getp( trc, EP_DSPN, &locstat );
1458                        if  (trc == NULL)  break;
1459                        /* compute traveltime and setup phase descr. */
1460                        statinf = cu_get_statinf( trc, status );
1461                        if  (*status == CUE_BEAMSTATION)  {*status=BC_NOERROR; continue;}
1462                        if  (SySevere(status))  return;
1463                        mb_spherediff( statinf->lat, statinf->lon,
1464                                par->source_lat, par->source_lon,
1465                                &distance, &azimuth );
1466                        locstat = cBcNoError;
1467                        travtime = pt_travel( curr_phase, distance,
1468                                par->depth, &locstat );
1469                        if  (locstat != cBcNoError)  continue;
1470                        if  (Severe(status))  return;
1471                        cu_reset_phase( &theo_phase );
1472                        strcpy( theo_phase.name, curr_phase );
1473                        tc_tadd( par->origin, travtime,
1474                                theo_phase.onset, status );
1475                        if  (SySevere(status))  return;
1476                        theo_phase.spec = cPiSpecEmergent;
1477                        /*theo_phase.phasetrc = mg_trcptr( t+1 );*/
1478                        theo_phase.sign = 0;
1479                        theo_phase.source = cPiSourceTheo;
1480                        /* put phase on screen */
1481                        cu_accept_phase( wm, ws, &theo_phase, trc, FALSE, status );
1482                        if  (SySevere(status))  return;
1483                } /*endfor*/
1484
1485        } /*endwhile*/
1486
1487} /* end of cu_theo_arrivals */
1488
1489
1490
1491/*--------------------------------------------------------------------------*/
1492
1493
1494
1495void cu_delete_all_phases( Widget wm, Widget ws, char name[],
1496        TSyBoolean allmem )
1497
1498/* All phases with name "name" are deleted.  If name=="--theo--", all
1499 * theoretical phases will be deleted, if name="--pseudo--", all pseudo-phases
1500 * starting with 'b' are deleted.
1501 *
1502 * parameters of routine
1503 * Widget     wm;       input; widget ID of main drawing area
1504 * Widget     ws;       input; widget ID of single draw window
1505 * char       name;     input; name of phases to be deleted
1506 * TSyBoolean allmem;   input; all phases in memory (TRUE) or on display only
1507 */
1508{
1509        /* local variables */
1510        TSyStatus   locstat;            /* local status */
1511        int         trcno;              /* number of traces */
1512        TSyBoolean  do_theo;            /* delete theo phases */
1513        TSyBoolean  do_pseudo;          /* delete all pseudo phases */
1514        TPiPhaseRoot  *proot;           /* pointer to phase root */
1515        TPiPhaseList  *plist;           /* pointer to phase list */
1516        int         plist_lth;          /* length of phase list */
1517        int         p;                  /* phase counter */
1518        TPiPhase    *rem_phase;         /* phase to be removed */
1519        TPmTrace    *trc;               /* pointer to trace */
1520
1521        /* executable code */
1522
1523        do_theo = (strcmp(name,"--theo--") == 0);
1524        do_pseudo = (strcmp(name,"--pseudo--") == 0);
1525
1526        /* loop over traces on display */
1527        proot = NULL;
1528        FOREVER  {
1529                proot = PiNextPhaseRoot( proot );
1530                if  (proot == NULL)  break;
1531                plist = PiPhaseListOfRoot( proot );
1532                if  (plist == NULL)  continue;
1533                plist_lth = PiPhaseListLength( plist );
1534                for  (p=0; p<plist_lth; p++)  {
1535                        locstat = cBcNoError;
1536                        rem_phase = PiGetPhase( plist, p, &locstat );
1537                        if  (locstat != cBcNoError)  continue;
1538                        if  (do_pseudo && rem_phase->name[0] != 'b')  continue;
1539                        if  (do_theo && rem_phase->source != cPiSourceTheo)  continue;
1540                        if  (strcmp(name,"*") != 0)
1541                                if  (!do_pseudo && !do_theo && (strcmp(rem_phase->name,name) != 0))
1542                                        continue;
1543                        /* remove phase(s) from display */
1544                        trc = NULL;
1545                        FOREVER  {
1546                                trc = PmFindTrace( trc, PiDescrOfRoot(proot) );
1547                                if  (trc == NULL)  break;
1548                                mg_mark_one_phase( wm, ws, rem_phase, trc, FALSE );
1549                        } /*endfor*/
1550                        PiDeletePhase( plist, rem_phase, &locstat );
1551                        p--;
1552                        plist_lth--;
1553                } /*endfor*/
1554        } /*endfor*/
1555
1556} /* end of cu_delete_all_phases */
1557
1558
1559
1560/*--------------------------------------------------------------------------*/
1561
1562
1563
1564static GLT_STATINF *cu_get_statinf( TPmTrace *trc, TSyStatus *status )
1565
1566/* returns pointer to static station info block of trace number "trcno"
1567 *
1568 * parameters of routine
1569 * TPmTrace   *trc;           input; pointer to trace
1570 * TSyStatus  *status;        output; return status
1571 *                            returns static pointer to station info
1572 */
1573{
1574        /* local variables */
1575        GLT_STATINF *statinf;               /* pointer to station info */
1576        TSyStatus   locstat;                /* local status */
1577        char        station[BC_LINELTH+1];  /* station name */
1578
1579        /* executable code */
1580
1581        locstat = cBcNoError;
1582        statinf = (GLT_STATINF *)db_getp( trc, EP_STAT, &locstat );
1583        if  (statinf == NULL)  {
1584                db_gets( trc, ES_STATION, BC_LINELTH, station, status );
1585                if  (Severe(status))  return NULL;
1586                if  (strcmp(station,"BEAM") == 0 || strcmp(station,"ALIGN") == 0)  {
1587                        *status = CUE_BEAMSTATION;
1588                        return NULL;
1589                } /*endif*/
1590                statinf = gl_store_station( station, TRUE, status );
1591                if  (Severe(status))  return NULL;
1592                db_setp( trc, EP_STAT, statinf, status );
1593                if  (Severe(status))  return NULL;
1594        } /*endif*/
1595
1596        return statinf;
1597
1598} /* end of cu_get_statinf */
1599
1600
1601
1602/*--------------------------------------------------------------------------*/
1603
1604
1605
1606void cu_alert_message( Widget w, char text [] )
1607
1608/* puts alert box on screen
1609 *
1610 * parameters of routine
1611 * Widget     w;         input; alert box widget ID
1612 * char       text[];    input; alert message
1613 */
1614{
1615        /* local variables */
1616        Arg      arg[3];    /* argument list */
1617        int      n;         /* arg counter */
1618        static XmString   xstr;             /* x string */
1619        static TSyBoolean xstr_init=FALSE;  /* x string created */
1620
1621        /* executable code */
1622
1623        if  (XtIsManaged(w))  XtUnmanageChild( w );
1624
1625        /*if  (xstr_init)  XmStringFree( (char *)xstr );*/
1626        xstr = XmStringLtoRCreate( text, XmSTRING_DEFAULT_CHARSET );
1627        xstr_init = TRUE;
1628
1629        n = 0;
1630        XtSetArg( arg[n], XmNmessageString, xstr );  n++;
1631        XtSetValues( w, arg, n );
1632
1633        XtManageChild( w );
1634
1635        if  (GpGetInt(cGpI_debug_level) > 3)
1636                printf( "SHM-dbg4: cu_alert_message: after XtManageChild\n" );
1637
1638} /* end of cu_alert_message */
1639
1640
1641
1642/*--------------------------------------------------------------------------*/
1643
1644
1645
1646void cu_alert( TSyStatus status )
1647
1648/* puts alert message on screen
1649 *
1650 * parameters of routine
1651 * TSyStatus     status;   input; status code
1652 */
1653{
1654        /* local variables */
1655        char     str[BC_LONGSTRLTH+1];   /* scratch string */
1656        char     context[BC_LINELTH+1];  /* error context */
1657
1658        /* executable code */
1659
1660        err_msg( status, str );
1661        err_getcontext( context );
1662        if  (*context != '\0')  {
1663                if  (strlen(str)+strlen(context)+1 < BC_LONGSTRLTH)  {
1664                        strcat( str, "\n" );
1665                        strcat( str, context );
1666                } /*endif*/
1667                err_clearcontext();
1668        } /*endif*/
1669
1670        if  (cuv_alert_widget == (Widget)0)  {
1671                printf( "*SHM: alert widget not yet set: ***\n" );
1672                printf( "%s\n", str );
1673                return;
1674        } /*endif*/
1675
1676        if  (GpGetInt(cGpI_debug_level) > 3)
1677                printf( "SHM-dbg4: want to create error message: %s\n", str );
1678
1679        cu_alert_message( cuv_alert_widget, str );
1680
1681} /* end of cu_alert */
1682
1683
1684
1685/*--------------------------------------------------------------------------*/
1686
1687
1688
1689void cu_set_alert_widget( Widget w )
1690
1691/* sets alert widget
1692 *
1693 * parameters of routine
1694 * Widget     w;     input; widget ID of alert box
1695 */
1696{
1697        /* local variables */
1698
1699        /* executable code */
1700
1701        cuv_alert_widget = w;  /* used for status message output */
1702
1703} /* end of cu_set_alert_widget */
1704
1705
1706
1707/*--------------------------------------------------------------------------*/
1708
1709
1710
1711void cu_set_multiplication_widget( Widget box, Widget label, Widget edit )
1712
1713/* sets widget ID's of multiplication box
1714 *
1715 * parameters of routine
1716 * Widget     box;     input; widget ID of whole box
1717 * Widget     label;   input; widget ID of title label
1718 * Widget     edit;    input; widget ID of value editable text
1719 */
1720{
1721        /* executable code */
1722
1723        cuv_multipli_box = box;
1724        cuv_multipli_value = label;
1725        cuv_multipli_edit = edit;
1726
1727} /* end of cu_set_multiplication_widget */
1728
1729
1730
1731/*--------------------------------------------------------------------------*/
1732
1733
1734
1735void cu_multiplication_dialog( TPmTrace *phtrc, TPiPhase *phase )
1736
1737/* let the user multiply the value
1738 *
1739 * parameters of routine
1740 * TPmTrace   *phtrc  input; phase pointer
1741 * TPiPhase   *phase;   modify; phase amplitudes to update
1742 */
1743{
1744        /* local variables */
1745        static XmString val;            /* value text */
1746        static BOOLEAN val_init=FALSE;  /* value is initalized */
1747        Arg      a[1];                  /* argument */
1748        char     str[BC_LINELTH+1];     /* scratch string */
1749
1750        /* executable code */
1751
1752        cuv_multipli_phase = phase;
1753        cuv_multipli_trc = phtrc;
1754        sprintf( str, "value %f", phase->ampl );
1755
1756        if  (XtIsManaged(cuv_multipli_box))
1757                XtUnmanageChild( cuv_multipli_box );
1758        if  (val_init)  XtFree( (char *)val );
1759        val = XmStringLtoRCreate( str, "" );
1760        val_init = TRUE;
1761        XtSetArg( a[0], XmNlabelString, val );
1762        XtSetValues( cuv_multipli_value, a, 1 );
1763        XtManageChild( cuv_multipli_box );
1764
1765} /* end of cu_multiplication_dialog */
1766
1767
1768
1769/*--------------------------------------------------------------------------*/
1770
1771
1772
1773void cu_do_multiplication( float fac, TSyStatus *status )
1774
1775/* performs multiplication prepared by cu_multiplication_dialog
1776 *
1777 * parameters of routine
1778 * float      fac;         input; factor
1779 * TSyStatus  *status;     output; return status
1780 */
1781{
1782        /* local variables */
1783        char       *valptr;     /* pointer to value */
1784        float      factor;      /* multiplication factor */
1785        TSyStatus  locstat;     /* local status */
1786
1787        /* executable code */
1788
1789        if  (cuv_multipli_phase == NULL)  {
1790                *status = CUE_NOMULTIPLI;
1791                return;
1792        } else if  (cuv_multipli_trc == NULL)  {
1793                *status = CUE_NOMULTIPLI;
1794                return;
1795        } /*endif*/
1796
1797        if  (fac == CUC_MULTIPLI_EDIT_MUL || fac == CUC_MULTIPLI_EDIT_DIV)  {
1798                valptr = cu_get_string( cuv_multipli_edit );
1799                if  (sscanf( valptr, "%f", &factor ) != 1)  {
1800                        *status = CUE_CNV_FLOAT;
1801                        err_setcontext( " ## number: " );
1802                        err_setcontext( valptr );
1803                        return;
1804                } /*endif*/
1805                if  (fac == CUC_MULTIPLI_EDIT_DIV)
1806                        factor = 1.0 / factor;
1807        } else {
1808                factor = fac;
1809        } /*endif*/
1810
1811        cuv_multipli_phase->period *= factor;
1812        locstat = BC_NOERROR;
1813        cu_ampl_restitution( cuv_multipli_trc,
1814                        cuv_multipli_phase->ampl,
1815                        cuv_multipli_phase->period, "DSP",
1816                        &(cuv_multipli_phase->ampl_displ), cuv_multipli_phase->filter,
1817                        &locstat );
1818        if  (locstat != BC_NOERROR)  cuv_multipli_phase->ampl_displ = 0.0;
1819        locstat = BC_NOERROR;
1820        cu_ampl_restitution( cuv_multipli_trc,
1821                        cuv_multipli_phase->ampl,
1822                        cuv_multipli_phase->period, "VEL",
1823                        &(cuv_multipli_phase->ampl_veloc), cuv_multipli_phase->filter,
1824                        &locstat );
1825        if  (locstat != BC_NOERROR)  cuv_multipli_phase->ampl_veloc = 0.0;
1826        cu_print_phase( cuv_multipli_phase );
1827        cuv_multipli_phase = NULL;
1828
1829        if  (XtIsManaged(cuv_multipli_box))
1830                XtUnmanageChild( cuv_multipli_box );
1831
1832} /* end of cu_do_multiplication */
1833
1834
1835
1836/*--------------------------------------------------------------------------*/
1837
1838
1839
1840void cu_print_phase( TPiPhase *phase )
1841
1842/* prints out phase information
1843 *
1844 * parameters of routine
1845 * TPiPhase   *phase;      input; phase info
1846 */
1847{
1848        /* local variables */
1849        TPmTrace   *trcptr;            /* trace pointer */
1850        char       str[BC_LINELTH+1];  /* scratch string */
1851        TSyStatus  locstat=cBcNoError; /* local status */
1852
1853        /* executable code */
1854
1855        printf( "\n" );
1856        printf( "   phase : %s   ", phase->name );
1857        if  (phase->spec == cPiSpecEmergent)   printf( "emergent  " );
1858        if  (phase->spec == cPiSpecImpulsive)  printf( "impulsive " );
1859        if  (phase->sign == 1)   printf( "compression " );
1860        if  (phase->sign == -1)  printf( "dilatation  " );
1861        if  (phase->source == cPiSourceTheo)  printf( "theoretical" );
1862        if  (phase->source == cPiSourceAuto)  printf( "automatic" );
1863        printf( "\n" );
1864        printf( "   onset : %s\n", phase->onset );
1865        if  (phase->period > 0.0)  {
1866                printf( "   period: %5.2f\n", phase->period );
1867        } else {
1868                printf( "   period: not specified\n" );
1869        } /*endif*/
1870        if  (phase->filter[0] != '\0')  {
1871                printf( "   filter: %s\n", phase->filter );
1872        } else {
1873                printf( "   filter: none\n" );
1874        } /*endif*/
1875        if  (phase->ampl > 0.0)  {
1876                printf( "   amplitude (plain): %6.1f\n", phase->ampl );
1877        } else {
1878                printf( "   amplitude (plain): not specified\n" );
1879        } /*endif*/
1880        if  (phase->ampl_veloc > 0.0)  {
1881                printf( "   amplitude (veloc): %6.1f\n", phase->ampl_veloc );
1882        } else {
1883                printf( "   amplitude (veloc): not specified\n" );
1884        } /*endif*/
1885        if  (phase->ampl_displ > 0.0)  {
1886                printf( "   amplitude (displ): %6.1f\n", phase->ampl_displ );
1887        } else {
1888                printf( "   amplitude (displ): not specified\n" );
1889        } /*endif*/
1890        if  (phase->bb.bbampl > 0.0)  {
1891                printf( "   amplitude (BB)   : %6.1f\n", phase->bb.bbampl );
1892        } else {
1893                printf( "   amplitude (BB)   : not specified\n" );
1894        } /*endif*/
1895        if  (phase->ampl_time > 0.0)  {
1896                printf( "   amplitude time   : %5.2f\n", phase->ampl_time );
1897        } else {
1898                printf( "   amplitude time   : not specified\n" );
1899        } /*endif*/
1900        if  (phase->comment[0] != '\0')
1901                printf( "   comment: %s\n", phase->comment );
1902
1903#       ifdef XXX
1904        trcptr = phase->phasetrc;
1905        if  (trcptr != NULL)  {
1906                db_gets( trcptr, ES_STATION, BC_LINELTH, str, &locstat );
1907                if  (locstat == BC_NOERROR)
1908                        printf( "   station: %s\n", str );
1909        } /*endif*/
1910#       endif
1911        printf( "\n" );
1912
1913} /* end of cu_print_phase */
1914
1915
1916
1917/*--------------------------------------------------------------------------*/
1918
1919
1920
1921void cu_ampl_restitution( TPmTrace *trcptr, float ampl, float period,
1922        char kind[], float *rest_ampl, char filter[], TSyStatus *status )
1923
1924/* returns restituted amplitude, velocity or displacement, depending on
1925 * parameter "kind" ("VEL" or "DSP", respectively).  The filter variable
1926 * must have length BC_LINELTH+1.
1927 *
1928 * parameters of routine
1929 * void       *trcptr;         input; pointer to trace info
1930 * float      ampl;            input; input amplitude
1931 * float      period;          input; period of signal in sec
1932 * char       kind[];          input; either "VEL" or "DSP"
1933 * float      *rest_ampl;      output; restituted amplitude
1934 * char       filter[];        output; filter name (min. length BC_LINELTH+1)
1935 * TSyStatus  *status;         output; return status
1936 *                             returns restituted amplitude
1937 */
1938{
1939        /* local variables */
1940        char       str[BC_LINELTH+1];      /* scratch string */
1941        TSyStatus  locstat;                /* local status */
1942        char       *filptr;                /* pointer to filter name */
1943        float      frq;                    /* frequency of signal in Hz */
1944        float      tffac;                  /* transfer function factor */
1945        float      tffac2;                 /* second factor of this kind */
1946        char       lfilname[BC_LINELTH+1]; /* local filter name */
1947        TIME       ttime;                  /* trace time */
1948        char       strtime[cBcTimeLth+1];  /* string time */
1949        int        trcflags;               /* trace flags for filtered traces */
1950
1951        /* executable code */
1952
1953        if  (trcptr == NULL)  {
1954                *status = CUE_BUG;
1955                printf(
1956                        "*SHM: cu_ampl_restitution: NULL ptr (illegal phase->phasetrc)\n" );
1957                return;
1958        } /*endif*/
1959
1960        if  (period < 1.e-8)  {
1961                *status = CUE_ZERO_PERIOD;
1962                return;
1963        } /*endif*/
1964        frq = 1/period;
1965
1966        /* if a filter is applied the comment info entry contains its name */
1967        locstat = BC_NOERROR;
1968        db_gets( trcptr, ES_COMMENT, BC_LINELTH, str, &locstat );
1969        if  (locstat == BC_NOERROR)  {
1970                /* we have to look for a substring starting with 'FLT:' */
1971                filptr = strstr( str, "FLT:" );
1972                if  (filptr == NULL)  filptr = strstr( str, "flt:" );
1973                if  (filptr != NULL)  {
1974                        sscanf( filptr+4, "%s", filter );
1975                } else {
1976                        *filter = '\0';
1977                } /*endif*/
1978        } else {
1979                /* if no filter found in the comment string it is an unfiltered trace */
1980                *filter = '\0';
1981        } /*endif*/
1982        strcpy( lfilname, filter );
1983
1984        /* if it is an unfiltered trace, take the transfer function of the recording
1985         * instrument.  This is returned by cu_lookup_filter. */
1986        if  (*lfilname == '\0')  {
1987                locstat = cBcNoError;
1988                db_gett( trcptr, ET_START, &ttime, &locstat );
1989                tc_a2t( &ttime, strtime, &locstat );
1990                cu_get_stream_string( trcptr, str, status );
1991                if  (Severe(status))  return;
1992                cu_lookup_filter( str, strtime, lfilname, &trcflags, status );
1993                if  (Severe(status))  return;
1994        } /*endif*/
1995
1996        /* if the trace is unfiltered or filtered with an simulation filter, the
1997         * transfer function is found by applying a prefix 'TF_VEL_' or 'TF_DSP_'.
1998         * Then this this contains the complete information needed here.
1999         * Build filter name & read amplitude */
2000        strcpy( str, "TF_" );
2001        strcat( str, kind );
2002        strcat( str, "_" );
2003        strcat( str, lfilname );
2004        tffac = ff_filter_amplitude( str, frq, status );
2005
2006        /* if the filter cannot be found with a TF_VEL/DSP prefix it is not a
2007         * simulation filter, so we need the transfer function of the filter
2008         * and the transfer function of the recording instrument.
2009         */
2010        if  (SySevere(status))  {
2011                /* at an unfiltered trace this means that the transfer function of the
2012                 * recording instrument has not been found before.  So nothing can
2013                 * be done here. */
2014                if  (*lfilname == '\0')  return;
2015                *status = cBcNoError;
2016                /* get amplification of applied filter */
2017                tffac = ff_filter_amplitude( lfilname, frq, status );
2018                printf( "SHM-dbg2: fac1: filter applied: %s -> %f\n", lfilname, tffac );
2019                if  (SySevere(status))  return;
2020                /* add transfer function of recording instrument (like code above) */
2021                locstat = cBcNoError;
2022                db_gett( trcptr, ET_START, &ttime, &locstat );
2023                tc_a2t( &ttime, strtime, &locstat );
2024                cu_get_stream_string( trcptr, str, status );
2025                if  (SySevere(status))  return;
2026                cu_lookup_filter( str, strtime, lfilname, &trcflags, status );
2027                if  (SySevere(status))  return;
2028                strcpy( str, "TF_" );
2029                strcat( str, kind );
2030                strcat( str, "_" );
2031                strcat( str, lfilname );
2032                tffac2 = ff_filter_amplitude( str, frq, status );
2033                printf( "SHM-dbg2: fac2: transfer function of rec. instr. %s -> %f\n",
2034                        str, tffac2 );
2035                tffac *= tffac2;
2036        } /*endif*/
2037
2038        if  (GpGetInt(cGpI_debug_level) > 1)
2039                printf( "SHM-dbg2: filter %s, frq %f, factor %f\n", str, frq, tffac );
2040
2041        if  (tffac < 1.e-10)  {
2042                *status = CUE_ZERO_TRANSF;
2043                return;
2044        } /*endif*/
2045        *rest_ampl = ampl / tffac;
2046
2047} /* end of cu_ampl_restitution */
2048
2049
2050
2051/*--------------------------------------------------------------------------*/
2052
2053
2054
2055void cu_get_tf_name( char station[], int maxlth, char filter[],
2056        TSyStatus *status )
2057
2058/* returns name of transfer function derived from station name
2059 *
2060 * parameters of routine
2061 * char       station[];        input; station name
2062 * int        maxlth;           input; maximum length of output string
2063 * char       filter[];         output; derived filter name
2064 * TSyStatus  *status;          output; return status
2065 */
2066{
2067        /* executable code */
2068
2069        if  (maxlth < 7)  {
2070                *status = CUE_STROVFL;
2071                return;
2072        } /*endif*/
2073
2074        if  (strncmp(station,"GR",2) == 0 && station[2] >= 'A' &&
2075                station[2] <= 'C' && station[3] >= '1' && station[3] <= '5')  {
2076                strcpy( filter, "GRF" );
2077        } else if  (strcmp(station,"GEC2B") == 0 || strcmp(station,"GEC2") == 0)  {
2078                strcpy( filter, "GRSN" );
2079        } else if  (strcmp(station,"GEC2A") == 0)  {
2080                strcpy( filter, "GERESS" );
2081        } else if  (strncmp(station,"GE",2) == 0 && station[2] >= 'A' &&
2082                station[2] <= 'D' && station[3] >= '0' && station[3] <= '9')  {
2083                strcpy( filter, "GERESS" );
2084        } else if  (strcmp(station,"BFO") == 0)  {
2085                strcpy( filter, "GRSN" );
2086        } else if  (strcmp(station,"BRG") == 0)  {
2087                strcpy( filter, "GRSN" );
2088        } else if  (strcmp(station,"BRNL") == 0)  {
2089                strcpy( filter, "GRSN" );
2090        } else if  (strcmp(station,"BUG") == 0)  {
2091                strcpy( filter, "GRSN" );
2092        } else if  (strcmp(station,"CLL") == 0)  {
2093                strcpy( filter, "GRSN" );
2094        } else if  (strcmp(station,"CLZ") == 0)  {
2095                strcpy( filter, "GRSN" );
2096        } else if  (strcmp(station,"FUR") == 0)  {
2097                strcpy( filter, "GRSN" );
2098        } else if  (strcmp(station,"GSH") == 0)  {
2099                strcpy( filter, "GRSN" );
2100        } else if  (strcmp(station,"HAM") == 0)  {
2101                strcpy( filter, "GRSN" );
2102        } else if  (strcmp(station,"IBB") == 0)  {
2103                strcpy( filter, "GRSN" );
2104        } else if  (strcmp(station,"LID") == 0)  {
2105                strcpy( filter, "GRSN" );
2106        } else if  (strcmp(station,"MOX") == 0)  {
2107                strcpy( filter, "GRSN" );
2108        } else if  (strcmp(station,"SEG") == 0)  {
2109                strcpy( filter, "GRSN" );
2110        } else if  (strcmp(station,"STU") == 0)  {
2111                strcpy( filter, "GRSN" );
2112        } else if  (strcmp(station,"TNS") == 0)  {
2113                strcpy( filter, "GRSN" );
2114        } else if  (strcmp(station,"WET") == 0)  {
2115                strcpy( filter, "GRSN" );
2116        } else {
2117                strcpy( filter, station );
2118        } /*endif*/
2119
2120} /* end of cu_get_tf_name */
2121
2122
2123
2124/*--------------------------------------------------------------------------*/
2125
2126
2127
2128void cu_print_info( char str[] )
2129
2130/* prints out informational message
2131 *
2132 * parameters of routine
2133 * char       str[];       input; message to print
2134 */
2135{
2136        /* executable code */
2137
2138        printf( "SHM-i! %s\n", str );
2139
2140} /* end of cu_print_info */
2141
2142
2143
2144/*--------------------------------------------------------------------------*/
2145
2146
2147
2148void cu_set_string( Widget w, char str[] )
2149
2150/* sets string in text widget str.  Checks whether str is empty, in this case
2151 * a single blank is inserted because of bug in Motif software
2152 *
2153 * parameters of routine
2154 * Widget     w;         input; widget ID
2155 * char       str[];     input; text to be set
2156 */
2157{
2158        /* local variables */
2159
2160        /* executable code */
2161
2162        if  (*str == '\0')  {
2163                XmTextSetString( w, " " );
2164        } else {
2165                XmTextSetString( w, str );
2166        } /*endif*/
2167
2168} /* end of cu_set_string */
2169
2170
2171
2172/*--------------------------------------------------------------------------*/
2173
2174
2175
2176char *cu_get_string( Widget w )
2177
2178/* gets string from text widget str.  Checks whether string in text widget is
2179 * a single blank, in this case a pointer to an empty string is returned
2180 * because of bug in Motif software
2181 *
2182 * parameters of routine
2183 * Widget     w;         input; widget ID
2184 *                       returns pointer to static string
2185 */
2186{
2187        /* local variables */
2188        static char  zero='\0';
2189        char         *ptr;         /* pointer to widget string */
2190
2191        /* executable code */
2192
2193        ptr = (char *)XmTextGetString( w );
2194        if  (ptr[0] == ' ' && ptr[1] == '\0')  {
2195                return &zero;
2196        } else {
2197                return ptr;
2198        } /*endif*/
2199
2200} /* end of cu_set_string */
2201
2202
2203
2204/*---------------------------------------------------------------------------*/
2205
2206
2207
2208#define ON_ERROR_RETURN \
2209        if  (Severe(status))  { \
2210                err_setcontext( " ## station " ); \
2211                err_setcontext( station ); \
2212                return; \
2213        }
2214
2215
2216
2217void cu_reference_location( STATLOC *lat, STATLOC *lon, float *xrel,
2218        float *yrel, int *arrcode, STATUS *status )
2219
2220/* returns location of reference point
2221 *
2222 * parameters of routine
2223 * STATLOC    *lat, *lon;        output; reference location (if not NULL)
2224 * float      *xrel, *yrel;      output; relative location in km (if not NULL)
2225 * int        *arrcode;          output; array code (if not NULL)
2226 * STATUS     *status;           output; return status
2227 */
2228{
2229        /* local variables */
2230        TPmTrace *trc;                       /* pointer to trace */
2231        char     station[BC_SHORTSTRLTH+1];  /* current station name */
2232        int      dsplth;                     /* number of traces on display */
2233        STATUS   locstat;                    /* local status */
2234        GLT_STATINF *statinf;                /* pointer to station info */
2235        STATLOC  mean_lat, mean_lon;         /* mean location */
2236        float    mean_x, mean_y;             /* mean relative location */
2237        int      mean_arrcode;               /* array code of all */
2238
2239        /* executable code */
2240
2241        /* check for first trace */
2242        if  (strcmp(GpGetString(cGpS_refstation),"FIRST") == 0)  {
2243                trc = db_getp( NULL, EP_DSPN, NULL );
2244                if  (trc == NULL)  {*status = CUE_NOTRACES; return;}
2245                db_gets( trc, ES_STATION, BC_SHORTSTRLTH, station, status );
2246                ON_ERROR_RETURN
2247                statinf = gl_store_station( station, TRUE, status );
2248                ON_ERROR_RETURN
2249                if  (lat != NULL)  *lat = statinf->lat;
2250                if  (lon != NULL)  *lon = statinf->lon;
2251                if  (xrel != NULL)  *xrel = statinf->xrel;
2252                if  (yrel != NULL)  *yrel = statinf->yrel;
2253                if  (arrcode != NULL)  *arrcode = statinf->arr_id;
2254                return;
2255        } /*endif*/
2256
2257        /* check for other station than center */
2258        if  (strcmp(GpGetString(cGpS_refstation),"CENTRE") != 0
2259                && strcmp(GpGetString(cGpS_refstation),"CENTER") != 0)  {
2260                statinf = gl_store_station( GpGetString(cGpS_refstation), TRUE, status );
2261                ON_ERROR_RETURN
2262                if  (lat != NULL)  *lat = statinf->lat;
2263                if  (lon != NULL)  *lon = statinf->lon;
2264                if  (xrel != NULL)  *xrel = statinf->xrel;
2265                if  (yrel != NULL)  *yrel = statinf->yrel;
2266                if  (arrcode != NULL)  *arrcode = statinf->arr_id;
2267                return;
2268        } /*endif*/
2269
2270        /* loop all traces on display and compute center */
2271        /* !!! actually this is not quite correct, fix it later !!! */
2272        dsplth = 0;
2273        mean_lat = mean_lon = 0.0;
2274        mean_x = mean_y = 0.0;
2275        mean_arrcode = -1;
2276        trc = NULL;
2277        FOREVER  {
2278                trc = db_getp( trc, EP_DSPN, NULL );
2279                if  (trc == NULL)  break;
2280                locstat = BC_NOERROR;
2281                db_gets( trc, ES_STATION, BC_SHORTSTRLTH, station, status );
2282                ON_ERROR_RETURN
2283                if  (strcmp(station,"BEAM") == 0 || strcmp(station,"ALIGN") == 0)
2284                        continue;
2285                statinf = gl_store_station( station, TRUE, status );
2286                ON_ERROR_RETURN
2287                mean_lat += statinf->lat;
2288                mean_lon += statinf->lon;
2289                mean_x += statinf->xrel;
2290                mean_y += statinf->yrel;
2291                if  (mean_arrcode == -1)  mean_arrcode = statinf->arr_id;
2292                else if  (mean_arrcode != 0)
2293                        if  (mean_arrcode != statinf->arr_id)
2294                                mean_arrcode = 0;
2295                dsplth++;
2296        } /*endfor*/
2297
2298        if  (dsplth == 0)  {
2299                *status= CUE_NOTRACES;
2300                return;
2301        } /*endif*/
2302
2303        if  (lat != NULL)  *lat = mean_lat / (float)dsplth;
2304        if  (lon != NULL)  *lon = mean_lon / (float)dsplth;
2305        if  (xrel != NULL)  *xrel = mean_x / (float)dsplth;
2306        if  (yrel != NULL)  *yrel = mean_y / (float)dsplth;
2307        if  (arrcode != NULL)  *arrcode = mean_arrcode;
2308
2309} /* end of cu_reference_location */
2310
2311
2312
2313#undef ON_ERROR_RETURN
2314
2315
2316
2317/*--------------------------------------------------------------------------*/
2318
2319
2320
2321void cu_delete_trace( void *trc )
2322
2323/* deletes trace from memory
2324 *
2325 * parameters of routine
2326 * void       *trc;       input; pointer to trace
2327 */
2328{
2329        /* local variables */
2330
2331        /* executable code */
2332
2333        sy_deallocmem( db_getp(trc,EP_DATA,NULL) );
2334        if  (db_getp(trc,EP_USR1,NULL) != NULL)
2335                sy_deallocmem( db_getp(trc,EP_USR1,NULL) );
2336        if  (db_getp(trc,EP_USR2,NULL) != NULL)
2337                sy_deallocmem( db_getp(trc,EP_USR2,NULL) );
2338        db_delist( gc, trc );
2339        db_delete( trc );
2340
2341} /* end of cu_delete_trace */
2342
2343
2344
2345/*--------------------------------------------------------------------------*/
2346
2347
2348
2349void cu_get_stream_string( TPmTrace *trc, char stream[], STATUS *status )
2350
2351/* Returns stream string of specified trace.  If status != NULL then
2352 * error codes are returned otherwise 'X'-characters are copied to the
2353 * output string.  Minimum length of output string is cBcShortStrLth.
2354 *
2355 * parameters of routine
2356 * TPmTrace   *trc;         input; pointer to trace
2357 * char       stream[];     output; stream string (e.g. BFO-BH-Z)
2358 * STATUS     *status;      output; return status
2359 */
2360{
2361        /* local variables */
2362        char     str[cBcLineLth+1];     /* scratch string */
2363        STATUS   locstat;               /* local status */
2364        char     comp, ch1, ch2;        /* channel and component info */
2365
2366        /* executable code */
2367
2368        locstat = cBcNoError;
2369        db_gets( trc, ES_STATION, BC_LINELTH, str, &locstat );
2370        if  (SySevere(&locstat))  {
2371                if  (status != NULL)  {*status = locstat; return;}
2372                strcpy( str, "XXX" );
2373        } /*endif*/
2374        if  (strlen(str) >= cBcShortStrLth-5)  str[cBcShortStrLth-5] = '\0';
2375
2376        locstat = cBcNoError;
2377        comp = db_getc( trc, EC_COMP, &locstat );
2378        if  (SySevere(&locstat))  {
2379                if  (status != NULL)  {*status = locstat; return;}
2380                comp = 'X';
2381        } /*endif*/
2382
2383        locstat = cBcNoError;
2384        ch1 = db_getc( trc, EC_CHAN1, &locstat );
2385        if  (SySevere(&locstat))  {
2386                if  (status != NULL)  {*status = locstat; return;}
2387                ch1 = 'X';
2388        } /*endif*/
2389
2390        locstat = cBcNoError;
2391        ch2 = db_getc( trc, EC_CHAN2, &locstat );
2392        if  (SySevere(&locstat))  {
2393                if  (status != NULL)  {*status = locstat; return;}
2394                ch2 = 'X';
2395        } /*endif*/
2396
2397        sprintf( stream, "%s-%c%c-%c", str, ch1, ch2, comp );
2398
2399} /* end cu_get_stream_string */
2400
2401
2402
2403/*--------------------------------------------------------------------------*/
2404
2405
2406
2407void cu_trace_check( int ptrop )
2408
2409/* Loops all traces in list (specified by ptrop) and prints station names
2410 * and components
2411 *
2412 * parameters of routine
2413 * int        ptrop;       input; pointer name
2414 */
2415{
2416        /* local variables */
2417        void     *trc;                   /* pointer to trace */
2418        TSyStatus locstat;               /* return status */
2419        char     station[cBcFileLth+1];  /* current station name */
2420        int      t;                      /* trace counter */
2421
2422        /* executable code */
2423
2424        t = 0;
2425        trc = NULL;
2426        FOREVER {
2427                locstat = cBcNoError;
2428                trc = db_getp( trc, ptrop, &locstat );
2429                if  (trc == NULL)  break;
2430                locstat = cBcNoError;
2431                db_gets( trc, ES_STATION, cBcLineLth, station, &locstat );
2432                printf( "trcchk: %02d: %s\n", ++t, station );
2433        } /*endfor*/
2434
2435} /* end of cu_trace_check */
2436
2437
2438
2439/*---------------------------------------------------------------------------*/
2440
2441
2442
2443void cu_lookup_filter( char station[], char ttime[], char tfname[],
2444        int *trcflags, TSyStatus *status )
2445
2446/* Tries to find transfer function name for given station.  If not found
2447 * station name is returned in tfname.  'station' and 'tfname' may be the
2448 * same variable.
2449 *
2450 * parameters of routine
2451 * char       station[];   input; station name
2452 * char       ttime[];     input; trace time
2453 * char       tfname[];    output; filter name
2454 * int        *trcflags    output; trace flags to be set on created traces
2455 * TSyStatus  *status;     output; return status
2456 */
2457{
2458        /* local variables */
2459        char     *env;                       /* pointer to value of SH_INPUTS */
2460        char     lookup_file[cBcFileLth+1];  /* name of lookup table */
2461        FILE     *look;                      /* pointer to lookup table file */
2462        char     line[cBcLineLth+1];         /* current line of file */
2463        char     stat[cBcLineLth+1];         /* local copy of station name */
2464        char     l_station[cBcLineLth+1];    /* current station */
2465        char     l_filter[cBcLineLth+1];     /* current filter */
2466        char     t_from[cBcLineLth+1];       /* time interval start */
2467        char     t_until[cBcLineLth+1];      /* time interval end */
2468        char     flagstr[cBcLineLth+1];      /* additional info */
2469        float    tdiff;                      /* difference time */
2470        int      readret;                    /* number of items read */
2471        int      filecnt;                    /* file counter */
2472        char     *fl;                        /* pointer to lookup file name */
2473        TSyStatus locstat;                   /* return status */
2474
2475        /* executable code */
2476
2477        /* copy station name */
2478        if  (strlen(station) > cBcLineLth)  {
2479                *status = CUE_STROVFL;
2480                return;
2481        } /*endif*/
2482        if  (strncmp(station,"B@",2) == 0)  {
2483                strcpy( stat, station+2 );
2484        } else {
2485                strcpy( stat, station );
2486        } /*endif*/
2487
2488        *trcflags = 0;
2489
2490        /* search built-in table (faster) */
2491        if  (stat[0] == 'G' && stat[1] == 'R')  {
2492                if  (strncmp(stat,"GRA1-BH-",8) == 0)  {
2493                        locstat = cBcNoError;
2494                        tdiff = tc_tdiff( ttime, "26-may-2006_20:00", &locstat );
2495                        if  (tdiff < 0.0)  {
2496                                strcpy(tfname,"GRF"); return;
2497                        } else {
2498                                strcpy(tfname,"GRSN"); return;
2499                        } /*endif*/
2500                } /*endif*/
2501                if  (strncmp(stat,"GRA2-BH-",8) == 0)  {
2502                        locstat = cBcNoError;
2503                        tdiff = tc_tdiff( ttime, "09-Oct-2006_9:00", &locstat );
2504                        if  (tdiff < 0.0)  {
2505                                strcpy(tfname,"GRF"); return;
2506                        } else {
2507                                strcpy(tfname,"GRSN"); return;
2508                        } /*endif*/
2509                } /*endif*/
2510                if  (strncmp(stat,"GRA3-BH-",8) == 0)  {
2511                        locstat = cBcNoError;
2512                        tdiff = tc_tdiff( ttime, "11-Oct-2006_9:00", &locstat );
2513                        if  (tdiff < 0.0)  {
2514                                strcpy(tfname,"GRF"); return;
2515                        } else {
2516                                strcpy(tfname,"GRSN"); return;
2517                        } /*endif*/
2518                } /*endif*/
2519                if  (strncmp(stat,"GRA4-BH-",8) == 0)  {
2520                        locstat = cBcNoError;
2521                        tdiff = tc_tdiff( ttime, "25-Sep-2006_8:00", &locstat );
2522                        if  (tdiff < 0.0)  {
2523                                strcpy(tfname,"GRF"); return;
2524                        } else {
2525                                strcpy(tfname,"GRSN"); return;
2526                        } /*endif*/
2527                } /*endif*/
2528                if  (strncmp(stat,"GRB1-BH-",8) == 0)  {
2529                        locstat = cBcNoError;
2530                        tdiff = tc_tdiff( ttime, "15-Sep-2006_8:00", &locstat );
2531                        if  (tdiff < 0.0)  {
2532                                strcpy(tfname,"GRF"); return;
2533                        } else {
2534                                strcpy(tfname,"GRSN"); return;
2535                        } /*endif*/
2536                } /*endif*/
2537                if  (strncmp(stat,"GRB2-BH-",8) == 0)  {
2538                        locstat = cBcNoError;
2539                        tdiff = tc_tdiff( ttime, "21-jun-2006_9:07", &locstat );
2540                        if  (tdiff < 0.0)  {
2541                                strcpy(tfname,"GRF"); return;
2542                        } else {
2543                                strcpy(tfname,"GRSN"); return;
2544                        } /*endif*/
2545                } /*endif*/
2546                if  (strncmp(stat,"GRB3-BH-",8) == 0)  {
2547                        locstat = cBcNoError;
2548                        tdiff = tc_tdiff( ttime, "19-oct-2006_9:00", &locstat );
2549                        if  (tdiff < 0.0)  {
2550                                strcpy(tfname,"GRF"); return;
2551                        } else {
2552                                strcpy(tfname,"GRSN"); return;
2553                        } /*endif*/
2554                } /*endif*/
2555                if  (strncmp(stat,"GRB4-BH-",8) == 0)  {
2556                        locstat = cBcNoError;
2557                        tdiff = tc_tdiff( ttime, "28-Sep-2006_10:00", &locstat );
2558                        if  (tdiff < 0.0)  {
2559                                strcpy(tfname,"GRF"); return;
2560                        } else {
2561                                strcpy(tfname,"GRSN"); return;
2562                        } /*endif*/
2563                } /*endif*/
2564                if  (strncmp(stat,"GRB5-BH-",8) == 0)  {
2565                        locstat = cBcNoError;
2566                        tdiff = tc_tdiff( ttime, "7-aug-2006_9:00", &locstat );
2567                        if  (tdiff < 0.0)  {
2568                                strcpy(tfname,"GRF"); return;
2569                        } else {
2570                                strcpy(tfname,"GRSN"); return;
2571                        } /*endif*/
2572                } /*endif*/
2573                if  (strncmp(stat,"GRC1-BH-",8) == 0)  {
2574                        locstat = cBcNoError;
2575                        tdiff = tc_tdiff( ttime, "15-mar-2005_9:00", &locstat );
2576                        if  (tdiff < 0.0)  {
2577                                strcpy(tfname,"GRF"); return;
2578                        } else {
2579                                strcpy(tfname,"GRSN"); return;
2580                        } /*endif*/
2581                } /*endif*/
2582                if  (strncmp(stat,"GRC2-BH-",8) == 0)  {
2583                        locstat = cBcNoError;
2584                        tdiff = tc_tdiff( ttime, "9-may-2006_9:44", &locstat );
2585                        if  (tdiff < 0.0)  {
2586                                strcpy(tfname,"GRF"); return;
2587                        } else {
2588                                strcpy(tfname,"GRSN"); return;
2589                        } /*endif*/
2590                } /*endif*/
2591                if  (strncmp(stat,"GRC3-BH-",8) == 0)  {
2592                        locstat = cBcNoError;
2593                        tdiff = tc_tdiff( ttime, "26-jul-2006_9:00", &locstat );
2594                        if  (tdiff < 0.0)  {
2595                                strcpy(tfname,"GRF"); return;
2596                        } else {
2597                                strcpy(tfname,"GRSN"); return;
2598                        } /*endif*/
2599                } /*endif*/
2600                if  (strncmp(stat,"GRC4-BH-",8) == 0)  {
2601                        locstat = cBcNoError;
2602                        tdiff = tc_tdiff( ttime, "19-Aug-2006_9:00", &locstat );
2603                        if  (tdiff < 0.0)  {
2604                                strcpy(tfname,"GRF"); return;
2605                        } else {
2606                                strcpy(tfname,"GRSN"); return;
2607                        } /*endif*/
2608                } /*endif*/
2609        } else if  (stat[0] == 'G' && stat[1] == 'E')  {
2610                if  (strcmp(stat,"GEA0-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2611                if  (strcmp(stat,"GEA0-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2612                if  (strcmp(stat,"GEA0-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2613                if  (strcmp(stat,"GEA1-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2614                if  (strcmp(stat,"GEA1-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2615                if  (strcmp(stat,"GEA1-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2616                if  (strcmp(stat,"GEA2-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2617                if  (strcmp(stat,"GEA2-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2618                if  (strcmp(stat,"GEA2-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2619                if  (strcmp(stat,"GEA3-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2620                if  (strcmp(stat,"GEA3-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2621                if  (strcmp(stat,"GEA3-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2622                if  (strcmp(stat,"GEB1-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2623                if  (strcmp(stat,"GEB1-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2624                if  (strcmp(stat,"GEB1-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2625                if  (strcmp(stat,"GEB2-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2626                if  (strcmp(stat,"GEB2-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2627                if  (strcmp(stat,"GEB2-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2628                if  (strcmp(stat,"GEB3-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2629                if  (strcmp(stat,"GEB3-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2630                if  (strcmp(stat,"GEB3-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2631                if  (strcmp(stat,"GEB4-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2632                if  (strcmp(stat,"GEB4-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2633                if  (strcmp(stat,"GEB4-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2634                if  (strcmp(stat,"GEB5-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2635                if  (strcmp(stat,"GEB5-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2636                if  (strcmp(stat,"GEB5-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2637                if  (strcmp(stat,"GEC1-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2638                if  (strcmp(stat,"GEC1-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2639                if  (strcmp(stat,"GEC1-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2640                if  (strcmp(stat,"GEC2-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2641                if  (strcmp(stat,"GEC2-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2642                if  (strcmp(stat,"GEC2-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2643                if  (strcmp(stat,"GEC3-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2644                if  (strcmp(stat,"GEC3-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2645                if  (strcmp(stat,"GEC3-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2646                if  (strcmp(stat,"GEC4-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2647                if  (strcmp(stat,"GEC4-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2648                if  (strcmp(stat,"GEC4-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2649                if  (strcmp(stat,"GEC5-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2650                if  (strcmp(stat,"GEC5-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2651                if  (strcmp(stat,"GEC5-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2652                if  (strcmp(stat,"GEC6-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2653                if  (strcmp(stat,"GEC6-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2654                if  (strcmp(stat,"GEC6-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2655                if  (strcmp(stat,"GEC7-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2656                if  (strcmp(stat,"GEC7-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2657                if  (strcmp(stat,"GEC7-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2658                if  (strcmp(stat,"GED1-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2659                if  (strcmp(stat,"GED1-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2660                if  (strcmp(stat,"GED1-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2661                if  (strcmp(stat,"GED2-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2662                if  (strcmp(stat,"GED2-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2663                if  (strcmp(stat,"GED2-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2664                if  (strcmp(stat,"GED3-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2665                if  (strcmp(stat,"GED3-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2666                if  (strcmp(stat,"GED3-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2667                if  (strcmp(stat,"GED4-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2668                if  (strcmp(stat,"GED4-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2669                if  (strcmp(stat,"GED4-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2670                if  (strcmp(stat,"GED5-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2671                if  (strcmp(stat,"GED5-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2672                if  (strcmp(stat,"GED5-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2673                if  (strcmp(stat,"GED6-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2674                if  (strcmp(stat,"GED6-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2675                if  (strcmp(stat,"GED6-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2676                if  (strcmp(stat,"GED7-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2677                if  (strcmp(stat,"GED7-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2678                if  (strcmp(stat,"GED7-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2679                if  (strcmp(stat,"GED8-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2680                if  (strcmp(stat,"GED8-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2681                if  (strcmp(stat,"GED8-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2682                if  (strcmp(stat,"GED9-SH-Z") == 0)  {strcpy(tfname,"GERESS"); return;}
2683                if  (strcmp(stat,"GED9-SH-N") == 0)  {strcpy(tfname,"GERESS"); return;}
2684                if  (strcmp(stat,"GED9-SH-E") == 0)  {strcpy(tfname,"GERESS"); return;}
2685        } /*endif*/
2686        if  (strcmp(stat,"BFO-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2687        if  (strcmp(stat,"BFO-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2688        if  (strcmp(stat,"BFO-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2689        if  (strcmp(stat,"BRG-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2690        if  (strcmp(stat,"BRG-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2691        if  (strcmp(stat,"BRG-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2692        if  (strcmp(stat,"BRNL-BH-Z") == 0) {strcpy(tfname,"GRSN"); return;}
2693        if  (strcmp(stat,"BRNL-BH-N") == 0) {strcpy(tfname,"GRSN"); return;}
2694        if  (strcmp(stat,"BRNL-BH-E") == 0) {strcpy(tfname,"GRSN"); return;}
2695        if  (strcmp(stat,"BSEG-BH-Z") == 0) {strcpy(tfname,"GRSN"); return;}
2696        if  (strcmp(stat,"BSEG-BH-N") == 0) {strcpy(tfname,"GRSN"); return;}
2697        if  (strcmp(stat,"BSEG-BH-E") == 0) {strcpy(tfname,"GRSN"); return;}
2698        if  (strcmp(stat,"BUG-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2699        if  (strcmp(stat,"BUG-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2700        if  (strcmp(stat,"BUG-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2701        if  (strcmp(stat,"CLL-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2702        if  (strcmp(stat,"CLL-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2703        if  (strcmp(stat,"CLL-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2704        if  (strcmp(stat,"CLZ-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2705        if  (strcmp(stat,"CLZ-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2706        if  (strcmp(stat,"CLZ-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2707        if  (strcmp(stat,"FUR-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2708        if  (strcmp(stat,"FUR-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2709        if  (strcmp(stat,"FUR-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2710        if  (strcmp(stat,"GSH-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2711        if  (strcmp(stat,"GSH-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2712        if  (strcmp(stat,"GSH-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2713        if  (strcmp(stat,"HAM-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2714        if  (strcmp(stat,"HAM-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2715        if  (strcmp(stat,"HAM-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2716        if  (strcmp(stat,"IBB-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2717        if  (strcmp(stat,"IBB-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2718        if  (strcmp(stat,"IBB-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2719        if  (strcmp(stat,"IBBN-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2720        if  (strcmp(stat,"IBBN-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2721        if  (strcmp(stat,"IBBN-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2722        if  (strcmp(stat,"LID-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2723        if  (strcmp(stat,"LID-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2724        if  (strcmp(stat,"LID-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2725        if  (strcmp(stat,"MOX-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2726        if  (strcmp(stat,"MOX-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2727        if  (strcmp(stat,"MOX-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2728        if  (strcmp(stat,"TNS-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2729        if  (strcmp(stat,"TNS-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2730        if  (strcmp(stat,"TNS-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2731        if  (strcmp(stat,"RGN-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2732        if  (strcmp(stat,"RGN-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2733        if  (strcmp(stat,"RGN-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2734        if  (strcmp(stat,"STU-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2735        if  (strcmp(stat,"STU-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2736        if  (strcmp(stat,"STU-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2737        if  (strcmp(stat,"WET-BH-Z") == 0)  {strcpy(tfname,"GRSN"); return;}
2738        if  (strcmp(stat,"WET-BH-N") == 0)  {strcpy(tfname,"GRSN"); return;}
2739        if  (strcmp(stat,"WET-BH-E") == 0)  {strcpy(tfname,"GRSN"); return;}
2740        if  (strcmp(stat,"GRFO-BH-Z") == 0) {strcpy(tfname,"GRFO"); return;}
2741        if  (strcmp(stat,"GRFO-BH-N") == 0) {strcpy(tfname,"GRFO"); return;}
2742        if  (strcmp(stat,"GRFO-BH-E") == 0) {strcpy(tfname,"GRFO"); return;}
2743
2744        /* search lookup table files */
2745        for  (filecnt=0;;filecnt++)  {
2746
2747                /* get next filter lookup file and open it */
2748                fl = GpGetStringElem( cGpL_filter_lookup_table, filecnt );
2749                if  (fl == NULL)  break;
2750                if  (strlen(fl) > cBcFileLth)  {
2751                        *status = CUE_STROVFL;
2752                        return;
2753                } /*endif*/
2754                strcpy( lookup_file, fl );
2755                if  (GpGetInt(cGpI_debug_level) > 6)
2756                        printf( "SHM-dbg7: open filter_lookup %s for %s at %s\n",
2757                                lookup_file, station, ttime );
2758                look = sy_fopen( lookup_file, "r" );
2759                if  (look == NULL)  {
2760                        *status = CUE_OPENREAD;
2761                        err_setcontext( " ## file " ); err_setcontext( lookup_file );
2762                        return;
2763                } /*endif*/
2764
2765                /* read through this filter lookup file */
2766                while  (fgets(line,cBcLineLth,look) != NULL)  {
2767                        if  (*line == '!' || *line == '\n')  continue;
2768                        readret = sscanf( line, "%s %s %s %s %s", l_station, l_filter,
2769                                t_from, t_until, flagstr );
2770                        if  (readret < 2 || readret == 3)  {
2771                                /* at least stream name and translation name (filter) must be specified */
2772                                *status = CUE_READ_INPUT;
2773                                err_setcontext( " ## file " ); err_setcontext( lookup_file );
2774                                sy_fclose( look );
2775                                return;
2776                        } /*endif*/
2777                        if  (strcmp(l_station,stat) == 0)  {
2778                                /* check whether a time interval is specified and if time is within this */
2779                                if  (readret >= 4)  {
2780                                        if  (strcmp(t_from,"...") != 0)  {
2781                                                tdiff = tc_tdiff( ttime, t_from, status );
2782                                                if  (SySevere(status))  {sy_fclose(look); return;}
2783                                                if  (tdiff < 0.0)  continue;  /* time before start time */
2784                                        } /*endif*/
2785                                        if  (strcmp(t_until,"...") != 0)  {
2786                                                tdiff = tc_tdiff( ttime, t_until, status );
2787                                                if  (SySevere(status))  {sy_fclose(look); return;}
2788                                                if  (tdiff > 0.0)  continue;  /* time after end time */
2789                                        } /*endif*/
2790                                } /*endif*/
2791                                /* now check for flags */
2792                                if  (readret > 4)  {
2793                                        if  (strstr(flagstr,"-ALERT-") != NULL)
2794                                                *trcflags |= CUC_F_TRC_ALERT;
2795                                        if  (strstr(flagstr,"-FORCEFFT-") != NULL)
2796                                                *trcflags |= CUC_F_TRC_FORCE_F;
2797                                        if  (strstr(flagstr,"-FORCETAB-") != NULL)
2798                                                *trcflags |= CUC_F_TRC_FORCE_T;
2799                                } /*endif*/
2800                                strcpy( tfname, l_filter );
2801                                sy_fclose( look );
2802                                return;
2803                        } /*endif*/
2804                } /*endwhile*/
2805
2806        } /*endfor*/
2807
2808        /* nothing found, return station name itself */
2809        if  (tfname != stat)  strcpy( tfname, stat );
2810        sy_fclose( look );
2811
2812        /* replace hyphens '-' by colons ':' */
2813        env = tfname-1;
2814        while  (*(++env) != '\0')
2815                if  (*env == '-')  *env = ':';
2816
2817} /* end of cu_lookup_filter */
2818
2819
2820
2821/*--------------------------------------------------------------------------*/
2822
2823#ifdef XXX
2824
2825/* this is the old version reading via external_routine */
2826
2827void cu_next_read_dialog( void )
2828
2829/* Displays next station list in dialog box
2830 *
2831 * parameters of routine
2832 */
2833{
2834        /* local variables */
2835        static int cnt=0;                /* set counter */
2836        char     shcmd[cBcLineLth+1];    /* sh command string */
2837        TSyBoolean  redraw;              /* not used */
2838        TSyStatus   status;              /* return status */
2839
2840        /* executable code */
2841
2842        sprintf( shcmd, "shm_cmd_read_dialog statlist_%02d.stx", ++cnt );
2843        status = cBcNoError;
2844        callsh( shcmd, &redraw, &status );
2845
2846        if  (status != cBcNoError)  {
2847                status = cBcNoError;
2848                cnt=1;
2849                callsh( "shm_cmd_read_dialog statlist_01.stx", &redraw, &status );
2850        } /*endif*/
2851
2852} /* end of cu_next_dialog */
2853
2854#endif
2855
2856/*--------------------------------------------------------------------------*/
2857
2858
2859
2860void cu_next_read_dialog( Widget w[] )
2861
2862/* Displays next station list in dialog box
2863 *
2864 * parameters of routine
2865 * Widget     w[]; input; widget array
2866 */
2867{
2868        /* local variables */
2869        static int cnt=0;                /* set counter */
2870        TSyStatus   status;              /* return status */
2871
2872        /* executable code */
2873
2874        status = cBcNoError;
2875        mx_name_read_buttons( w, ++cnt, &status );
2876        if  (status != cBcNoError)  {
2877                status = cBcNoError;
2878                cnt=1;
2879                mx_name_read_buttons( w, cnt, &status );
2880        } /*endif*/
2881
2882} /* end of cu_next_dialog */
2883
2884
2885
2886/*--------------------------------------------------------------------------*/
2887
2888
2889
2890void cu_set_exec_flag( int flag, TSyBoolean value )
2891
2892/* Sets/Clears execution flags
2893 *
2894 * parameters of routine
2895 * int        flag;       input; which flag to set/clear
2896 * TSyBoolean val;        input; new value of flag
2897 */
2898{
2899        /* executable code */
2900
2901        if  (value)  {
2902                cuv_execflags |= flag;
2903        } else {
2904                cuv_execflags &= ~flag;
2905        } /*endif*/
2906
2907} /* end of cu_set_exec_flag */
2908
2909
2910
2911/*--------------------------------------------------------------------------*/
2912
2913
2914
2915TSyBoolean cu_get_exec_flag( int flag )
2916
2917/* Returns flag status
2918 *
2919 * parameters of routine
2920 * int        flag;      input; flag to return status
2921 */
2922{
2923        /* executable code */
2924
2925        return (cuv_execflags & flag);
2926
2927} /* end of cu_get_exec_flag */
2928
2929
2930
2931/*--------------------------------------------------------------------------*/
2932
2933
2934
2935void cu_clear_exec_flags( void )
2936
2937/* Clears all execution flags
2938 *
2939 * no parameters
2940 */
2941{
2942        /* executable code */
2943
2944        cuv_execflags = 0;
2945
2946} /* end of cu_clear_exec_flags */
2947
2948
2949
2950/*--------------------------------------------------------------------------*/
2951
2952
2953
2954void cu_rename_phase( Widget w[] )
2955
2956/* renames phase from or to unknown phase '???'
2957 *
2958 * parameters of routine
2959 * Widget     w[];     input widget array
2960 */
2961{
2962        /* local variables */
2963        char     pname[cBcLineLth+1];   /* current phase name */
2964        int      cnt;                   /* change counter */
2965
2966        /* executable code */
2967
2968        strcpy( pname, cu_get_string(w[k_widget_phase_name_text]) );
2969        if  (PiPhaseIsPicked("???"))  {
2970                PiRenamePhase( "???", pname, &cnt );
2971        } else {
2972                PiRenamePhase( pname, "???", &cnt );
2973        } /*endif*/
2974
2975} /* end of cu_rename_phase */
2976
2977
2978
2979/*--------------------------------------------------------------------------*/
2980
2981
Note: See TracBrowser for help on using the repository browser.