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

Revision 188, 90.8 KB checked in by marcus, 13 years ago (diff)

r109 | svn | 2010-01-25 21:06:08 +0100 (Mo, 25 Jan 2010) | 1 line

fixed bug: initialisation of resid-array in cu_localization

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