Kestrel Technology (United States)

View Video Presentation: https://doi.org/10.2514/6.2021-0349.vid Personnel airdrop operations are subject to the unsteady flow around aircraft and variations in the jumper's exit orientation, body, weight, and balance. This could lead to non-repeatable airdrop operations including a possibility of the jumper collision with the aircraft or another jumper leaving the opposite side. The trajectory sensitivity analysis of personnel airdrop to the jumper variations is therefore an essential tool to increase aircrew and soldier safety. This work specifically considers the trajectory analysis of two different paratrooper models with different weight and balance data leaving the troop door of a C-130H/J aircraft using the kCFD flow solver of HPCMP CREATE-AV Kestrel simulation tools. The aircraft model has an open troop door with fully-opened air deflector and extended flaps flying at 1,000ft, Mach number of 0.1972, and without propeller blades. Right and left exit cases are simulated using a responding-body motion capability in Kestrel in which the body positions and rotational angles at each time instant are estimated from the equations of motions based upon initial exit conditions, gravitational forces/moments, and calculated aerodynamic forces and moments. In these simulations, the time of drop, ejector force ratio to weight (except for one case), and initial position and orientation are fixed. Trajectory data are extracted and compared with each other. A normalized parameter of distance to the jumper diameter is defined to measure the trajectory translation deviations from a baseline exit case. The results show that trajectory data are more sensitive to the weight and balance data than aerodynamic forces/moments due to body variations. For all tested right exits, the maximum deviations measure about 3$D$, and all follow similar trajectory paths. Cases with small moments of inertia around z-axis and a small side-force can lead to a negative yaw turn at initial exit times and a possible contact of main canopy container with aircraft. The results show that left and right exit trajectories are very different mainly due to asymmetric paratrooper models.

The goal of this study is to conduct time accurate simulations of two high-fidelity paratrooper models exiting the left- and right-side troop/exit doors of a C-130 after an initial prescribed motion. Upon completing the prescribed motion, the paratrooper model is permitted to respond to the influence of the aircraft flow field and gravity. Solutions are calculated using HPCMP CREATE-AV Kestrel software. Both the second-order, unstructured finite-volume solver kCFD and the structured Cartesian finite-volume solver SAMAir, which enables near-body/off-body calculations and adaptive mesh refinement, were used. The results of these simulations document and characterize the strong moments associated with the asymmetric paratrooper models, which serve as initial conditions for the subsequent parachute deployment.

The F-16XL flight vehicle has been used extensively to study the aerodynamics of medium to high-angle-of-attack flight. Flight test data, including surface pressures, is available for a wide range of flight conditions, allowing direct comparison between computational fluid dynamics and fullscale flight data. The most recent comprehensive study, made possible by NASA, was conducted by NATO Task Group AVT-113 and had participants from many different countries. One of the conclusions of the study was that unsteady flow simulations with high-resolution turbulence treatment was necessary to compare well with the high-angle-of-attack flight test data. The current work applies the HPCMP CREATE-AV Kestrel fixed-wing simulation tool to the F-16XL configuration at high-angle-of-attack flight conditions. Kestrel couples a near-body, spatially 2-order solver with an off-body, spatially 3or 5-order solver to achieve a very high-resolution computation of the aerodynamic features of the flow-field. Adaptive mesh refinement (AMR) is also performed in the off-body domain as the solution progresses to maintain the vortical structures away from the body. The resulting simulation data is compared to flight test data, and found to be in very good agreement for this flight condition.

This paper presents a framework for confirming deadlock potentials detected by runtime analysis of a single run of a multi-threaded program. The multi-threaded program under examination is instrumented to emit lock and unlock events. When the instrumented program is executed, a trace is generated consisting of the lock and unlock operations performed during that specific run. A lock graph is constructed which can reveal deadlock potentials in the form of cycles. The effectiveness of this analysis is caused by the fact that successful non-deadlocking runs yield as good, and normally better, information as deadlocking runs. Each cycle is then used to construct an observer that can detect the occurrence of the corresponding real deadlock, should it occur during subsequent test runs; and a controller, which, when composed with the program, determines the optimal scheduling strategy that will maximize the probability for the corresponding real deadlock to occur. The framework is formalized in terms of transition systems and is implemented in Java.

Summary form only given. We briefly present a rule-based framework, called EAGLE, shown to be capable of defining and implementing finite trace monitoring logics, including future and past time temporal logic, extended regular expressions, real-time and metric temporal logics (MTL), interval logics, forms of quantified temporal logics, and so on. In this paper we focus on a linear temporal logic (LTL) specialisation of EAGLE. For an initial formula of size m, we establish upper bounds of O(m/sup 2/2/sup m/logm) and O(m/sup 4/2/sup 2m/log/sup 2/m) for the space and time complexity, respectively, of single step evaluation over an input trace. EAGLE has been successfully used, in both LTL and metric LTL forms, to test a real-time controller of an experimental NASA planetary rover.

In this paper we present a scalable pointer analysis for embedded applications that is able to distinguish between instances of recursively defined data structures and elements of arrays. The main contribution consists of an efficient yet precise algorithm that can handle multithreaded programs. We first perform an inexpensive flow-sensitive analysis of each function in the program that generates semantic equations describing the effect of the function on the memory graph. These equations bear numerical constraints that describe nonuniform points-to relationships. We then iteratively solve these equations in order to obtain an abstract storage graph that describes the shape of data structures at every point of the program for all possible thread interleavings. We bring experimental evidence that this approach is tractable and precise for real-size embedded applications.

Software testing is typically an ad hoc process where human testers manually write many test inputs and expected test results, perhaps automating their execution in a regression suite. This process is cumbersome and costly. This paper reports preliminary results on an approach to further automate this process. The approach consists of combining automated test case generation based on systematically exploring the program's input domain, with runtime analysis, where execution traces are monitored and verified against temporal logic specifications, or analyzed using advanced algorithms for detecting concurrency errors such as data races and deadlocks. The approach suggests to generate specifications dynamically per input instance rather than statically once-and-for-all. The paper describes experiments with variants of this approach in the context of two examples, a planetary rover controller and a space craft fault protection system.

The problem of testing a linear temporal logic (LTL) formula on a finite execution trace of events, generated by an executing program, occurs naturally in runtime analysis of software. An algorithm which takes a past time LTL formula and generates an efficient dynamic programming algorithm is presented. The generated algorithm tests whether the formula is satisfied by a finite trace of events given as input and runs in linear time, its constant depending on the size of the LTL formula. The memory needed is constant, also depending on the size of the formula. Further optimizations of the algorithm are suggested. Past time operators suitable for writing succinct specifications are introduced and shown definitionally equivalent to the standard operators. This work is part of the PathExplorer project, the objective of which it is to construct a flexible framework for monitoring and analyzing program executions.