• Stars
    star
    131
  • Rank 275,867 (Top 6 %)
  • Language
    C
  • License
    Other
  • Created over 9 years ago
  • Updated 2 months ago

Reviews

There are no reviews yet. Be the first to send feedback to the community and the maintainers!

Repository Details

The Sandia Engineering Analysis Code Access System (SEACAS) is a suite of preprocessing, postprocessing, translation, and utility applications supporting finite element analysis software using the Exodus database file format.

SEACAS [Documentation] [Wiki]

Codacy Badge Analysis Status Spack Version Appveyor Build SEACAS Docker Exodus Docker Github Actions -- CI Serial Github Actions -- CI Variants Github Actions -- CI Intel Github Actions -- CI MSYS2

Get the sources

git clone https://github.com/sandialabs/seacas.git

This will create a directory that will be referred to as seacas in the instructions that follow. You can rename this directory to any other name you desire. Set an environment variable pointing to this location by doing:

cd seacas && export ACCESS=`pwd`

Build instructions

Automatically download and build dependencies (Third-Party Libraries)

There are a few externally developed third-party libraries (TPL) that are required (or optional) to build SEACAS: HDF5, NetCDF, CGNS, MatIO, Kokkos, and (if MPI set) PnetCDF libraries. You can build the libraries using the install-tpl.sh script, or you can install them manually as detailed in TPL-Manual-Install.md.

  • To use the script, simply type ./install-tpl.sh
  • The default behavior can be modified via a few environment variables:
Variable Values Default Description
INSTALL_PATH path to install pwd Root of install path; default is current location
COMPILER clang, gnu, intel, ibm nvidia gnu What compiler should be used for non-parallel build. Must have C++-17 capability.
MPI YES, NO NO If YES, then build parallel capability
FORCE YES, NO NO Force downloading and building even if lib is already installed.
BUILD YES, NO YES Should TPLs be built and installed.
DOWNLOAD YES, NO YES Should TPLs be downloaded.
USE_PROXY YES, NO NO Sandia specific -- use proxy when downloading tar files
DEBUG YES, NO NO Build debug executable; default is optimized
SHARED YES, NO YES Build shared libraries if YES, archive (.a) if NO
CRAY YES, NO YES Is this a Cray system (special parallel options)
NEEDS_ZLIB YES, NO NO If system does not have zlib installed, download and install it (HDF5 compression).
USE_ZLIB_NG YES, NO NO Should the improved zlib-ng library be used to provide ZLIB capability
NEEDS_SZIP YES, NO NO If system does not have szip installed, download and install it (HDF5 compression).
USE_64BIT_INT YES, NO NO In CGNS, enable 64-bit integers
CGNS YES, NO YES Should CGNS TPL be built.
MATIO YES, NO YES Should matio TPL be built.
METIS YES, NO NO Should metis TPL be built (parallel decomposition).
PARMETIS YES, NO NO Should parmetis TPL be built (parallel decomposition).
ADIOS2 YES, NO NO Should adios2 TPL be built.
CATALYST2 YES, NO NO Should catalyst 2 TPL be built.
KOKKOS YES, NO NO Should Kokkos TPL be built.
GNU_PARALLEL YES, NO YES Should GNU parallel script be built.
FMT YES, NO YES Should Lib::FMT TPL be built.
H5VERSION V114, V110, V18 V110 Use HDF5-1.14.X, HDF5-1.10.X or HDF5-1.8.X
BB YES, NO NO Enable Burst Buffer support in PnetCDF
JOBS {count} 2 Number of "jobs" used for simultaneous compiles
SUDO "" or sudo "" If need to be superuser to install
  • NOTE: The DOWNLOAD and BUILD options can be used to download all TPL source; move to a system with no outside internet access and then build/install the TPLs.
  • The arguments can either be set in the environment as: export COMPILER=gnu, or passed on the script invocation line: COMPILER=gnu ./install-tpl.sh

Configure, Build, and Install SEACAS

At this time, you should have all external TPL libraries built and installed into ${ACCESS}/lib and ${ACCESS}/include. You are now ready to configure the SEACAS CMake build.

  • cd $ACCESS
  • mkdir build
  • cd build
  • edit the ${ACCESS}cmake-config file and adjust compilers and other settings as needed.
  • enter the command ../cmake-config and cmake should configure everything for the build.
  • make && make install
  • If everything works, your applications should be in ${ACCESS}/bin
  • To install in a different location, do INSTALL_PATH={path_to_install} ../cmake-config
  • The default behavior can be modified via a few environment variables:
Variable Values Default Description
INSTALL_PATH path to install pwd Root of install path; default is current location
BUILDDIR {dir} pwd/build Directory to do config and build
COMPILER clang, gnu, intel, ibm gnu What compiler should be used for non-parallel build
SHARED YES, NO YES Build and use shared libraries is YES
APPLICATIONS YES, NO YES Should all SEACAS applications be built (see cmake-config)
LEGACY YES, NO YES Should the legacy SEACAS applications be built (see cmake-config)
FORTRAN YES, NO YES Should fortran libraries and applications be built (see cmake-config)
ZOLTAN YES, NO YES Should zoltan library and nem_slice be built
BUILD_TYPE debug, release release what type of build
MODERN YES, NO NO Use "modern" CMake configuration files for netCDF and HDF5
DEBUG -none- If specified, then do a debug build. Can't be used with BUILD_TYPE
HAVE_X11 YES, NO YES Does the system have X11 libraries and include files; used for blot, fastq
THREADSAFE YES, NO NO Compile a thread-safe IOSS and Exodus library
USE_SRUN YES, NO NO If MPI enabled, then use srun instead of mpiexec to run parallel tests
DOXYGEN YES, NO NO Run doxygen on several packages during build to generate documentation
OMIT_DEPRECATED YES, NO NO Should the deprecated code be omitted; NO will enable deprecated code
EXTRA_WARNINGS YES, NO NO Build with extra warnings enabled; see list in cmake-config
SANITIZER many NO If not NO, build using specified sanitizer; see list in cmake-config
GENERATOR many "Unix Makefiles" what generator should CMake use; see cmake doc
  • The arguments can either be set in the environment as: export COMPILER=gnu, or passed on the script invocation line: COMPILER=gnu ./install-tpl.sh

Parallel Build

For some areas of use, a parallel version of SEACAS is required. This will build a "parallel-aware" version of the exodus library and a parallel version of the Ioss library.

The only modification to the serial build described above is to make sure that the mpicc parallel C compiler is in your path and to add the MPI=YES argument to the install-tpl.sh script invocation when building the TPLs. For example:

   MPI=YES ./install-tpl.sh

This will download all requested libraries and build them with parallel capability enabled (if applicable). You can then continue with the steps outlined in the previous section.

Testing

There are a few unit tests for zoltan, exodus, ioss, and aprepro that can be run via make test or ctest if you configured with -D Seacas_ENABLE_TESTS=YES.

There is also a system-level test that just verifies that the applications can read and write exodus files correctly. This test runs off of the installed applications. To run do:

  • make install
  • cd ../SEACAS-Test
  • make clean; make

This will run through several of the SEACAS applications creating a mesh (exodus file) and then performing various manipulations on the mesh. If the test runs successfully, there is some hope that everything has built and is running correctly.

Exodus

If you only want the exodus library, then follow most of the above instructions with the following exceptions:

  • Clone entire source tree as above. (There used to be a zip file, but difficult to keep up-to-date)
  • You only need the netcdf and optionally hdf5 libraries
  • Use the cmake-exodus file instead of cmake-config.
  • This will build, by default, a shared exodus library and also install the exodus.py and exomerge.py Python interfaces.

Trilinos

Although SEACAS is included in Trilinos (https://github.com/trilinos/Trilinos), it is also possible to use the SEACAS code from this repository to override the possibly older SEACAS code in Trilinos. The steps are to directly pull SEACAS from github under Trilinos and then build SEACAS under Trilinos with that version using SEACAS_SOURCE_DIR_OVERRIDE. Here is how you do it:

cd Trilinos/
git clone https://github.com/sandialabs/seacas.git
cd BUILD/
cmake -DSEACAS_SOURCE_DIR_OVERRIDE:STRING=seacas/packages/seacas -DTrilinos_ENABLE_SEACAS [other options] ..

SPACK

The SPACK package manager (https://spack.io/) can be used to install SEACAS and all dependent third-party libraries. SEACAS is a supported package in SPACK as of December 2018.

git clone https://github.com/spack/spack.git
. spack/share/spack/setup-env.sh
spack install seacas~mpi   # Serial build (most common)

Docker

An Ubuntu-based Docker image, with SEACAS built and installed, is available on Docker Hub.

docker pull mrbuche/seacas

SEACAS is located in /seacas when running the container. There is also a similar image available on Docker Hub with only Exodus built and installed.

docker pull mrbuche/exodus

CMake Example Usage

A simple example of using the SEACAS Exodus library in your external project. Here is the CMakeLists.txt file:

project(ExodusCMakeExample VERSION 1.0 LANGUAGES C Fortran)
cmake_minimum_required(VERSION 3.1...3.26)

#### C ####
find_package(SEACASExodus CONFIG)
add_executable(ExodusWriteC ExodusWrite.c)
target_link_libraries(ExodusWriteC PRIVATE SEACASExodus::all_libs)

#### FORTRAN #####
IF ("${CMAKE_Fortran_COMPILER_ID}" MATCHES "GNU")
  SET(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -fcray-pointer -fdefault-real-8 -fdefault-integer-8 -fno-range-check")
ELSEIF ("${CMAKE_Fortran_COMPILER_ID}" MATCHES "XL")
  SET(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -qintsize=8 -qrealsize=8")
ELSEIF ("${CMAKE_Fortran_COMPILER_ID}" MATCHES "Cray")
  SET(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -sdefault64")
ELSE()
  SET(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} -r8 -i8")
ENDIF()

find_package(SEACASExodus_for CONFIG)
add_executable(ExodusReadFor ExodusRead.f)
target_link_libraries(ExodusReadFor PRIVATE SEACASExodus_for::all_libs)

The cmake-use-example directory contains this sample CMakeLists.txt file and a couple C and Fortran files which provide an example of how to build and link a C or Fortran program with the Exodus library installed as part of a build of this package.

To use this, copy the contents of the directory to your own filespace and modify the contents as needed. The example provides a C executable and a Fortran Executable which both are linked to the Exodus library.

To configure and build, you would do something like:

  mkdir build; cd build
  CMAKE_PREFIX_PATH={path_to_root_of_seacas_install} cmake ..
  make

And you would then get ExodusWriteC and ExodusReadFor compiled and linked against the Exodus library.

Required Software

The SEACAS system requires that there be some libraries and applications already existing on the chosen system prior to building SEACAS and its required Third-Party Liberaries.

These include:

  • The git application is used to access the SEACAS and TPL git repositories

  • CMake is used to generate the build system.

  • C, C++, and (optionally) Fortran compilers. The C compiler must support the C11 standard and C++ must support C+++17. GNU, Clang, Intel, Cray, compilers are supported and tested regularly.

  • For parallel capability, an MPI library is needed. We have used openmpi, mpich, mvapich, intel, and cray MPI libraries. It is recommended to use as current an MPI library as possible.

  • Automake is used to configure some of the TPL builds

  • wget is needed to download some of the TPL library source code.

  • python is required to use the exodus.py and exomerge.py Python interfaces to Exodus databases. Python3 is recommended.

  • To use the blot and fastq applications, an X11 development environment is needed.

  • Flex and Bison are optional if you are developing new capabilities in aprepro.

  • M4 is needed to build the netCDF library.

Mac

On a mac system, I use the brew system which provides all of the applications listed above. The X11 system I use is XQuartz. The Mac also requires XCode

Linux

On an ubuntu system, the following is used to set up the basic packages needed to compile SEACAS:

apt install -y libaec-dev zlib1g-dev automake autoconf \
libcurl4-openssl-dev libjpeg-dev wget curl bzip2 m4 flex bison cmake \
libzip-dev openmpi-bin libopenmpi-dev \

Windows

On windows, I have used the following packages for MINGW64:

git mingw-w64-x86_64-toolchain make mingw-w64-x86_64-hdf5 \
mingw-w64-x86_64-cgns mingw-w64-x86_64-netcdf mingw-w64-x86_64-zlib \
mingw-w64-x86_64-gcc-fortran mingw-w64-x86_64-gcc-libgfortran \
mingw-w64-x86_64-cmake mingw-w64-x86_64-fmt

There is also a Visual Studio build performed at each commit to the SEACAS git repository. See the file .appveyor.yml for more details.

License

SEACAS is licensed under the Modified BSD License. See the LICENSE file for details.

The following externally-developed software routines are used in some of the SEACAS applications and are under a separate license:

Routine Where Used License
getline packages/seacas/libraries/aprepro_lib/apr_getline_int.c MIT
getline packages/seacas/libraries/suplib_c/getline.c BSD
GetLongOpt packages/seacas/libraries/suplib_cpp/GetLongOpt.C public domain
adler hash packages/seacas/libraries/suplib_c/adler.c zlib
MurmurHash packages/seacas/libraries/ioss/src/Ioss_FaceGenerator.C public domain
json include file packages/seacas/libraries/ioss/src/visualization/ MIT
terminal_color packages/seacas/libraries/aprepro_lib zlib
Tessil Hash packages/seacas/libraries/ioss/src/hash MIT
doctest packages/seacas/libraries/ioss/src/doctest.h MIT
pdqsort packages/seacas/libraries/ioss/src Zlib License

Contact information

Greg Sjaardema ([email protected], [email protected])

More Repositories

1

wiretap

Wiretap is a transparent, VPN-like proxy server that tunnels traffic via WireGuard and requires no special privileges to run.
Go
847
star
2

toyplot

Interactive plotting for Python.
Jupyter Notebook
422
star
3

Albany

Sandia National Laboratories' Albany multiphysics code
C++
281
star
4

scot

Sandia Cyber Omni Tracker (SCOT)
JavaScript
237
star
5

qthreads

Lightweight locality-aware user-level threading runtime.
C
170
star
6

dr_robot

This tool can be used to enumerate the subdomains associated with a company by aggregating the results of multiple OSINT (Open Source Intelligence) tools.
Python
138
star
7

pyGSTi

A python implementation of Gate Set Tomography
Jupyter Notebook
134
star
8

snl-quest

An open source, Python-based software platform for energy storage simulation and analysis developed by Sandia National Laboratories.
Python
128
star
9

InterSpec

spectral radiation analysis software
C++
120
star
10

omega_h

Simplex mesh adaptivity for HPC
C++
105
star
11

slycat

Web-based data science analysis and visualization platform.
JavaScript
75
star
12

pecos

Python package for performance monitoring of time series data
Python
64
star
13

gr-pdu_utils

GNU Radio PDU Utilities
C++
61
star
14

UQTk

Sandia Uncertainty Quantification Toolkit
Fortran
59
star
15

chama

Python package for sensor placement optimization
Python
57
star
16

bcnn

3D Bayesian Convolutional Neural Network (BCNN) for Credible Geometric Uncertainty. Code for the paper: https://arxiv.org/abs/1910.10793
Python
56
star
17

gr-fhss_utils

Bursty modem utilities
C++
56
star
18

Whetstone

Python
47
star
19

TChem

TChem - A Software Toolkit for the Analysis of Complex Kinetic Models
Jupyter Notebook
44
star
20

tracktable

Tracktable: moving object trajectory analysis in C++ and Python
C++
39
star
21

tbnn

This code implements the Tensor Basis Neural Network (TBNN) as described in Ling et al. (Journal of Fluid Mechanics, 2016).
Python
38
star
22

hyram

Python
38
star
23

reverse_argparse

A Python library to determine what exactly the user ran at the command line, along with default values, and any transformations that happened after parsing arguments.
Python
38
star
24

pyapprox

Python
37
star
25

Spitfire

Spitfire is a Python/C++ library for constructing tabulated chemistry models and solving differential equations.
Python
37
star
26

portals4

Portals is a low-level network API for high-performance networking on high-performance computing systems developed by Sandia National Laboratories, Intel Corporation, and the University of New Mexico. The Portals 4 Reference Implementation is a complete implementation of Portals 4, with transport over InfiniBand VERBS and UDP. Shared memory transport is available as an optimization, including Linux KNEM support. The Portals 4 reference implementation is supported on both modern 64 bit Linux and 64 bit Mac OS X. The reference implementation has been developed by Sandia National Laboratories, Intel Corporation, and System Fabric Works. For more information on the Portals 4 standard, please see the Portals 4 page.
C
34
star
27

cross-sim

CrossSim: accuracy simulation of analog in-memory computing
Python
33
star
28

NuMAD

Numerical Manufacturing And Design Tool (NuMAD) -- A design tool for wind and water turbine composite blades
MATLAB
33
star
29

Prove-It

A tool for proving and organizing general theorems using Python.
Jupyter Notebook
27
star
30

SpecUtils

A library for opening, manipulating, and exporting gamma spectral files
C++
26
star
31

optimism

Computational solid mechanics made easy with Jax
Python
26
star
32

spack-manager

A project and machine deployment model using Spack
Python
25
star
33

gr-timing_utils

GNU Radio Timing Utilties
C++
25
star
34

MATLAB_PV_LIB

MATLAB PV function library
HTML
24
star
35

lgrtk

Tool Kit for Lagrangian Grid Reconnection
C++
22
star
36

mac-sandbox

This is a malware analyzer for Mac OS X that extends the Cuckoo Sandbox project (https://cuckoosandbox.org/)
Python
22
star
37

gait

Zeek Extension to Collect Metadata for Profiling of Endpoints and Proxies
Zeek
21
star
38

n2a

An object-oriented language for modeling large-scale neural systems, along with an IDE for writing and simulating models.
Java
21
star
39

MEWS

Multi-scenario Extreme Weather Simulator (MEWS)
Python
20
star
40

spat

A graphical user interface for measuring and performing inter-active analysis of physical unclonable functions (PUFs)
Python
20
star
41

compadre

Compadre (Compatible Particle Discretization and Remap)
C++
20
star
42

pyttb

Python Tensor Toolbox
Python
19
star
43

poblano_toolbox

Nonlinear optimization for MATLAB.
MATLAB
19
star
44

pycheron

Pycheron - A python library for quality control of seismic data based on IRIS Mustang.
Python
18
star
45

MatMCNP

A utility code for generating material cards for MCNP
Python
18
star
46

Zoltan

Zoltan Dynamic Load Balancing and Graph Algorithm Toolkit -- Distribution site
C
18
star
47

pvOps

A set of documented functions for supporting operations research of photovoltaic energy systems.
Jupyter Notebook
18
star
48

verdict

verdict
C++
17
star
49

Chordly

Chordly is a javascript library that may be used to detect and act upon key sequences entered by a user.
JavaScript
17
star
50

SandiaDecay

Easy to use C++ library to calculate nuclear decays and emissions
C++
17
star
51

CACTUS

CACTUS (Code for Axial and Cross-flow TUrbine Simulation) is a turbine performance simulation code, based on a free wake vortex method, to study wind turbines and marine hydrokinetic (MHK) devices.
Fortran
17
star
52

sceptre-phenix

phenix is an orchestration tool and GUI for Sandia's minimega platform
JavaScript
17
star
53

Gulliver

Gulliver is a C# utility package and library engineered for the manipulation of arbitrary sized byte arrays accounting for appropriate endianness and jagged byte length.
C#
15
star
54

PyRIID

ML-based radioisotope identification and estimation from gamma spectra in Python.
Python
15
star
55

suncal

Suncal - Sandia PSL Uncertainty Calculator
Python
14
star
56

Fugu

Python
14
star
57

cambio

Spectroscopic file conversion tool
C
14
star
58

mesquite

Mesquite: Mesh Quality Improvement Toolkit
HTML
14
star
59

sandialabs.github.io

JavaScript
14
star
60

packet2vec

Word2Vec embeddings over packet capture data n-grams.
C++
14
star
61

parapint

Parallel solution of structured nonlinear optimization problems
Python
13
star
62

WecOptTool

WEC Design Optimization Toolbox
Python
13
star
63

Matrices

Contains the matrix generation software and normed matrices described in "Recreating Raven's: Software for systematically generating large numbers of Raven-like matrix problems with normed properties," published in Behavior Research Methods in 2010
13
star
64

SNL-Delft3D-CEC

Fortran
12
star
65

staged-script

A Python package enabling the development of robust automation scripts that are subdivided into stages.
Python
12
star
66

p3a

Portably Performant Physical Algebra
C++
12
star
67

LCM

Laboratory for Computational Mechanics
C++
12
star
68

gr-sandia_utils

Misc blocks
C++
12
star
69

RUBRIC

C++
12
star
70

parsegen-cpp

A C++17 library for parser generation for LALR(1) languages
C++
12
star
71

snl-pstess

The Power and Energy Storage Systems Toolbox
MATLAB
12
star
72

sibl

Sandia Injury Biomechanics Laboratory (SIBL)
Python
11
star
73

shadow

Shadow semi-supervised consistency regularization PyTorch library
Python
11
star
74

lim1tr

Lithium-Ion Modeling with 1-D Thermal Runaway (LIM1TR)
Python
11
star
75

StrideSearch

Storm detection in climate data
C++
11
star
76

SNL-SWAN

SNL-SWAN
Fortran
11
star
77

sceptre-bennu

Modeling and simulation of ICS devices
C++
11
star
78

barcs

Ballistic Asynchronous Reversible Computing with Superconductors -- Tool for functional element enumeration and classification.
Python
10
star
79

lapart-python

Python
10
star
80

TIGER

Target / Integrative Genetic Element Retriever: precisely maps IGEs (a defined type of genomic island) in bacterial and archaeal genomes; package also includes orthogonal program Islander
Perl
10
star
81

miniIsosurface

A mini-app to explore algorithms for generating contours from 3D volumes.
C++
10
star
82

chemical-recommender-system

Platform for rapid computation of molecular similarity and integration of custom machine learning models
Python
9
star
83

sdynpy

A Structural Dynamics Python Library
Python
9
star
84

quinn

Quantification of Uncertainties in Neural Networks
Python
9
star
85

Arcus

Arcus, developed by Sandia National Laboratories, is a C# library for calculating, parsing, formatting, converting and comparing both IPv4 and IPv6 addresses and subnets. It accounts for 128-bit numbers on 32-bit platforms.
C#
9
star
86

SpokeDartsPublic

SpokeDarts sphere-packing sampling in any dimension. Advancing front sampling from radial lines (spokes) through prior samples.
C++
9
star
87

linkshop

Python
8
star
88

capp

A simple, portable package manager for applications
CMake
8
star
89

pyperc

Python package to model invasion percolation
Python
8
star
90

Fenix

Fenix: A Portable, Flexible Fault Tolerance Programming Framework for MPI Applications
C
8
star
91

svp_1547.1

Test scripts for IEEE 1547.1
Python
8
star
92

pyNuMAD

pynumad is an object-oriented, open-source software program written in Python which simplifies the process of creating a three-dimensional model of a wind turbine blade.
Python
8
star
93

rattlesnake-vibration-controller

Vibration Controller targetting Multiple-Input-Multiple-Output (MIMO) and Combined Environments Control
Python
8
star
94

mcdn-3d-seg

Monte Carlo Dropout Network for 3D Image Segmentation
Python
8
star
95

phoenix

An astrodynamics library.
Scala
7
star
96

xyz

zip metadata extraction tool
Python
7
star
97

CSPlib

Computational singular perturbation analysis library
Jupyter Notebook
7
star
98

BioCompoundML

BioCompoundML is a software tool for rapidly screening chemicals by chemical properties, using machine learning.
Python
7
star
99

miniGraphics

Miniapp to demonstrate parallel rendering in an MPI environment using a sort-last parallel rendering approach.
C++
7
star
100

PRIME

PRIME is a modeling framework designed for the "real-time" characterization and forecasting of partially observed epidemics
Python
7
star