Reference documentation for deal.II version Git 053e5b2 2017-07-21 22:33:36 -0600
Classes | Public Member Functions | Protected Member Functions | Protected Attributes | List of all members
SolverFIRE< VectorType > Class Template Reference

#include <deal.II/lac/solver_fire.h>

Inheritance diagram for SolverFIRE< VectorType >:
[legend]

Classes

struct  AdditionalData
 

Public Member Functions

 SolverFIRE (SolverControl &solver_control, VectorMemory< VectorType > &vector_memory, const AdditionalData &data=AdditionalData())
 
 SolverFIRE (SolverControl &solver_control, const AdditionalData &data)
 
virtual ~SolverFIRE ()
 
template<typename PreconditionerType = DiagonalMatrix<VectorType>>
void solve (const std::function< double(VectorType &, const VectorType &)> &compute, VectorType &x, const PreconditionerType &inverse_mass_matrix)
 
template<typename MatrixType , typename PreconditionerType >
void solve (const MatrixType &A, VectorType &x, const VectorType &b, const PreconditionerType &precondition)
 
- Public Member Functions inherited from Solver< VectorType >
 Solver (SolverControl &solver_control, VectorMemory< VectorType > &vector_memory)
 
 Solver (SolverControl &solver_control)
 
boost::signals2::connection connect (const std::function< SolverControl::State(const unsigned int iteration, const doublecheck_value, const VectorType &current_iterate)> &slot)
 
- Public Member Functions inherited from Subscriptor
 Subscriptor ()
 
 Subscriptor (const Subscriptor &)
 
 Subscriptor (Subscriptor &&)
 
virtual ~Subscriptor ()
 
Subscriptoroperator= (const Subscriptor &)
 
Subscriptoroperator= (Subscriptor &&)
 
void subscribe (const char *identifier=nullptr) const
 
void unsubscribe (const char *identifier=nullptr) const
 
unsigned int n_subscriptions () const
 
void list_subscribers () const
 
template<class Archive >
void serialize (Archive &ar, const unsigned int version)
 

Protected Member Functions

virtual void print_vectors (const unsigned int, const VectorType &x, const VectorType &v, const VectorType &g) const
 

Protected Attributes

const AdditionalData additional_data
 
- Protected Attributes inherited from Solver< VectorType >
GrowingVectorMemory< VectorType > static_vector_memory
 
VectorMemory< VectorType > & memory
 
boost::signals2::signal< SolverControl::State(const unsigned int iteration, const double check_value, const VectorType &current_iterate), StateCombineriteration_status
 

Additional Inherited Members

- Public Types inherited from Solver< VectorType >
typedef VectorType vector_type
 
- Static Public Member Functions inherited from Subscriptor
static::ExceptionBase & ExcInUse (int arg1, char *arg2, std::string &arg3)
 
static::ExceptionBase & ExcNoSubscriber (char *arg1, char *arg2)
 

Detailed Description

template<typename VectorType = Vector<double>>
class SolverFIRE< VectorType >

FIRE (Fast Inertial Relaxation Engine) for minimization of (potentially non-linear) objective function \(E(\mathbf x)\), \(\mathbf x\) is a vector of \(n\) variables ( \(n\) is the number of variables of the objective function). Like all other solver classes, it can work on any kind of vector and matrix as long as they satisfy certain requirements (for the requirements on matrices and vectors in order to work with this class, see the documentation of the Solver base class). The type of the solution vector must be passed as template argument, and defaults to Vector<double>.

FIRE is a damped dynamics method described in Structural Relaxation Made Simple by Bitzek et al. 2006, typically used to find stable equilibrium configurations of atomistic systems in computational material science. Starting from a given initial configuration of the atomistic system, the algorithm relies on inertia to obtain (nearest) configuration with least potential energy.

Notation:

Given initial values for \(\Delta t\), \(\alpha = \alpha_0\), \(\epsilon\), \(\mathbf x = \mathbf x_0\) and \(\mathbf v= \mathbf 0\) along with a given mass matrix \(\mathbf M\), FIRE algorithm is as follows,

  1. Calculate \(\mathbf g = \nabla E(\mathbf x)\) and check for convergence ( \(\mathbf g \cdot \mathbf g < \epsilon^2 \)).
  2. Update \(\mathbf x\) and \(V\) using simple (forward) Euler integration step,
    \(\mathbf x = \mathbf x + \Delta t \mathbf v\),
    \(\mathbf v = \mathbf v + \Delta t \mathbf M^{-1} \cdot \mathbf g\).
  3. Calculate \(p = \mathbf g \cdot \mathbf v\).
  4. Set \(\mathbf v = (1-\alpha) \mathbf v + \alpha \frac{|\mathbf v|}{|\mathbf g|} \mathbf g\).
  5. If \(p<0\) and number of steps since \(p\) was last negative is larger than certain value, then increase time step \(\Delta t\) and decrease \(\alpha\).
  6. If \(p>0\), then decrease the time step, freeze the system i.e., \(\mathbf v = \mathbf 0\) and reset \(\alpha = \alpha_0\).
  7. Return to 1.

Also see Energy-Minimization in Atomic-to-Continuum Scale-Bridging Methods by Eidel et al. 2011.

Author
Vishal Boddu, Denis Davydov, 2017

Definition at line 89 of file solver_fire.h.

Constructor & Destructor Documentation

template<typename VectorType = Vector<double>>
SolverFIRE< VectorType >::SolverFIRE ( SolverControl solver_control,
VectorMemory< VectorType > &  vector_memory,
const AdditionalData data = AdditionalData() 
)

Constructor.

template<typename VectorType = Vector<double>>
SolverFIRE< VectorType >::SolverFIRE ( SolverControl solver_control,
const AdditionalData data 
)

Constructor. Use an object of type GrowingVectorMemory as a default to allocate memory.

template<typename VectorType = Vector<double>>
virtual SolverFIRE< VectorType >::~SolverFIRE ( )
virtual

Virtual destructor.

Member Function Documentation

template<typename VectorType = Vector<double>>
template<typename PreconditionerType = DiagonalMatrix<VectorType>>
void SolverFIRE< VectorType >::solve ( const std::function< double(VectorType &, const VectorType &)> &  compute,
VectorType &  x,
const PreconditionerType &  inverse_mass_matrix 
)

Obtain a set of variables x that minimize an objective function described by the polymorphic function wrapper compute, with a given preconditioner inverse_mass_matrix and initial x values. The function compute returns the objective function's value and updates the objective function's gradient (with respect to the variables) when passed in as first argument based on the second argument– the state of variables.

template<typename VectorType = Vector<double>>
template<typename MatrixType , typename PreconditionerType >
void SolverFIRE< VectorType >::solve ( const MatrixType &  A,
VectorType &  x,
const VectorType &  b,
const PreconditionerType &  precondition 
)

Solve for x that minimizes \(E(\mathbf x)\) for the special case when \(E(\mathbf x) = \frac{1}{2} \mathbf x^{T} \mathbf A \mathbf x - \mathbf x^{T} \mathbf b\).

template<typename VectorType = Vector<double>>
virtual void SolverFIRE< VectorType >::print_vectors ( const unsigned  int,
const VectorType &  x,
const VectorType &  v,
const VectorType &  g 
) const
protectedvirtual

Interface for derived class. This function gets the current iteration x (variables), v (x's time derivative) and g (the gradient) in each step. It can be used for a graphical output of the convergence history.

Member Data Documentation

template<typename VectorType = Vector<double>>
const AdditionalData SolverFIRE< VectorType >::additional_data
protected

Additional data to the solver.

Definition at line 187 of file solver_fire.h.


The documentation for this class was generated from the following file: