Procedures

A RouteProcedure defines a maneuver over an area of interest or waypoint along a route. A procedure also has a RouteProfile associated with it, in order to specify the height and speed at which to traverse the procedure. Procedures represent the primary way in which users specify the geometry of a route.

Note
The functionality described in this topic requires a license for the Route Design Library.

Available Procedures

Procedure	Description
TakeoffProcedure	Represents a takeoff trajectory with respect to a runway surface specified by the underlying terrain. If there is a taxi prior to the runway, the platform will turn onto the runway's heading. Then, the platform rolls a given distance before taking off to reach the target height. Lastly, the platform will execute a level turn toward the next procedure.
LandingProcedure	Represents a landing trajectory with respect to a runway surface specified by the underlying terrain. The platform will execute a level turn on the approach toward the runway before descending along the glide slope. The platform then rolls to a stop over a given distance. Lastly, if there are any taxi procedures after the landing, the platform will turn toward the next procedure.
TurnAfterWaypointProcedure	Represents a simple turn at a specific position such that the platform will arrive at the waypoint on the heading from the previous procedure before turning toward the next procedure.
TurnBeforeWaypointProcedure	Represents a simple turn at a specific position such that the platform will turn prior to the waypoint in order to arrive on the heading toward the next waypoint.
InscribedTurnProcedure	Represents a simple turn at a position specified by a waypoint. However, the path will never reach the given waypoint unless the change in heading is negligible. Instead, the turn will be inscribed between the lines connecting the previous procedure to the given waypoint and the waypoint to the next procedure. The position will arrive along the line from the previous procedure toward the given waypoint and leave along the line from the given waypoint toward the next procedure.
HeadingAtWaypointProcedure	Represents a maneuver such that the platform will arrive and leave from a given waypoint at a given heading. This is especially useful when defining initial or final conditions for a route or for smoothly connecting multiple routes together.
HeightTransitionProcedure	Represents a maneuver at a given waypoint such that the platform will enter into a spiral prior to reaching the given waypoint in order to adjust its current height. This is useful in cases where the maximum ascent or descent velocity would otherwise be violated while trying to transition from one procedure to another.
CircularHoldProcedure	Represents a holding pattern with a given turning radius such that a platform will enter and exit the hold on a tangent to the curve. The platform then spends a minimum amount of time (or revolutions) in the hold.
RacetrackHoldProcedure	Represents a holding pattern which is defined by two circular arcs connected by two straight lines or 'legs'. The platform will enter the hold at the closest of six entry points. Two of these entries are tangents to the hold arcs themselves. The other four are additional arcs placed at the ends of the 'legs'.
RasterSearchProcedure	Represents a sequence of maneuvers which cover a given rectangular area over the surface. The platform will enter the search at entry point closest to the previous procedure and proceed to search along its length before turning 180 degrees to search the other direction. The number of search legs requires is specified by the width of the search area. After finishing the search, the platform then turns toward the next procedure.
SurfaceCurveProcedure	Represents a straight traversal over the surface of the central body based on an EllipsoidSurfaceCurve. This is useful for specifying long cruise segments or for defining a custom procedure by using an EllipsoidComplexSurfaceCurve with a list of Cartographic vertices. Note, however, that this will not include turns as with the FollowPathProcedure.
FollowPathProcedure	Represents a sequence of turns at a set of specified vertices. This is useful for representing a ground vehicle traversing a set of map coordinates following roads or other features.
StationaryHoldProcedure	Represents a waypoint at which a vehicle will slow to a stop, wait for a specified amount of time, and then continue toward the next procedure. This is useful for representing ground vehicles or ships which wish to stop and wait at a given location. However, note that unlike most other procedures, this will create a discontinuity in the surface path if the previous and next procedures aren't in a straight line with the stationary hold when the velocity drops to zero.

Using Procedures

Primarily, most routes can be created with a collection of simple turns as shown in the following code sample:

Java

Copy

TurnAfterWaypointProcedure turnAfter = new TurnAfterWaypointProcedure();
turnAfter.setProfile(procedureProfile);
turnAfter.setSurfaceShape(earth.getShape());
turnAfter.setTurningRadius(turningRadius);
turnAfter.setWaypoint(waypoints.get(wpIndex++));
propagator.getSegments().add(turnAfter);

TurnBeforeWaypointProcedure turnBefore = new TurnBeforeWaypointProcedure();
turnBefore.setProfile(procedureProfile);
turnBefore.setSurfaceShape(earth.getShape());
turnBefore.setTurningRadius(turningRadius);
turnBefore.setWaypoint(waypoints.get(wpIndex++));
propagator.getSegments().add(turnBefore);

InscribedTurnProcedure turnShort = new InscribedTurnProcedure();
turnShort.setProfile(procedureProfile);
turnShort.setSurfaceShape(earth.getShape());
turnShort.setTurningRadius(turningRadius);
turnShort.setWaypoint(waypoints.get(wpIndex++));
propagator.getSegments().add(turnShort);

However, other more complex procedures are included for convenience and to help with common maneuvers such as holding patterns, search patterns, takeoff, and landing. In addition, the HeightTransitionProcedure is useful for situations where an aircraft needs to transition from one height to another but doesn't have enough room to do so in a straight line. In this case, the transition will allow the aircraft to spiral to reach the appropriate height before continuing on to the next procedure. It is possible to set the procedure to update its boundary conditions as needed while propagating. If no change in height is needed, it will behave like a TurnBeforeWaypointProcedure. Otherwise, it will spiral around the turn arc until it reaches the new target height. Here is an example:

Java

Copy

HeightTransitionProcedure transition = new HeightTransitionProcedure();
transition.setDynamics(profileDynamics);
transition.setSpeed(cruiseSpeed);
transition.setHeightReferenceSurface(localTerrain);
transition.setInitialHeight(higherCruiseHeight.getHeight());
transition.setFinalHeight(finalHeight);
transition.setTurningRadius(turningRadius);
transition.setWaypoint(waypoints.get(wpIndex++));
// By allowing the modification of the initial height, it ensures that the route will be
// feasible as it comes in to approach the next procedure
transition.setAllowModificationOfInitialHeight(true);
transition.setAllowModificationOfFinalHeight(false);
propagator.getSegments().add(transition);

Lastly, the HeadingAtWaypointProcedure can be used to provide an initial or final state for the route. To do so, specify the surface position, heading, height, and speed of the platform and the route will ensure tangency at that point. This is a useful way to combine multiple routes together. However, it can also be used to combine a route with a real time data point, an trajectory file, or any other kind of trajectory. Here is an example:

Java

Copy

Motion1<Cartesian> initialRouteState = stateInFixedFrame;

ProfileDynamics dynamics = new ProfileDynamics();
dynamics.setAscentSpeed(10.0); // meters per second
dynamics.setDescentSpeed(dynamics.getAscentSpeed());
dynamics.setPitchUpAcceleration(Constants.EarthSurfaceGravity);
dynamics.setPushOverAcceleration(Constants.EarthSurfaceGravity);
dynamics.setThrustAcceleration(Constants.EarthSurfaceGravity);
dynamics.setThrustDeceleration(Constants.EarthSurfaceGravity);
double radius = 100.0; // meters

HeadingAtWaypointProcedure initialProcedure = HeadingAtWaypointProcedure.getInitialFromPreviousState(earth, initialRouteState, dynamics, radius);

RoutePropagator propagator = new RoutePropagator();
propagator.getSegments().add(initialProcedure);

// Insert other procedures and configure route here