source: SH_SHM/trunk/util/check_evt.c @ 108

Revision 108, 19.0 KB checked in by marcus, 14 years ago (diff)

r80 | svn | 2009-03-17 08:58:51 +0100 (Di, 17 Mär 2009) | 1 line

fixed bug in check_evt; open new mseed file when record length changes (seed_tidy); additional station info

Line 
1
2/* file check_evt.c
3 *      ===========
4 *
5 * version 10, 16-Jan-2007
6 *
7 * Checks consistency of created output file of SHM
8 * K. Stammler, 21-Jul-94
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
36#include <stdio.h>
37#include <string.h>
38#include <stdlib.h>
39#include BASECNST
40#include BC_SYSBASE
41#include "eventdsc.h"
42#include "tcusrdef.h"
43#include "earthloc.h"
44
45
46#define MAX_PKP_SLOWNESS 4.5
47#define MIN_P_SLOWNESS 4.3
48
49#define EVTYPE_UNDEF 0
50#define EVTYPE_LOCAL 1
51#define EVTYPE_P     2
52#define EVTYPE_PKP   3
53
54/* next error number currently 031 */
55
56
57
58/* global variables */
59static float   efv_reflat=49.0;           /* reference latitude */
60static float   efv_reflon=11.0;           /* reference longitude */
61static char    efv_infile[BC_FILELTH+1];  /* name of input file */
62static char    efv_uncorrphase[EvPHASELTH+1]; /* name of phase on uncorr beam */
63static BOOLEAN efv_first_arrival=FALSE;   /* first arrival phase selected */
64static BOOLEAN efv_only_grf=TRUE;         /* only GRF stations used */
65static BOOLEAN efv_gra1_picked=FALSE;     /* pick on GRA1 found */
66static BOOLEAN efv_uncorr_loc=FALSE;      /* uncorrected beam for location */
67static BOOLEAN efv_telex_phase=FALSE;     /* telex phase found */
68static BOOLEAN efv_mb_found=FALSE;        /* mb determination done */
69static BOOLEAN efv_ms_found=FALSE;        /* ms determination done */
70static BOOLEAN efv_mbb_found=FALSE;       /* mbb determination done */
71static int     efv_subtype=EVTYPE_UNDEF;  /* event type */
72static EvEventTypeT efv_evtype=EvcEventTypeUndefined; /* event type */
73static float   efv_depth=(-100.0);        /* depth of event */
74static float   efv_magn=0.0;              /* max. magnitude found */
75static int     efv_pkp_count=0;           /* number of PKP phases */
76static BOOLEAN efv_illegal_origin;        /* illegal origin time */
77static BOOLEAN efv_foundPg=FALSE;         /* Pg phase found */
78static BOOLEAN efv_foundPnSn=FALSE;       /* Pn/Sn found */
79static BOOLEAN efv_foundTele=FALSE;       /* teleseismic phase found */
80static float   efv_latitude=0.0;          /* epicentre latitude */
81static float   efv_longitude=0.0;         /* epicentre longitude */
82static char    efv_analyst[EvANALYSTLTH+1]=""; /* analysts initials */
83static BOOLEAN efv_showinitials=FALSE;    /* show initials */
84
85
86/* prototypes of local routines */
87void EfPutCheck( FILE *out, EvEventT *event, EvStatusT *status );
88static BOOLEAN EfPhaseIsFirstArrival( char name[] );
89static void EfFinalCheck( FILE *out );
90static BOOLEAN EfIsLocalPhase( char phase[] );
91
92
93
94int main( int argc, char *argv[] )
95{
96        /* local variables */
97        char      infile[BC_FILELTH+1];    /* input file */
98        char      outfile[BC_FILELTH+1];   /* output file */
99        EvStatusT status;                  /* return status */
100        int       i;                       /* counter */
101    char      tmpstr[cBcLongStrLth+1]; /* scratch string */
102
103        /* executable code */
104
105        if  (argc < 2)  {
106                fprintf( stderr, "Usage: %s <input> [<output>] [<showinitials>]\n",
107                        argv[0] );
108                return 1;
109        } /*endif*/
110
111        strcpy( infile, argv[1] );
112        if  (argc > 2)  {
113                strcpy( outfile, argv[2] );
114                if  (*outfile == '\0')
115                        strcpy( outfile, "TT" );
116        } else {
117                strcpy( outfile, "TT" );
118        } /*endif*/
119        efv_showinitials = FALSE;
120        if  (argc > 3)
121                efv_showinitials = (strcmp(argv[3],"showinitials") == 0);
122
123#ifdef XXX
124        /* efv_infile is used for messages, directory will be removed */
125        i = strlen( infile ) - 1;
126        while  (infile[i] != '/' && i > 0)
127                i--;
128        strcpy( efv_infile, infile+i );
129#endif
130    strcpy( efv_infile, infile );
131
132        status = EveNOERROR;
133        EvReformatEventfile( infile, outfile, EvGetEvent,
134                EfPutCheck, &status );
135
136    /* now call the Python script for additional checks */
137    if  (strcmp(outfile,"TT") == 0)  {
138        sprintf( tmpstr, "%s/CheckEvt.py %s", (char *)getenv("SH_UTIL"),
139            efv_infile );
140        system( tmpstr );
141    } else {
142        sprintf( tmpstr, "%s/CheckEvt.py %s %s", (char *)getenv("SH_UTIL"),
143            efv_infile, outfile );
144        system( tmpstr );
145    } /*endif*/
146
147        return 0;
148
149} /* end of main */
150
151
152
153/*---------------------------------------------------------------------------*/
154
155
156
157void EfPutCheck( FILE *out, EvEventT *event, EvStatusT *status )
158
159/* Prints error messages of event to file 'out'.
160 *
161 * parameters of routine
162 * FILE       *out;          input; output file
163 * EvEventT   *event;        input; event information
164 * EvStatusT  *status;       output; return status
165 */
166{
167        /* local variables */
168        static BOOLEAN locqual_checked=FALSE; /* location quality checked ? */
169        BOOLEAN  amplitude_measured;      /* amplitude measured */
170        BOOLEAN  is_l_phase;              /* phase is L (or (L)) */
171        BOOLEAN  is_pkp_phase;            /* phase is PKP */
172        BOOLEAN  is_p_phase;              /* phase is P or (P) */
173        BOOLEAN  loc_given;               /* location given in this record */
174        NTIME    ntime;                   /* numeric origin time */
175
176        /* executable code */
177
178        /* final check if event is NULL */
179        if  (event == NULL)  {
180                EfFinalCheck( out );
181                locqual_checked = FALSE;
182                return;
183        } /*endif*/
184
185        /* fprintf( out, "--> check phase %s\n", event->phase ); */
186
187        /* is a location given here ? */
188        loc_given = (event->latitude > 0.0 && event->longitude > 0.0);
189        if  (loc_given)  {
190                efv_latitude = event->latitude;
191                efv_longitude = event->longitude;
192        } /*endif*/
193
194        /* is this an L phase ? */
195        is_l_phase = (strcmp(event->phase,"L") == 0
196                || strcmp(event->phase,"(L)") == 0);
197
198        /* is this a P phase ? */
199        is_p_phase = (strcmp(event->phase,"P") == 0
200                || strcmp(event->phase,"(P)") == 0);
201
202        /* is this a PKP phase ? */
203        is_pkp_phase = (strstr(event->phase,"PKP") != NULL);
204        if  (is_pkp_phase)
205                efv_foundTele = TRUE;
206
207    /* is this a leftover from an amplitude measurement? */
208    if  (strncmp(event->phase,"w-",2) == 0)
209                fprintf( out, "F012 %s: illegal phase %s found on %s\n",
210                        efv_infile, event->phase, event->station );
211       
212
213        /* a depth phase can found only in teleseismic events */
214        if  (event->phase[0] == 'p' || event->phase[0] == 's')
215                efv_foundTele = TRUE;
216
217        /* check for local and regional phases */
218        if  (strcmp(event->phase,"Pg") == 0)
219                efv_foundPg = TRUE;
220        if  (strcmp(event->phase,"Pn") == 0)
221                efv_foundPnSn = TRUE;
222        if  (strcmp(event->phase,"Sn") == 0)
223                efv_foundPnSn = TRUE;
224
225        if  (event->event_type != EvcEventTypeUndefined)
226                efv_evtype = event->event_type;
227
228        /* setup global variables used in final check */
229        /* ------------------------------------------ */
230
231        /* is it a GRF station ? */
232        if  (strncmp(event->station,"GR",2) != 0
233                || event->station[2] < 'A' || event->station[2] > 'C')
234                efv_only_grf = FALSE;
235        if  (strcmp(event->station,"GRA1") == 0)
236                efv_gra1_picked = TRUE;
237
238        /* is a first arrival phase there ? */
239        if  (EfPhaseIsFirstArrival(event->phase))
240                efv_first_arrival = TRUE;
241
242        /* is there a location done with uncorrected beam ? */
243        if  ((loc_given && event->b_slowness != EvEMPTY_SLOWNESS &&
244                event->l_slowness == EvEMPTY_SLOWNESS
245                && event->loc_quality == EvcLocQualReliable
246                && strcmp(event->source,"SZGRF") == 0)
247                || (event->loc_method == EvcLocMethUncorrBeam))  {
248                efv_uncorr_loc = TRUE;
249                strcpy( efv_uncorrphase, event->phase );
250        } /*endif*/
251
252        /* is there an origin time from 1970? */
253        if  (loc_given)  {
254                tc_t2n( event->origin_time, &ntime, status );
255                if  (SySevere(status))  {
256                        efv_illegal_origin = TRUE;
257                } else if  (ntime.year == 1970)  {
258                        efv_illegal_origin = TRUE;
259                } /*endif*/
260        } /*endif*/
261
262        /* look for telex phase */
263        if  (strchr(event->phase_flags,EvFLAG_TELEX) != NULL)
264                efv_telex_phase = TRUE;
265
266        /* look for depth */
267        if  (efv_depth < -99.0 && event->depth_type != EvcDepthUndefined)
268                efv_depth = event->depth;
269
270        /* find plain mistakes */
271        /* ------------------- */
272
273        /* special for L phases */
274        if  (is_l_phase)  {
275                /* is there an impulsive L phase ? */
276                if  (event->onset_type == EvcOnsetImpulsive)
277                        fprintf( out, "F001 %s: phase L with impulsive onset\n", efv_infile );
278                /* is a legal filter used ? */
279                if  (strcmp(event->filter,"G_WWSSN_SP") == 0
280                        || strcmp(event->filter,"STANDARD_BP") == 0
281                        || event->filter[0] == '\0')
282                        fprintf( out, "F002 %s: L phase reading with illegal filter %s\n",
283                                efv_infile, event->filter );
284                /* is there slowness and azimuth ? if yes that's real nonsense */
285                if  (event->b_slowness != EvEMPTY_SLOWNESS
286                        || event->b_azimuth != EvEMPTY_AZIMUTH
287                        || event->l_slowness != EvEMPTY_SLOWNESS
288                        || event->l_azimuth != EvEMPTY_AZIMUTH)
289                        fprintf( out, "F003 %s: slowness and/or azimuth for phase %s\n",
290                                efv_infile, event->phase );
291                /* is amplitude & period determined ? */
292                if  (event->amplitude == EvEMPTY_AMPLITUDE
293                        || event->period == EvEMPTY_PERIOD)
294                        fprintf( out, "F004 %s: no amplitude / period for phase %s\n",
295                                efv_infile, event->phase );
296        } /*endif*/
297
298        if  (is_pkp_phase)  {
299                /* check slowness range */
300                if  (event->b_slowness != EvEMPTY_SLOWNESS
301                        && event->b_slowness > MAX_PKP_SLOWNESS)
302                        fprintf( out, "F005 %s: illegal beam slowness %3.1f for phase %s\n",
303                                efv_infile, event->b_slowness, event->phase );
304                if  (event->l_slowness != EvEMPTY_SLOWNESS
305                        && event->l_slowness > MAX_PKP_SLOWNESS)
306                        fprintf( out, "F006 %s: illegal corr. slowness %3.1f for phase %s\n",
307                                efv_infile, event->l_slowness, event->phase );
308                efv_subtype = EVTYPE_PKP;
309                efv_pkp_count++;
310        } /*endif*/
311
312        if  (is_p_phase)  {
313                /* check slowness range */
314                if  (event->b_slowness != EvEMPTY_SLOWNESS
315                        && event->b_slowness < MIN_P_SLOWNESS)
316                        if  (event->l_slowness == EvEMPTY_SLOWNESS)
317                                fprintf( out, "F007 %s: illegal beam slowness %3.1f for phase %s\n",
318                                        efv_infile, event->b_slowness, event->phase );
319                if  (event->l_slowness != EvEMPTY_SLOWNESS
320                        && event->l_slowness < MIN_P_SLOWNESS)
321                        fprintf( out, "F008 %s: illegal corr. slowness %3.1f for phase %s\n",
322                                efv_infile, event->l_slowness, event->phase );
323                efv_subtype = EVTYPE_P;
324        } /*endif*/
325
326        if  (EfIsLocalPhase(event->phase))  efv_subtype = EVTYPE_LOCAL;
327
328        /* amplitude measurement must be complete */
329        amplitude_measured = (event->period != EvEMPTY_PERIOD
330                || event->amplitude != EvEMPTY_AMPLITUDE
331                || event->amplitude_time != EvEMPTY_AMPLITUDE_TIME
332                || event->amplitude_vel != EvEMPTY_AMPLITUDE);
333        if  (amplitude_measured)
334                if  (event->period == EvEMPTY_PERIOD
335                        || event->amplitude == EvEMPTY_AMPLITUDE
336                        || (event->amplitude_time == EvEMPTY_AMPLITUDE_TIME && !is_l_phase)
337                        || event->amplitude_vel == EvEMPTY_AMPLITUDE
338                        || event->ap_source == EvcApSourceUndefined)
339                        fprintf( out,
340                                "F009 %s: incomplete amplitude determination at phase %s, station %s\n",
341                                efv_infile, event->phase, event->station );
342
343        /* check for magnitudes determined */
344        if  (event->mag[EvcMagMb] != EvEMPTY_MAGNITUDE)  {
345                efv_mb_found = TRUE;
346                if  (event->mag[EvcMagMb] > efv_magn)  efv_magn = event->mag[EvcMagMb];
347        } /*endif*/
348        if  (event->mag[EvcMagMs] != EvEMPTY_MAGNITUDE)  {
349                efv_ms_found = TRUE;
350                if  (event->mag[EvcMagMs] > efv_magn)  efv_magn = event->mag[EvcMagMs];
351        } /*endif*/
352        if  (event->mag[EvcMagMbb] != EvEMPTY_MAGNITUDE) efv_mbb_found = TRUE;
353
354        /* magnitudes mb,MS are valid only with amplitude */
355        if  (event->mag[EvcMagMs] != EvEMPTY_MAGNITUDE
356                || event->mag[EvcMagMb] != EvEMPTY_MAGNITUDE)
357                if  (!amplitude_measured)
358                        fprintf( out, "F010 %s: magnitude without amplitude on phase %s\n",
359                                efv_infile, event->phase );
360
361        /* a reliable location with PKP is not possible */
362        if  (event->loc_quality == EvcLocQualReliable && is_pkp_phase
363                && strcmp(event->source,"SZGRF") == 0 && loc_given)
364                fprintf( out, "F011 %s: reliable location with phase %s not possible\n",
365                        efv_infile, event->phase );
366
367        /* event type tele and local phases Pn, Pg, Sn, Sg */
368        if  (event->event_type == EvcEventTypeTeleQuake
369                && EfIsLocalPhase(event->phase))
370                fprintf( out, "F012 %s: incompatible event type TELE with phase %s\n",
371                        efv_infile, event->phase );
372
373        /* is there a location quality specified in the first phase ? */
374        if  (loc_given && !locqual_checked && event->phase[0] != '\0')  {
375                if  (event->loc_quality == EvcLocQualUndefined)
376                        fprintf( out, "F013 %s: no location quality specified\n", efv_infile );
377                locqual_checked = TRUE;
378        } /*endif*/
379
380        if  (event->analyst[0] != '\0')
381                strcpy( efv_analyst, event->analyst );
382
383} /* end of EfPutCheck */
384
385
386
387/*---------------------------------------------------------------------------*/
388
389
390
391static BOOLEAN EfPhaseIsFirstArrival( char name[] )
392
393/* Checks whether phase is first arrival
394 *
395 * parameters of routine
396 * char       name[];        input; name of phase
397 *                           returns TRUE if phase is possible first arrival
398 */
399{
400        /* executable code */
401
402        if  (strcmp(name,"P") == 0)  return TRUE;
403        if  (strcmp(name,"(P)") == 0)  return TRUE;
404        if  (strncmp(name,"PKP",3) == 0)  return TRUE;
405        if  (strncmp(name,"(PKP",4) == 0)  return TRUE;
406        if  (strncmp(name,"Pn",2) == 0)  return TRUE;
407        if  (strncmp(name,"Pg",2) == 0)  return TRUE;
408        if  (strcmp(name,"(Pn)") == 0)  return TRUE;
409        if  (strcmp(name,"(Pg)") == 0)  return TRUE;
410        if  (strcmp(name,"Pdiff") == 0)  return TRUE;
411        if  (strcmp(name,"(Pdiff)") == 0)  return TRUE;
412        if  (strcmp(name,"Pdif") == 0)  return TRUE;
413        if  (strcmp(name,"(Pdif)") == 0)  return TRUE;
414
415        return FALSE;
416
417} /* end of EfPhaseIsFirstArrival */
418
419
420
421/*---------------------------------------------------------------------------*/
422
423
424
425static void EfFinalCheck( FILE *out )
426
427/* Prints result of final check to output file 'out'
428 *
429 * parameters of routine
430 * FILE       *out;         input; pointer to output file
431 */
432{
433        /* local variables */
434        char     expl[cBcLongStrLth+1];   /* explanation string */
435
436        /* executable code */
437
438        /* fprintf( out, "--> final check\n" ); */
439        if  (efv_showinitials)
440                sprintf( expl, "%s (%s)", efv_infile, efv_analyst );
441        else
442                strcpy( expl, efv_infile );
443
444        /* a first arrival must be specified */
445        if  (!efv_first_arrival)
446                fprintf( out, "F014 %s: no first arrival phase selected\n", expl );
447
448        /* beam with uncorrected slowness at GRF is at least suspicious */
449        if  (efv_only_grf && efv_uncorr_loc)
450                fprintf( out, "F015 %s: GRF location with uncorrected beam at phase %s\n",
451                        expl, efv_uncorrphase );
452
453        /* only GRF picked but no GRA1? */
454        if  (efv_only_grf && !efv_gra1_picked)
455                fprintf( out, "F035 %s: only GRF picks but none at GRA1\n", expl );
456
457        /* no telex phase */
458        /* disabled 12-Nov-2008 K.S.
459        if  (!efv_telex_phase)
460                fprintf( out, "F016 %s: no telex phase found\n", expl );
461        */
462
463        /* mb determined? */
464        if  (efv_subtype == EVTYPE_P && !efv_mb_found)
465                fprintf( out, "F017 %s: no Magnitude mb determined for P phase\n", expl );
466
467        /* Ms determined? */
468        if  (efv_subtype >= EVTYPE_P && efv_depth <= 50.0 && efv_magn > 5.6 &&
469                !efv_ms_found)
470                fprintf( out, "F018 %s: no Magnitude Ms determined for magn %3.1f event\n",
471                        expl, efv_magn );
472        if  (efv_subtype == EVTYPE_PKP && efv_depth <= 50.0 && efv_pkp_count > 3 &&
473                !efv_ms_found)
474                fprintf( out, "F019 %s: no Magnitude Ms determined for PKP event\n",
475                        expl );
476        if  (efv_ms_found && efv_depth > 50.0)
477                fprintf( out, "F020 %s: Magnitude Ms determined for depth %5.1f event\n",
478                        expl, efv_depth );
479
480        /* Mbb determined? */
481        if  (efv_mb_found && efv_magn > 6.2 && !efv_mbb_found)
482                fprintf( out, "F021 %s: no Broadband Magnitude determined for magn %3.1f event\n",
483                        expl, efv_magn );
484
485        /* depth ok? */
486        if  (efv_evtype == EvcEventTypeMining && Abs(efv_depth-1.0) > 0.1)
487                fprintf( out, "F022 %s: depth %5.1f given for mining event\n",
488                        expl, efv_depth );
489        if  (efv_evtype == EvcEventTypeBlast && Abs(efv_depth) > 0.1)
490                fprintf( out, "F023 %s: depth %5.1f given for blast\n",
491                        expl, efv_depth );
492        if  (efv_evtype == EvcEventTypeTeleQuake && (efv_depth < 10.0))
493                fprintf( out, "F026 %s: depth %5.1f for teleseismic event\n",
494                        expl, efv_depth );
495        if  ((efv_evtype == EvcEventTypeLocalQuake
496                || efv_evtype == EvcEventTypeRegioQuake) && (efv_depth < 2.0))
497                fprintf( out, "F027 %s: depth %5.1f for local/regional event\n",
498                        expl, efv_depth );
499        if  (efv_evtype == EvcEventTypeLocalQuake && efv_depth > 50.0)
500                fprintf( out, "F036 %s: depth %5.1f given for local event\n",
501                        expl, efv_depth );
502        if  (efv_evtype == EvcEventTypeUndefined)
503                fprintf( out, "F024 %s: no event type specified\n", expl );
504        if  (efv_depth < -99.0)
505                fprintf( out, "F025 %s: no depth specified\n", expl );
506
507        /* proper event type? */
508        if  (efv_foundPg && efv_evtype == EvcEventTypeTeleQuake)
509                fprintf( out, "F028 %s: improper teleseismic event type: found Pg\n",
510                        expl );
511        if  (efv_foundPnSn && efv_evtype == EvcEventTypeTeleQuake)
512                fprintf( out, "F029 %s: improper teleseismic event type: found Pn/Sn\n",
513                        expl );
514        if  (efv_foundTele && efv_evtype == EvcEventTypeLocalQuake)
515                fprintf( out, "F030 %s: improper local event type: found tele phase\n",
516                        expl );
517        if  (efv_foundTele && efv_evtype == EvcEventTypeRegioQuake)
518                fprintf( out, "F031 %s: improper regional event type: found tele phase\n",
519                        expl );
520
521        /* check distance and event type */
522        if  (efv_latitude != 0.0 || efv_longitude != 0.0)  {
523                double dist, azim, bazim;   /* result of distance computation */
524                float fdist;    /* single precision distance */
525                mb_locdiff( (double)efv_reflat, (double)efv_reflon, (double)efv_latitude,
526                        (double)efv_longitude, &dist, &azim, &bazim );
527                fdist = dist;
528                if  (dist > 15.0 && efv_evtype == EvcEventTypeLocalQuake)
529                        fprintf( out, "F032 %s: improper local event type (distance %f deg)\n",
530                                expl, dist );
531                if  (dist > 30.0 && efv_evtype == EvcEventTypeRegioQuake)
532                        fprintf( out, "F033 %s: improper regional event type (distance %f deg)\n",
533                                expl, dist );
534                if  (dist < 25.0 && efv_evtype == EvcEventTypeTeleQuake)
535                        fprintf( out, "F034 %s: improper teleseismic event type (distance %f deg)\n",
536                                expl, dist );
537        } /*endif*/
538
539} /* end of EfFInalCheck */
540
541
542
543/*---------------------------------------------------------------------------*/
544
545
546
547static BOOLEAN EfIsLocalPhase( char phase[] )
548
549/* checks whether 'phase' is a local phase
550 *
551 * parameters of routine
552 * char       phase[];         input; phase name
553 */
554{
555        /* local variables */
556
557        /* executable code */
558
559        if  (strcmp(phase,"Pg") == 0)  return TRUE;
560        if  (strcmp(phase,"Pn") == 0)  return TRUE;
561        if  (strcmp(phase,"Sg") == 0)  return TRUE;
562        if  (strcmp(phase,"Sn") == 0)  return TRUE;
563        if  (strcmp(phase,"(Pg)") == 0)  return TRUE;
564        if  (strcmp(phase,"(Pn)") == 0)  return TRUE;
565        if  (strcmp(phase,"(Sg)") == 0)  return TRUE;
566        if  (strcmp(phase,"(Sn)") == 0)  return TRUE;
567
568        return FALSE;
569
570} /* end of EfIsLocalPhase */
571
572
573
574/*---------------------------------------------------------------------------*/
575
Note: See TracBrowser for help on using the repository browser.