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

Revision 83, 90.8 KB checked in by marcus, 14 years ago (diff)

r65 | svn | 2008-11-22 11:54:07 +0100 (Sa, 22 Nov 2008) | 1 line

new french stations; changes in SHM to position within a detection list via events file

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