Engineering Papers⌕ Search

SEARCH · Engineering Papers

Results for “abstract data types”

Search indexed NASA NTRS and DOE OSTI research on propulsion, heat transfer, battery materials and energy systems. Follow report and document links to the original sources.

Quote a phrase for an exact phrase match. Source license links do not imply unrestricted reuse.

At least 37 records · Page 2
All sourcesNASA NTRSDOE OSTI
NASA NTRS1989

Advanced Software Development Workstation Project

The Advanced Software Development Workstation Project, funded by Johnson Space Center, is investigating knowledge-based techniques for software reuse in NASA software development projects. Two prototypes have been demonstrated and a third is now in development. The approach is to build a foundation that provides passive reuse support, add a layer that uses domain-independent programming knowledge, add a layer that supports the acquisition of domain-specific programming knowledge to provide active support, and enhance maintainability and modifiability through an object-oriented approach. The development of new application software would use specification-by-reformulation, based on a cognitive theory of retrieval from very long-term memory in humans, and using an Ada code library and an object base. Current tasks include enhancements to the knowledge representation of Ada packages and abstract data types, extensions to support Ada package instantiation knowledge acquisition, integration with Ada compilers and relational databases, enhancements to the graphical user interface, and demonstration of the system with a NASA contractor-developed trajectory simulation package. Future work will focus on investigating issues involving scale-up and integration.

Lee, Daniel↗
NASA NTRS1989

Lessons learned in the transition to ADA from FORTRAN at NASA/Goddard

A case study was done at Goddard Space Flight Center, in which two dynamics satellite simulators are developed from the same requirements, one in Ada and the other in FORTRAN. The purpose of the research was to find out how well the prescriptive Ada development model worked to develop the Ada simulator. The FORTRAN simulator development, as well as past FORTRAN developments, provided a baseline for comparison. Since this was the first simulator developed here, the prescriptive Ada development model had many similarities to the usual FORTRAN development model. However, it was modified to include longer design and shorter testing phases, which is generally expected with Ada development. One surprising result was that the percentage of time the Ada project spent in the various development activities was very similar to the percentage of time spent in these activities when doing a FORTRAN project. Another surprising finding was the difficulty the Ada team had with unit testing as well as with integration. In retrospect it is realized that adding additional steps to the design phase, such as an abstract data type analysis, and certain guidelines to the implementation phase, such as to use primarily library units and nest sparingly, would have made development much easier.

Brophy, Carolyn Elizabeth↗
NASA NTRS1989

Lessons learned in the transition to Ada from FORTRAN at NASA/Goddard

Two dynamics satellite simulators are developed from the same requirements, one in Ada and the other in FORTRAN. The purpose of the research was to find out how well the prescriptive Ada development model worked to develop the Ada simulator. The FORTRAN simulator development, as well as past FORTRAN developments, provided a baseline for comparison. Since this was the first simulator developed, the prescriptive Ada development model had many similarities to the usual FORTRAN development model. However, it was modified to include longer design and shorter testing phases, which is generally expected with Ada developments. One result was that the percentage of time the Ada project spent in the various development activities was very similar to the percentage of time spent in these activities when doing a FORTRAN project. Another finding was the difficulty the Ada team had with unit testing as well as with integration. It was realized that adding additional steps to the design phase, such as an abstract data type analysis, and certain guidelines to the implementation phase, such as to use primarily library units and nest sparingly, would have made development easier. These are among the recommendations made to be incorporated in a new Ada development model next time.

Brophy, Carolyn Elizabeth↗
NASA NTRS1991

Programming in a proposed 9X distributed Ada

The studies of the proposed Ada 9X constructs for distribution, now referred to as AdaPT are reported. The goals for this time period were to revise the chosen example scenario and to begin studying about how the proposed constructs might be implemented. The example scenario chosen is the Submarine Combat Information Center (CIC) developed by IBM for the Navy. The specification provided by IBM was preliminary and had several deficiencies. To address these problems, some changes to the scenario specification were made. Some of the more important changes include: (1) addition of a system database management function; (2) addition of a fourth processing unit to the standard resources; (3) addition of an operator console interface function; and (4) removal of the time synchronization function. To implement the CIC scenario in AdaPT, the decided strategy were publics, partitions, and nodes. The principle purpose for implementing the CIC scenario was to demonstrate how the AdaPT constructs interact with the program structure. While considering ways that the AdaPt constructs might be translated to Ada 83, it was observed that the partition construct could reasonably be modeled as an abstract data type. Although this gives a useful method of modeling partitions, it does not at all address the configuration aspects on the node construct.

Waldrop, Raymond S.↗
NASA NTRS1993

Experimental evaluation of the certification-trail method

Certification trails are a recently introduced and promising approach to fault-detection and fault-tolerance. A comprehensive attempt to assess experimentally the performance and overall value of the method is reported. The method is applied to algorithms for the following problems: huffman tree, shortest path, minimum spanning tree, sorting, and convex hull. Our results reveal many cases in which an approach using certification-trails allows for significantly faster overall program execution time than a basic time redundancy-approach. Algorithms for the answer-validation problem for abstract data types were also examined. This kind of problem provides a basis for applying the certification-trail method to wide classes of algorithms. Answer-validation solutions for two types of priority queues were implemented and analyzed. In both cases, the algorithm which performs answer-validation is substantially faster than the original algorithm for computing the answer. Next, a probabilistic model and analysis which enables comparison between the certification-trail method and the time-redundancy approach were presented. The analysis reveals some substantial and sometimes surprising advantages for ther certification-trail method. Finally, the work our group performed on the design and implementation of fault injection testbeds for experimental analysis of the certification trail technique is discussed. This work employs two distinct methodologies, software fault injection (modification of instruction, data, and stack segments of programs on a Sun Sparcstation ELC and on an IBM 386 PC) and hardware fault injection (control, address, and data lines of a Motorola MC68000-based target system pulsed at logical zero/one values). Our results indicate the viability of the certification trail technique. It is also believed that the tools developed provide a solid base for additional exploration.

Sullivan, Gregory F.↗
NASA NTRS1997

How to Express C++ Concepts in Fortran90

r summarizes techniques for emulating in Fortran90 the most important object-oriented concepts of C++ classes (including abstract data types, encapsulation and function overloading), inheritance and dynamic dispatching.

Fortran90↗
NASA NTRS2005

Type-definition objects

This paper presents a number of type definition objects implemented as part of the Joint Asymmetric Warfare Simulation (JAWS).

OOP↗
DOE OSTI2025

Generic Discretization Library

The GenDiL library is a collection of C++ software abstractions designed to discretize and solve partial differential equations (PDEs) for high-performance computing (HPC) applications. Its primary focus is on modern C++ generic programming, which helps ensure portability across various hardware architectures. The central idea behind the library is to provide building blocks for numerical algorithms-such as discretization methods and iteration patterns-so that domain experts can focus on the math, rather than the low-level details of hardware or implementation. By defining abstractions for data types, iteration over computational grids, and scheduling of operations, the library isolates the high-level PDE algorithms from the platform-specific optimizations needed to achieve efficient performance.

Dudouit, Yohann [Lawrence Livermore National Labor↗
NASA NTRS1995

(abstract) Application of Non-coherent Data Types for Deep Space Navigation

Several options are being examined to reduce the costs of spacecraft and deep space missions. One such option is to fly spacecraft in a non-coherent mode, that is, the spacecraft does not carry a transponder and cannot coherently return a Doppler signal. Historically, such one-way data has not been used as the sole data type due to the instability of the onboard oscillator, the use of S-band frequencies, and the corresponding larger error sources which could not be modeled. However, with the advent of high-speed work stations and more sophisticated modeling ability, the possibility of using one-way data is being re-examined. This paper addresses the navigation performance of various one-way data types for use in interplanetary missions.

deep space navigation non-coherent data spacecraft↗
NASA NTRS1993

A path-oriented matrix-based knowledge representation system

Experience has shown that designing a good representation is often the key to turning hard problems into simple ones. Most AI (Artificial Intelligence) search/representation techniques are oriented toward an infinite domain of objects and arbitrary relations among them. In reality much of what needs to be represented in AI can be expressed using a finite domain and unary or binary predicates. Well-known vector- and matrix-based representations can efficiently represent finite domains and unary/binary predicates, and allow effective extraction of path information by generalized transitive closure/path matrix computations. In order to avoid space limitations a set of abstract sparse matrix data types was developed along with a set of operations on them. This representation forms the basis of an intelligent information system for representing and manipulating relational data.

Feyock, Stefan↗
DOE OSTI2024

The Dark Energy Survey: Cosmology Results with ∼1500 New High-redshift Type Ia Supernovae Using the Full 5 yr Data Set

Abstract We present cosmological constraints from the sample of Type Ia supernovae (SNe Ia) discovered and measured during the full 5 yr of the Dark Energy Survey (DES) SN program. In contrast to most previous cosmological samples, in which SNe are classified based on their spectra, we classify the DES SNe using a machine learning algorithm applied to their light curves in four photometric bands. Spectroscopic redshifts are acquired from a dedicated follow-up survey of the host galaxies. After accounting for the likelihood of each SN being an SN Ia, we find 1635 DES SNe in the redshift range 0.10 < z < 1.13 that pass quality selection criteria sufficient to constrain cosmological parameters. This quintuples the number of high-quality z > 0.5 SNe compared to the previous leading compilation of Pantheon+ and results in the tightest cosmological constraints achieved by any SN data set to date. To derive cosmological constraints, we combine the DES SN data with a high-quality external low-redshift sample consisting of 194 SNe Ia spanning 0.025 < z < 0.10. Using SN data alone and including systematic uncertainties, we find Ω M = 0.352 ± 0.017 in flat ΛCDM. SN data alone now require acceleration ( q 0 < 0 in ΛCDM) with over 5 σ confidence. We find ( Ω M , w ) = ( 0.264 − 0.096 + 0.074 , − 0.80 − 0.16 + 0.14 ) in flat w CDM. For flat w 0 w a CDM, we find ( Ω M , w 0 , w a ) = ( 0.495 − 0.043 + 0.033 , − 0.36 − 0.30 + 0.36 , − 8.8 − 4.5 + 3.7 ) , consistent with a constant equation of state to within ∼2 σ . Including Planck cosmic microwave background, Sloan Digital Sky Survey baryon acoustic oscillation, and DES 3 × 2pt data gives (Ω M , w ) = (0.321 ± 0.007, −0.941 ± 0.026). In all cases, dark energy is consistent with a cosmological constant to within ∼2 σ . Systematic errors on cosmological parameters are subdominant compared to statistical errors; these results thus pave the way for future photometrically classified SN analyses.

79 ASTRONOMY AND ASTROPHYSICS↗
NASA NTRS1986

Some design constraints required for the assembly of software components: The incorporation of atomic abstract types into generically structured abstract types

It is nearly axiomatic, that to take the greatest advantage of the useful features available in a development system, and to avoid the negative interactions of those features, requires the exercise of a design methodology which constrains their use. A major design support feature of the Ada language is abstraction: for data, functions processes, resources, and system elements in general. Atomic abstract types can be created in packages defining those private types and all of the overloaded operators, functions, and hidden data required for their use in an application. Generically structured abstract types can be created in generic packages defining those structured private types, as buildups from the user-defined data types which are input as parameters. A study is made of the design constraints required for software incorporating either atomic or generically structured abstract types, if the integration of software components based on them is to be subsequently performed. The impact of these techniques on the reusability of software and the creation of project-specific software support environments is also discussed.

Johnson, Charles S.↗
DOE OSTI2024

Linking transients to their host galaxies – II. A comparison of host galaxy properties and rate dependencies across supernova types

ABSTRACT We use the latest data set of supernova (SN) host galaxies to investigate how the host properties – stellar mass, star formation rate (SFR), metallicity, absolute magnitude, and colour–differ across SN types, with redshift-driven selection effects controlled. SN Ib and Ic host galaxies, on average, are more massive, metal-rich, and redder than SN II hosts. For subtypes, SN Ibn and Ic-BL have bluer hosts than their normal SN Ib and Ic siblings; SN IIb has consistent host properties with SN Ib, while hosts of SN IIn are more metal-rich than those of SN II. Hydrogen-deficient superluminous SNe feature bluer and lower luminosity hosts than most subtypes of core-collapse supernova (CC SN). Assuming simple proportionality of CC SN rates and host SFRs does not recover the observed mean host properties; either a population of long-lived progenitors or a metallicity-dependent SN production efficiency better reproduces the observed host properties. Assuming the latter case, the rates of SN II are insensitive to host metallicity, but the rates of SN Ib and Ic are substantially enhanced in metal-rich hosts by a factor of $\sim 10$ per dex increase in metallicity. Hosts of SN Ia are diverse in their observed properties; subtypes including SN Ia-91T, Ia-02cx, and Ia-CSM prefer star-forming hosts, while subtypes like SN Ia-91bg and Ca-rich prefer quiescent hosts. The rates of SN Ia-91T, Ia-02cx, and Ia-CSM are closely dependent on, or even proportional to, their host SFRs, indicating relatively short-lived progenitors. Conversely, the rates of SN Ia-91bg and Ca-rich transients are proportional to the total stellar mass, favouring long-lived progenitors.

Qin, Yu-Jing (ORCID:0000000336586026)↗
DOE OSTI2025

The Analysis Description Language Ecosystem: Latest developments and physics applications

We present latest developments in Analysis Description Language (ADL), a declarative domain-specific language describing the physics algorithm of a HEP data analysis decoupled from software frameworks. Analyses written in ADL can be integrated into any framework for various tasks. ADL is a multipurpose construct with uses ranging from analysis design to preservation, reinterpretation, queries, visualisation, combination, etc. The most advanced infrastructure to execute ADL on events is the CutLang runtime interpreter. Recent technical developments include an automated interface with different data types, generation of the abstract syntax tree, a visualization tool that that auto-converts analysis flows to graphs, incorporation of trained machine learning models and a Jupyter-based plotting tool. We also report physics implications including a large scale LHC analysis implementation and validation effort for beyond the standard model reinterpretation purposes and studies with ATLAS and CMS open data.

Sekmen, Sezen [Kyungpook National Univ., Daegu (Ko↗
NASA NTRSDate not supplied

Statistical Classification of Biosignature Information: Combining Elemental, Molecular, Reflectance, and Raman Data to Increase Life Detection Confidence

Planetary exploration missions seeking past or present signs of life carry not just a single instrument, but a suite. There is a need to study how these multiple data types can be combined to create “composite” biosignatures [1]. Algorithmic methods using existing data on living and non-living systems, though limited by the n = 1 of Earth, can nonetheless be informative. We assembled a database of 1277 measurements spanning 16 representative systems either indicative or non-indicative of life. Five classification (machine learning) methods were used on each individual data type, then on the entire set. This abstract summarizes the results; the data is described in more detail in [2], and methods in [3].

Biosignatures↗
NASA NTRS1992

Fortran for the nineties

Fortran has largely enjoyed prominence for the past few decades as the computer programming language of choice for numerically intensive scientific, engineering, and process control applications. Fortran's well understood static language syntax has allowed resulting parsers and compiler optimizing technologies to often generate among the most efficient and fastest run-time executables, particularly on high-end scalar and vector supercomputers. Computing architectures and paradigms have changed considerably since the last ANSI/ISO Fortran release in 1978, and while FORTRAN 77 has more than survived, it's aged features provide only partial functionality for today's demanding computing environments. The simple block procedural languages have been necessarily evolving, or giving way, to specialized supercomputing, network resource, and object-oriented paradigms. To address these new computing demands, ANSI has worked for the last 12-years with three international public reviews to deliver Fortran 90. Fortran 90 has superseded and replaced ISO FORTRAN 77 internationally as the sole Fortran standard; while in the US, Fortran 90 is expected to be adopted as the ANSI standard this summer, coexisting with ANSI FORTRAN 77 until at least 1996. The development path and current state of Fortran will be briefly described highlighting the many new Fortran 90 syntactic and semantic additions which support (among others): free form source; array syntax; new control structures; modules and interfaces; pointers; derived data types; dynamic memory; enhanced I/O; operator overloading; data abstraction; user optional arguments; new intrinsics for array, bit manipulation, and system inquiry; and enhanced portability through better generic control of underlying system arithmetic models. Examples from dynamical astronomy, signal and image processing will attempt to illustrate Fortran 90's applicability to today's general scalar, vector, and parallel scientific and engineering requirements and object oriented programming paradigms. Time permitting, current work proceeding on the future development of Fortran 2000 and collateral standards will be introduced.

Himer, J. T.↗
DOE OSTI2025

Comparative Economic Analysis Between Bioenergy and Forage Types of Switchgrass for Sustainable Biofuel Feedstock Production: A Data Envelopment Analysis and Cost–Benefit Analysis Approach

ABSTRACT The capacity to produce switchgrass efficiently and cost‐effectively across diverse environments can be pivotal in achieving the short‐ and medium‐term Sustainable Aviation Fuel targets set by the U.S. Department of Energy. This study evaluated the economic performance of forage‐ and bioenergy‐type switchgrass cultivars and their response to N fertilization under diverse marginal environments across the US Midwest that included Illinois (IL), Iowa (IA), Nebraska (NE), and South Dakota (SD). Data Envelopment Analysis (DEA) was used to evaluate the efficiency of 23 Decision‐Making Units (DMUs)—cultivar types and N fertilization rate combinations—while a cost–benefit analysis calculated their profitability over 5 years. Results showed that two energy‐type cultivars—“Independence” and “Liberty”—were superior economically to the forage cultivars. Independence performed best with the highest profit margin when fertilized at 56 kg N ha −1 , particularly in the US hardiness zone 6a (Urbana, IL). Liberty exhibited the highest profit margins in hardiness zone 5b (Madrid, IA, and Ithaca, NE) at 56 kg N ha −1 and showed exceptional profitability with 28 kg N ha −1 in hardiness zone 6b (Brighton, IL). Switchgrass cultivar “Carthage” showed better efficiency score and profitability results in hardiness zone 4b (South Shore, SD) at 56 kg N ha −1 . The profit trends observed in current study sites may indicate broader patterns across similar US hardiness zones. This study provides valuable insights for decision‐makers to optimize input strategies for biomass production of bioenergy switchgrass to meet renewable energy demands.

Arshad, Muhammad Umer [Department of Crop Sciences↗
NASA NTRS2014

SSL Freeform Generator v1.00

The Orion spacecraft utilizes a system of Compact Unique Identifiers (CUIs) to identify telemetry measurements in the process of communicating with the ground. While avionic systems are still in development, simulation of telemetric data must be used for the development of dependent systems. The SuperScript Language (SSL) developed by Honeywell Aerospace provides users a programming language for simulation of this data. The use of tools that provide SSL generation capabilities at a higher level allows for faster and more efficient generation of simulation waveforms. Previous SSL Generator implementations such as Orion Scripted Interface Generator (OrionSIG) relied on software supported routines to generate simulation points for the SSL scripts. This provided relevant simulation capabilities, but was reduced in flexibility by the available software routines available. For this approach, software supported routines have been entirely dropped. Rather, the user is required to enter their own simulation waveform input. This allows arbitrarily complex functions to be utilized simulated with maximum degree of freedom for the user.: The idea for this version of the SSL Generator was a mapping of arbitrary waveforms to Orion CUI telemetry data. The SSL Generator implemented offers a higher degree of freedom to the user than previous versions while attempting to maintain abstraction from the underlying SSL script and the Orion CUI data types. As such, many mappings of waveforms to CUIs will simply not work. Certain implementation decisions were made to minimize the damage caused by these unintended side-effects, such as saturation of values exceeding the maximum or minimum bounds of the data type. Other details, such as signed values being represented in unsigned data types, present problems which cant be fixed to an acceptable degree of intended behavior without user input. Awareness of the limitations of all layers of the software stack will increase the productivity of the end-user.

telemetry↗