Finite Element Software (FES)

FES is a modular finite element framework designed around weighted residual methods, with emphasis on portability and clear separation of geometry, physics, and project flow.

Features

• Finite element and method of moments (MoM) wave-equation workflows.
• Mesh processing via Triangle and TetGen.
• Linear algebra and eigenvalue backend built on OpenBLAS, ARPACK-NG, and MUMPS.
• Model-driven runs using .poly and .vtp project inputs.

Repository Layout

• configure: bootstrap script for dependency build + core build.
• core/: main C++ source tree and CMake project.
• dep/: downloaded third-party sources, build tree, and installed artifacts (created by configure --dependencies).
• mdl/: sample input models (.poly) for quick runs.
• Makefile: convenience build targets for the core project.

Requirements

You need a Unix-like environment (Linux or macOS) with:

• git
• cmake
• make
• C/C++/Fortran toolchain (gcc, g++, gfortran)

The configure script can install compiler/build-tool packages when requested.

Quick Start

From repository root:

chmod +x configure
./configure --compiler --dependencies

Use --compiler when you want the script to install system packages:

• macOS: Homebrew (brew install ...)
• Arch Linux: pacman (sudo pacman -S ...)
• Debian/Ubuntu-like Linux: apt (sudo apt install ...)

If your system toolchain is already installed, but you still want this script to clone/build third-party dependencies:

./configure --dependencies

If you only want to verify runtime/link dependencies for the built binary:

./configure --libraries

If both your system toolchain and third-party dependencies are already prepared, run without either optional installation/build step:

./configure

Configure Script Behavior

Current options:

Usage: ./configure [--compiler] [--dependencies] [--libraries]
  --compiler   Install compiler and build tool packages
  --dependencies   Clone and build third-party dependencies
  --libraries   Run library/dependency link checks (ldd/otool)

What configure does:

1. Optionally installs compiler/build tooling (--compiler).
2. Optionally clones third-party dependencies into dep/src/ (--dependencies).
3. Optionally generates local CMakeLists.txt files for Triangle and TetGen (--dependencies).
4. Optionally builds and installs dependencies under dep/ (--dependencies).
5. Builds and installs FES in core/.
6. Optionally runs dependency-link checks (ldd on Linux, otool -L on macOS) with --libraries.
7. Executes the built fes binary.

Recommended full bootstrap command on a fresh machine:

./configure --compiler --dependencies --libraries

Usage

After building, you can run the FES executable with a model file:

./core/build/bin/fes mdl/BilatFilter.poly

The executable accepts .poly or .vtp project files as input.

You can also use the provided Makefile for convenience:

make build  # Build the project
make test   # Run test on BilatFilter.poly

Build Artifacts

• Dependency install prefix: dep/
• Dependency build directories: dep/build/*
• Core build directory: core/build/
• FES executable: core/build/bin/fes

Running FES

Example run with a bundled model:

core/build/bin/fes mdl/WR90.poly

Executable usage:

fes /path/to/project_name.ext (ext := vtp, poly)

Re-running and Cleanup

The script clones missing dependency repositories and attempts fast-forward updates for repositories that already exist under dep/src/.

Use cleanup when you want a full, fresh dependency rebuild.

Typical cleanup before a full rebuild:

rm -rf dep/src/OpenBLAS dep/src/arpack-ng dep/src/mumps-superbuild dep/src/triangle dep/src/tetgen
rm -rf dep/build core/build
./configure --dependencies

To also refresh system package installation and run linker checks on fresh setup:

./configure --compiler --dependencies --libraries

Troubleshooting

• Permission denied on configure:

chmod +x configure

• sudo prompts or package manager errors: Run with proper privileges or install required packages manually, then run ./configure without --compiler.

• Missing third-party libraries during core build: Re-run with --dependencies to clone/build/install dependencies under dep/.

• Build failures in dependencies: Inspect CMake output in dep/build/* and verify your compiler toolchain and Fortran support.

• Runtime linker diagnostics: Run ./configure --libraries to print linked libraries (ldd/otool -L) after build and identify missing system libraries.

Development Notes

• Core uses CMake and C++17.
• Non-macOS link behavior is controlled in core/CMakeLists.txt.
• VTK-related integration hooks exist in CMake but may be disabled depending on branch state.

References

• Laurent Ntibarikure, Contributions to the Art of Finite Element Analysis in Electromagnetics, FLORE, February 2014.
• Zhizhang Chen and Michel Ney, The Method of Weighted Residuals: A General Approach to Deriving Time- and Frequency-Domain Numerical Methods, IEEE Antennas and Propagation Magazine, Vol. 51, No. 1, February 2009.