PyOMP: Programming GPUs with OpenMP and Python
Explore the source record for details and available documents.
Computer science↗
SEARCH · Search NASA
Results for “python”
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.
MARIE: A Python-Based Framework for Comprehensive Fuel Recycling Modeling
One of the most pressing challenges to the continued deployment of nuclear energy systems is in the ultimate management and disposition of discharged fuel assemblies. While reprocessing and recovery of valuable materials from UNF assemblies has been considered as part of an overall strategy for minimization of the volume of reactor-based wastes to be managed, the deployment of commercial-scale reprocessing facilities presents an enormous economic challenge. The MARIE software package has been developed as a means of confronting this challenge. Representing components of a generic fuel reprocessing operation as individual physical processes, MARIE is designed as a modular framework intended to allow for analysis and cost-optimization for a hypothetical reprocessing facility while realistically accounting for the physical characteristics of the used fuel source term, such as decay heat, activity, and radiation dose (informing corresponding shielding requirements). Capabilities supported by MARIE include head-end operations such as fuel shearing, voloxidation, and dissolution; generic solvent extraction operations informed by available open-literature data; a suite of unit operations intended to represent electrochemical processing of used fuel assemblies (i.e., oxide reduction, electrorefining, and electrowinning); and finally, accounting for both costs and physical features of discharged waste streams, which can be used to inform follow-on analyses such as the feasibility of deep-borehole disposal of HLW. This paper presents an overview of the MARIE software capabilities, including how individual unit operations are implemented to enable a larger-scale optimization of a hypothetical reprocessing operation on aspects such as cost and recovery of valuable materials.
Skutnik, Steve [ORNL] (ORCID:000000016441135X)↗
Programming GPUs with OpenMP and Python
Explore the source record for details and available documents.
Computer science↗
ForceFinder: A Python Package for Inverse Source Estimation
Explore the source record for details and available documents.
Carter, Steven Phillip [Sandia National Laboratori↗
A bespoke model of Arctic river basins based on hillslope delineation: Model Archive
This dataset is a model archive of the paper A bespoke model of Arctic river basins based on hillslope delineation (in prep), which introduces a watershed decomposition and parameterization method for large scale permafrost hydrology simulation. With this dataset, this study aims to address the research question: whether a computationally efficient hillslope-based modeling framework can reliably simulate discharge at Arctic river-basin scales. This dataset contains model input and output data for five modeling scenarios at a study site located in the Sagavanirktok River basin. The five modeling scenarios include three modeling cases under temperate conditions using full 3D, decomposed 3D, and decomposed 2D modeling strategies; and two modeling cases under actual Arctic conditions with permafrost using full 3D and decomposed 2D modeling strategies. Simulations were performed using the Advanced Terrestrial Simulator (ATS, v1.6 for three temperate scenarios and v1.5 for two Arctic scenarios), a physics-rich integrated surface–subsurface hydrologic model with cryo-hydrology features. For the three temperate models, simulations were conducted for the period of 10/01/1993 - 09/30/2002; and for the two Arctic models, simulations were conducted for the period of 01/01/1994 - 12/31/2002. To facilitate reproducibility of simulations, all datasets are organized hierarchically. The dataset contains: (1) Mesh files (.exo) for full 3D model, decomposed 3D models, and decomposed 2D models, located in huc/190604020802_gauge15906000/mesh/. Mesh files can be visualized through Paraview or read by Python. (2) Climate forcings (.h5) for full 3D model and decomposed 3D/2D models are located in huc/190604020802_gauge15906000/daymet_onePiece/, and huc/190604020802_gauge15906000/vp_pr_revised_daymet_1980_2006_with_wind/ separately. Accessible by Python. (3) Raw measured gage discharge (.csv) from USGS, located in huc/190604020802_gauge15906000/gaged_basin15906000_discharge_usgs/. Accessible by Python. (4) Delineated subdomain raster (.tif) and shape files (.shp), and the final parameterized results (.npy) for decomposed models, located in huc/190604020802_gauge15906000/data_preprocessed-meshing. Accessible by Python. (5) Temperate models are located in nonpermaf_huc190604020802_gauge15906000/, which includes three cases: decomposed 2D models (inside model_0*-hillslope_*), decomposed 3D models (inside model_1*-subcatchment_*), and full 3D model (inside model_2*-onepiece_*). Two step spin-up results (checkpoint_final.h5) are located in model_*1-*_spinup_steadystate and model_*2-*_spinup_cycle, separately, which are used to initialize real transient models. The input files (.xml) and output results (.dat) of the real transient models are located in model_*3-*_transient/. Especially, for two example hillslope models (ID=-11 and 11), additional h5py files are included in model_03-hillslope_transient/hillslope-11/, model_03-hillslope_transient/hillslope11, model_13-subcatchment_transient/subcatchment-11/, model_13-subcatchment_transient/subcatchment/11, respectively, which are used to plot the saturation figure (Figure 5) in the manuscript. Accessible by Python. (6) Arctic models are located in huc190604020802_gauge15906000/, which includes two cases: decomposed 2D models (inside model_04-hillslope_transient), and full 3D model (inside model_05-onepiece_transient_mannp1_ra). Three step spin-up results (checkpoint_final.h5) are located in model_01-column_freezeup/, model_02-column_spinup/, model_03-hillslope_spinup/, respectively, which are used to initialize real 2D transient hillslope models. The input files (.xml) and output results (.dat) of transient 2D hillslope models are located in model_04-hillslope_transient/. The input files (.xml) and output results (.dat) of the full 3D transient model is located in model_05-onepiece_transient_mannp1_ra/. The full 3D transient model is initialized by model_02-column_spinup/. Accessible by Python. (7) The MOSART routed discharge results (.csv) under Arctic conditions is located in huc190604020802_gauge15906000/MOSART/. Accessible by Python. (8) All Python codes (.py) used to parameterize full 3D model to decomposed 2D models are located in script/. These codes fit with watershed workflow (a watershed delineation tool) v1.4 under the branch gaob/v1.4 from https://github.com/gaobhub/watershed-workflow.git.
EARTH SCIENCE > CRYOSPHERE↗
Hydrologic Model Data for the East Fork Poplar Creek Watershed Simulated with the Advanced Terrestrial Simulator (ATS): Streamflow and Network Expansion–Contraction Dynamics
This dataset supports hydrologic modeling and stream network expansion–contraction analysis for the East Fork Poplar Creek (EFPC) Watershed in Tennessee. It includes a Jupyter notebook for model setup, model configuration files, simulation outputs, and derived products used to evaluate model performance and investigate stream dynamics under varying hydrologic conditions. The dataset was generated using the Watershed Workflow Python package and the Advanced Terrestrial Simulator (ATS), enabling integrated surface–subsurface hydrologic simulations using a stream-aligned mesh. Outputs include high-resolution time series of streamflow, active network length, water table depth, and related hydrologic variables. Also included are spatially explicit stream persistency indices and classifications of reaches as perennial or non-perennial. These data facilitate reproducibility and support further research on stream intermittency and variability in network extent.The model data archive is organized in following directories:1) model_setup_inputsContains the Watershed Workflow Jupyter notebooks (accessed through any open source code editor), selected input datasets, and resulting ATS input files, including XML files (access through any open source code editor), computational mesh (.exo files can be viewed using Paraview), and meteorological forcing files (.h5 files can be accessed through h5py python package and HDFView open source software). 2) model_outputsIncludes ATS simulation outputs relevant to this study. Time series of spatially integrated or averaged variables (e.g., streamflow, water table depth) are provided as CSV files. Select spatial fields (e.g., ponded depth and water table depth) are saved as pickled Python objects to reduce file size, and can be accessed through pickle package in Python. Key geometry objects from Watershed Workflow—such as the surface mesh and river tree—are also included to support analysis of streamflow persistency and expansion–contraction dynamics. These files can also be accessed through Watershed Workflow Python package.3) model_evaluationProvides observed streamflow time series and field survey-based flow regime classifications used to evaluate model performance. Jupyter notebooks for processing ATS outputs and comparing model predictions with observations to build confidence in the model prior to scientific analysis are also included.4) Q_L_relationshipsContains workflows for generating time series of discharge, active network length, and related hydrologic variables used in the stream network expansion–contraction analysis. Includes routines for delineating baseflow-dominated periods. For each catchment, notebooks and processed data (as pickled DataFrames accessed through Pandas Python package) are provided. 5) figure_scriptsProvides the Jupyter notebooks used to generate the figures presented in the paper.
54 ENVIRONMENTAL SCIENCES↗
PFLOTRAN modeling data and scripts associated with “Refining the Hydrogeologic Framework of a Large River Corridor Model Using Waterborne Transient Electromagnetics”
NOTE: The manuscript associated with this data package is currently in review. The data may be revised based on reviewer feedback. Upon manuscript acceptance, this data package will be updated with the final dataset and additional metadata. This data package is associated with the publication “Refining the Hydrogeologic Framework of a Large River Corridor Model Using Waterborne Transient Electromagnetics” submitted to Water Resources Research (Terry et al. 2025). The data package contains the groundwater modeling dataset from PFLOTRAN software. It includes the python script for mesh generation, boundary condition setting, PFLOTRAN input deck formation and postprocessing. It couples groundwater flow and species transport for Hanford Reach river corridor and pipelines the model generation and processing. This model can be used to easily generate the model and analysis for Hanford site. It can also be adjusted to other hydrologic area with ease. For details on how to navigate data packages generated by this project, see https://data.ess-dive.lbl.gov/portals/PNNLRiverCorridorSFA/About. The data package consists of 6 folders: (1) “data” contains all necessary data as input and intermediate data for processing; (2) “mesh” contains all mesh related files to generate mesh in Hanford Reach river corridor; (3) “model_run” contains the generated script for PFLOTRAN modeling; (4) “notebooks” contains all the Python script to generate the model; (5) “output” contains all the output from the computation; (6) “postprocessing” contains the Python script to generate scientific figure for manuscript. All files are .csv (comma-separated values), .h5 (HDF5 format), .in (input files), .ipynb (Jupyter notebooks), .p (Python pickle), .png (images), .PNG (images), .py (Python scripts), .pyc (Python bytecode), .r (R scripts), .sh (shell scripts), .txt (text files), .vtu (3D mesh/visualization format), .xz (compressed archive), or .zip (compressed archive).
54 ENVIRONMENTAL SCIENCES↗
Urban morphology and urban water demand evolution in the Los Angeles region
Detailed description of the dataset sources used in this study, the experimental workflow, and plotting for the paper figures provided at the associated GitHub Meta Repo: https://github.com/IMMM-SFA/Ferencz_et_al_2024_ERL The future water demand projections from this study are hypothetical future water demands that reflect the population and urban land cover changes represented by the scenarios considered. The intent and emphasis of this work is investigating the interactions between population change, evolution of urban morphology, and water demand. These projections are not meant to be likely future demands for specific water providers or the LA region and should not be interpreted as such. The folders contain input and output data for each step of the "Recreate my Experiment" workflow described in the associated GitHub meta-repository as well as data used for plotting Figures for the paper that this dataset supports. Description of each folder's contents and use: Step_1a: Inputs to the associated python script provided on the GitHub repo. Step_1b: Inputs (downscaled population rasters) used by the associated python script provided on the GitHub repo. Original 1-km squared rasters that were downscaled also provided. Step_1c: Urban growth projection rasters corresponding to SSP3 and SSP5 population scenarios are provided in separate subfolders as well as the water provider boundaries used for analysis. Outputs of data processing also provided. Associated python script provided on GitHub. Step_1d: Description of Inputs used by the QGIS Model Builder GUI that automates geospatial processing and clipping the of the high-resolution 60 cm land cover data for each urban land class footprint within a defined polygon boundary. The Model Builder is provided on the GitHub repo and can be used by QGIS. The outputs of this step are in "Clipped Provider Hi Res Landcover". If the user wants to use The Model Builder for different regions of LA or to test our outputs, they will need to download the hi resolution landcover raster listed in the Readme and in Ref [2] of the GitHub Page. Step_1e: All necessary inputs to generate average monthly demand over the 2017-2021 period and the minimum and maximum demands over the 2014-2021 for each water provider. Associated python scripts are on GitHub. Step 2: Output data about land cover metrics (areas and fractions) for each urban land class for each water provider. Associated python script on GitHub. Uses outputs from Step 1d "Clipped Provider Hi Res Landcover" Step 3: Both the Inputs for and Outputs from the urban projection raster analysis Python script on GitHub. The inputs are urban land class rasters for specific SSP and zoning scenarios (low, medium, high) from Step 1c. The outputs are rasters of urban pixels that were converted to a higher land class and the number of land class units that changed (Values of 1, 2, or 3). For example, a value of 2 could be LC 21 -> 23 or LC 22 -> 24. These maps are label "intensification." The other outputs are "urban growth" rasters showing the conversion of non urban to urban land, which are indicated by pixel values of 1. These are used for the urban growth change maps in Figure 3. Step 4: Output projections of indoor and outdoor annual and monthly demands for each water provider for the average, minimum, and maximum monthly demand scenarios for each of the four urban growth scenarios (SSP3 med, SSP5 low, SSP5 med, and SSP5 high). The outputs also include metrics on each water provider used for the demand sensitivity analysis presented in Figure 8. Outputs from Step 4 are used for Figures 4 - 8 of the paper. Figures: This folder has data used for plotting Figures 1 through 5, and 8. Data for Figures 6 and 7 are sourced directly from folders associated with the Processing and Analysis Steps 1 - 4. The GitHub meta repository provides descriptions of how each figure was made and the associated plotting scripts used.
Los Angeles↗
Deep Learning-based Non-Stationary Bias Correction (NSBC)
This work develops the NSBC (non-stationary bias correction) methodology to correct temperature projection bias from E3SM. The NSBC deep learning framework consists of a three-part architecture: an auto-encoder for compressing the spatial information, an LSTM for predicting annual temperature mean, and a U-Net for capturing the residual bias in temperature. The non-stationary bias correction (NSBC) framework can correct the non-stationarity of the biases of the climate models, which significantly improves the accuracy of future temperature prediction and improves the overestimation of extreme high temperatures that many existing bias correction methods suffer from. Getting started 1. Obtain the historical climate simulation and observation data. The E3SM simulation data are available through https://aims2.llnl.gov/search/cmip6/. The pseudo observations, the Geophysical Fluid Dynamics Laboratory (GFDL)-ESM4 model (Krasting et al., 2018) are available through https://aims2.llnl.gov/search/cmip6/. The spatial resolution of E3SM and pseudo observation datasets are both regridded to a common 1° resolution grid using conservative interpolation. The regridded E3SM and pseudo observation with 1° resolution can be found throught ./data/. 2. Train the Auto-encoder model. Python 0-autoencoder.py 3. Train the LSTM Python 1-LSTM.py 4. Generate the annual mean temperature based on trained LSTM Python 2-generate_annual_mean_LSTM.py 5. Train the U-Net. Python 3-unet.py 6. Evaluation and compared with the baseline Python 4_evaluation.py Is there a deadline approaching that requires the release of yo
Lucas, Donald↗
stor4build
The EnergyPlus simulation engine supports modeling and simulation of thermal energy storage (TES) systems in several ways, including using the Python-EMS feature, which extends the operation of the engine with custom code written in Python. Creation of models using this feature can be tedious and error prone, with the connection of the model components to the Python code a particularly troublesome area. The stor4build Python package simplifies this process by modifying an input model to add a selected TES technology (implemented with the Python-EMS feature) and runs the simulation. The package leverages the OpenStudio middleware software development kit to automate this process as much as possible, eliminating potential errors and simplifying usage of EnergyPlus. The package provides objects, functions, and OpenStudio measures that implement the necessary operations to automate the creation of EnergyPlus models that integrate TES technologies with building systems. In addition, two user interfaces are provided: a command line interface and a web application programming interface. The automated process implemented by the package greatly simplifies the modeling and simulation process, allowing for parametric studies to be executed much more efficiently and effectively. The OpenStudio-based workflow is also very flexible and will allow for future additions of new technologies.
DeGraw, JasonWilliam [Oak Ridge National Laborator↗
sourcePy
Pollutant source identification techniques (of which there are many variations) are either locked behind researchers writing their own code for each use case or GUI platforms that are easy to use but inflexible and opaque. The Python package sourcePy brings together many of the pollutant source identification algorithms, giving the user full control out of the box. It aims to create a platform for source identification experiments where the full analysis from beginning to end can be done in Python, with a level of specificity in design that isn't available in the GUI options. sourcePy provides users with a few key features: -A Python interface with HYSPLIT, which can be used to generate trajectories and concentration plumes -Several Python classes which standardize the preparation and processing of data related to source identification experiments -Example scripts and notebooks that allow even new python users to get started with their own experiments quickly -Visualization methods
Arseneau, Isaac [Oak Ridge National Laboratory (OR↗
Spinbox: tools for many-body quantum systems in a Monte Carlo context
Spinbox is a piece of software that facilitates quantum mechanical calculations relevant to Monte Carlo simulation of atomic nuclei. At the front lines of research on the nuclear many-body problem are a large number of supercomputer-scale simulation codes. These codes produce valuable results but can be hard to understand, especially for those without intimate knowledge of the relevant theoretical methods. Thus, tools that fill pedagogical roles are extremely valuable. Spinbox makes it easy for one to replicate and analyze the computational processes relevant to a Quantum Monte Carlo (QMC) simulation that may be difficult to understand/debug/analyze due to the scale of the corresponding simulation software. Spinbox is written in Python using other state-of-the-art Python modules for numerical calculations. While a number of Python libraries exist that are suited to general quantum many-body calculations, the motivation of Spinbox is quite particular. In Diffusion Monte Carlo methods (DMC, GFMC, AFDMC), the central calculation is the imaginary-time propagation of individual samples of the many-body wavefunction. Although quantum wavefunctions generally must be described by a probability distribution over a basis, DMC imbues particles (within one sample) with classical spatial coordinates. This method is unusual, so other Python packages are typically not set up to do this easily. Furthermore, the software has built-in options for nuclear systems assuming isospin symmetry, which can be set up with other libraries but is a nontrivial process to do so. Features: - numerical representation of samples of the many-body wavefunctions, including tensor-product states (used in AFDMC) - numerical representation of many-body operators, including tensor-product operators: general, spin, imaginary-time propagation, etc. - the correct associated arithmetic and algebra, implemented as class methods - classes for representing realistic nuclear two- and three-body Hamiltonians (e.g. Argonne V18, Illinois NNN) - large-scale parallel integration over random variables, crucial for the AFDMC method My goal is to make this package open source so that anyone may use it and contribute to it, particularly other researchers doing AFDMC calculations
Fox, Jordan↗
Data and scripts from: “Denoising autoencoder for reconstructing sensor observation data and predicting evapotranspiration: noisy and missing values repair and uncertainty quantification”
This data package includes data and scripts from the manuscript “Denoising autoencoder for reconstructing sensor observation data and predicting evapotranspiration: noisy and missing values repair and uncertainty quantification”.The study addressed common challenges faced in environmental sensing and modeling, including uncertain input data, missing sensor observations, and high-dimensional datasets with interrelated but redundant variables. Point-scaled meteorological and soil sensor observations were perturbed with noises and missing values, and denoising autoencoder (DAE) neural networks were developed to reconstruct the perturbed data and further predict evapotranspiration. This study concluded that (1) the reconstruction quality of each variable depends on its cross-correlation and alignment to the underlying data structure, (2) uncertainties from the models were overall stronger than those from the data corruption, and (3) there was a tradeoff between reducing bias and reducing variance when evaluating the uncertainty of the machine learning models.This package includes:(1) Four ipython scripts (.ipynb): “DAE_train.ipynb” trains and evaluates DAE neural networks, “DAE_predict.ipynb” makes predictions from the trained DAE models, “ET_train.ipynb” trains and evaluates ET prediction neural networks, and “ET_predict.ipynb” makes predictions from trained ET models.(2) One python file (.py): “methods.py” includes all user-defined functions and python codes used in the ipython scripts.(3) A “sub_models” folder that includes five trained DAE neural networks (in pytorch format, .pt), which could be used to ingest input data before being fed to the downstream ET models in ‘ET_train.ipynb” or ‘ET_predict.ipynb’.(4) Two data files (.csv). Daily meteorological, vegetation, and soil data is in “df_data.csv”, where “df_meta.csv” contains the location and time information of “df_data.csv”. Each row (index) in “df_meta.csv” corresponds to each row in “df_data.csv”. These data files are formatted to follow the data structure requirements and be directly used in the ipython scripts, and they have been shuffled chronologically to train machine learning models. The meteorological and soil data was collected using point sensors between 2019-2023 at(4.a) Three shrub-dominated field sites in East River, Colorado (named “ph1”, “ph2” and “sg5” in “df_meta.csv”, where “ph1” and “ph2” were located at PumpHouse Hillslopes, and “sg5” was at Snodgrass Mountain meadow) and(4.b) One outdoor, mesoscale, and herbaceous-dominated experiment in Berkeley, California (named “tb” in “df_meta.csv”, short for Smartsoils Testbed at Lawrence Berkeley National Lab).- See "df_data_dd.csv" and "df_meta_dd.csv" for variable descriptions and the Methods section for additional data processing steps. See "flmd.csv" and "README.txt" for brief file descriptions.- All ipython scripts and python files are written in and require PYTHON language software.
54 ENVIRONMENTAL SCIENCES↗
Data From: "Warming and snow loss increase reliance on old groundwater in a Colorado River headwater"
This repository contains the data and code associated with the paper titled "Warming and snow loss increase reliance on old groundwater in a Colorado River headwater," published in Nature Geoscience, 2026. This study seeks to answer how various ages of groundwater interact with mountainous streamflow in mountainous headwaters such as the East River. It includes various model-data processing scripts, primarily for ParFlow-CLM analysis of simulated water years 2015-2021, and two numerical warming experiments (+2.5 and +4.0 degrees C), including run scripts, forcing scripts, and post-processing, as well as comparison to observation datasets, detailed below. This data requires the use of R (.r, .rmd), Python (.py), Jupyter Notebook or Jupyter Lab (.ipynb), ParFLOW-CLM, EcoSLIM. Further information on the use of all file formats mentioned below (e.g. .tff. .nc) are provided within the associated scripts and directory where the files are located. Contents & Usage ASO/: Contains the bash and python scripts used to convert airborne snow observatory (ASO) data (ASO, 2023) in various data formats (georeferenced tiff file, NetCDF, UTM, and to latitude/longitude) then regrided to the ParFlow equivalent grid. Output data are in regrid_regll_data.zip and subsequently visualized and analyzed in plot_and_compare.py for Supplementary Figures A14 and A15. The wksht_ASO_comparison.xlsx spreadsheet is used to calculate the data for Supplementary Figure A16. EcoSLIM/: Contains the scripts and input files to run the EcoSLIM particle tracking simulations (/run_scripts) and the post-processing python script (/plot_scripts/eco_agedist_plots.ipynb). Jasechko et al./: Contains the jupyter notebook (Extract_Elevation.ipynb) to determine the outlet elevations of the 260 watersheds used in Jasechko et al. (2016), and the corresponding table, Table_S1_Watersheds_alt.csv. Used to create Supplementary Information Figure A2. PLM_Wells/: Contains the QA/QC-ed groundwater level time series of the PLM-1 and PLM-6 Monitoring Wells from Faybishenko et al. (2023), reformatted to water years used for Supplementary Figures A19 and and A20. ParFlow/: Contains the input files and run scripts to run ParFlow-CLM (/run_scripts), the python and tool command language (Tcl) scripts to create and distribute the ParFlow forcing simulation files (/forcing), and various scripts and intermediary files to analyze the model outputs (/post_process). SQUIRE/: Contains the processing scripts and intermediary files for the Surface QUantitatIve pRecipitation Estimation (SQUIRE) data (Grover, 2023) used to generate Supplementary Figure A18. USGS_Streamflow/: Contains the raw and gap-filled United States Geological Survey streamflow data (U.S. Geological Survey, 2026) used at the Almont station (site number 09112500). Gap-filling is performed in the R script with data from the Taylor station (site number 09110000). (/USGS_09112500_EAST_RIVER_AT_ALMONT_GAP_FILLED/code_almont_streamflow_gap_fill.Rmd). discharge/: Contains the gap-filled discharge data at the Watershed Function SFA East River pumphouse site (Newcomer et al., 2022) used to generate Supplementary Figure A13 and to compute hourly Nash-Sutcliffe model efficiency coefficients (NSE) in Table A4. snotel_and_flux_tower/: Contains the snow telemetry data (U.S. Department of Agriculture, 2024) from the Butte (site ID 380) and Schofield (site ID 737) stations, reformatted by water year, accessed with the snotelr R package. Used to create Supplementary Figure A17. Also contains the flux tower observational data (FluxTower_Pumphouse_ESS-DIVE.ET_only.h.txt) from Ryken et al. (2022) and sap flux transpiration data (MaxB_Transpiration_5Sites.daily_sums.h.txt) from Ryken (2021), used to create Supplementary Figures A22 and A23, respectively. Raw EcoSLIM model outputs are in excess of 24TB, and are stored on National Energy Research Scientific Computing Center (NERSC) and publicly available via the external link provided in the paper.
atmospheric warming↗
Electricity Baseline 2022 Background Data and Log File
The ElectricityLCI v2 Python package (https://github.com/USEPA/ElectricityLCI/tree/v2.0) was used to generate the 2022 electricity baseline: a regionalized life cycle inventory model of U.S. electricity generation, consumption, and distribution using standardized facility and generation data. ElectricityLCI implements a local data store for downloading and accessing public data on an individual's computer. The data store follows the folder definition provided by USEPA's esupy Python package (https://github.com/USEPA/esupy), which utilized the appdirs Python dependency (https://pypi.org/project/appdirs/). This submission includes the background data used to generate the 2022 electricity baseline inventory. Each zip archive stores the source files as found in their data stores. Sub-folders in each of the data stores are archived separately. For example, stewi.zip contains the JSON files, while stewi.facility.zip is the 'facility' sub-folder of stewi data store that stores the parquet files. To reproduce the data store, extract each zip file and drag-and-drop sub-folders in to their appropriate root folders to recreate the data stores, then copy the root folders to your data store folder (as returned by running the following on the command line: `python -c "import appdirs; print(appdirs.user_data_dir())"`). The main five data stores include: 'electricitylci', 'facilitymatcher', 'fedelemflowlist', 'stewi', and 'stewicombo'. The log file generated by the 2022 model run is also included, which contains the statements at the DEBUG level and above.
Electricity; LCA; data inventory↗
Electricity Baseline 2021 Background Data and Log File
The ElectricityLCI v2 Python package (https://github.com/USEPA/ElectricityLCI/tree/v2.0) was used to generate the 2021 electricity baseline: a regionalized life cycle inventory model of U.S. electricity generation, consumption, and distribution using standardized facility and generation data. ElectricityLCI implements a local data store for downloading and accessing public data on an individual's computer. The data store follows the folder definition provided by USEPA's esupy Python package (https://github.com/USEPA/esupy), which utilizes the appdirs Python dependency (https://pypi.org/project/appdirs/). An overview of the ElectricityLCI data stores may be found on the README (https://github.com/USEPA/ElectricityLCI/blob/v2.0/README.md#data-store). This submission includes the background data used to generate the 2021 electricity baseline inventory. Each zip archive stores the source files as found in their data stores. Sub-folders in each of the data stores are archived separately. For example, stewi.zip contains the JSON files, while stewi.facility.zip is the 'facility' sub-folder of stewi data store that stores the parquet files. To reproduce the data store, extract each zip file and drag-and-drop sub-folders in to their appropriate root folders to recreate the data stores, then copy the root folders to your data store folder (as returned by running the following on the command line: python -c "import appdirs; print(appdirs.user_data_dir())"). The main five data stores include: 'electricitylci', 'facilitymatcher', 'fedelemflowlist', 'stewi', and 'stewicombo'. The log file generated by the 2021 model run is also included, which contains the statements at the DEBUG level and above.
Electricity; LCA; LCI; Life Cycle; data inventory↗
Electricity Baseline 2020 Background Data and Log File
The ElectricityLCI v2 Python package (https://github.com/USEPA/ElectricityLCI/tree/v2.0) was used to generate the 2020 electricity baseline: a regionalized life cycle inventory model of U.S. electricity generation, consumption, and distribution using standardized facility and generation data. ElectricityLCI implements a local data store for downloading and accessing public data on an individual's computer. The data store follows the folder definition provided by USEPA's esupy Python package (https://github.com/USEPA/esupy), which utilizes the appdirs Python dependency (https://pypi.org/project/appdirs/). An overview of the ElectricityLCI data stores may be found on the README (https://github.com/USEPA/ElectricityLCI/blob/v2.0/README.md#data-store). This submission includes the background data used to generate the 2020 electricity baseline inventory. Each zip archive stores the source files as found in their data stores. Sub-folders in each of the data stores are archived separately. For example, stewi.zip contains the JSON files, while stewi.facility.zip is the 'facility' sub-folder of stewi data store that stores the parquet files. To reproduce the data store, extract each zip file and drag-and-drop sub-folders in to their appropriate root folders to recreate the data stores, then copy the root folders to your data store folder (as returned by running the following on the command line: python -c "import appdirs; print(appdirs.user_data_dir())"). The main five data stores include: 'electricitylci', 'facilitymatcher', 'fedelemflowlist', 'stewi', and 'stewicombo'. The log file generated by the 2020 model run is also included, which contains the statements at the DEBUG level and above.
Electricity; LCA; LCI; Life Cycle; data inventory↗
Large language model evaluation for high–performance computing software development
We apply AI-assisted large language model (LLM) capabilities of GPT-3 targeting high-performance computing (HPC) kernels for (i) code generation, and (ii) auto-parallelization of serial code in C ++, Fortran, Python and Julia. Our scope includes the following fundamental numerical kernels: AXPY, GEMV, GEMM, SpMV, Jacobi Stencil, and CG, and language/programming models: (1) C++ (e.g., OpenMP [including offload], OpenACC, Kokkos, SyCL, CUDA, and HIP), (2) Fortran (e.g., OpenMP [including offload] and OpenACC), (3) Python (e.g., numpy, Numba, cuPy, and pyCUDA), and (4) Julia (e.g., Threads, CUDA.jl, AMDGPU.jl, and KernelAbstractions.jl). Kernel implementations are generated using GitHub Copilot capabilities powered by the GPT-based OpenAI Codex available in Visual Studio Code given simple + + prompt variants. To quantify and compare the generated results, we propose a proficiency metric around the initial 10 suggestions given for each prompt. For auto-parallelization, we use ChatGPT interactively giving simple prompts as in a dialogue with another human including simple “prompt engineering” follow ups. Results suggest that correct outputs for C++ correlate with the adoption and maturity of programming models. For example, OpenMP and CUDA score really high, whereas HIP is still lacking. We found that prompts from either a targeted language such as Fortran or the more general-purpose Python can benefit from adding language keywords, while Julia prompts perform acceptably well for its Threads and CUDA.jl programming models. Finally, we expect to provide an initial quantifiable point of reference for code generation in each programming model using a state-of-the-art LLM. Overall, understanding the convergence of LLMs, AI, and HPC is crucial due to its rapidly evolving nature and how it is redefining human-computer interactions.
97 MATHEMATICS AND COMPUTING↗