FEBio 4.8
Finite Elements for Biomechanics
Loading...
Searching...
No Matches
Overview of FEBio

FEBio is a finite element solver that is specifically designed for biomechanical and biophysics applications. It offers biologically relevant constitutive models and modeling scenarios.

The source code is organized into different libraries. The following figure shows the relationship between the different libraries (sometimes referred to as modules).

Overview of FEBio's organization of modules.

Each library collects a set of classes and functions that implement part of the FEBio feature set. The following list shows the different libraries and the functionality they implement. A more detailed description of each library is provided below.

  • FECore: a library containing mostly base classes that define the FEBio framework. FECore also manages the kernel.
  • NumCore: a library that contains mostly third-party linear solvers
  • FEBioMech: a library implementing solution algorithms for solving 3D structural mechanics problems.
  • FEBioMix: this library extends FEBioMech and adds support for biphasic and materials with solutes (e.g. triphasic and multiphasic), as well as chemical reactions.
  • FEBioFluid: a library that implements a fluid mechanics solver for solving transient fluid dynamics problems, as well as a fluid-solid-interaction (FSI) solver.
  • FEAMR: a library that implements adaptive remeshing algorithms.
  • FEImgLib: a library that implements a simple 3D image structure and some basic image operations.
  • FEBioOpt: a library implementing parameter optimization methods.
  • FEBioRVE: this library implements material homogenization approaches
  • FEBioTest: this library implements various tests and diagnostics.
  • FEBioXML: An xml-parser for reading the FEBio input files
  • FEBioPlot: library for creating the FEBio plot files.
  • FEBioLib: the main FEBio library that collects all features and provides the hooks for other codes to interact with FEBio directly.

FEBio Libraries

FECore

The FECore library contains all the base classes for developing finite element software. It has classes for representing meshes, constitutive models, boundary conditions, solvers, and more. Many of the classes in this library are virtual base classes. New features are implemented by deriving classes from these base classes and overriding some of the virtual functions. This library also implements the FECore kernel class, which is used for registering classes with the FEBio framework. Registering classes with FEBio is part of the automation mechanism that allows other modules to instantiate classes. For instance, this mechanism makes it possible for users to implement a new feature that will automatically be recognized in the FEBio input file, without the need to write any I/O code.

NumCore

The NumCore library implements algorithms for storing and solving linear systems of equations. Most of the linear solver classes are wrappers to third-party linear solver packages, such as Pardiso. Most of these classes are designed for dealing with sparse matrices, although a dense matrix class and a linear solver for dense systems is implemented as well.

FEBioMech

This library implements algorithms for solving 3D quasi-static and dynamic structural mechanics problems. Both implicit and explicit solvers are availalbe. It also contains a large number of nonlinear, constitutive models. Many types of boundary conditions and loads can be found here. Contact algorithms for various types of tied and sliding interfaces can be found in this library as well.

FEBioMix

The FEBioMix library extends the FEBioMech library by solving a type of coupled fluid-mechanics problem where the domain is assumed to be a solid-fluid mixture. The fluid is assumed to be composed of a solvent that may contain one or more solutes. Optionally, the solute concentrations can be affected by chemical reactions. This library also implements contact algorithms for handling fluid flow across contacting interfaces. Both quasi-static as well as transient conditions can be modeled.

FEBioFluid

The FEBioFluid library implements a fluid mechanics solver for solving quasi-static and transient fluid dynamics problems. It also implements a fluid-solid (FSI) solver that couples the solid mechanics and the fluid solver.

FEAMR

The FEAMR (pronounced 'femur') implements adaptive meshing algorithms that allows users to make changes to the mesh as part of the solution process. Applications are element erosion, where elements are removed from the analysis based on certain criteria, and local mesh refinement, where accuracy heuristics can be used to increase (or decrease) mesh resolution in parts of the mesh.

FEImgLib

This library implements a simple 3D image structure and basic image operations. This library exists mostly to support some other plugins that use images, such as the FEBioWarp plugin.

FEBioOpt

This library implements several algorithms for performing model parameter optimizations.

FEBioRVE

The FEBioRVE library implements an algorithm for performing first-order "FE squared" material homogenization.

FEBioTest

This library provides various tests and diagnostics that can be used to test different aspects of model solving with FEBio. For instance, it offers several tangent diagnostics to test whether the material tangent of a constitutive formulation is consistent with its stress evaluations. The library also has tools for testing restart and other features.

FEBioXML

The FEBioXML library implements an XML-based parser that reads the FEBio input file. This library makes extensive use of the automation mechanism that is implemented in FEBio. This mechanism facilitates the interaction between modules such that explicit knowledge of the contents of each module is not required. A great advantage of this is that users rarely have to modify this library directly.

FEBioPlot

This library implements the XPLT format that is used for storing the FEBio output results. The XPLT format is an extendible data format that can easily by customized to the needs of the model. As in the FEBioXML library, the automation mechanism is used to define the contents of the xplt file and developers will rarely need to modify this library directly.

FEBioLib

The FEBio library is a library that handles initialization of all the modules. It also defines the FEBioModel class, derived from FEModel, which handles most of the file management. This library also manages all the plugins.

FEBio

The FEBio module brings everything together by providing a command line front-end to the FEBio libraries. This project effectively builds the executable that is run by users. It also implements a command manager, used on the FEBio prompt, manages the configuration file and offers several diagnostic tools for debugging implementations.