Search NASA⌕ Search

SEARCH · Search NASA

Results for “program compilers”

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 397 records · Page 22

Automated Approach for Construction of Long-Term, Data-Intensive Watershed Models

Watershed models such as the Hydrological Simulation Program in FORTRAN (HSPF) are frequently used to analyze large-scale water quantity and water quality issues. The construction of HSPF models is a difficult and time-consuming process, because it requires compilation of extensive quantities of data into formatted files followed by a simultaneous fitting of many uncertain parameters. Because of these complications, studies are often limited to calibration periods of only a few years even when analyzing long time-scale issues such as climate and land-use changes that are difficult or impossible to reproduce. High-level, open source programming languages provide an environment for automating the extraction and processing of various sources of data in addition to the calibration process required by HSPF. Recently developed software can be used to build HSPF input files, run simulations, and postprocess simulation results using the Python programming language. The combination of tools in Python, public data sets on the Internet, and software extensions enables rapid development of long-term, reproducible, and sophisticated models for new hydrologic insight. Herein, the utility of these tools is illustrated by developing an automated 30-year HSPF model with a Nash-Sutcliffe efficiency of 0.88 for monthly flows and 0.75 for daily flows in a simulation time of approximately 3h. The integration of HSPF with a high-level programming language creates opportunities to more rigorously explore model assumptions, calibration methods, and alternative data sets.

Lampert, Dave J↗

Synthetic genetic circuits as a means of reprogramming plant roots

We report the shape of a plant’s root system influences its ability to reach essential nutrients in the soil and to acquire water during drought. Progress in engineering plant roots to optimize water and nutrient acquisition has been limited by our capacity to design and build genetic programs that alter root growth in a predictable manner. We developed a collection of synthetic transcriptional regulators for plants that can be compiled to create genetic circuits. These circuits control gene expression by performing Boolean logic operations and can be used to predictably alter root structure. This work demonstrates the potential of synthetic genetic circuits to control gene expression across tissues and reprogram plant growth.

59 BASIC BIOLOGICAL SCIENCES↗

AstraAI v1

AstraAI is an open-source, structure-aware AI coding agent designed for large scientific and DOE-HPC codebases such as AMReX-based applications. Unlike general-purpose coding assistants, AstraAI combines retrieval-augmented generation (RAG) with compiler-level Abstract Syntax Tree (AST) analysis to perform precise, scope-constrained code modifications. It identifies exact function spans, enforces locality of edits, and maintains cross-file invariants, enabling deterministic and build-safe transformations in complex C++/GPU environments. AstraAI is intended for developers working on large, evolving HPC frameworks where correctness, reproducibility, and structural integrity are critical. Typical use cases include modifying physics kernels, updating GPU device lambdas, and performing multi-file refactors without breaking compilation or runtime semantics. Compared to conventional LLM-based coding agents - even those with repository access - AstraAI provides structural guarantees rather than free-form text patches. It minimizes unintended diffs, prevents scope drift, preserves formatting and build stability, and reduces structural hallucinations. By integrating compiler tooling directly into the generation loop, AstraAI transforms AI-assisted coding from probabilistic text editing into deterministic, structure-preserving program transformation suitable for mission-critical scientific software.

Natarajan, Mahesh [Lawrence Berkeley National Labo↗

Software Synthesis for High Productivity Exascale Computing

Over the three years of our project, we accomplished three key milestones: We demonstrated how ideas from generative programming and software synthesis can help support the development of bulk-synchronous distributed memory kernels. These ideas are realized in a new language called MSL, a C-like language that combines synthesis features with high level notations for array manipulation and bulk-synchronous parallelism to simplify the semantic analysis required for synthesis. We also demonstrated that these high level notations map easily to low level C code and show that the performance of this generated code matches that of handwritten Fortran. Second, we introduced the idea of solver-aided domain-specific languages (SDSLs), which are an emerging class of computer-aided programming systems. SDSLs ease the construction of programs by automating tasks such as verification, debugging, synthesis, and non-deterministic execution. SDSLs are implemented by translating the DSL program into logical constraints. Next, we developed a symbolic virtual machine called Rosette, which simplifies the construction of such SDSLs and their compilers. We have used Rosette to build SynthCL, a subset of OpenCL that supports synthesis. Third, we developed novel numeric algorithms that move as little data as possible, either between levels of a memory hierarchy or between parallel processors over a network. We achieved progress in three aspects of this problem. First we determined lower bounds on communication. Second, we compared these lower bounds to widely used versions of these algorithms, and noted that these widely used algorithms usually communicate asymptotically more than is necessary. Third, we identified or invented new algorithms for most linear algebra problems that do attain these lower bounds, and demonstrated large speed-ups in theory and practice.

97 MATHEMATICS AND COMPUTING↗

Technology inventory: energy efficiency measures for residential, commercial, and industrial sectors in the United States

Energy efficiency is expected to continue to be one of main levers for governments to address the energy and climate crisis. While a diverse mix of energy efficiency programs has been regarded as an important part of governmental actions, an energy efficiency policy or program needs to identify and assess eligible savings measures, i.e., specific technologies or practices, for designing key features, e.g., target type, target stringency, covered load, and cost recovery. This report briefly discusses U.S. energy efficiency policies and programs, explores publicly available resources of energy efficiency measures for residential, commercial, and industrial sectors in the U.S., and describes how to compile key measures and characteristics into an integrated spreadsheet database. The database in the initial version offers, for more than 1,200 measures, efficiency or improvement potential, technical notes, costs at a given year, where applicable. Energy efficiency measures compiled here could play an important role in determining savings targets and target stringency under a potential energy efficiency policy such as an energy efficiency resource standard in Korea, and offer significant opportunities for energy efficiency improvement.

32 ENERGY CONSERVATION, CONSUMPTION, AND UTILIZATI↗

SorpPropLib : An Open-Source Database for Sorption Equilibrium Properties

Hundreds of sorption working pair equilibrium measurements have been reported in the literature, and many experimental results have been fitted to equilibrium equations. However, an open database does not exist for the equilibrium equations. Therefore, this work compiled 438 published equilibrium equations of sorption working pairs into an open-source database called SorpPropLib. SorpPropLib is accessible from six programming environments commonly used in sorption cycle simulation (C++, Excel®, Python®, Matlab®, Modelica® and Lab-VIEW™). Plotting capabilities allow fast cycle visualization in each programming environment. Thereby, the open-source database SorpPropLib aims to enable and encourage easy data sharing to advance sorption research.

Engelpracht, Mirko↗

Performance and Architecture Lab Modeling Tool

Analytical application performance models are critical for diagnosing performance-limiting resources, optimizing systems, and designing machines. Creating models, however, is difficult. Furthermore, models are frequently expressed in forms that are hard to distribute and validate. The Performance and Architecture Lab Modeling tool, or Palm, is a modeling tool designed to make application modeling easier. Palm provides a source code modeling annotation language. Not only does the modeling language divide the modeling task into sub problems, it formally links an application's source code with its model. This link is important because a model's purpose is to capture application behavior. Furthermore, this link makes it possible to define rules for generating models according to source code organization. Palm generates hierarchical models according to well-defined rules. Given an application, a set of annotations, and a representative execution environment, Palm will generate the same model. A generated model is a an executable program whose constituent parts directly correspond to the modeled application. Palm generates models by combining top-down (human-provided) semantic insight with bottom-up static and dynamic analysis. A model's hierarchy is defined by static and dynamic source code structure. Because Palm coordinates models and source code, Palm's models are 'first-class' and reproducible. Palm automates common modeling tasks. For instance, Palm incorporates measurements to focus attention, represent constant behavior, and validate models. Palm's workflow is as follows. The workflow's input is source code annotated with Palm modeling annotations. The most important annotation models an instance of a block of code. Given annotated source code, the Palm Compiler produces executables and the Palm Monitor collects a representative performance profile. The Palm Generator synthesizes a model based on the static and dynamic mapping of annotations to program behavior. The model -- an executable program -- is a hierarchical composition of annotation functions, synthesized functions, statistics for runtime values, and performance measurements.

Tallent, Nathan↗

Data Locality Enhancement of Dynamic Simulations for Exascale Computing (Final Report)

The development of modern processors exhibits two trends that complicate the optimizations of modern software. The first is the increasing sensitivity of processors' throughput to irregularities in computation. With more processors produced through a massive integration of simple cores, future systems will increasingly favor regular data-level parallel computations, but deviate from the needs of applications with complex patterns. Some evidences are already shown on Graphic Processing Units (GPU): Irregular data accesses (e.g., indirect references A[D[i]]) and conditional branches are limiting many GPU applications' performance at a level an order of magnitude lower than the peak of GPU. The second hardware trend is the growing gap between memory bandwidth and the aggregate speed—that is, the sum of all cores' computing power—of a Chip Multiprocessor (CMP). Despite the capped growth of the peak CPU speed, the aggregate speed of a CMP keeps increasing as more cores get into a single chip. It is expected that by 2018, node concurrency in an exascale system will increase by hundreds of times, whereas, memory bandwidth will expand by only 10 to 20 times. Consequently, data movement and storage is expected to consume more than 70% of the total system power. Bridging this gap is difficult; the complexities of modern CMP memory hierarchy make it even harder: Data cache becomes shared among computing units, and the sharing is often non-uniform—whether two computing units share a cache depends on their proximity and the level of the cache. On the recent IBM Power7 architecture, for instance, four hardware contexts (or SMT threads) in a core share the entire memory hierarchy, all cores in one chip share an on-chip L3 cache, and cores across chips share L3 and main memory through off-chip connections. These two trends complicate the translation of computing power into performance, especially for a program with either intensive data accesses or complex patterns in data accesses or control flow paths. Unfortunately, both attributes present and will persist in a class of important applications. For instance, many scientific simulations deal with a large volume of data. And meanwhile, as most real-world processes are non-uniform and evolving (e.g., the evolution of a galaxy or the process of a drug injection), both the computations and data accesses of these programs tend to be irregular and dynamically changing. Currently, the lack of support to these applications on modern CMP severely limits their performance. On GPU, as our recent study shows and other studies echo, performance enhancement of a factor of integers is possible when memory accesses or control flows are streamlined for a set of GPU applications. On multicore CPU, our studies show that traditional locality enhancement, for being oblivious to the new features of multicore memory hierarchy, may even cause large slowdown to data-intensive dynamic applications. The severity of the issues is expected to worsen as the two hardware trends continue. Some recent studies try to match software with the trends, but in a limited scope or manner. For irregularities on GPU, most studies focus on irregularities analyzable through static analysis (e.g., data accesses in regular loops). Dynamic irregularities are harder to address because the needed analysis and transformations typically have to happen at run time. Some other research resorts to hardware extensions, an actual adoption of which is unclear for the entailed space cost and complexity. For data locality, recent years have seen some exploitations of the new memory hierarchy on multicore for performance, but most of them are on process or thread scheduling, rather than program transformations. Our recent study reveals that program-level transformations may magnify the scheduling benefits by a factor of seven, concluding that program-level transformation should play a central role for data locality enhancement on modern CMP. But research in this direction has been sparse, and most have focused on data layout or cache performance modeling, rather than program transformations to match with the new memory hierarchy features. Overall, it is still an open question how to bridge the gap between dynamic computations and the two prominent properties of modern processors. The goal of this project is to develop a set of techniques and software tools to enhance the matching between memory accesses in dynamic simulations and the prominent features of modern and future CMP, alleviating the memory performance issues for petascale and exascale computing. This report summarizes the discoveries and products produced throughout this project. It includes free launch, a new software approach to overcoming the shortcomings of both methods; coherence-free multiview, an approach that allows multiple views of a single data object to co-exist on GPU memory during a GPU kernel execution; algorithmic optimizations to data analytics problems, especially those that involve lots of distance calculations. Supporting dynamic parallelism is important for GPU to benefit a broad range of applications. There are currently two fundamental ways for programs to exploit dynamic parallelism on GPU: a software-based approach with software-managed worklists, and a hardware-based approach through dynamic subkernel launches. Neither is satisfactory. The former is complicated to program and is often subject to some load imbalance; the latter suffers large runtime overhead. In this work, we propose free launch, a new software approach to overcoming the shortcomings of both methods. It allows programmers to use subkernel launches to express dynamic parallelism. It employs a novel compiler-based code transformation named subkernel launch removal to replace the subkernel launches with the reuse of parent threads. Coupled with an adaptive task assignment mechanism, the transformation reassigns the tasks in the subkernels to the parent threads with a good load balance. The technique requires no hardware extensions, immediately deployable on existing GPUs. It keeps the programming convenience of the subkernel launch-based approach while avoiding its large runtime overhead. Meanwhile, its superior load balancing makes it outperform manual worklist-based techniques by 3X on average. The work was published at the 48th Annual IEEE/ACM International Symposium on Microarchitecture (Micro'2015). A Graphic Processing Unit (GPU) system is typically equipped with many types of memory (e.g., global, constant, texture, shared, cache). Data placement determines what data are placed on which type of memory, essential for GPU memory performance. Prior optimizations of data placement always require a single view of a data object on memory, which limits the optimization effectiveness. In this work, we propose coherence-free multiview, an approach that allows multiple views of a single data object to co-exist on GPU memory during a GPU kernel execution. We demonstrate that under certain conditions, the multiple views can remain incoherent while facilitating enhanced data placement. We present a theorem and some compiler support to ensure the soundness of the usage of coherence-free multiview. We further develop reference-discerning data placement, a new way to enhance data placements on GPU. It enables more flexible data placements by using coherence-free multiview to leverage the slack in coherence requirement of some GPU programs. Experiments on three types of GPU systems show that, with less than 200KB space cost, the new data placement technique can provide a 1.6X average (up to 4.27X) speedup. In addition, we have examined algorithmic optimizations to data analytics problems, especially those that involve lots of distance calculations. Computing distances among data points is an essential part of many important algorithms in data analytics, graph analysis, and other domains. In each of these domains, developers have spent significant manual effort optimizing algorithms, often through novel applications of the triangle equality, in order to minimize the number of distance computations in the algorithms. In this work, we observe that many algorithms across these domains can be generalized as an instance of a generic distance-related abstraction. Based on this abstraction, we derive seven principles for correctly applying the triangular inequality to optimize distance-related algorithms. Guided by the findings, we develop Triangular OPtimizer (TOP), the first software framework that is able to automatically produce optimized algorithms that either matches or outperforms manually designed algorithms for solving distance-related problems. TOP achieves up to 237x speedups and 2.5X on average. The work has been published at the 32nd International Conference on Machine Learning (ICML'15) and the 41st International Conference on Very Large Data Bases (VLDB'15).

42 ENGINEERING↗

Accuracy of pencil-beam redefinition algorithm dose calculations in patient-like cylindrical phantoms for bolus electron conformal therapy

Purpose: The purpose of this study was to document the improved accuracy of the pencil beam redefinition algorithm (PBRA) compared to the pencil beam algorithm (PBA) for bolus electron conformal therapy using cylindrical patient phantoms based on patient computed tomography (CT) scans of retromolar trigone and nose cancer.Methods: PBRA and PBA electron dose calculations were compared with measured dose in retromolar trigone and nose phantoms both with and without bolus. For the bolus treatment plans, a radiation oncologist outlined a planning target volume (PTV) on the central axis slice of the CT scan for each phantom. A bolus was designed using the planning.decimal{sup Registered-Sign} (p.d) software (.decimal, Inc., Sanford, FL) to conform the 90% dose line to the distal surface of the PTV. Dose measurements were taken with thermoluminescent dosimeters placed into predrilled holes. The Pinnacle{sup 3} (Philips Healthcare, Andover, MD) treatment planning system was used to calculate PBA dose distributions. The PBRA dose distributions were calculated with an in-house C++ program. In order to accurately account for the phantom materials a table correlating CT number to relative electron stopping and scattering powers was compiled and used for both PBA and PBRA dose calculations. Accuracy was determined by comparing differences in measured and calculated dose, as well as distance to agreement for each measurement point.Results: The measured doses had an average precision of 0.9%. For the retromolar trigone phantom, the PBRA dose calculations had an average {+-}1{sigma} dose difference (calculated - measured) of -0.65%{+-} 1.62% without the bolus and -0.20%{+-} 1.54% with the bolus. The PBA dose calculation had an average dose difference of 0.19%{+-} 3.27% without the bolus and -0.05%{+-} 3.14% with the bolus. For the nose phantom, the PBRA dose calculations had an average dose difference of 0.50%{+-} 3.06% without bolus and -0.18%{+-} 1.22% with the bolus. The PBA dose calculations had an average dose difference of 0.65%{+-} 6.21% without bolus and 1.75%{+-} 5.94% with the bolus. From a clinical perspective an agreement of 5% or better between planned (calculated) and delivered (measured) dose is desired. Statistically, this was true for 99% ({+-}2{sigma}) of the dose points for three of the four cases for the PBRA dose calculations, the exception being the nose without bolus for which this was true for 89% ({+-}1.6{sigma}) of the dose points. For the retromolar trigone, with and without bolus, the PBA showed agreement of 5% or better for approximately 86% ({+-}1.5{sigma}) of the dose points. For the nose, with and without bolus, the PBA showed agreement of 5% or better for only approximately 58% ({+-}0.8{sigma}) of the dose points.Conclusions: The measured data, whose high precision makes them useful for evaluation of the accuracy of electron dose algorithms, will be made publicly available. Based on the spread in dose differences, the PBRA has at least twice the accuracy of the PBA. From a clinical perspective the PBRA accuracy is acceptable in the retromolar trigone and nose for electron therapy with and without bolus.

61 RADIATION PROTECTION AND DOSIMETRY↗

Hawthorne Nevada Deep Direct-Use Feasibility Study - Data Used for Geothermal Resource Conceptual Modeling and Power Capacity Estimates

This data submission includes several data components that were used to develop a conceptual model and power capacity-estimates of two low-temperature geothermal resources that define geothermal prospect A at Hawthorne, Nevada. Data are sourced from a combination of legacy publicly-available data and more recent data acquisition conducted by the US Navy Geothermal Program Office (2008-2013) and the Great Basin Center for Geothermal Energy at the University of Nevada, Reno (2008-2010). Data sets include compiled fluid geochemistry data, down-hole temperature logs for wells in the vicinity of prospect A, 2 meter temperature survey data, temperature-spinner logs acquired in well HWAAD-2A, fracture picks from image log data acquired in wells HWAAD-2 and HWAAD-3, and X-Ray Diffraction (XRD) analyses on cuttings from wells HWAAD-2A and HWAAD-3. These data have been reviewed for errors and inconsistencies, but it is possible that few errors could still remain. The resource conceptual model and power capacity estimates are included in the final report to the US Department of Energy, and are presented in a manuscript by Ayling and Hinz. A link to the manuscript published in Geothermics is linked below in this submission.

15 GEOTHERMAL ENERGY↗

A Compilation of Internship Reports - 2012

This compilation documents all research project undertaken by the 2012 summer Department of Energy - Workforce Development for Teachers and Scientists interns during their internship program at Brookhaven National Laboratory.

99 GENERAL AND MISCELLANEOUS↗

OpenACC acceleration for the P N – P N - 2 algorithm in Nek5000

Due to its high performance and throughput capabilities, GPU-accelerated computing is becoming a popular technology in scientific computing, in particular using programming models such as CUDA and OpenACC. The main advantage with OpenACC is that it enables to simply port codes in their ‘‘original’’ form to GPU systems through compiler directives, thus allowing an incremental approach. An OpenACC implementation is applied to the CFD code Nek5000 for simulation of incompressible flows, based on the spectral-element method. The work follows up previous implementations and focuses now on the P N - P N-2 method for the spatial discretization of the Navier–Stokes equations. Performance results of the ported code show a speed-up of up to 3.1 on multi-GPU for a polynomial order N > 11.

97 MATHEMATICS AND COMPUTING↗

Deploying and Tracking Software with NCCS Software Provisioning

The National Center for Computational Sciences (NCCS) at Oak Ridge National Laboratory has a long history of deploying ground-breaking leadership-class supercomputers for the U.S. Department of Energy. The latest in this line of supercomputers is Frontier, the first supercomputer to break the exascale barrier (1018 floating-point operations per second) on the TOP500 list. Frontier serves a wide array of scientific domains, from traditional simulation-based workloads to newer AI and Machine Learning workloads. To best serve the NCCS user community, NCCS uses Spack to deploy a comprehensive software stack of scientific software packages, providing straightforward access to these packages through Lmod Environment Modules. Maintaining a large software stack while also including multiple new compiler releases each year is a very time-consuming task. Additionally, it is not straightforward to provide a software stack alongside existing vendor-provided software such as the HPE/Cray Programming Environment (CPE), and existing CPE, Spack, and Lmod integration does not allow for multiple versions of GPU libraries such as AMD’s ROCm to be used. To address these challenges and shortcomings, NCCS has developed the NCCS Software Provisioning tool (NSP)1, a tool for deploying and monitoring software stacks on HPC systems. NSP allows NCCS to quickly and effectively provision software stacks from the ground up using template-driven recipes and configuration files. NSP is successfully deployed on Frontier and several other NCCS clusters, enabling the NCCS software team to quickly deploy software stacks for newly-released compilers, expand current software offerings, better support GPU-based software, and monitor Lmod module usage to identify unused software packages that can be removed from the software stack. In this work, we discuss the shortcomings of the previous CPE, Spack, and Lmod usage at NCCS, provide further details on the implementation and structure of NSP, then discuss the benefits that NSP provides.

Rentschler, Asa [ORNL] (ORCID:0009000597694743)↗

The Ongoing Impact of the U.S. Fast Reactor Integral Experiments Program

The creation of a large database of integral fast reactor physics experiments advanced nuclear science and technology in ways that were unachievable by less capital intensive and operationally challenging approaches. They enabled the compilation of integral physics benchmark data, validated (or not) analytical methods, and provided assurance of future rector designs The integral experiments performed at Argonne National Laboratory (ANL) represent decades of research performed to support fast reactor design and our understanding of neutronics behavior and reactor physics measurements. Experiments began in 1955 with the Zero Power Reactor No. 3 (ZPR-3) and terminated with the Zero Power Physics Reactor (ZPPR, originally the Zero Power Plutonium Reactor) in 1990 at the former ANL-West site in Idaho, which is now part of the Idaho National Laboratory (INL). Two additional critical assemblies, ZPR-6 and ZPR-9, operated at the ANL-East site in Illinois. A total of 128 fast reactor assemblies were constructed with these facilities [1]. The infrastructure and measurement capabilities are too expensive to be replicated in the modern era, making the integral database invaluable as the world pushes ahead with development of liquid metal cooled reactors.

11 NUCLEAR FUEL CYCLE AND FUEL MATERIALS↗

RELAP5-3D Developer Guidelines and Programming Practices

Our ultimate goal is to create and maintain RELAP5-3D as the best software tool available to analyze nuclear power plants. This begins with writing excellent programming and requires thorough testing. This document covers development of RELAP5-3D software, the behavior of the RELAP5-3D program that must be maintained, and code testing. RELAP5-3D must perform in a manner consistent with previous code versions with backward compatibility for the sake of the users. Thus file operations, code termination, input and output must remain consistent in form and content while adding appropriate new files, input and output as new features are developed. As computer hardware, operating systems, and other software change, RELAP5-3D must adapt and maintain performance. The code must be thoroughly tested to ensure that it continues to perform robustly on the supported platforms. The coding must be written in a consistent manner that makes the program easy to read to reduce the time and cost of development, maintenance and error resolution. The programming guidelines presented her are intended to institutionalize a consistent way of writing FORTRAN code for the RELAP5-3D computer program that will minimize errors and rework. A common format and organization of program units creates a unifying look and feel to the code. This in turn increases readability and reduces time required for maintenance, development and debugging. It also aids new programmers in reading and understanding the program. Therefore, when undertaking development of the RELAP5-3D computer program, the programmer must write computer code that follows these guidelines. This set of programming guidelines creates a framework of good programming practices, such as initialization, structured programming, and vector-friendly coding. It sets out formatting rules for lines of code, such as indentation, capitalization, spacing, etc. It creates limits on program units, such as subprograms, functions, and modules. It establishes documentation guidance on internal comments. The guidelines apply to both existing and new subprograms. They are written for both FORTRAN 77 and FORTRAN 95. The guidelines are not so rigorous as to inhibit a programmer’s unique style, but do restrict the variations in acceptable coding to create sufficient commonality that new readers will find the coding in each new subroutine familiar. It is recognized that this is a “living” document and must be updated as languages, compilers, and computer hardware and software evolve.

22 GENERAL STUDIES OF NUCLEAR REACTORS↗

The HITRAN2016 molecular spectroscopic database

This paper describes the contents of the 2016 edition of the HITRAN molecular spectroscopic compilation. The new edition replaces the previous HITRAN edition of 2012 and its updates during the intervening years. The HITRAN molecular absorption compilation is comprised of five major components: the traditional line-by-line spectroscopic parameters required for high-resolution radiative-transfer codes, infrared absorption cross-sections for molecules not yet amenable to representation in a line-by-line form, collision-induced absorption data, aerosol indices of refraction, and general tables such as partition sums that apply globally to the data. The new HITRAN is greatly extended in terms of accuracy, spectral coverage, additional absorption phenomena, added line-shape formalisms, and validity. Moreover, molecules, isotopologues, and perturbing gases have been added that address the issues of atmospheres beyond the Earth. Of considerable note, experimental IR cross-sections for almost 200 additional significant molecules have been added to the database.

Gordon, I. E.↗

Early Experiences Porting the NAMD and VMD Molecular Simulation and Analysis Software to GPU-Accelerated OpenPOWER Platforms, In: ISC High Performance 2016: High Performance Computing

All-atom molecular dynamics simulations of biomolecules provide a powerful tool for exploring the structure and dynamics of large protein complexes within realistic cellular environments. Unfortunately, such simulations are extremely demanding in terms of their computational requirements, and they present many challenges in terms of preparation, simulation methodology, and analysis and visualization of results. We describe our early experiences porting the popular molecular dynamics simulation program NAMD and the simulation preparation, analysis, and visualization tool VMD to GPU-accelerated OpenPOWER hardware platforms. We report our experiences with compiler-provided autovectorization and compare with hand-coded vector intrinsics for the POWER8 CPU. We explore the performance benefits obtained from unique POWER8 architectural features such as 8-way SMT and its value for particular molecular modeling tasks. Finally, we evaluate the performance of several GPU-accelerated molecular modeling kernels and relate them to other hardware platforms.

Computer Science↗

Emulating Multiple Inheritance in Fortran 2003/2008

Although the high-performance computing (HPC) community increasingly embraces object-oriented programming (OOP), most HPC OOP projects employ the C++ programming language. Until recently, Fortran programmers interested in mining the benefits of OOP had to emulate OOP in Fortran 90/95. The advent of widespread compiler support for Fortran 2003 now facilitates explicitly constructing object-oriented class hierarchies via inheritance and leveraging related class behaviors such as dynamic polymorphism. Although C++ allows a class to inherit from multiple parent classes, Fortran and several other OOP languages restrict or prohibit explicit multiple inheritance relationships in order to circumvent several pitfalls associated with them. Nonetheless, what appears as an intrinsic feature in one language can be modeled as a user-constructed design pattern in another language. The present paper demonstrates how to apply the facade structural design pattern to support a multiple inheritance class relationship in Fortran 2003. The design unleashes the power of the associated class relationships for modeling complicated data structures yet avoids the ambiguities that plague some multiple inheritance scenarios.

97 MATHEMATICS AND COMPUTING↗