Two programs for the factor analysis of geologic and remote-sensing data
Fortran IV programs for factor analysis of geologic and remote sensing data
SEARCH · Engineering Papers
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.
Fortran IV programs for factor analysis of geologic and remote sensing data
Fortran IV program for calculating orbital heating rates to various-shaped satellites in general trajectory
FORTRAN program for B number computation applied to solid state physics
NASA JPL has been creating a code in FORTRAN called KINETICS to model the chemistry of planetary atmospheres. Recently there has been an effort to introduce Message Passing Interface (MPI) into the code so as to cut down the run time of the program. There has been some implementation of MPI into KINETICS; however, the code could still be more efficient than it currently is. One way to increase efficiency is to send only certain variables to all the processes when an MPI subroutine is called and to gather only certain variables when the subroutine is finished. Therefore, all the variables that are used in three of the main subroutines needed to be investigated. Because of the sheer amount of code that there is to comb through this task was given as a ten-week project. I have been able to create flowcharts outlining the subroutines, common blocks, and functions used within the three main subroutines. From these flowcharts I created tables outlining the variables used in each block and important information about each. All this information will be used to determine how to run MPI in KINETICS in the most efficient way possible.
Copernicus is a spacecraft trajectory design and optimization application developed at the NASA Johnson Space Center. Copernicus is written in Fortran and uses many features of the latest language standards. The tool is used for a wide range of projects at NASA, including the upcoming Artemis missions to flight test the Orion spacecraft and then return humans to the Moon. This presentation gives a brief overview of the software, its history, how it was designed, and how it is used.
An approach for modernizing legacy scientific software, based on the new features of Fortran 90/95, is presented.
Adaptive mesh refinement (AMR) calculations carried out on structured meshes play an exceedingly important role in several areas of science and engineering. A strategy for using Fortran 90 in an object-oriented fashion is presented. This permits AMR applications to be expressed in terms of familiar abstractions that are natural to the process of solving AMR hierarchies. The OpenMP features that are useful for parallel processing of AMR hierarchies in a load balanced fashion on multiprocessors is described.
- LS-DYNA Explicit Finite Element Analysis software and CADPROG Internal Ballistic Analysis code are integrated as a single modeling tool to analyze pyro-mechanical devices. - Combining these two codes allows the ballistic calculations to be performed without modeling the propellant in an FEA mesh. At each LS-DYNA time step, CADPROG is analytically run using the kinematic data (stroke, velocity, chamber volume) fed back from the LS-DYNA simulation. Calculated pressure is then applied to a piston or any applicable surface mesh in LS-DYNA model interactively. -All external loads such as friction, damping loads, assisting/resisting loads, locking/unlocking loads are modeled in LS-DYNA and coupled with pressure loads from CADPROG to create a fully defined equation of motion -Both codes are written in Fortran 77. CADPROG is inserted in LS-DYNA source code as a user-defined subroutine and re-compiled to generate a custom executable.
LS-DYNA Explicit Finite Element Analysis software and CADPROG Internal Ballistic Analysis code are integrated as a single modeling tool to analyze pyro-mechanical devices. Coupling these two codes allows the ballistic calculations to be performed without modeling the propellant in an FEA mesh. At each LS-DYNA time step, CADPROG is run analytically using the kinematic data (stroke, velocity, chamber volume) fed back from the LS-DYNA simulation. The calculated pressure is then applied to a piston or any applicable surface mesh in LS-DYNA model interactively. All external loads such as friction, damping loads, assisting/resisting loads, locking/unlocking loads are modeled in LS-DYNA and coupled with pressure loads from CADPROG to create a fully defined equation of motion Both codes are written in Fortran 77. CADPROG is integrated in the LS-DYNA source code as a user-defined subroutine and recompiled to generate a custom executable.
INSTANT is the INL's next generation neutron transport solver to support high-fidelity multi-physics reactor simulation INSTANT is in continuous development to extend its capability Code is designed to take full advantage of middle to large cluster (10-1000 processors) Code is designed to focus on method adaptation while also mesh adaptation will be possible. It utilizes the most modern computing techniques to generate a neutronics tool of full-core transport calculations for reactor analysis and design. It can perform calculations on unstructured 2D/3D triangular, hexagonal and Cartesian geometries. Calculations can be easily extended to more geometries because of the independent mesh framework coded with the model Fortran. This code has a multigroup solver with thermal rebalance and Chebyshev acceleration. It employs second-order PN and Hybrid Finite Element method (PNHFEM) discretization scheme. Three different in-group solvers - preconditioned Conjugate Gradient (CG) method, preconditioned Generalized Minimal Residual Method (GMRES) and Red-Black iteration - have been implemented and parallelized with the spatial domain decomposition in the code. The input is managed with extensible markup language (XML) format. 3D variables including the flux distributions are outputted into VTK files, which can be visualized by tools such as VisIt and ParaView. An extension of the code named INSTANTHPS provides the capability to perform 3D heterogeneous transport calculations within fuel pins. C5G7 is an OECD/NEA benchmark problem created to test the ability of modern deterministic transport methods and codes to treat reactor core problems without spatial homogenization. This benchmark problem had been widely analyzed with various code packages. In this transaction, results of the applying the INSTANT-HPS code to the C5G7 problem are summarized.
CNKemu is a kernel-based system for the 9k variant of the Plan 9 kernel. It is designed to provide transparent binary support for programs compiled for IBM's Compute Node Kernel (CNK) on the Blue Gene series of supercomputers. This support allows users to build applications with the standard Blue Gene toolchain, including C++ and Fortran compilers. While the CNK is not Linux, IBM designed the CNK so that the user interface has much in common with the Linux 2.0 system call interface. The Plan 9 CNK emulator hence provides the foundation of kernel-based Linux system call support on Plan 9. In this paper we discuss cnkemu's implementation and some of its more interesting features, such as the ability to easily intermix Plan 9 and Linux system calls.
PFLOTRAN, a next-generation reactive flow and transport code for modeling subsurface processes, has been designed from the ground up to run efficiently on machines ranging from leadership-class supercomputers to laptops. Based on an object-oriented design, the code is easily extensible to incorporate additional processes. It can interface seamlessly with Fortran 9X, C and C++ codes. Domain decomposition parallelism is employed, with the PETSc parallel framework used to manage parallel solvers, data structures and communication. Features of the code include a modular input file, implementation of high-performance I/O using parallel HDF5, ability to perform multiple realization simulations with multiple processors per realization in a seamless manner, and multiple modes for multiphase flow and multicomponent geochemical transport. Chemical reactions currently implemented in the code include homogeneous aqueous complexing reactions and heterogeneous mineral precipitation/dissolution, ion exchange, surface complexation and a multirate kinetic sorption model. PFLOTRAN has demonstrated petascale performance using 2{sup 17} processor cores with over 2 billion degrees of freedom. Accomplishments achieved to date include applications to the Hanford 300 Area and modeling CO{sub 2} sequestration in deep geologic formations.
One of the current challenges in underwater acoustic array signal processing is the detection of quiet targets in the presence of noise. In order to enable robust detection, one of the key processing steps requires data and replica whitening. This, in turn, involves the eigen-decomposition of the sample spectral matrix, Cx = 1/K xKX(k)XH(k) where X(k) denotes a single frequency snapshot with an element for each element of the array. By employing the singular value decomposition (SVD) method, the eigenvectors and eigenvalues can be determined directly from the data without computing the sample covariance matrix, reducing the computational requirements for a given level of accuracy (van Trees, Optimum Array Processing). (Recall that the SVD of a complex matrix A involves determining V, , and U such that A = U VH where U and V are orthonormal and is a positive, real, diagonal matrix containing the singular values of A. U and V are the eigenvectors of AAH and AHA, respectively, while the singular values are the square roots of the eigenvalues of AAH.) Because it is desirable to be able to compute these quantities in real time, an efficient technique for computing the SVD is vital. In addition, emerging multicore processors like graphical processing units (GPUs) are bringing parallel processing capabilities to an ever increasing number of users. Since the computational tasks involved in array signal processing are well suited for parallelization, it is expected that these computations will be implemented using GPUs as soon as users have the necessary computational tools available to them. Thus, it is important to have an SVD algorithm that is suitable for these processors. This work explores the effectiveness of two different parallel SVD implementations on an NVIDIA Tesla C2050 GPU (14 multiprocessors, 32 cores per multiprocessor, 1.15 GHz clock - peed). The first algorithm is based on a two-step algorithm which bidiagonalizes the matrix using Householder transformations, and then diagonalizes the intermediate bidiagonal matrix through implicit QR shifts. This is similar to that implemented for real matrices by Lahabar and Narayanan ("Singular Value Decomposition on GPU using CUDA", IEEE International Parallel Distributed Processing Symposium 2009). The implementation is done in a hybrid manner, with the bidiagonalization stage done using the GPU while the diagonalization stage is done using the CPU, with the GPU used to update the U and V matrices. The second algorithm is based on a one-sided Jacobi scheme utilizing a sequence of pair-wise column orthogonalizations such that A is replaced by AV until the resulting matrix is sufficiently orthogonal (that is, equal to U ). V is obtained from the sequence of orthogonalizations, while can be found from the square root of the diagonal elements of AH A and, once is known, U can be found from column scaling the resulting matrix. These implementations utilize CUDA Fortran and NVIDIA's CUB LAS library. The primary goal of this study is to quantify the comparative performance of these two techniques against themselves and other standard implementations (for example, MATLAB). Considering that there is significant overhead associated with transferring data to the GPU and with synchronization between the GPU and the host CPU, it is also important to understand when it is worthwhile to use the GPU in terms of the matrix size and number of concurrent SVDs to be calculated.
In this work genetic algorithm was proposed to solve fuel loading pattern optimization problem in thorium fueled heavy water reactor. The objective function of optimization was to maximize the conversion ratio and minimize power peaking factor. Those objectives were simultaneously optimized using non-dominated Pareto-based population ranking optimal method. Members of non-dominated population were assigned selection probabilities based on their rankings in a manner similar to Baker's single criterion ranking selection procedure. A selected non-dominated member was bred through simple mutation or one-point crossover process to produce a new member. The genetic algorithm program was developed in FORTRAN 90 while neutronic calculation and analysis was done by COREBN code, a module of core burn-up calculation for SRAC. (authors)
MPACT (Michigan Parallel Characteristics Transport Code) is a new reactor analysis tool. It is being developed by students and research staff at the University of Michigan to be used for an advanced pin-resolved transport capability within VERA (Virtual Environment for Reactor Analysis). VERA is the end-user reactor simulation tool being produced by the Consortium for the Advanced Simulation of Light Water Reactors (CASL). The MPACT development project is itself unique for the way it is changing how students do research to achieve the instructional and research goals of an academic institution, while providing immediate value to industry. The MPACT code makes use of modern lean/agile software processes and extensive testing to maintain a level of productivity and quality required by CASL. MPACT's design relies heavily on object-oriented programming concepts and design patterns and is programmed in Fortran 2003. These designs are explained and illustrated as to how they can be readily extended to incorporate new capabilities and research ideas in support of academic research objectives. The transport methods currently implemented in MPACT include the 2-D and 3-D method of characteristics (MOC) and 2-D and 3-D method of collision direction probabilities (CDP). For the cross section resonance treatment, presently the subgroup method and the new embedded self-shielding method (ESSM) are implemented within MPACT. (authors)
To aid in WIPP PA calculations, the US DOE has undertaken a broad modernization effort that includes: 1) updating the hardware and operating system used; 2) moving the current PA (performance assessment) codes to the new system; and 3) adding a database to store results essential for the analysis of assessments; 4) integrating run-control scripts with a web site to facilitate monitoring of performance assessment calculations; and 5) adding new capabilities via implementation of the PFLOTRAN code to replace multiple codes currently in use. The majority of codes were migrated from an Open VMS/Alpha processor system to a Unix/Intel processor system. Most codes were upgraded to use the dynamic allocation features of Fortran 95 and double precision variables. A few codes were migrated from Linux/Intel systems to the Unix/Intel systems and these code required nearly no changes to the source code. All of the migrated codes were re-qualified under Sandia's WIPP QA program. The implementation of some of the conceptual models using PFLOTRAN is being driven by the expectation that changes in the configuration of the repository will require a 3-dimensional representation of the mined areas. Symmetry in the current configuration of the repository made a 2-D representation adequate. PFLOTRAN is an open-source, state-of-the-art massively parallel subsurface flow and reactive transport code. A version of this code is being developed specifically for WIPP PA in order to maintain the capabilities of the current flow and transport codes, as well as add the capabilities of a parallel code that will treat additional processes, including: 1) miscible multi-phase flow; and 2) heat transfer. PFLOTRAN will replace the two codes (i.e. BRAGFLO and NUTS) currently used for flow and transport calculations, simplifying the PA code structure and speeding up calculations by simultaneously solving for flow and transport with a single code. To ensure that PFLOTRAN reproduces the results of the current code suite, existing test cases have been used for verification purposes. Additional test cases have been developed to establish the new capabilities for WIPP PA. The result of the modernization effort will be a state-of-the-art subsurface flow and transport capability that will serve WIPP PA into the future. (authors)
In 2006, NVIDIA Corporation introduced the Computer Unified Device Architecture (CUDA) for C, C++, and Fortran programming languages. The CUDA parallel computing platform uses the Graphics Processing Unit (GPU) of NVIDIA graphics card, and it is designed for parallel computations. In these computations, the same algorithms are executed on the data in parallel. The GPU contains many Streaming Multiprocessors (SM) that can independently execute blocks of threads. A thread is a sequence of serial programmed instructions. The SM executes threads in groups of 32 and a group of 32 threads is called warp. The threads within a block can be synchronized and have access to a shared memory that is visible only to them. Conversely, blocks of threads cannot be synchronized and have access only to the global memory of the graphics card. This memory is called device memory and is independent of the host memory controlled by the Central Processing Unit (CPU). A single thread has access to a local memory (register) that is not visible to any other thread. The part of the program that is executed on the graphics card is called kernel. Each thread of the kernel has a unique identification index that is accessible by the in-built variable threadIdx; the latter is a 3-component vector. A threads block can contain up to 1024 threads. Blocks of threads have a unique identification index that is accessible by the in-built variable blockIdx; the latter is a 3-component vector. The in-built variable blockDim contains the number of threads per block; this variable is a 3-component vector. Threads and blocks represent different levels of parallelism; a kernel is executed as a grid of blocks of threads. Figure 1 illustrates a grid of thread blocks for a GPU with 2 SM. A SM can execute multiple blocks of threads in parallel; a block of threads is executed on a single SM. A GPU can execute multiple kernels concurrently. This work has used the Quadro M5000 graphics card with the following technical specifications: - 2048 cores with 861 MHz frequency, - 16 streaming multiprocessors, - 5.2 trillion transistors, - 8.2 Gb device memory, - 64 kb register memory (per thread), - 48 kb shared memory (per block) - 211.6 GB/s memory bandwidth, and - 3.5 GFLOPS floating point performance.
Knowledge of the plasma fluxes at geosynchronous orbit is important to both scientific and operational investigations. We present a new empirical model of the ion flux and the electron flux at geosynchronous orbit (GEO) in the energy range ~1 eV to ~40 keV. The model is based on a total of 82 satellite-years of observations from the Magnetospheric Plasma Analyzer instruments on Los Alamos National Laboratory satellites at GEO. These data are assigned to a fixed grid of 24 local-times and 40 energies, at all possible values of Kp. Bi-linear interpolation is used between grid points to provide the ion flux and the electron flux values at any energy and local-time, and for given values of geomagnetic activity (proxied by the 3-hour Kp index), and also for given values of solar activity (proxied by the daily F10.7 index). Initial comparison of the electron flux from the model with data from a Compact Environmental Anomaly Sensor II (CEASE-II), also located at geosynchronous orbit, indicate a good match during both quiet and disturbed periods. The model is available for distribution as a FORTRAN code that can be modified to suit user-requirements.