|
|
FFTX is the exascale follow-on to the FFTW open-source discrete FFT package for executing the Fast Fourier Transform as well as higher-level operations composed of linear operations combined with discrete Fourier transforms. Though backward compatible with FFTW, this is an entirely new work developed as a cooperative effort between Lawrence Berkeley National Laboratory, Carnegie Mellon University, and SpiralGen, Inc.
See our page with FFTX references: http://www.spiral.net/software/fftx.html
FFTX Project documentation: https://spiral-software.github.io/fftx/
See our github site for installation: https://github.com/spiral-software/fftx
See our github site.
Right now, it is a copy of the Chombo page.This is the home of the FFTX space.To help you on your way, we've inserted some of our favourite macros on this home page. As you start creating pages, adding news items and commenting you'll see the macros below fill up with all the activity in your space.
Panel | ||||||||||
---|---|---|---|---|---|---|---|---|---|---|
| ||||||||||
Chombo provides a set of tools for implementing finite difference and finite volume methods for the solution of partial differential equations on block-structured adaptively refined rectangular grids. Both elliptic and time-dependent modules are included. Chombo supports calculations in complex geometries with both embedded boundaries and mapped grids, and Chombo also supports particle methods. Most parallel platforms are supported, and cross-platform self-describing file formats are included. The Chombo package is a product of the community of collaborators working with the Applied Numerical Algorithms Group part of the Computational Research Division at LBNL. Chombo is a Swahili word meaning "tool" or "container". |
Introduction
- Chombo supports time-accurate, conservative discretizations of complex PDE's by using a cross-discipline approach: scalable algorithms, mathematical simplifications and careful software design.
- If you're new to Block Structured Adaptive Mesh Refinement (AMR), see the Overview of Block Structured AMR.
- Complex geometries are handled using an Embedded Boundary approach, as well as Mapped Multiblock Grids
- Chombo's approach to solving PDE's uses algorithms that have good (memory and wall clock) scaling, so that the same code can run on a desktop or the largest supercomputers in the world.
Download
Chombo is provided as a fully open-source distribution, released under a modified BSD license. We have a Chombo Download Page if you want to see details but here is the gist.
The current Chombo release is distributed via the svn version control system. Before you can download Chombo, you must register. Registration is free and does not carry an encumbrance on your part. We just need to keep a record of access. Registration gets you an account via which you can access the Chombo svn repository via svn. If you have already previously registered for Chombo download, you may skip directly to the download page.
Latest Release: Chombo 3.2 was released March 25, 2014. This release includes support for hybrid OpenMP/MPI parallelism, new interfaces for using PETSc and a compressible Navier Stokes application for high speed flows in complex geometries which uses embedded boundaries.
The Design Docs for Chombo can be downloaded independently of the source and without registration.
Citing Chombo
If you publish using Chombo as one of your tools, please cite the following technical report.:
- M. Adams, P. Colella, D. T. Graves, J.N. Johnson, N.D. Keen, T. J. Ligocki. D. F. Martin. P.W. McCorquodale, D. Modiano. P.O. Schwartz, T.D. Sternberg and B. Van Straalen, Chombo Software Package for AMR Applications - Design Document, Lawrence Berkeley National Laboratory Technical Report LBNL-6616E.
If you use the embedded boundary tools, please also cite the following technical report.
P. Colella, D. T. Graves, T. J. Ligocki, G.H. Miller , D. Modiano, P.O. Schwartz, B. Van Straalen, J. Pillod, D. Trebotich and M. Barad, EBChombo Software Package for Cartesian Grid, Embedded Boundary Applications, Lawrence Berkeley National Laboratory Technical Report LBNL-6615E.- The current version of the Chombo Design Doc is a fairly comprehensive overview of the layers and classes in Chombo.
- Here is design document that focuses on the Chombo embedded boundary infrastructure
- Here is the Doxygen Chombo3.2 reference manual for the current Chombo 3.2 release.
- Here is a current version of the Chombo development reference manual . This changes with the repository.
Chombo User Community
To contact the Chombo developers, e-mail us at [email protected]
Research
- There are many areas of research enabled by Chombo, here are just a few:
- Shallow Water simulations of the SF Bay and Delta
- Compressible Navier-Stokes with embedded boundaries.
- Modeling the dynamics of Land Ice Sheets
- The LAVA software package from NASA Ames uses some of the tools from Chombo and EBChombo. Some examples of their work are found here, here, and here. Very cool stuff.
- GRChombo is a general relativity code written using Chombo.
- Chombo is built from the ground up to provide scaling on massively parallel platforms
- Many scientific papers have used Chombo as the software infrastructure
ANAG
The Applied Numerical Algorithms Group is part of the Computational Research Division at LBNL. We are funded by the Department of Energy.
FFTX
This is the source tree for FFTX.
Building FFTX
Prerequisites
C Compiler and Build Tools
FFTX builds on Linux/Unix with gcc and make, on Windows it builds with Visual Studio.
FFTW
You can download FFTW from fftw.org.
On Windows install FFTW in C:\FFTW3 if possible. Be sure to follow the instructions in README-WINDOWS in the FFTW root directory about using the lib command to create the .lib files.
CMake
FFTX needs a version of CMake no older than 3.8, but try to use the most recent version, which is currently 3.14.
You can download CMake from cmake.org, where there are source trees and Windows installers. Be wary of pre-built Linux packages from other sources, as they are often out of date.
On super computers the default CMake version may be quite old, requiring you to explicitly load the module for the latest version.
Building on Linux and Other Unix-Like Systems
From the top level FFTX directory:
mkdir build cd build cmake .. make make test
Using a Custom FFTW Installation
There are two command line variables to CMake for FFTX that specify the include dir and library for a custom FFTW installation, FFTW_INCLUDE_DIR and FFTW_LIBRARY. Use them in the CMake command line as in the following example where FFTW is installed in ~/fftw3
:
cmake -D FFTW_INCLUDE_DIR=~/fftw3/include -D FFTW_LIBRARY=~/fftw3/lib/libfftw3.a ..
Release and Debug Builds
Use the CMAKE_BUILD_TYPE command line variable to explicitly control the FFTX build type. The value can be eitherDebug or Release, as in:
cmake -D CMAKE_BUILD_TYPE=Debug ..
Building on Windows
In the top level FFTX directory, make a directory called build. From a terminal window in the build directory enter one of the following commands, depending on your version of Visual Studio. See the CMake documentation if your version isn't shown here.
cmake -G "Visual Studio 14 2015" -A x64 ..
cmake -G "Visual Studio 15 2017" -A x64 ..
cmake -G "Visual Studio 16 2019" -A x64 ..
When CMake is finished, open the new FFTX.sln with Visual Studio to build the projects in the code tree.
Building on Summit
The following minimal script will set up your environment to build with the instructions for Linux.
module load gcc/8.1.1
module load fftw/3.3.8
module load cmake/3.13.4
export CC='/sw/summit/gcc/8.1.1/bin/gcc'
CMake looks for the CC environment variable to override the default C compiler, which is /usr/bin/cc on Summit, even if you explicitly load a gcc module.