Results for “Fortran” — Page 28

DOE OSTI2024

RGM: Random Geological Model Generation Package

This Fortran code is to accompany a manuscript to be submitted to Computers & Geosciences, a high-impact, peer-reviewed journal in computer methods for geosciences research. This Fortran code focuses on generation of synthetic geological models using a multi-randomization strategy. Generating high-fidelity synthetic geological models, including realistic seismic reflector migration images, faults, salt bodies, and relative geological time images, is the key for many supervised machine learning methods that aim to delineate faults and other geological properties of interest from seismic migration images. Our package contains two major functionalities: generating 2D synthetic random geological models and generating 3D synthetic random geological models. In each step of the generation process, we set random values for key properties of a geological model to improve the fidelity of the resulting geological model. The package also includes example codes on how to use the random geological model generation subroutines. We name this package RGM – Random Geological Model generation package.

Gao, Kai↗

DOE OSTI2026

fpm-find v0.1.0

This program searches the fortran-lang community's package index (https://github.com/fortran-lang/webpage/blob/main/data/package_index.yml). The program is designed for use as a Fortran Package Manager (fpm) plugin.

Rouson, Damian [Lawrence Berkeley National Laborat↗

DOE OSTI2024

Equilipy: a python package for calculating phase equilibria

The CALPHAD (CALculation of PHAse Diagram) approach (Nigel Saunders & Miodownik, 1998) provides predictions for thermodynamically stable phases in multicomponent-multiphase materials across a wide range of temperatures. Consequently, the CALPHAD calculations became an essential tool in materials and process design (Luo, 2015). Such design tasks frequently require navigating a high-dimensional space due to multiple components involved in the system. This increasing complexity demands high-throughput CALPHAD calculations, especially in the rapidly evolving field of alloy design. In response to the need, we developed Equilipy an open-source Python package designed for calculating phase equilibria of multicomponent-multiphase systems. Equilipy is specifically tailored for high-throughput CALPHAD calculations, offering parallel computations across multiple processors and nodes with the given NPT input conditions namely elemental compositions (N), pressure (P), and temperature (T). Equilipy utilizes the program structure and Gibbs energy functions from the Fortran-based program, Thermochimica (Piro et al., 2013), with incorporating a new Gibbs energy minimization algorithm. This algorithm, originally developed by Capitani and Brown in 1987 (Capitani & Brown, 1987), has been revised and implemented to enhance the stability and performance of calculations. The Fortran codes are precompiled and interfaced with Python via F2PY, ensuring high computation speed. Benchmark tests shown in Figure 1 demonstrate that Equilipy’s computation speed is comparable to those of established commercial software, TC-Python and PanPython. This result highlights its efficiency and potential applications in various scientific and industrial fields.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2010

Shavano C++ Conversion Proposal

The following document proposes a three-year plan for conversion of the Shavano project code base from augmented Fortran to standard C++. The Shavano project has been developing physics applications since about 1995, using the homegrown AJAX backplane that augments Fortran 77 to provide a type of object-oriented programming. This unconventional approach has provided some advantages to the project over the years; however, as time progresses, its disadvantages have become more pronounced: (1) Most AJAX capabilities can now be done (and done better) using modem languages and standard tool; (2) Modem software tools, such as static code analyzers, cannot be used with AJAX; (3) Shavano developers are hard to find/train/retain; (4) AJAX maintainers are hard to find/train/retain; (5) Student or faculty collaboration is rare; (6) Third-party library developers are often unable/unwilling to integrate their libraries into Shavano code, leaving the task to the core team; (7) Mastery of AJAX-based programming is a nontransferable skill. To address these problems, conversion of the Shavano code base to C++ has been proposed. This proposal builds on an earlier study on C++ conversion, done in March-July 2010 (see Appendix A). This study anticipated a short conversion process: roughly one year for the main work, with cleanup to be done afterward as time allowed. Unfortunately, we discovered that some of our initial assumptions were false, and the scope of the project would be much greater than we had expected. Therefore, in this revision we have increased the estimated project length to approximately three years.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2014

User's Manual of the TOUGH+ Core Code v1.5: A General-Purpose Simulator of Non-Isothermal Flow and Transport through Porous and Fractured Media

TOUGH+ v1.5 is a numerical code for the simulation of multi-phase, multi-component flow and transport of mass and heat through porous and fractured media, and represents the third update of the code since its first release [Moridis et al., 2008]. TOUGH+ is a successor to the TOUGH2 [Pruess et al., 1991] family of codes for multi-component, multiphase fluid and heat flow developed at the Lawrence Berkeley National Laboratory. It is written in standard FORTRAN 95/2003, and can be run on any computational platform (workstations, PC, Macintosh). TOUGH+ v1.5 employs dynamic memory allocation, thus minimizing storage requirements. It has a completely modular structure, follows the tenets of Object-Oriented Programming (OOP), and involves the advanced features of FORTRAN 95/2003, i.e., modules, derived data types, the use of pointers, lists and trees, data encapsulation, defined operators and assignments, operator extension and overloading, use of generic procedures, and maximum use of the powerful intrinsic vector and matrix processing operations. This report presents the core TOUGH+ v1.5 code, i.e., the part of the code that is common to all its applications. It provides a description of the underlying physics and thermodynamics of non-isothermal flow, of the mathematical and numerical approaches, as well as a detailed explanation of the general (common to all applications) input requirements, options, capabilities and output specifications. The core code cannot run by itself: it needs to be coupled with the code for the specific TOUGH+ application option that describes a particular type of problem. The additional input requirements specific to a particular TOUGH+ application options and related illustrative examples can be found in the corresponding User’s Manual.

54 ENVIRONMENTAL SCIENCES↗

DOE OSTI2015

PFLOTRAN User Manual: A Massively Parallel Reactive Flow and Transport Model for Describing Surface and Subsurface Processes

PFLOTRAN solves a system of generally nonlinear partial differential equations describing multi-phase, multicomponent and multiscale reactive flow and transport in porous materials. The code is designed to run on massively parallel computing architectures as well as workstations and laptops (e.g. Hammond et al., 2011). Parallelization is achieved through domain decomposition using the PETSc (Portable Extensible Toolkit for Scientific Computation) libraries for the parallelization framework (Balay et al., 1997). PFLOTRAN has been developed from the ground up for parallel scalability and has been run on up to 218 processor cores with problem sizes up to 2 billion degrees of freedom. Written in object oriented Fortran 90, the code requires the latest compilers compatible with Fortran 2003. At the time of this writing this requires gcc 4.7.x, Intel 12.1.x and PGC compilers. As a requirement of running problems with a large number of degrees of freedom, PFLOTRAN allows reading input data that is too large to fit into memory allotted to a single processor core. The current limitation to the problem size PFLOTRAN can handle is the limitation of the HDF5 file format used for parallel IO to 32 bit integers. Noting that 2 32 = 4; 294; 967; 296, this gives an estimate of the maximum problem size that can be currently run with PFLOTRAN. Hopefully this limitation will be remedied in the near future.

58 GEOSCIENCES↗

DOE OSTI2013

PETSc Users Manual (Rev. 3.3)

This manual describes the use of PETSc for the numerical solution of partial differential equations and related problems on high-performance computers. The Portable, Extensible Toolkit for Scientific Computation (PETSc) is a suite of data structures and routines that provide the building blocks for the implementation of large-scale application codes on parallel (and serial) computers. PETSc uses the MPI standard for all message-passing communication. PETSc includes an expanding suite of parallel linear, nonlinear equation solvers and time integrators that may be used in application codes written in Fortran, C, C++, Python, and MATLAB (sequential). PETSc provides many of the mechanisms needed within parallel application codes, such as parallel matrix and vector assembly routines. The library is organized hierarchically, enabling users to employ the level of abstraction that is most appropriate for a particular problem. By using techniques of object-oriented programming, PETSc provides enormous flexibility for users. PETSc is a sophisticated set of software tools; as such, for some users it initially has a much steeper learning curve than a simple subroutine library. In particular, for individuals without some computer science background, experience programming in C, C++ or Fortran and experience using a debugger such as gdb or dbx, it may require a significant amount of time to take full advantage of the features that enable efficient software use. However, the power of the PETSc design and the algorithms it incorporates may make the efficient implementation of many application codes simpler than “rolling them” yourself; For many tasks a package such as MATLAB is often the best tool; PETSc is not intended for the classes of problems for which effective MATLAB code can be written. PETSc also has a MATLAB interface, so portions of your code can be written in MATLAB to “try out” the PETSc solvers. The resulting code will not be scalable however because currently MATLAB is inherently not scalable; and PETSc should not be used to attempt to provide a “parallel linear solver” in an otherwise sequential code. Certainly all parts of a previously sequential code need not be parallelized but the matrix generation portion must be parallelized to expect any kind of reasonable performance. Do not expect to generate your matrix sequentially and then “use PETSc” to solve the linear system in parallel. Since PETSc is under continued development, small changes in usage and calling sequences of routines will occur. PETSc is supported; see the web site http://www.mcs.anl.gov/petsc for information on contacting support. A http://www.mcs.anl.gov/petsc/publications may be found a list of publications and web sites that feature work involving PETSc. We welcome any reports of corrections for this document.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2014

PETSc Users Manual (Rev. 3.4)

This manual describes the use of PETSc for the numerical solution of partial differential equations and related problems on high-performance computers. The Portable, Extensible Toolkit for Scientific Computation (PETSc) is a suite of data structures and routines that provide the building blocks for the implementation of large-scale application codes on parallel (and serial) computers. PETSc uses the MPI standard for all message-passing communication. PETSc includes an expanding suite of parallel linear, nonlinear equation solvers and time integrators that may be used in application codes written in Fortran, C, C++, Python, and MATLAB (sequential). PETSc provides many of the mechanisms needed within parallel application codes, such as parallel matrix and vector assembly routines. The library is organized hierarchically, enabling users to employ the level of abstraction that is most appropriate for a particular problem. By using techniques of object-oriented programming, PETSc provides enormous flexibility for users. PETSc is a sophisticated set of software tools; as such, for some users it initially has a much steeper learning curve than a simple subroutine library. In particular, for individuals without some computer science background, experience programming in C, C++ or Fortran and experience using a debugger such as gdb or dbx, it may require a significant amount of time to take full advantage of the features that enable efficient software use. However, the power of the PETSc design and the algorithms it incorporates may make the efficient implementation of many application codes simpler than “rolling them” yourself; For many tasks a package such as MATLAB is often the best tool; PETSc is not intended for the classes of problems for which effective MATLAB code can be written. PETSc also has a MATLAB interface, so portions of your code can be written in MATLAB to “try out” the PETSc solvers. The resulting code will not be scalable however because currently MATLAB is inherently not scalable; and PETSc should not be used to attempt to provide a “parallel linear solver” in an otherwise sequential code. Certainly all parts of a previously sequential code need not be parallelized but the matrix generation portion must be parallelized to expect any kind of reasonable performance. Do not expect to generate your matrix sequentially and then “use PETSc” to solve the linear system in parallel. Since PETSc is under continued development, small changes in usage and calling sequences of routines will occur. PETSc is supported; see the web site http://www.mcs.anl.gov/petsc for information on contacting support. A http://www.mcs.anl.gov/petsc/publications may be found a list of publications and web sites that feature work involving PETSc. We welcome any reports of corrections for this document.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2014

PETSc Users Manual (Rev. 3.5)

This manual describes the use of PETSc for the numerical solution of partial differential equations and related problems on high-performance computers. The Portable, Extensible Toolkit for Scientific Computation (PETSc) is a suite of data structures and routines that provide the building blocks for the implementation of large-scale application codes on parallel (and serial) computers. PETSc uses the MPI standard for all message-passing communication. PETSc includes an expanding suite of parallel linear, nonlinear equation solvers and time integrators that may be used in application codes written in Fortran, C, C++, Python, and MATLAB (sequential). PETSc provides many of the mechanisms needed within parallel application codes, such as parallel matrix and vector assembly routines. The library is organized hierarchically, enabling users to employ the level of abstraction that is most appropriate for a particular problem. By using techniques of object-oriented programming, PETSc provides enormous flexibility for users. PETSc is a sophisticated set of software tools; as such, for some users it initially has a much steeper learning curve than a simple subroutine library. In particular, for individuals without some computer science background, experience programming in C, C++ or Fortran and experience using a debugger such as gdb or dbx, it may require a significant amount of time to take full advantage of the features that enable efficient software use. However, the power of the PETSc design and the algorithms it incorporates may make the efficient implementation of many application codes simpler than “rolling them” yourself. ;For many tasks a package such as MATLAB is often the best tool; PETSc is not intended for the classes of problems for which effective MATLAB code can be written. PETSc also has a MATLAB interface, so portions of your code can be written in MATLAB to “try out” the PETSc solvers. The resulting code will not be scalable however because currently MATLAB is inherently not scalable; and PETSc should not be used to attempt to provide a “parallel linear solver” in an otherwise sequential code. Certainly all parts of a previously sequential code need not be parallelized but the matrix generation portion must be parallelized to expect any kind of reasonable performance. Do not expect to generate your matrix sequentially and then “use PETSc” to solve the linear system in parallel. Since PETSc is under continued development, small changes in usage and calling sequences of routines will occur. PETSc is supported; see the web site http://www.mcs.anl.gov/petsc for information on contacting support. A http://www.mcs.anl.gov/petsc/publications may be found a list of publications and web sites that feature work involving PETSc. We welcome any reports of corrections for this document.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2015

New Routes for the Production of Fission Products and Their Separation from the Source Material for the Development of Realistic Nuclear Forensic Debris

In order to fully characterize the NIF neutron spectrum, SAND-II-SNL software was requested/received from the Radiation Safety Information Computational Center. The software is designed to determine the neutron energy spectrum through analysis of experimental activation data. However, given that the source code was developed in Sparcstation 10, it is not compatible with current version of FORTRAN. Accounts have been established through the Lawrence Livermore National Laboratory’s High Performance Computing in order to access different compiles for FORTRAN (e.g. pgf77, pgf90). Additionally, several of the subroutines included in the SAND-II-SNL package have required debugging efforts to allow for proper compiling of the code.

37 INORGANIC, ORGANIC, PHYSICAL, AND ANALYTICAL CH↗

DOE OSTI2017

Supplement to the NUBOW-3D Manual

The NUBOW-3D code (NUBOW) developed in 1978 is a custom FORTRAN analysis code that models the complex mechanical interaction of the fuel assemblies and the core restraint system in response to the effects of thermal expansion and irradiation swelling and creep. NUBOW-3D models the fuel assembly ducts as beams with springs representing the contact between ducts. The core temperature profile and neutron flux profiles are provided at various times during the planned operation of the reactor. NUBOW then calculates the changing shapes of the fuel assemblies and their equilibrium positions within the core restraints. An optional post-processing step calculates the reactivity changes based on new positions of the fuel assemblies using input displacement reactivity WORTHS. Understanding this reactivity change is a key feature to the inherent safety of a fast reactor core. NUBOW was developed to support the design of limited free bow core restraint systems. The NUBOW software was modified in 1987 but the documentation of the upgrades was not completed due to abrupt funding cuts. In the last few years, the software has been ported to a Windows platform using a current FORTRAN compiler and additional changes have been made including consolidating the code to a single executable. While the original NUBOW manual [1] written in 1978 provides an excellent description of the code and input parameters, it lacks the additional features added in the upgrades and in some cases describes features that are no longer operable. This report attempts to bridge the information gap between the original manual and the current state of the software.

11 NUCLEAR FUEL CYCLE AND FUEL MATERIALS↗

DOE OSTI2019

Converting the MCNP Runtape to HDF5

The current runtape in MCNP is a Fortran unformatted IO dump of approximately 800 variables used for restarting an MCNP simulation. This format has a number of technical issues for those who interact with it. First, Fortran unformatted IO is not guaranteed to be portable. As a result, a runtape generated on one machine is not necessarily readable on another. Second, for users who wish to extract data from the runtape, there is no simple approach. It is impossible to extract one variable without knowing the size and position of every other one. Finally, the runtape itself is not backwards compatible such that a future version of MCNP could open it. Users are expected to keep around versions of MCNP that are compatible with saved runtapes.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2019

The Development of the Generalized Spallation Model [Thesis]

The generalized spallation model (GSM) is a general spallation physics event generator with a physics-rich history dating back to the early 1970s during the development of the CEM. GSM estimates the outcome of high-energy hadron-nucleus and nucleus-nucleus collisions, where collision energies often exceed hundreds of MeV. Such a collision may include a neutron incident on carbon, for example. The thesis presented here outlines the continued development and modernization of GSM, whereby it was migrated from a legacy Fortran code to utilize an advanced and modern Fortran architecture. Verification and validation of GSM also took place throughout the continued development of GSM. The results of this work have transformed GSM into a highly modern and powerful event generator, where numerous benefits have been fostered and precipitated, including but not limited to portability, modularization, flexibility, robustness, and scalability. GSM is a robust and well developed software library that clients and end-users may confidently use, within the scope outlined here, as a result of this work.

73 NUCLEAR PHYSICS AND RADIATION PHYSICS↗

DOE OSTI2020

PETSc Users Manual (Rev. 3.13)

This manual describes the use of PETSc for the numerical solution of partial differential equations and related problems on high-performance computers. The Portable, Extensible Toolkit for Scientific Computation (PETSc) is a suite of data structures and routines that provide the building blocks for the implementation of large-scale application codes on parallel (and serial) computers. PETSc uses the MPI standard for all message-passing communication. PETSc includes an expanding suite of parallel linear solvers, nonlinear solvers, and time integrators that may be used in application codes written in Fortran, C, C++, and Python. PETSc provides many of the mechanisms needed within parallel application codes, such as parallel matrix and vector assembly routines. The library is organized hierarchically, enabling users to employ the level of abstraction that is most appropriate for a particular problem. By using techniques of object-oriented programming, PETSc provides enormous flexibility for users. PETSc is a sophisticated set of software tools; as such, for some users it initially has a much steeper learning curve than a simple subroutine library. In particular, for individuals without some computer science background, experience programming in C, C++, python, or Fortran and experience using a debugger such as gdb or dbx, it may require a significant amount of time to take full advantage of the features that enable efficient software use. However, the power of the PETSc design and the algorithms it incorporates may make the efficient implementation of many application codes simpler than \rolling them" yourself.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2020

Coupling of CTF and TRANSFORM using the Functional Mockup Interface

An in-memory coupling between the sub-channel thermal hydraulics code COBRA-TF (CTF), which is included in the Virtual Environment for Reactor Applications (VERA), and the systems code Transient Simulation Framework of Reconfigurable Models (TRANSFORM) was developed in this work. Data exchange is accomplished by using the Functional Mock-Up Interface (FMI), an open standard for coupling dynamic systems models together. The FMI-based coupling necessitated the development of a novel FORTRAN wrapper for communicating with Functional Mock-Up Units. This wrapper will facilitate future FMI-based code couplings with other FORTRAN-based programs. CTF-TRANSFORM is exercised on a simplified Molten Salt Reactor Experiment (MSRE) model in steady-state and transient configurations. The coupled CTF-TRANSFORM model is shown to predict core temperature deltas similar to those available in historical MSRE operational data and is shown to be robust to fast power transients.The coupling paves the way to performing sensitivity and design studies impossible with VERA/CTF alone, in which secondary and tertiary loop operating conditions and design parameters may be perturbed and their impact on the core operating conditions studied.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2021

Flibcpp User Manual

Flibcpp uses SWIG-Fortran to generate native Fortran-2003 interfaces to efficient and robust algorithms and data containers implemented in the C++ standard library.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2023

PETSc/TAO Users Manual (Rev. 3.19)

This manual describes the use of the Portable, Extensible Toolkit for Scientific Computation (PETSc) and the Toolkit for Advanced Optimization (TAO) for the numerical solution of partial differential equations and related problems on high-performance computers. PETSc/TAO is a suite of data structures and routines that provide the building blocks for the implementation of large-scale application codes on parallel (and serial) computers. PETSc uses the MPI standard for all distributed memory communication. PETSc/TAO includes a large suite of parallel linear solvers, nonlinear solvers, time integrators, and opti mization that may be used in application codes written in Fortran, C, C++, and Python (via petsc4py; see Getting Started). PETSc provides many of the mechanisms needed within parallel application codes, such as parallel matrix and vector assembly routines. The library is organized hierarchically, enabling users to employ the level of abstraction that is most appropriate for a particular problem. By using techniques of object-oriented programming, PETSc provides enormous flexibility for users. PETSc is a sophisticated set of software tools; as such, for some users it initially has a much steeper learning curve than packages such as MATLAB or a simple subroutine library. In particular, for individuals without some computer science background, experience programming in C, C++, python, or Fortran and experience using a debugger such as gdb or lldb, it may require a significant amount of time to take full advantage of the features that enable efficient software use. However, the power of the PETSc design and the algorithms it incorporates may make the efficient implementation of many application codes simpler than “rolling them” yourself. For many tasks a package such as MATLAB is often the best tool; PETSc is not intended for the classes of problems for which effective MATLAB code can be written. There are several packages, built on PETSc, that may satisfy your needs without requiring directly using PETSc. We recommend reviewing these packages functionality before starting to code directly with PETSc. PETSc can be used to provide a “MPI parallel linear solver” in an otherwise sequential, or OpenMP parallel code. This approach cannot provide extremely large improvements in the application time by utilizing large numbers of MPI processes but can still improve the performance. Certainly all parts of a previously sequential code need not be parallelized but the matrix generation portion must be parallelized to expect true scalability to large numbers of MPI processes. See PCMPI for details on how to utilize the PETSc MPI linear solver server. Since PETSc is under continued development, small changes in usage and calling sequences of routines will occur. PETSc has been supported for twenty-five years; see mailing list information on our website for information on contacting support.

97 MATHEMATICS AND COMPUTING↗

DOE OSTI2026

Deflagration to Detonation Transition Update: XDDT Code Modularization

A legacy FORTRAN 77 implementation of the Baer–Nunziato two-phase mixture theory for deflagration-to-detonation transition (DDT) in reactive granular materials—hereafter the XDDT (eXplosive DDT) code—has been modularized to Fortran 90 with modular structure, external input files, and adaptive mesh capability. During validation, two code defects were identified and corrected: an inconsistency in the nodal solid pressure evaluation and a nonphysical burn-front tracking criterion. The ignition criterion was also corrected to use the granular surface temperature from the interface heat transfer model, matching the original Baer implementation. An initial attempt to validate against Figure 3 of the original Baer and Nunziato (1986) paper revealed that the code’s detonation velocity on a 201-node mesh (5.5 km/s) was approximately 21% below the expected Chapman–Jouguet value for 70% TMD HMX (∼7 km/s). Validation was redirected to the piston-driven DDT experiments of McAfee et al. (1989), Shot B-9036, for which well-characterized ionization-pin data are available. With the compaction-burn coefficient calibrated to 𝐶 𝛼 = 75, the XDDT code reproduces the DDT transition time to within 0.4% and produces a steady-state detonation velocity within 4% of the McAfee experimental value of 6.36 km/s. The burn model was generalized to support pressure-dependent exponents, enabling application to nitrocellulose-based ball propellants (TS3659) with a cube-root pressure dependence. Validation against the Sandusky/Baer PDC82 piston-impact experiment yielded a reactive wave velocity of 2.3–2.8 km/s, in good agreement with the experimental value of ∼2.2 km/s, and wave coalescence within 5% of the experimental timing. The mathematical model, input parameter requirements, and a roadmap for extending XDDT to PETN with an autocatalytic burn model are presented.

45 MILITARY TECHNOLOGY, WEAPONRY, AND NATIONAL DEF↗