PROJECT FINAL REPORT
DSES-6620 – Spring 2002
Scott Munro
1.0 Overview
Instrument approach equipment and procedures allow aircraft to make safe
landings in weather conditions that would preclude such a landing using visual
references only (i.e. flying by “looking out the window”). An airport may have one
or more instrument approaches associated with it. A “non-precision” approach
employs a non-directional radio beacon (NDB) or VHF Omni-Directional Range
(VOR) system to provide positive and accurate course during the approach, and
may possibly employ Distance Measuring Equipment (DME) to provide range
information. A “precision approach” will typically employ an Instrument Landing
System (ILS). The ILS includes a localizer to provide highly accurate course
guidance, in conjunction with an electronic glide slope to control descent.
Additionally, outer and middle marker beacons provide the pilot with positional
information during the descent. Precision approach equipment will allow the pilot
to land with lower ceilings and visibility limits than allowed by the non-precision
approach system.
The method in which precision or non-precision approach equipment is used for
an instrument landing is described by the “approach procedure”, graphically
depicted in an approach plate (ref. Figure 1 and 2). The approach procedure
includes parameters such as approach fixes, reporting points, minimum safe
altitudes, missed approach procedures, and communications frequencies.
The project described herein entails the simulation of traffic at a small
commercial airport, with the intent of assessing the benefit of implementing a
precision instrument approach procedure in addition to and existing nonprecision approach. Airport operations during varying weather conditions are
limited by available approaches to a given runway. Minimum ceiling, visibility,
and aircraft approach category limits specified for an instrument approach dictate
whether or not a landing can be made IFR weather conditions. While use of
precision instrument approach systems are desirable in that they allow landings
in weather which might otherwise result in flight delays and possible diversion to
alternate airports, they represent a significant capital investment by the airport
operator.
2.0 Problem Description
The airport configuration shall be notionally similar to Tweed New Haven. The
baseline airport will consist of a single runway served by a single non-precision
VOR approach procedure. The procedure is shown below in Figure 1a and 1b.
Figure 1a – Non-precision VOR Approach
Figure 1b – Non-precision VOR Approach
Figure 2a – Precision ILS Approach
Figure 2b – Precision ILS Approach
For the purposes of the simulation, the important components of the approach
are:



the initial approach fix at 5.0 nm out from the New Haven VOR, identified
on the plate as PONDS.
the missed approach point - 0.4 nm from the New Haven VOR.
the missed approach procedure – climbing right turn to 2000 feet, then
direct to Madison VOR and hold as published.
Minimum weather conditions required for this approach are:


Visibility greater or equal to 1 mile.
Minimum descent altitude of 380 feet above sea level (altitude at which
runway environment must be in sight to continue with landing).
The modified configuration of the airport employs a precision Instrument Landing
System (ILS) approach procedure. The procedure is shown above in Figure 2a
and 2b.
The relevant components of the approach are:



the initial approach fix, interception of glide slope at 1500 feet, 5.5 nm out
from the New Haven ILS, identified on the plate as SALLT.
the missed approach condition - descent to decision height
the missed approach procedure – climbing right turn to 2000 feet, then
direct to Madison VOR and hold as published.
Minimums for this approach are:


Visibility greater of equal to ¾ mile
Minimum descent altitude of 257 feet above sea level (altitude at which
runway environment must be in sight to continue with landing).
It shall be assumed that all landings are straight in, and all instrument approach
equipment, including glide-slope, localizer, airport lighting system and RAIL, are
operational. Additionally, arriving commercial traffic will fall within approach
category A, B, or C (these approach categories are a function of aircraft stall
speed). The assumptions are made so that minimums for a given approach do
no change during the simulation. Additionally, the simulation will not consider the
impact of departing aircraft on the availability of the runway for arrivals. The
details of each approach shall be described in the section on methodology below.
3.0 Objective
The objective of the modeling effort is to quantify the benefit derived from
implementation of the additional precision ILS approach. In order to accomplish
this, both the non-precision VOR and precision ILS approach must be modeled.
The goal is to determine the following measures of merit for each approach type
under realistic operating conditions:



Average number of landings per hour (runway utilization)
Average number of diversions to an alternate airport due to weather, per
hour
Average delay in minutes due to weather, per aircraft
4.0 Methodology
In order to provide a reasonable level of fidelity in predicting airport performance,
the model must consider each of the following elements:
Element
Impact
Approach Procedure
Time and weather required to
successfully execute the approach.
Time required to execute the missed
approach procedure.
Air Traffic Control
Minimum separation between aircraft,
and aircraft arrival rate.
Federal Aviation Regulations
Fuel on board for each aircraft on an
instrument flight plan.
Weather
Current ceilings, visibility, and winds at
any given time during the simulation.
Aircraft Performance
Approach speeds, landing distances
and maximum crosswind limits for
landing.
Each of these elements and their instantiation in the model are described in
detail below.
4.1 Weather
Over 10,000 hours of weather observation data was used in the model. This data
was obtained from the US National Climatic Data Center in the form of Surface
Weather Observations from the Bridgeport reporting station. This data consists of
hourly recordings of meteorological conditions including ceilings, visibility,
surface wind speed, direction, and variability. A sample record for a single hour’s
observation is shown below in Figure 3.
Figure 3 – Sample Surface Weather Observation
The elements of importance for the simulation are the local standard time of a
given record, wind direction, wind speed in knots, surface visibility in fractional
miles, present weather notation, and ceilings. The present weather and ceiling
data is encoded. The encoded “present weather” data includes local surface
conditions. For example, “-SN” means light snow; “FG” means fog. The encoded
ceiling data includes coverage and height. “BKN005 OVC015” would indicate a
broken ceiling at five hundred feet, and an overcast ceiling at fifteen hundred
feet.
Due to the nature of weather, it is probably ill advised to attempt and represent it
as a statistical distribution (an unsuccessful attempt was made to do this using
Stat::Fit). Climatic conditions for a given hour have some dependence on the
conditions of the preceding hour. Stated differently, if we have fog and ½ mile
visibility at 1200 hours, it is unlikely that we will have clear air and unlimited
visibility at 1300 hours. Accordingly, a decision was made that the weather data
would be “played back” for the purposes of the simulation. Specifically, for any
given hour of the simulation, the corresponding weather record for that hour was
looked up from a large array of weather data.
To accomplish this, an application was written called “weather.exe” which parsed
10714 hours of weather data, decoded the ceilings and other pertinent
meteorological condition, and formatted it into a tab delimited database. The
database records are ordered by observation hour, and contain the current wind
direction and velocity, visibility, and lowest significant ceiling which would impact
an approach. This database was then converted to an Excel spreadsheet, which
was then imported into an Array within ProModel. The source code for
weather.exe may be found in Appendix A.
4.3 Air Traffic Control
Air Traffic Control (ATC) is responsible for providing separation between all
aircraft operating under and instrument flight plan. Within 40 miles of a radar
facility, this separation is specified to be 3 miles laterally, and 500 feet vertically.
In the model, vertical separation is implied (ie. not explicitly enforced). Lateral
separation is maintained by dividing all routes within the model into a series of “3
mile long” queues with a capacity of one. This ensures that aircraft entity in the
simulation maintain proper separation. Transit time through the queue is based
on aircraft cruise and approach speed for the given segment.
4.4 Federal Aviation Regulations (FAR)
FAR Part 91.167 requires that aircraft operating on an IFR flight plan carry
enough fuel to fly to the destination airport, fly from that airport to an alternate
airport, and after that fly for an additional 45 minutes. Therefor, for the purposes
of the model, an assumption is made that aircraft will hold for a maximum of 45
minutes due to below minimums weather before they divert to an alternate
airport. To accomplish this, a “FuelRemaining” attribute is created and assigned
to each aircraft entity with an initial value of 45. During a hold, this value is
reduced by one for each minute of simulation time. When fuel remaining equals
zero, the aircraft will divert to the alternate (and exit the simulation).
4.6 Aircraft Performance
The three components of aircraft performance that are relevant to the model are
approach speed, cruise speed, and landing ground roll. These elements, in
conjunction with approach segment lengths and winds, will allow us to determine
the transit time for each approach segment of the model. For the purposes of the
model, only a single aircraft type is considered. This is a Piper PA-28 and is a
relatively common type of single engine general aviation aircraft (The Tweed
New Haven Fixed Base Operator has a number of these). The following speeds
are relevant to PA-28 operations and used in the model:



Approach Speed
Final Approach Speed
Cruise Speed (airport area)
: 70 Knots Indicated Airspeed (KIAS)
: 63 KIAS
: 90 KIAS
Landing ground roll is a bit more complicated, as it is a function of outside air
temperature, pressure altitude and current runway head wind. The landing
performance chart for the PA-28 is shown in Figure 4. This chart, in conjunction
with the assumption of sea-level standard conditions and the current head winds
as determined from the weather database are used to determine ground roll. The
ground roll, coupled with the average speed on the runway (from touchdown to
full-stop) is then used to determine the Runway Obstruction Time (ROT) for each
aircraft landing.
Figure 4 – Landing Performance for PA-28
Aircraft performance also governs the maximum allowable crosswinds. If the
crosswind due to the current weather conditions is beyond this maximum, the
aircraft must hold and wait for them to decrease. The maximum allowable
crosswind used for the PA-28 is 14 knots.
4.7 Approach Procedure
For the purposes of the simulation, the aircraft arrive at the initial approach fix;
aircraft activity prior to the initial approach fix is not considered. If the ceiling or
visibility are below limits for the specific approach, the arriving aircraft are routed
directly to the Madison VOR to hold for appropriate weather. If the weather is
within limits, the aircraft begins the approach to the missed approach point. If the
weather changes during the approach such that it is out of limits, a missed
approach must be executed and the aircraft proceeds to the Madison VOR to
hold. Otherwise, it completes the landing and exits the simulation. Aircraft holding
at the Madison VOR will be sequentially routed back to the initial approach fix if
the weather improves to within landing limits.
5.0 Model Description
The ProModel simulation of the airport is show below in Figure 5. The same
model is show again in Figure 6 with the graphics removed to allow better
understanding of each of the models functional components.
Figure 5 – Runtime View of ProModel Airport Simulation
Each of the models components will now be described in turn to illustrate its
operation.
5.1 Entities
The model employs only a single entity, which is the PA-28 aircraft. Each entity
has an attribute named FuelRemaining which is assigned an initial value of 45
minutes. This value is reduced by one for each minute the aircraft may hold
awaiting acceptable weather minimums for the approach being modeled.
5.2 Arrivals
Aircraft arrive at the initial approach fix, PONDS. Since the model is intended to
investigate maximum airport capacity, the arrival rate is fixed at a maximum
frequency of four minutes, based on the assumption that there is only one aircraft
an on final approach at a time.
Figure 6 – View of ProModel Airport Simulation with Background Graphics Removed and
Locations Labelled
5.3 Locations and Processing
Please refer to Figure 6 for locations described in the following section.
5.3.1 PONDS – The Initial Approach Fix
PONDS is the arrival point for aircraft entities and the initial approach fix for the
runway. Upon entry to PONDS, the simulation calls the subroutine
UpdateWeather(). This subroutine reads the appropriate record from the weather
array for the current simulation time. It uses the weather data to set the following
global variables:
Visibility_Current
Wind_Dir_Current
Wind_Vel_Current
Ceiling_Current
: The current visibility in fractional miles
: The current wind direction in degrees
: The current wind velocity in kts
: The current ceiling in hundreds of feet
Crosswind_Current : The current crosswind velocity component in kts
V_Headwind
: The current headwind velocity in kts
UpdateWeather() calls a number of subroutines as part of its processing.
UpdateWindComponents() calculates the wind vector components parallel and
perpendicular to the runway heading (headwind and crosswind components).
Additionally, the trigonometric subroutines sin() and cos() where created due to
the fact that ProModel lacks these functions (sin and cos were implemented as
Taylor series expansions).
After the call to UpdateWeather(), the current weather global variable values are
examined to see if they are less than the current requirements for the approach
being modeled. Specifically, Visibility_Current and Ceiling_Current must be
greater than the approach minimums, and the Crosswind_Current must be less
than the maximum allowable for the aircraft type being modeled. Note: in order to
alter the minimums for the appropriate precision or non-precision approach
values, they were implemented as the following macros:
Visibility_Min
Ceiling_Min
Crosswind_Max
: Min. visibility for the specific approach in miles
: Min. ceiling for the specific approach in 100’s of feet
: Max. allowable crosswind for aircraft type in kts
If the approach requirements are met, the aircraft entity is routed onto the first
approach segment, “AproachSeg1”. Otherwise, it is routed to the Madison VOR
to hold awaiting acceptable weather.
5.3.2 ApproachSeg1 and ApproachSeg2 – The Approach Segment
The total length of the approach is 4.6 nm. In order to ensure proper IFR
separation of aircraft entities, it is broken into two queues of capacity one. The
first segment, ApproachSeg1, is conceptually 3 nm. The second segment,
ApproachSeg2, is 1.6 nm. Since movement through the queue is expressed in
time and not distance, we must calculate the appropriate value. As previously
stated, the approach velocity of the aircraft entity is 70 nm/hr. The maximum
allowable speed deviation during instrument flight procedures is 5% or 10 knots,
whichever is greater (in this case 10 knots). This implies a triangular distribution
of possible times to complete each approach segment as follows:
ApproachSeg1
Minimum time = (3 nm / (70 kts – 10 kts)) * 60 min/hr = 3.0 min
Mode time = (3 nm / 70 kts) * 60 min/hr = 2.6 min
Maximum time = (3nm / (70 kts + 10 kts)) * 60 min/hr = 2.3 min
This is implemented in the location processing as:
MOVE FOR T(2.3,2.6,3.0)
ApproachSeg2
In a similar manner as described for ApproachSeg2, which is 1.6 nm in length,
the following movement is defined:
MOVE FOR T(1.2,1.4,1.6)
5.3.3 HVN – The Missed Approach Point
During a real approach, the pilot must have the runway environment in sight by
the missed approach point. If not, he must execute the missed approach
procedure. The missed approach point is designated as location HVN in the
model. At HVN, the subroutine UpdateWeather() is called to see if there has
been a change in weather that occurred during the preceding approach segment.
If there has, and the minimums are no longer acceptable for the approach, the
aircraft will be routed onto the missed approach segment “MAP Seg1”.
Otherwise, it continues with the landing.
5.3.4 Rwy2 – The Landing
The landing consists of the final descent and flare, ground roll, and exit from the
runway onto a taxiway. For the VOR approach, the final descent is 400 ft at 500
ft/min or 0.8 minutes. The ground roll is determined via the landing performance
chart in Figure 4 and is a function of headwind. The nominal touchdown speed is
63 knots, with a variation of 5 knots (based on the author’s experience in this
aircraft). Assuming a full stop landing, the average velocities on the runway are:
Maximum: [(65 kts + 5kts) + 0kts]/2 = 34 kt = 3446 ft/min
Mode: [65 kts + 0kts]/2 = 32 kt = 3242 ft/min
Minimum: [(65 kts – 5 kts) – 0 kts]/2 = 29 kt = 2939 ft/min
The ground roll distance at sea-level standard conditions, 2325 lbs gross weight
is:
450 ft with a 15 knot headwind
750 ft with a 5 kt tailwind
These ground rolls and average runway speeds can be combined to determine
ground roll time as follows:
a. with 15 kt headwind:
Maximum: 450 ft / 3446 ft/min = 0.13 min
Mode: 450 ft / 3242 ft/min = 0.14 min
Minimum: 450 ft / 2939 ft/min = 0.15 min
b. With 5 knot tailwind:
Maximum: 750 ft / 3446 ft/min = 0.22 min
Mode: 750 ft / 3242 ft/min = 0.23 min
Minimum: 750 ft / 2939 ft/min = 0.26 min
The information in items a. and b. above can be used to interpolate a given
maximum, mode, and minimum ground roll time as a function of headwind. This
has been accomplished in the model via the subroutines:
InterpMaxRoll()
InterpModeRoll()
InterpMinRoll()
Each of these subroutines takes the current headwind as an argument and
returns the appropriate ground roll time. The final piece of information required is
the time to exit the runway, which is specified at 30 seconds (again based on
experience). The descent time of 0.8 minutes and runway exit time of 0.5
minutes are added to the ground roll time in the interpolation subroutines. The
final triangular distribution for runway obstruction time becomes:
MOVE FOR T(InterpMinRoll(),InterpModeRoll(),InterpMaxRoll())
After completion of the movement along the runway, aircraft entities exit the
simulation.
5.3.5 MAP_Seg1, MAP_Seg2, MAP_Seg3 – The Missed Approach Segment
The missed approach segment consists of the distance from the missed
approach point to the hold at Madison VOR. This is measured from the
appropriate Low Altitude Enroute Chart and is approximately 9 nm. This is
broken into three separate 3-mile long segments to ensure proper IFR separation
of aircraft. The average cruise speed during the missed approach is 90 kts, 10
kts. In an analogous manner to section 5.3.2, the triangular distribution for each
segment is:
MOVE FOR T(1.8,2.0,2.3)
5.3.6 MAD – The Holding Pattern at Madison VOR
Aircraft entities hold at the Madison VOR location awaiting acceptable weather
for landing, or to run low on fuel and therefore divert to an alternate airport. In
reality, aircraft hold by flying a racetrack pattern off one of the VOR radials, with
multiple aircraft separated by altitude (this is often called “the stack”). For the
purposes of the simulation, the hold is simply modeled as a queue of infinite
capacity. Note: clearly, an infinite number of aircraft cannot hold at a VOR with a
finite amount of vertical airspace. In practice, ATC may vector aircraft to multiple
holding locations, divert aircraft to alternate airports, etc. This is beyond the
scope of the current model and is the simplifying assumption of infinite capacity
was made. In addition, during the actual running of the model, the average queue
contents were observed to remain reasonable.
Aircraft holding at the MAD location check the updated weather in 1-minute
intervals. At each interval, the aircraft entity’s FuelRemaining attribute is reduced
by on minute. If the weather changes such that approach limits are met, the
aircraft are routed onto the return segment to attempt a landing. Otherwise, if the
fuel remaining is exhausted (FuelRemaining=0), they are routed onto the Divert
segment and are routed to the alternate airport.
5.3.7 Return_Seg1, Return_Seg2, Return_Seg3, Return_Seg4 – The Return
Segment
If weather conditions return to acceptable approach minimums, holding aircraft
with sufficient fuel return to the initial approach fix PONDS via the return
segment. A direct return from the hold at MAD to the initial approach fix was
measured from the Low Altitude Enroute Chart at approximately 12 nm. To
maintain IFR aircraft separation, the route is divided into four separate 3-mile
long segments of capacity one. Assuming the same average velocities as in the
missed approach segment, the time to transit each return segment is:
MOVE FOR T(1.8,2.0,2.3)
5.3.8 Divert – The Divert to Alternate Airport Segment
If aircraft exhaust their fuel allotted for holding without acceptable weather
minimums, they are diverted to their “alternate airport” by being routed onto the
Divert segment. Aircraft move along this segment of two minutes and then exit
the simulation.
6.0 Model Verification and Validation
In order to verify that the model logic operated correctly, a dummy weather file
was created to force certain conditions to exist and observe that aircraft entities
behaved as desired. Specifically, the following conditions were modeled:
Condition
Behavior
Weather always within
approach mimimums
All aircraft proceed from initial approach fix to
the runway.
Visibility always below
approach minimums.
All aircraft are routed to hold at MAD, and
eventually divert to the alternate airport.
Ceiling always below
approach minimums
All aircraft are routed to hold at MAD, and
eventually divert to the alternate airport.
Crosswind always above
maximum allowable for
aircraft
All aircraft are routed to hold at MAD, and
eventually divert to the alternate airport
Weather minimums initially
below approach minimums,
but improve to within
approach minimums
All aircraft are routed to hold at MAD, but return
to the initial approach fix PONDS when weather
is update.
Weather minimums initially
within approach minimums,
but subsequently fall below
minimums
All aircraft are routed onto the approach
segment. When weather is updated, aircraft on
approach segment are routed onto the missed
approach segment. Subsequent arrivals at the
initial approach fix are routed directly to MAD to
hold.
7.0 Model Input
The model-input text can be found in Appendix B. Differences between the
precision and non-precision approach models are annotated in the Macros
section. Graphs of the first year of weather input data are found in Figures 7
though 10 below.
Wind Speed vs Run Hour
25
Wind Speed (kt)
20
15
10
5
0
Jan-01
Feb-01
Mar-01
Apr-01
May-01
Jun-01
Jul-01
Aug-01
Sep-01
Oct-01
Nov-01
Dec-01
Oct-01
Nov-01
Dec-01
Time
Figure 7 – Wind Speed Data
Wind Direction vs Run Hour
350
300
Wind Direction (deg)
250
200
150
100
50
0
Jan-01
Feb-01
Mar-01
Apr-01
May-01
Jun-01
Jul-01
Aug-01
Sep-01
Time
Figure 8 – Wind Direction Data
Ceilings vs. Run Hour
200
180
160
Ceiling (x10^2 Ft)
140
120
100
80
60
40
20
0
Jan-01
Feb-01
Mar-01
Apr-01
May-01
Jun-01
Jul-01
Aug-01
Sep-01
Oct-01
Nov-01
Dec-01
Oct-01
Nov-01
Dec-01
Hour
Figure 9 – Ceiling Height Data
Visibility vs Run Hour
10
9
8
Visibility (mi)
7
6
5
4
3
2
1
0
Jan-01
Feb-01
Mar-01
Apr-01
May-01
Jun-01
Jul-01
Aug-01
Time
Figure 10 – Visibility Data
Sep-01
8.0 Model Results
The model was run for both the non-precision VOR and precision ILS
configurations. Each run was for 10714 hours, which represents the extent of the
weather database employed. The text output from the precision ILS and nonprecision VOR approach models can be found in Appendices C and D
respectively.
The impact of the availability of each approach type is summarized in Tables 1
and 2 below. Table 1 shows the total number of landings, diversions to
alternates, and missed approaches for each approach type. Table 2 shows the
same parameters on a per hour basis.
Approach Type
VOR
ILS
Parameter
Landings
Divert to Alternate Airport
Missed Approached
148353
12342
387
151375
9320
332
Change
3022
-3022
-55
% Change
2.0%
-24.5%
-14.2%
Table 1 – Total Airport Approach Performance
Parameter (per hour)
Landings
Divert to Alternate Airport
Missed Approached
Approach Type
VOR
ILS
13.85
1.15
0.036
14.13
0.87
0.031
Change
0.28
-0.28
-0.005
% Change
2.0%
-24.5%
-14.2%
Table 2 – Airport Approach Performance Per Hour
It can be seen from the results that use of the precision ILS approach provides a
2% increase in the total number of landings during the simulation period, as well
as a reduction in diversions to alternates and missed approaches of 24.5% and
14.2% respectively. These numbers are relevant with respect to aircraft arriving
at the maximum capacity of the approach. For a small Fixed Base Operator, the
two percent increase in landings may not merit the investment in precision
approach equipment. For a larger commercial operation, this would represent a
significant increase in landing fees.
Another parameter with which to gauge the approach performance is average
delay time. This is defined as the difference between the average minutes in
operation per aircraft entity and the theoretical minimum time in operation given
an non-eventful approach and landing. The average delay times for each
approach are summarized below.
Approach Type
Average Delay (min)
Precision ILS
3.55
Non-precision VOR
4.43
The use of the ILS approach reduces the average delay by almost one minute.
In summary, it is important to point out that actual IFR operations are highly
complex. ATC and aircraft are systems operating in real-time and controlled by
humans making decisions based on a myriad of parameters. As such, a
simulation like the one presented here may be made arbitrarily complex and still
not provide accurate representation on an event by event basis. Where a
simulation such as this is useful is in examining aggregate behavior of the
system over long periods of time with the intent of determining the impact of
changes to the system.
Appendix A
Source Code for Surface Weather Observation Decoding Application
//: === WEATHER.C ===
//:
//: Description: Parses Form 10A Surface Observation ASCII files
//: 20020415, Scott Munro
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
"strman.h"
"parse.h"
#define MAXSTR 255
// ceiling type defines
#define BROKEN "BKN"
#define OVERCAST "OVC"
#define SCATTERED "SCT"
#define FOG "FG"
#define VERTVIS "VV"
void main(int argc, char *argv[]) {
FILE *flist_fp;
FILE *out_fp;
char *fields[MAXFIELDS];
char strbuf[MAXSTR];
char *strptr;
char datestr[MAXSTR];
int i;
int nfields;
int n_day=0;
int n_hour=0;
int hour;
int minute;
int ceiling;
float vis;
//
//
//
//
//
//
//
//
//
//
//
//
//
//
list of files to process
output file pointer
pointer to database fields
generic string buffer
generic string pointer
date string buffer
generic counter
number of fields read
day index
hour index
current hour
current minute
current ceiling
current visibility
int getceiling(const char *ctype, const char *cstrbuf); // decodes ceil. info
if (argc != 3) {
printf("\n\nUsage: weather [file list] [output file]\n\n");
exit(10);
}
// open input file list
if ((flist_fp=fopen(argv[1],"rb"))==NULL) {
printf("\nUnable to open input file %s\n", argv[1]);
exit(20);
}
// open output file list
if ((out_fp=fopen(argv[2],"wb"))==NULL) {
printf("\nUnable to open output file %s\n", argv[2]);
exit(25);
}
// initialize weather database
while (fgets(strbuf, 500, flist_fp)) {
if(!InitDelDBase(trim(strbuf))) {
printf("\nUnable to initialize database %s\n", strbuf);
exit(30);
}
// get date of current database
for (i=0; i<5; i++) GetDelDBase(",", fields);
strcpy(datestr, fields[1]);
trim(datestr);
// dump first four rows, which are just header info
for (i=0; i<4; i++) GetDelDBase(",", fields);
// read weather data
while((nfields = GetDelDBase(",", fields)) != NULL) {
fprintf(out_fp, "%s\t", datestr);
fprintf(out_fp, "%d\t", n_hour);
n_hour++;
// convert hour of reading to minutes
strcpy(strbuf, fields[1]);
trim(strbuf);
strbuf[2]='\0';
hour=atoi(strbuf);
strcpy(strbuf, fields[1]);
trim(strbuf);
strptr=&strbuf[2];
minute=atoi(strptr);
nfields = n_day*24*60+hour*60+minute;
fprintf(out_fp, "%ld\t", n_day*24*60+hour*60+minute);
// output wind direction and speed
fprintf(out_fp, "%s\t%s\t", trim(fields[2]), trim(fields[3]));
// output surface visability
if ((strptr=strstr(trim(fields[6]), "/")) != NULL) {
// decode fractional distance
strptr--;
vis = *strptr - '0';
strptr+=2;
vis = vis/(*strptr - '0');
if (strlen(fields[6]) == 5)
vis = vis + *fields[6] - '0';
} else
vis = (float )atof(fields[6]);
fprintf(out_fp, "%4.2f\t", vis);
// set current ceiling
ceiling = 999;
if ((i=getceiling(SCATTERED, fields[9])) != -1 && i < ceiling)
ceiling = i;
if ((i=getceiling(BROKEN, fields[9])) != -1 && i < ceiling)
ceiling = i;
if ((i=getceiling(OVERCAST, fields[9])) != -1 && i < ceiling)
ceiling = i;
if ((i=getceiling(VERTVIS, fields[9])) != -1 && i < ceiling)
ceiling = i;
// printf("\ni = %d, ceiling = %d\n", i, ceiling);
if (strstr(fields[8], FOG) != NULL)
ceiling=0;
fprintf(out_fp, "%d", ceiling);
fprintf(out_fp, "\n");
}
CloseDelDBase();
n_day++;
}
// deallocate memory for fields
// for (i=0; i < MAXFIELDS; i++) free(fields[i]);
fclose(flist_fp);
fclose(out_fp);
}
int getceiling(const char *ctype, const char *cstrbuf) { // decodes ceiling info
char ceilstr[MAXSTR];
char *strptr;
strcpy(ceilstr, cstrbuf);
if ((strptr=strstr(ceilstr, ctype)) != NULL) {
strptr+=3;
strptr[3]='\0';
return(atoi(trim(strptr)));
} else
return(-1);
}
//: === PARSE.C ===
//:
//: Description: File and buffer parsing utilities
//: Copyright 1996, Scott Munro
#include "parse.h"
//:
//:
//:
//:
//:
//:
//:
//:
//:
Program Name: loadfile
Description : Allocates memory and returns pointer to buffer containing
the contents of file with path <filename>. Returns NULL pointer
if unable to load file.
Author
: Scott Munro
Created
: 960513
Version
: 1.01
Modified
: 971121
Usage
: char *loadfile(char *filename)
char *loadfile(char *filename) {
char *buffer, *bufptr;
int c;
long buf_siz;
FILE *fp;
struct stat f_data;
// get page info
if (stat(filename, &f_data) == -1) {
fprintf(stderr, "\nloadfile: Can't get file info for %s\n", filename);
return(NULL);
}
buf_siz = f_data.st_size + 1;
// make sure file is a reasonable size
if ((buf_siz) > 0XFFFF)
{
fprintf(stderr, "\nloadfile: File %s too large for load\n", filename);
return(NULL);
}
// allocate memory for loading file
if ((buffer = (char *)malloc((size_t )buf_siz)) == NULL)
{
fprintf(stderr, "\nloadfile: Insufficient memory\n");
return(NULL);
}
// load page
if ((fp = fopen(filename, "rb")) == NULL)
{
fprintf(stderr, "\nloadfile: Unable to open %s for read\n", filename);
return(NULL);
}
bufptr = buffer;
while ((c = getc(fp)) != EOF) *bufptr++ = c;
*bufptr = NULL;
fclose(fp);
return(buffer);
}
//: Program Name: GetVal
//: Description : Subroutine locates comment of the form %<comment>: <value> in
//:
buffer pointed to by <buffer>. Returns pointer to string
//:
//:
//:
//:
//:
//:
Author
Created
Version
Modified
Usage
:
:
:
:
:
containing <value>. Returns NULL if unable to locate comment.
Scott Munro
960513
1.01
971121
*GetVal(char *buffer, char *comment)
char *GetVal(char *buffer, char *comment) {
char srch_str[80];
char val[80];
char *valptr;
char *value;
char *bufptr;
unsigned length;
strcpy(srch_str, "%");
strcat(srch_str, comment);
strcat(srch_str, ": ");
length = strlen(srch_str);
if ((bufptr = strstr(buffer, srch_str)) == NULL) return(NULL);
bufptr = bufptr + length;
valptr = val;
while (*bufptr != '\n' && *bufptr != '\r') *valptr++ = *bufptr++;
*valptr = NULL;
if ((value = malloc(strlen(val))) == NULL) {
fprintf(stderr, "\nGetVal: Unable to allocate memory for value\n");
return(NULL);
}
strcpy(value, val);
return(value);
}
//:
//:
//:
//:
//:
//:
//:
//:
//:
//:
Program Name: InitDelDBase
Description : Subroutine initializes delimited database for read prior to
calls to GetDelData. Required parameter is the file name
of the delimited database file. Returns 1 on success, 0 on
error.
Author
: Scott Munro
Created
: 971121
Version
: 1.00
Modified
:
Usage
: int InitDelDBase(char *filename)
static FILE *db_ptr;
int InitDelDBase(char *dbname) {
if ((db_ptr = fopen(dbname, "rb")) == NULL) return(0);
return(1);
}
//:
//:
//:
//:
//:
//:
//:
//:
//:
//:
//:
//:
//:
Program Name: GetDelDBase
Description : Subroutine reads the next record a delimited ASCII format
database and loads a pointer array with pointers to strings
containing values of the fields in that line. GetDelData
returns the number of fields successfully read, but will never
return more that MAXFIELDS values. The database must be
initialized with a call to InitDelData before a call to
GetDelData is made. On error or end of file it returns NULL.
Author
: Scott Munro
Created
: 971121
Version
: 1.00
Modified
:
Usage
: int GetDelDBase(char *delchars, char *fields[])
int GetDelDBase(char *delchars, char *fields[]) {
char recbuf[MAXRECLEN];
char *recbufptr;
int ifield = 0;
int flen;
int i;
char *strptr;
static int prevfields = 0;
//
//
//
//
buffer for database record
pointer for database record buffer
current field index
length of current field
// counter
// generic string pointer
// number of fields in previous record
if (fgets(recbuf, MAXRECLEN, db_ptr) == NULL) return(NULL);
// if we got a record of MAXRECLEN length back, it is likely that we did
// not read the entire record.
if (strlen(recbuf) >= MAXRECLEN)
fprintf(stderr, "GetDelDBase: Warning - database record larger than\
maximum allowable length.\n");
// break up strings into separate fields
recbufptr = recbuf;
while ((recbufptr = strtok(recbufptr, delchars)) != NULL) {
flen = strlen(recbufptr);
// check to see if a field buffer already exists. If it does, see if it
// is big enough and realloc if necessary. If it doesn't, allocate memory.
if (ifield > prevfields - 1) {
if ((fields[ifield] = (char *)malloc(flen+1)) == NULL) {
fprintf(stderr, "GetDelDBase: insufficient memory.\n");
return(NULL);
}
} else if (flen > strlen(fields[ifield])) {
// printf("realloc for field %d, size %d\n", ifield, flen+1);
if ((fields[ifield] = (char *)realloc(fields[ifield], flen+1)) ==
NULL) {
fprintf(stderr, "GetDelDBase: insufficient memory.\n");
return(NULL);
}
}
strcpy(fields[ifield], recbufptr);
// pop of any trailing carrige returns or line feeds
if ((strptr = strchr(fields[ifield], '\n')) != NULL) *strptr = '\0';
if ((strptr = strchr(fields[ifield], '\r')) != NULL) *strptr = '\0';
++ifield;
recbufptr = NULL;
}
// free unneeded fields
if (ifield < prevfields)
for (i = ifield; i < prevfields; i++)
free(fields[i]);
prevfields = ifield;
return(ifield);
}
//:
//:
//:
//:
//:
//:
//:
//:
//:
Program Name: RewindDelDBase
Description : Rewinds delimited database so that database pointer is
positioned at the first record. Database must have been
initially opened by a call to InitDelDBase.
Author
: Scott Munro
Created
: 971121
Version
: 1.00
Modified
:
Usage
: void RewindDelDBase(void)
void RewindDelDBase(void) {
rewind(db_ptr);
}
//:
//:
//:
//:
//:
//:
//:
Program Name:
Description :
Author
:
Created
:
Version
:
Modified
:
Usage
:
CloseDelDBase
Closes a delimited database initially opened via InitDelDBase.
Scott Munro
971121
1.00
void CloseDelDBase(void)
void CloseDelDBase(void) {
fclose(db_ptr);
}
//: === STRMAN.C ===
//:
//: Description: String Manipulation Utilities
//: Copyright 1997, Scott Munro
#include "strman.h"
//:
//:
//:
//:
//:
//:
//:
Program Name:
Description :
Author
:
Created
:
Version
:
Modified
:
Usage
:
trim
trims whitespace characters a string
Scott Munro
971125
1.00
char trim(char *str)
char *trim(char *str) {
char *strptr1, *strptr2;
strptr1 = strptr2 = str;
// trim preceding white space
while (isspace(*strptr2)) ++strptr2;
if (strptr2 != str) {
while (*strptr2 != '\0') *strptr1++ = *strptr2++;
*strptr1 = *strptr2;
}
// trim trailing white space
strptr1 = str + strlen(str) - 1;
while (isspace(*strptr1)) --strptr1;
*++strptr1 = '\0';
return(str);
}
//:
//:
//:
//:
//:
//:
//:
Program Name:
Description :
Author
:
Created
:
Version
:
Modified
:
Usage
:
atrim
trims arbitrary character delimiting a string
Scott Munro
971201
1.00
char trim(char *str, char c)
char *atrim(char *str, char c) {
char *strptr1, *strptr2;
strptr1 = strptr2 = str;
// trim preceding white space
while (*strptr2 == c) ++strptr2;
if (strptr2 != str) {
while (*strptr2 != '\0') *strptr1++ = *strptr2++;
*strptr1 = *strptr2;
}
// trim trailing white space
strptr1 = str + strlen(str) - 1;
while (*strptr1 == c) --strptr1;
*++strptr1 = '\0';
return(str);
}
//:
//:
//:
//:
//:
//:
//:
//:
//:
//:
//:
Program Name: sr
Description : Locates and replaces characters in a string. Returns a pointer
to a new string obtained by a call to malloc, which contains
the transformed string. The user is responsible for freeing
the space allocated by sr when it is no longer needed.
sr() returns a NULL pointer on failure.
Author
: Scott Munro
Created
: 971125
Version
: 1.00
Modified
:
Usage
: char *sr(const char *str, const char *findstr, const char *replstr)
char *sr(const char *str, const char *findstr, const char *replstr) {
char *oldstr, *newstr;
// buffers for original and transformed strings
char *strhead, *strend;
// some string pointers
unsigned incsize;
// incremental length to be added to newstr
unsigned rstrsiz, fstrsiz; // search and replacement string sizes
if (strlen(findstr) == 0)
return(strdup(str));
oldstr = strdup(str);
rstrsiz = strlen(replstr);
fstrsiz = strlen(findstr);
// calculate the size of the transformed string
strhead = oldstr;
incsize = 0;
while ((strhead = strstr(strhead, findstr)) != NULL) {
incsize = incsize + (rstrsiz - fstrsiz);
strhead = strhead + fstrsiz;
}
if ((newstr = (char *)malloc(sizeof(char) * (strlen(oldstr) + incsize + 1)))
== NULL) {
fprintf(stderr, "\nsr: insufficient memory.\n");
return(NULL);
}
// transform string
*newstr = '\0';
strhead = oldstr;
while ((strend = strstr(strhead, findstr)) != NULL) {
*strend = '\0';
strcat(newstr, strhead);
strcat(newstr, replstr);
strhead = strend + fstrsiz;
}
if (strlen(strhead))
strcat(newstr, strhead);
free(oldstr);
return(newstr);
}
//:
//:
//:
//:
//:
//:
//:
//:
Program Name: norm
Description : Normalizes the supplied input string by stripping spaces
and non-alphanumeric characters, then capitalizing the result.
Author
: Scott Munro
Created
: 971126
Version
: 1.00
Modified
:
Usage
: char *norm(char *str);
char *norm(char *str) {
char *newstr1, *newstr2;
newstr1 = strdup(str);
trim(newstr1);
newstr2 = sr(newstr1, "-", "");
free(newstr1);
newstr1 = sr(newstr2, "\\", "");
free(newstr2);
newstr2 = sr(newstr1, "/", "");
free(newstr1);
newstr1 = sr(newstr2, ".", "");
free(newstr2);
newstr2 = sr(newstr1, "(", "");
free(newstr1);
newstr1 = sr(newstr2, ")", "");
free(newstr2);
newstr2 = sr(newstr1, "&", "");
free(newstr1);
newstr1 = sr(newstr2, "*", "");
free(newstr2);
newstr2 = sr(newstr1, " ", "");
free(newstr1);
newstr1 = sr(newstr2, "#", "");
free(newstr2);
strupr(newstr1);
strcpy(str, newstr1);
free(newstr1);
return(str);
}
//
//
//
//
//
//
//
//
//
//
//
//
//
//
=== PARSE.H ===
Description: Header file for PARSE.C
Author: sdMunro
Created: 960513
Version: 1.0
Modified by:
Last Modified:
Copyright 1996, Hyperkinetics LLC
EDIT LOG
960513: Orignal program file
#ifndef PARSE_H
#define PARSE_H
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/stat.h>
#include<alloc.h>
#define MAXFIELDS 255 // the maximum number of fields returned by GetDelData()
#define MAXRECLEN 1024 // the maximum record length in a delimited database
// function prototypes
char *loadfile(char *filename);
char *GetVal(char *buffer, char *comment);
int GetDelDBase(char *delchars, char *fields[]);
int InitDelDBase(char *dbname);
void RewindDelDBase(void);
void CloseDelDBase(void);
#endif
//
//
//
//
//
//
//
//
//
//
//
=== STRMAN.H ===
Description: Header file for STRMAN.C
Author: sdMunro
Created: 971125
Version: 1.0
Modified by:
Last Modified:
Copyright 1997, Scott Munro
#ifndef STRMAN_H
#define STRMAN_H
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include <ctype.h>
#include <alloc.h>
#define TRUE 1
#define FALSE 0
// function prototypes
char *trim(char *str);
char *atrim(char *str, char c);
char *sr(const char *str, const char *findstr, const char *replstr);
char *norm(char *str);
#endif
Appendix B
Model Input Text
********************************************************************************
*
*
*
Formatted Listing of Model:
*
*
C:\My Documents\DESClass\Project\vorrwy2_020427.mod
*
*
*
********************************************************************************
Time Units:
Distance Units:
Initialization Logic:
Minutes
Feet
Visibility_Current=weather[1,3]
Ceiling_Current=weather[1,4]
Wind_Dir_Current=weather[1,1]
Wind_Vel_Current=weather[1,2]
********************************************************************************
*
Locations
*
********************************************************************************
Name
Cap
Units Stats
Rules
Cost
---------------- -------- ----- ----------- -------------- -----------PONDS
1
1
Time Series Oldest, ,
#
#First 3 nm segement, at 70kt => 2.6min
ApproachSeg1
1
1
Time Series
#
#Remaining segement, 1.6nm at 70kt => 1.4min
ApproachSeg2
1
1
Time Series
Rwy2
1
1
Time Series
MAD
INF
1
Time Series
Return_Seg1_2min 1
1
Time Series
Return_Seg2_2min 1
1
Time Series
Return_Seg3_2min 1
1
Time Series
Return_Seg4_2min 1
1
Time Series
HVN
1
1
Time Series
MAP_Seg1_2min
1
1
Time Series
MAP_Seg2_2min
1
1
Time Series
MAP_Seg3_3mi
INFINITE 1
Time Series
Divert
inf
1
Time Series
Oldest, FIFO,
Oldest,
Oldest,
Oldest,
Oldest,
Oldest,
Oldest,
Oldest,
Oldest,
Oldest,
Oldest,
Oldest,
Oldest,
,
FIFO,
FIFO,
FIFO,
FIFO,
FIFO,
FIFO,
,
FIFO,
FIFO,
FIFO,
FIFO,
********************************************************************************
*
Entities
*
********************************************************************************
Name
Speed (fpm) Stats
Cost
---------- ------------ ----------- -----------Aircraft
70
Time Series
********************************************************************************
*
Processing
*
********************************************************************************
Process
Entity
Location
Operation
Blk Output
-------- ---------------- --------------------- -------Aircraft PONDS
UpdateWeather()
IF (Ceiling_Current > Ceiling_Min
Crosswind_Max) THEN
{
ROUTE 1
}
ELSE
{
ROUTE 2
}
1
Aircraft
2
Aircraft
Aircraft ApproachSeg1
MOVE FOR T(2.3,2.6,3.0)
1
Aircraft
Aircraft ApproachSeg2
MOVE FOR T(1.2,1.4,1.6)
1
Aircraft
Aircraft HVN
UpdateWeather()
IF (Ceiling_Current > Ceiling_Min
Crosswind_Max) THEN
{
ROUTE 1
}
ELSE
{
ROUTE 2
}
Aircraft Rwy2
Routing
Destination
Rule
---------------- ------) AND (Visibility_Current
ApproachSeg1
MAD
FIRST 1
FIRST 1
ApproachSeg2
FIRST 1
HVN
FIRST 1
) AND (Visibility_Current
1
Aircraft Rwy2
FIRST 1
2
Aircraft MAP_Seg1_2min
FIRST 1
MOVE FOR T(InterpMinRoll(),InterpModeRoll(),InterpMaxRoll())
Move Logic
-----------> Visibility_Min) AND (Crosswind_Current <
> Visibility_Min) AND (Crosswind_Current <
Aircraft MAP_Seg1_2min
Aircraft MAP_Seg2_2min
Aircraft MAP_Seg3_3mi
Aircraft MAD
Aircraft Return_Seg1_2min
Aircraft Return_Seg2_2min
Aircraft Return_Seg3_2min
Aircraft Return_Seg4_2min
Aircraft Divert
1
Aircraft EXIT
FIRST 1
MOVE FOR T(1.8,2.0,2.3)
1
Aircraft MAP_Seg2_2min
FIRST 1
MOVE FOR T(1.8,2.0,2.3)
1
Aircraft MAP_Seg3_3mi
FIRST 1
MOVE FOR T(1.8,2.0,2.3)
1
Aircraft MAD
FIRST 1
UpdateWeather()
WHILE (((Ceiling_Current < Ceiling_Min ) OR (Visibility_Current < Visibility_Min) OR (Crosswind_Current >
Crosswind_Max)) AND (FuelRemaining > 0)) DO
{
WAIT 1
UpdateWeather()
FuelRemaining=FuelRemaining-1
}
IF (FuelRemaining <= 0)
THEN ROUTE 2
ELSE ROUTE 1
1
Aircraft Return_Seg1_2min FIRST 1
2
Aircraft Divert
FIRST 1
MOVE FOR T(1.8,2.0,2.3)
1
Aircraft Return_Seg2_2min FIRST 1
MOVE FOR T(1.8,2.0,2.3)
1
Aircraft Return_Seg3_2min FIRST 1
MOVE FOR T(1.8,2.0,2.3)
1
Aircraft Return_Seg4_2min FIRST 1
MOVE FOR T(1.8,2.0,2.3)
1
Aircraft PONDS
FIRST 1
MOVE FOR 10.0
1
Aircraft EXIT
FIRST 1
********************************************************************************
*
Arrivals
*
********************************************************************************
Entity
Location Qty each
First Time Occurrences Frequency Logic
-------- -------- ---------- ---------- ----------- ---------- -----------Aircraft PONDS
1
0
INF
4
FuelRemaining=45
********************************************************************************
*
Attributes
*
********************************************************************************
ID
Type
Classification
------------- ------------ -------------#
#Fuel remaining in minutes
FuelRemaining Integer
Entity
********************************************************************************
*
Variables (global)
*
********************************************************************************
ID
Type
Initial value Stats
-------------------- ------------ ------------- ----------#
#Current visibility from weather file
Visibility_Current
Real
0
#
#Current ceiling from weather file
Ceiling_Current
Integer
0
#
#Current cross-wind component from weather file
Crosswind_Current
Integer
0
#
#Current head-wind
Headwind_Current
Integer
0
#
#Current wind direction from weather file
Wind_Dir_Current
Integer
0
#
#Current wind speed from weather file
Wind_Vel_Current
Integer
0
#
#Current hour, trucncated to nearest integer
Hour_Current
Integer
0
Wind_Effective_Angle Integer
0
V_Headwind
Real
0
V_Crosswind
Real
0
Time Series
Time Series
Time Series
Time Series
Time Series
Time Series
Time
Time
Time
Time
Series
Series
Series
Series
********************************************************************************
*
Arrays
*
********************************************************************************
ID
Dimensions
Type
---------- ------------ -----------weather
25,4
Real
********************************************************************************
*
Macros
*
********************************************************************************
ID
------------------Visibility_Min
Ceiling_Min
Crosswind_Max
Runway_Heading
Text
-----------1
[Note: 0.75 for the precision ILS approach]
3.8 [Note: 2.57 for the precision ILS approach]
14
20
********************************************************************************
*
Subroutines
*
********************************************************************************
ID
Type
Parameter Type
Logic
-------------------- ------------ ---------- ------------ -----------------UpdateWeather
None
// subroutine updates weather current weather from the weather array
// and calculates the current crosswind component
// 1. Update time and current weather values
Hour_Current = trunc(clock(hr))
Wind_Dir_Current = weather[(1+Hour_Current),1]
Wind_Vel_Current = weather[(1+Hour_Current),2]
Visibility_Current = weather[(1+Hour_Current),3]
Ceiling_Current = weather[(1+Hour_Current),4]
// 2. Calculate current crosswind component for given runway heading
UpdateWindComponents()
Crosswind_Current=ROUND(V_Crosswind)
Headwind_Current=ROUND(V_Headwind)
UpdateWindComponents None
// subroutine calculates current runway crosswind and headwind components
IF (Runway_Heading <= Wind_Dir_Current AND Wind_Dir_Current <=
(Runway_Heading+90)) THEN
{
Wind_Effective_Angle = Wind_Dir_Current - Runway_Heading
V_Crosswind = Wind_Vel_Current * sin(Wind_Effective_Angle)
V_Headwind = Wind_Vel_Current * cos(Wind_Effective_Angle)
RETURN
}
IF ((Runway_Heading+90) < Wind_Dir_Current AND Wind_Dir_Current <=
(Runway_Heading+180)) THEN
{
Wind_Effective_Angle = Wind_Dir_Current - (Runway_Heading+90)
V_Crosswind = Wind_Vel_Current * cos(Wind_Effective_Angle)
V_Headwind = -1 * Wind_Vel_Current * sin(Wind_Effective_Angle)
RETURN
}
IF ((Runway_Heading+180) < Wind_Dir_Current AND Wind_Dir_Current <=
(Runway_Heading+270)) THEN
{
Wind_Effective_Angle = Wind_Dir_Current - (Runway_Heading+180)
V_Crosswind = Wind_Vel_Current * sin(Wind_Effective_Angle)
V_Headwind = -1 * Wind_Vel_Current * cos(Wind_Effective_Angle)
RETURN
}
IF ((Runway_Heading+270) < Wind_Dir_Current AND Wind_Dir_Current <=
(Runway_Heading+360)) THEN
{
Wind_Effective_Angle = Wind_Dir_Current - (Runway_Heading+270)
V_Crosswind = Wind_Vel_Current * cos(Wind_Effective_Angle)
V_Headwind = Wind_Vel_Current * sin(Wind_Effective_Angle)
RETURN
}
// we should never get here
DEBUG
sin
Real
theta
Real
// subroutine uses Taylor series expansion to calculate sin(theta)
// theta is in degrees
theta = theta * 3.14159 / 180.0
RETURN (theta - theta**3.0/6.0 + theta**5.0/120.0 - theta**7.0/5040.0)
cos
Real
theta
Real
// subroutine uses Taylor series expansion to calculate cos(theta)
// theta is in degrees
theta = theta * 3.14159 / 180.0
RETURN (1 - theta**2.0/2.0 + theta**4.0/24.0 - theta**6.0/720.0)
InterpMinRoll
Real
// subroutine interpolates max rollout time based on headwind
RETURN (0.8 + (-0.0045*(V_Headwind+5)+0.22) + 0.5)
InterpModeRoll
Real
// subroutine interpolates mode rollout time based on headwind
RETURN (0.8 + (-0.0045*(V_Headwind+5)+0.23) + 0.5)
InterpMaxRoll
Real
// subroutine interpolates minimum rollout time based on headwind
RETURN (0.8 + (-0.0055*(V_Headwind+5)+0.26) + 0.5)
Appendix C
Model Output Text for Precision ILS Approach Run
-------------------------------------------------------------------------------General Report
Output from C:\MYDOCU~1\DESCLASS\PROJECT\VORRWY~1.MOD [DSES6620 Project - HVN Precision and Non-precision Approach]
Date: Apr/28/2002
Time: 01:19:11 AM
-------------------------------------------------------------------------------Scenario
: Normal Run
Replication
: 1 of 1
Simulation Time : 10713 hr
-------------------------------------------------------------------------------LOCATIONS
Location
Name
---------------PONDS
ApproachSeg1
ApproachSeg2
Rwy2
MAD
Return Seg1 2min
Return Seg2 2min
Return Seg3 2min
Return Seg4 2min
HVN
MAP Seg1 2min
MAP Seg2 2min
MAP Seg3 3mi
Divert
Scheduled
Hours
--------10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
Capacity
-------999999
1
1
1
999999
1
1
1
1
1
1
1
1
999999
Total
Entries
------163063
151708
151707
151375
11687
2367
2367
2367
2367
151707
332
332
332
9320
Average
Minutes
Per Entry
--------0.446125
2.632871
1.400140
1.508257
42.937644
2.115407
2.092241
2.071916
2.035595
0.000000
2.035497
2.032690
2.033488
2.000000
LOCATION STATES BY PERCENTAGE (Multiple Capacity)
Location
Name
-------PONDS
MAD
Divert
Scheduled
Hours
--------10713
10713
10713
%
Empty
----97.45
92.23
97.14
%
Partially
Occupied
--------2.55
7.77
2.86
%
Full
---0.00
0.00
0.00
|
|
|
|
|
|
|
%
Down
---0.00
0.00
0.00
Average
Contents
---------0.113175
0.621406
0.330457
0.355195
0.780691
0.00778986
0.00770456
0.00762971
0.00749596
0
0.00105135
0.0010499
0.00105031
0.028999
Maximum
Contents
-------10
1
1
1
18
1
1
1
1
1
1
1
1
2
Current
Contents
-------0
1
0
1
0
0
0
0
0
0
0
0
0
0
% Util
-----0.00
62.14
33.05
35.52
0.00
0.78
0.77
0.76
0.75
0.00
0.11
0.10
0.11
0.00
LOCATION STATES BY PERCENTAGE (Single Capacity/Tanks)
Location
Name
---------------ApproachSeg1
ApproachSeg2
Rwy2
Return Seg1 2min
Return Seg2 2min
Return Seg3 2min
Return Seg4 2min
HVN
MAP Seg1 2min
MAP Seg2 2min
MAP Seg3 3mi
Scheduled
Hours
--------10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
%
Operation
--------62.14
33.05
35.52
0.75
0.75
0.75
0.75
0.00
0.11
0.10
0.11
%
Setup
----0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
%
Idle
-----37.86
66.95
64.48
99.22
99.23
99.24
99.25
100.00
99.89
99.90
99.89
Average
Minutes
In
System
-------9.054809
Average
Minutes
In Move
Logic
-------0.000000
%
Waiting
------0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
%
Blocked
------0.00
0.00
0.00
0.03
0.02
0.01
0.00
0.00
0.00
0.00
0.00
%
Down
---0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
FAILED ARRIVALS
Entity
Name
-------Aircraft
Location
Name
-------PONDS
Total
Failed
-----0
ENTITY ACTIVITY
Entity
Name
-------Aircraft
Total
Exits
-----160694
Current
Quantity
In System
--------2
Average
Minutes
Wait For
Res, etc.
--------0.129083
ENTITY STATES BY PERCENTAGE
Entity
Name
-------Aircraft
%
In Move
Logic
------0.00
%
Wait For
Res, etc.
--------1.43
%
In Operation
-----------93.23
%
Blocked
------5.34
Average
Minutes
In
Operation
--------8.442049
Average
Minutes
Blocked
-------0.483678
VARIABLES
Variable
Name
-------------------Visibility Current
Ceiling Current
Crosswind Current
Headwind Current
Wind Dir Current
Wind Vel Current
Hour Current
Wind Effective Angle
V Headwind
V Crosswind
N Missed Approach
N Divert
N Landings
N Multiple Approach
Wind Dir
Total
Changes
------802973
802973
802972
802972
802973
802973
802972
802972
802972
802972
332
9320
151375
2367
802972
Average
Minutes
Per Change
----------0.800500
0.800500
0.800501
0.800501
0.800500
0.800500
0.800501
0.800501
0.800501
0.800501
1931.204843
68.800107
4.246275
270.908587
0.800501
Minimum
Value
--------0
0
0
-21
0
0
0
0
-20.9967
-0.018757
0
0
0
0
0
Maximum
Value
------10
999
28
24
360
30
10713
90
24
28.1908
332
9320
151375
2367
370
Current
Value
-------10
999
7
-1
280
7
10713
80
-1.21309
6.89327
332
9320
151375
2367
280
Average
Value
-------7.91297
560.434
4.89191
0.988985
213.95
7.60039
5356
49.5538
0.988516
4.90966
188.344
5202.26
75143.9
1313.44
224.3
Appendix D
Model Output Text for Non-Precision VOR Approach Run
-------------------------------------------------------------------------------General Report
Output from C:\My Documents\DESClass\Project\vorrwy2_020427.mod [DSES6620 Project - HVN Precision and Non-precision Approach]
Date: Apr/28/2002
Time: 01:42:23 PM
-------------------------------------------------------------------------------Scenario
: Normal Run
Replication
: 1 of 1
Simulation Time : 10713 hr
-------------------------------------------------------------------------------LOCATIONS
Location
Name
---------------PONDS
ApproachSeg1
ApproachSeg2
Rwy2
MAD
Return Seg1 2min
Return Seg2 2min
Return Seg3 2min
Return Seg4 2min
HVN
MAP Seg1 2min
MAP Seg2 2min
MAP Seg3 3mi
Divert
Scheduled
Hours
--------10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
Capacity
-------999999
1
1
1
999999
1
1
1
1
1
1
1
1
999999
Total
Entries
------163261
148741
148740
148353
14907
2565
2565
2565
2565
148740
387
387
387
12342
Average
Minutes
Per Entry
--------0.483109
2.633699
1.399798
1.508423
43.249366
2.113183
2.090049
2.068131
2.033356
0.000000
2.026403
2.031749
2.023930
2.000000
LOCATION STATES BY PERCENTAGE (Multiple Capacity)
Location
Name
-------PONDS
MAD
Divert
Scheduled
Hours
--------10713
10713
10713
%
Empty
----97.24
90.20
96.20
%
Partially
Occupied
--------2.76
9.80
3.80
%
Full
---0.00
0.00
0.00
|
|
|
|
|
|
|
%
Down
---0.00
0.00
0.00
Average
Contents
---------0.122706
0.609445
0.323915
0.348143
1.00302
0.00843261
0.0083403
0.00825283
0.00811406
0
0.00122004
0.00122326
0.00121855
0.0384019
Maximum
Contents
-------10
1
1
1
18
1
1
1
1
1
1
1
1
2
Current
Contents
-------0
1
0
1
0
0
0
0
0
0
0
0
0
0
% Util
-----0.00
60.94
32.39
34.81
0.00
0.84
0.83
0.83
0.81
0.00
0.12
0.12
0.12
0.00
LOCATION STATES BY PERCENTAGE (Single Capacity/Tanks)
Location
Name
---------------ApproachSeg1
ApproachSeg2
Rwy2
Return Seg1 2min
Return Seg2 2min
Return Seg3 2min
Return Seg4 2min
HVN
MAP Seg1 2min
MAP Seg2 2min
MAP Seg3 3mi
Scheduled
Hours
--------10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
10713
%
Operation
--------60.94
32.39
34.81
0.81
0.81
0.81
0.81
0.00
0.12
0.12
0.12
%
Setup
----0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
%
Idle
-----39.06
67.61
65.19
99.16
99.17
99.17
99.19
100.00
99.88
99.88
99.88
Average
Minutes
In
System
-------9.929746
Average
Minutes
In Move
Logic
-------0.000000
%
Waiting
------0.00
0.00
0.00
0.00
0.00
0.01
0.00
0.00
0.00
0.00
0.00
%
Blocked
------0.00
0.00
0.00
0.03
0.02
0.01
0.00
0.00
0.00
0.00
0.00
%
Down
---0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
0.00
FAILED ARRIVALS
Entity
Name
-------Aircraft
Location
Name
-------PONDS
Total
Failed
-----0
ENTITY ACTIVITY
Entity
Name
-------Aircraft
Total
Exits
-----160694
Current
Quantity
In System
--------2
Average
Minutes
Wait For
Res, etc.
--------0.139926
ENTITY STATES BY PERCENTAGE
Entity
Name
-------Aircraft
%
In Move
Logic
------0.00
%
Wait For
Res, etc.
--------1.41
%
In Operation
-----------93.31
%
Blocked
------5.28
Average
Minutes
In
Operation
--------9.265546
Average
Minutes
Blocked
-------0.524274
VARIABLES
Variable
Name
-------------------Visibility Current
Ceiling Current
Crosswind Current
Headwind Current
Wind Dir Current
Wind Vel Current
Hour Current
Wind Effective Angle
V Headwind
V Crosswind
N Missed Approach
N Divert
N Landings
N Multiple Approach
Wind Dir
Total
Changes
------944214
944214
944213
944213
944214
944214
944213
944213
944213
944213
387
12342
148353
2565
944213
Average
Minutes
Per Change
----------0.680757
0.680757
0.680757
0.680757
0.680757
0.680757
0.680757
0.680757
0.680757
0.680757
1648.527276
51.954059
4.332773
249.996386
0.680757
Minimum
Value
--------0
0
0
-21
0
0
0
0
-20.9967
-0.018757
0
0
0
0
0
Maximum
Value
------10
999
28
24
360
30
10713
90
24
28.1908
387
12342
148353
2565
370
Current
Value
-------10
999
7
-1
280
7
10713
80
-1.21309
6.89327
387
12342
148353
2565
280
Average
Value
-------7.91297
560.434
4.89191
0.988985
213.95
7.60039
5356
49.5538
0.988516
4.90966
222.08
7013.33
73332.6
1441.45
224.3