1.FENICS/DOLFIN (Uses Numpy), LGPL (864 / 64)

1.FENICS/DOLFIN (uses numpy), LGPL (864 / 64)

But also: FENICS FINITE ELEMENT: (1080 / 34)

DOLFIN project is the C++ interface of FEniCS, providing a consistent PSE (Problem Solving Environment) for solving ordinary and partial differential equations.
Here are some key features of "DOLFIN":

 Simple, consistent and intuitive object-oriented API

 Automatic and efficient evaluation of variational forms through FFC

 Automatic and efficient assembly of linear systems

 Support for general families of finite elements, including continuous and discontinuous Lagrange finite elements of arbitrary order on triangles and tetrahedra through FIAT

 Support for arbitrary mixed elements, including Taylor-Hood

 High-performance parallel linear algebra through PETSc with simple C++ wrappers

 Triangular and tetrahedral meshes, including adaptive mesh refinement and mesh hierarchies

 Multi-adaptive mcG(q)/mdG(q) and mono-adaptive cG(q)/dG(q) ODE solvers

 Support for a range of output formats for post-processing, including DOLFIN XML, MATLAB, Octave, OpenDX, GiD, Tecplot and Paraview/VTK

 SWIG-generated Python interface PyDOLFIN (experimental) in addition to the standard C++ interface
Requirements:

 The latest version of FFC

 The latest version of FIAT

 PETSc version 2.3.0

 Libxml2 (Debian package libxml2-dev)
Note that FFC and FIAT are only needed if you want to define new differential equations, not if you are using one of the existing solvers/modules of DOLFIN.
What's New in This Release:

 The Python bindings for the new mesh library have been improved, and input/output is now supported for mesh functions.

 DOLFIN has switched from Python Numeric to Python NumPy in the Python interface.

FEniCS Project

From The FEniCS project

FEniCS is free software for automated solution of differential equations. We provide software tools for working with computational meshes, finite element variational formulations of PDEs, ODE solvers and linear algebra.

To get started, visit the Gallery or take the Tutorial.

Projects

FEniCS is organized as a collection of sub projects/components.

• DOLFIN, a C++/Python library for solving differential equations
• FErari, optimizations for evaluation of variational forms
• FFC, a compiler for finite element variational forms
• FIAT, tabulation of finite element function spaces
• Instant, simple inlining of C / C++ code in Python
• Puffin, simple finite element solver for Octave/MATLAB
• SyFi, finite element engine based on symbolic mathematics
• UFC, a unified code generation interface for form-compilers
• Viper, minimalistic scientific plotter and run-time visualization module

/

Vision

The vision of FEniCS is to set a new standard in Computational Mathematical Modeling (CMM), which is the Automation of CMM (ACMM), towards the goals of generality, efficiency, and simplicity, concerning mathematical methodology, implementation, and application.

Computational Mathematical Modeling is the modern manifestation of the basic principle of science: formulating mathematical equations (modeling) and solving equations (computation), with the equations usually taking the form of differential/integral equations.

The traditional organization of a technical university follows the principle that each department is devoted to the study of a particular differential equation with a particular set of analytical/numerical methods. Today, the computer opens entirely new possibilities of numerical solution of differential equations, and forces development to replace the traditional organization based on the one equation - one department model.

Partners

FEniCS is a joint project between University of Chicago, Argonne National Laboratory, Delft University of Technology, Royal Institute of Technology KTH, Simula Research Laboratory, Finite Element Center and University of Cambridge (in order of appearance).

+ support for both C++ and python

+ extensive manual, although some parts are slightly outdated

+ problem is entered in .form files, which are using own compiler FFC generated into .h, but it has also JIT compiler, the writing is very close to mathematical description

+ form compiler allows us to combine generality with efficiency

+ more developers

+ has beautiful presentations:

Current and future plans for FEniCS (DOLFIN/FFC) (molto bello!!!)
Anders Logg, BIT Circus Stockholm (September 1 2006)

In user manual, see, there is explanation how to make poisson:

In , there is a nice discussion about other softwares and overall goals of the library

In slide 0, there are nice demonstrations, of how it may look in other softwares and how it look in Fenics

In slide 5, there are nice samples of writing in integral form and appropriate representation in FFC

+ they even plan to make new mesh library!

- no paralel processing, yet, even planned (on the other hand, we do not need it) *

+ support for Gmsh and other software

+ support for Python, that seem that will have even more impact in simulation and computer science

+ has packages for Debian and Ubuntu => easy installation

+ looks most professional, most exciting, and future development is for sure…

+ initial examples are much more simple then the case of LibMesh, on the other hand they have already

prepared classes for Poisson and Dirichlet probléme

+ it is enough to write the math in variational form, the the rewrite to computer format is very easy,

+ After seeing the examples and documentation, I think even for beginners this library would be relatively easy, by my opinion easier entrance then with other libraries!

+ this library has 2x more references in Google scholar then libmesh (not counting fenics)

+ change log seem to me that library is under continous and serious development

+ whole framework, more tasks will be solved and can be used

+ Support for a range of output formats for post-processing, including DOLFIN XML, ParaView/Mayavi/VTK, OpenDX,

Tecplot, Octave, MATLAB, GiD (thanks to xml format...)

+ idea of point project and next generation FEM software seem to be good

- it seems there is no forum for fenics

+ prototyping can be made in python, see ; this is by the way easiest example to start on

+ own code is added by modules, authors claim there exists special coding practise how to do it

+ automatation approach

+ first release 2002

+ best presentations, best manual; even from these, a person who not familiar with differential equations and linear algebra will often have serious problems , howeever basic poisson equation is in form one can understand (with help from Massimo Totar)

+ mesh is stored in xml format; i.e we can easily convert to another formats (if necessary)

+ Description I found on CFD Online (one of websites with great attendence) - FEniCS - An open-source package for computational mathematical modeling. Has some functionality to solve Navier-Stokes. Looks very nice. FEniCS is being developed very quickly and can become very interesting for CFD people. FEniCS and its sister projects are used extensively in education.

+ FFC

- more dependencies then libmesh

+ I cannot help myself, I have overall feeling that this is the best one!

From The FEniCS project

The FEniCS Form Compiler FFC provides state-of-the-art automatic and efficient evaluation of general multilinear forms (variational formulations) for FEniCS. FFC functions as the form evaluation system for DOLFIN but can also be used to compile forms for other systems.

FFC works as a compiler for multilinear forms by generating code (C or C++) for the evaluation of a multilinear form given in mathematical notation. This new approach to form evaluation makes it possible to combine generality with efficency; the form can be given in mathematical notation and the generated code is as efficient as hand-optimized code.

+ Man-power (while libmesh is done mostly by PhD students)

The FEniCS core team consists of the following people, committed to implementing

a new standard in CMM software:

Prof. Todd Dupont

Dept. of Computer Science

University of Chicago, USA

Dr. Johan Ho_man

Courant Institute of Mathematical Sciences, New York, USA

Prof. Claes Johnson

Dept. of Computational Mathematics

ChalmersUniversity of Technology, G oteborg, Sweden

Ass. Prof. Robert Kirby

Dept. of Computer Science

University of Chicago, IllUSA

Ass. Prof. Mats Larson

Dept. of Computational Mathematics

ChalmersUniversity of Technology, G oteborg, Sweden

Mr. Anders Logg

Dept. of Computational Mathematics

ChalmersUniversity of Technology, G oteborg, Sweden

Prof. Ridgway Scott

Dept. of Computer Science

University of Chicago, USA

* Does it run in parallel?

No, not yet. However, since we use PETSc as a linear algebra backend for DOLFIN, parallel linear algebra is handled by PETSc. We are currently working on implementing parallel assembly to complete the parallel support in FEniCS.

2. LibMesh (1620 / 32) - GPL

libMesh currently supports 1D, 2D, and 3D steady and transient finite element simulations. The library makes use of high-quality, existing software whenever possible. PETSc is used for the solution of linear systems on both serial and parallel platforms, and LASPack is included with the library to provide linear solver support on serial machines. An optional interface to SLEPc is also provided for solving both standard and generalized eigenvalue problems. A complete list of external applications used in the library may be found here.

+ supports UNV format (which we can export from Salome)

+ is able to run paralel

+ enough presentations and examples

- syntax seem to be for me somewhat unclean

+ used by Rome

+ if problem is specified in 2D you can easily allegedly extend it to 3d (i.e. syntax is general)

- we can say that this library is defacto project of University of Texas, with no other subjects, while Fenics is guaranteed by cooperation of many universities, see

+ libmesh-0.6.1-rc1Notes(2007-10-14 14:26) libmesh-0.6.1-rc1.tar.gzMirror 3688028 5 Platform-Independent Source .gz libmesh-0.6.0Notes(2007-06-04 12:37) libmesh-0.6.0.tar.gzMirror 3513405 900 Platform-Independent Source .gz libmesh-0.5.0Notes(2005-06-10 15:05)

(however same, even better situation is with Fenics)

3. Getfem++ (583 / 29) - LGPL

The Getfem++ project focuses on the development of a generic and efficient C++ library for finite element methods. The goal is to provide a library allowing the computation of any elementary matrix (even for mixed finite element methods) on the largest class of methods and elements, and for arbitrary dimension (i.e. not only 2D and 3D problems).

It offers a complete separation between integration methods (exact or approximated), geometric transformations (linear or not) and finite element methods of arbitrary degrees. It can really relieve a more integrated finite element code of technical difficulties of elementary computations.

Examples of available finite element method are : Pk on simplices in arbitrary degrees and dimensions, Qk on parallelepipeds, P1, P2 with bubble functions, Hermite elements, Argyris element, elements with hierarchic basis (for multigrid methods for instance), discontinuous Pk or Qk, XFem, vectorial elements (RT0, Nedelec) ...

The addition of a new finite element method is relatively easy. Its description on the reference element must be provided (in most of the cases, this is the description of the basis functions, and nothing more). Extensions are provided for Hermite elements, piecewise polynomial, non-polynomial, vectorial elements and XFem.

The library also includes the usual tools for finite elements such as assembly procedures for classical PDEs, interpolation methods, computation of norms, mesh operations (including automatic refinement), boundary conditions, post-processing tools such as extraction of slices from a mesh ...

Getfem++ can be used to build very general finite elements codes, where the finite elements, integration methods, dimension of the meshes, are just some parameters that can be changed very easily, thus allowing a large spectrum of experimentations. Several examples are provided (see the screenshot section).

Getfem++ has no meshing capabilities (apart regular meshes and a small attempt), hence it is necessary to import meshes. Imports formats currently known by getfem are GiD , GmSH and emc2 mesh files. However, given a mesh, it is possible to refine it automatically.

Gmm++

Getfem++ includes a generic matrix template library inspired by MTL and ITL.

Matlab interface

A Matlab® interface to this library is also provided. Hence it is possible to use Getfem++ without any knowledge of C++. Moreover, this interface provides some post-processing functions which use matlab graphics. A great effort has been made to offer pictures that represent precisely the finite element solution (i.e. preserve discontinuities across elements, preserve polynomial order of f.e.m,..), and tools are provided for slice views with respect to a plane/half space/cylindar/sphere, and streamlines. The pictures from the screenshot section were all generated via the Matlab interface.

Python interface

A python interface is also available, it is very similar to the Matlab one, although it lacks the graphical abilities of the Matlab interface.

Licence

Getfem++ is freely distributed under the terms of the Gnu Lesser General Public License.

===

4. Rheolef (925 / 23) - GPL

-three man show

-last release almost 2 years

-Fenics is better

+already integrated with salome

+ While sparse matrix and meshes are standard

tools in most _nite element libraries, rheolef is the only one to our knowledge that bases on

powerful variational concepts, such as spaces, _elds and bilinear forms.

-no paralel processing yet

+ source code seem to be very clear

SANDIA - TAHOE (??? / ???)

Note: – tahoe is name of lake in US, we cannot determine Google searches correctly…

Tahoe is a research-oriented, open source platform for the development of numerical methods and material models. The goal of the work surrounding Tahoe is the simulation of stresses and deformations for situations that cannot be treated by standard continuum simulation techniques. These situations include material fracture or failure, interfacial adhesion and debonding, shear banding, length-scale dependent elasticity and plasticity, and deformation in small-scale structures. Aside from a collection of standard finite elements, Tahoe includes meshfree simulation capability and particle methods. Tahoe includes a number of "cohesive" approaches for modeling fracture. These include both surface and bulk constitutive models that incorporate cohesive behavior. Tahoe is capable of performing static and transient dynamic coupled-physics analysis in two and three dimensions. Many capabilities support parallel execution.

+ 35 developers (registered at sourceforge…)

+ most alive forum I have seen from FEM software

- seem to be solving lot of things, which many we do not need:

- simulation of stresses of materiál…

- last stable release 2004, version 2.1

+ uses high performance components

+ looks professional by the name of copany SANDIA

FETK Overview (584 / 37)

-does not use high performance tools, is too much ANSI-C (too much portable for us)

-no CVS

-confusing website, manual

-outdated (2004, last version 0.1.2!!!)

OOFEM.org (3330 / 37) - GPL

 Object oriented architecture

 Modular & extensible FEM kernel (OOFEMlib)

• fully extensible - The kernel is extensible in any "direction". The possibility of adding new element type, new material model with any type and number of internal history parameters, new boundary conditions, numerical algorithms or analysis modules, as well as ability to add and manage arbitrary degrees of freedom is matter of course.
• independent problem formulation, numerical solution and data storage - The kernel provides the independent abstractions for analysis, general numerical method and data storage (sparse matrices). The component mapping concept allows to formulate problem and numerical method independently and allows to use any suitable numerical method for problem solution without changes. This concept is further enhanced by abstract sparse matrix interface, allowing to formulate numerical method independently on sparse matrix implementation.
• full restart support - The kernel supports full restart from any previously saved state.
• staggered analysis - allows to group basic problems together and to transfer and share the solution fields between basic subproblems. The general design allows to use different discretizations for the basic subproblems.
• parallel processing support - based on domain decomposition and message passing paradigms. Many analyses can be run in parallel and very good performance scalability can be obtained on various platforms. Message passing concept is highly portable across many platforms (including massively parallel computers, shared memory systems and workstation clusters), For developers, general classes for efficient inter domain communication are provided built over the abstract general layer for message passing libraries.
• efficient sparse solvers - direct as well as iterative solvers are available. Direct solvers include symmetric and unsymmetric skyline solver and sparse direct solver, iterative solvers support many sparse storage formats and come with several preconditioners. Interfaces to third party linear solver libraries are available, including IML, PETSc (serial and parallel), and SPOOLES.
• adaptive analysis support - multiple domain concept. Support for error estimation with various remeshing criteria, support for primary unknown and internal variables mapping. Fast spatial localization algorithms based on tree techniques are available.

-one man show

-OOFEM is name of whole method (I found some articles about oofem but not related to the software), pages found by Google will be less

-Oo design is quite unusal, one has to derive a finite element problem from a class…

-Documentation is somewhat sparse and complex; could be better

-Low funding of this project; i.e. future less obvious for me…

-Many documents are just indexed from oofem domain…, so the Google weight is lower

OFELI (339 / 32) - GPL

(Object Finite Element LIbrary) is an object oriented library of C++ classes for development of finite element codes. Its main features are :

/ Various storage schemes of matrice (dense, sparse, skyline, tridiagonal).
/ Direct methods and preconditioned iterative strategies for the solution of linear systems of equations.
/ Shape functions of most "popular" finite elements
/ Element arrays of most popular problems (Heat Transfer, Fluid Flow, Solid Mechanics, Electromagnetics, ...).

The OFELI package is not only a library of classes for Finite Element developments. The package contains in addition :