oomph::AugmentedBlockFoldLinearSolver Class Reference

#include <assembly_handler.h>

Inheritance diagram for oomph::AugmentedBlockFoldLinearSolver:

Public Member Functions
	AugmentedBlockFoldLinearSolver (LinearSolver *const linear_solver_pt)
	Constructor, inherits the original linear solver. More...
	~AugmentedBlockFoldLinearSolver ()
	Destructor: clean up the allocated memory. More...
void	solve (Problem *const &problem_pt, DoubleVector &result)
	The solve function uses the block factorisation. More...
void	solve (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &result)
void	solve (DoubleMatrixBase *const &matrix_pt, const Vector< double > &rhs, Vector< double > &result)
void	resolve (const DoubleVector &rhs, DoubleVector &result)
	The resolve function also uses the block factorisation. More...
LinearSolver *	linear_solver_pt () const
	Access function to the original linear solver. More...
Public Member Functions inherited from oomph::LinearSolver
	LinearSolver ()
	Empty constructor, initialise the member data. More...
	LinearSolver (const LinearSolver &dummy)=delete
	Broken copy constructor. More...
void	operator= (const LinearSolver &)=delete
	Broken assignment operator. More...
virtual	~LinearSolver ()
	Empty virtual destructor. More...
void	enable_doc_time ()
	Enable documentation of solve times. More...
void	disable_doc_time ()
	Disable documentation of solve times. More...
bool	is_doc_time_enabled () const
	Is documentation of solve times enabled? More...
bool	is_resolve_enabled () const
	Boolean flag indicating if resolves are enabled. More...
virtual void	enable_resolve ()
virtual void	disable_resolve ()
virtual void	solve_transpose (Problem *const &problem_pt, DoubleVector &result)
virtual void	solve_transpose (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &result)
virtual void	solve_transpose (DoubleMatrixBase *const &matrix_pt, const Vector< double > &rhs, Vector< double > &result)
virtual void	resolve_transpose (const DoubleVector &rhs, DoubleVector &result)
virtual void	clean_up_memory ()
virtual double	jacobian_setup_time () const
virtual double	linear_solver_solution_time () const
virtual void	enable_computation_of_gradient ()
void	disable_computation_of_gradient ()
void	reset_gradient ()
void	get_gradient (DoubleVector &gradient)
	function to access the gradient, provided it has been computed More...
Public Member Functions inherited from oomph::DistributableLinearAlgebraObject
	DistributableLinearAlgebraObject ()
	Default constructor - create a distribution. More...
	DistributableLinearAlgebraObject (const DistributableLinearAlgebraObject &matrix)=delete
	Broken copy constructor. More...
void	operator= (const DistributableLinearAlgebraObject &)=delete
	Broken assignment operator. More...
virtual	~DistributableLinearAlgebraObject ()
	Destructor. More...
LinearAlgebraDistribution *	distribution_pt () const
	access to the LinearAlgebraDistribution More...
unsigned	nrow () const
	access function to the number of global rows. More...
unsigned	nrow_local () const
	access function for the num of local rows on this processor. More...
unsigned	nrow_local (const unsigned &p) const
	access function for the num of local rows on this processor. More...
unsigned	first_row () const
	access function for the first row on this processor More...
unsigned	first_row (const unsigned &p) const
	access function for the first row on this processor More...
bool	distributed () const
	distribution is serial or distributed More...
bool	distribution_built () const
void	build_distribution (const LinearAlgebraDistribution *const dist_pt)
void	build_distribution (const LinearAlgebraDistribution &dist)

Private Attributes
LinearSolver *	Linear_solver_pt
	Pointer to the original linear solver. More...
Problem *	Problem_pt
DoubleVector *	Alpha_pt
	Pointer to the storage for the vector alpha. More...
DoubleVector *	E_pt
	Pointer to the storage for the vector e. More...

Additional Inherited Members
Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()
Protected Attributes inherited from oomph::LinearSolver
bool	Enable_resolve
bool	Doc_time
	Boolean flag that indicates whether the time taken. More...
bool	Compute_gradient
bool	Gradient_has_been_computed
	flag that indicates whether the gradient was computed or not More...
DoubleVector	Gradient_for_glob_conv_newton_solve

Detailed Description

A custom linear solver class that is used to solve a block-factorised version of the Fold bifurcation detection problem.

Constructor & Destructor Documentation

AugmentedBlockFoldLinearSolver()

oomph::AugmentedBlockFoldLinearSolver::AugmentedBlockFoldLinearSolver ( LinearSolver *const  linear_solver_pt )

inline

Constructor, inherits the original linear solver.

      : Linear_solver_pt(linear_solver_pt), Problem_pt(0), Alpha_pt(0), E_pt(0)
    {
    }

~AugmentedBlockFoldLinearSolver()

oomph::AugmentedBlockFoldLinearSolver::~AugmentedBlockFoldLinearSolver

(

)

Destructor: clean up the allocated memory.

Clean up the memory that may have been allocated by the solver.

  {
    if (Alpha_pt != 0)
    {
      delete Alpha_pt;
    }
    if (E_pt != 0)
    {
      delete E_pt;
    }
  }

References Alpha_pt, and E_pt.

Member Function Documentation

linear_solver_pt()

LinearSolver* oomph::AugmentedBlockFoldLinearSolver::linear_solver_pt ( ) const

inline

Access function to the original linear solver.

    {
      return Linear_solver_pt;
    }

References Linear_solver_pt.

Referenced by oomph::FoldHandler::~FoldHandler().

resolve()

void oomph::AugmentedBlockFoldLinearSolver::resolve ( const DoubleVector &  rhs, DoubleVector &  result  )

virtual

The resolve function also uses the block factorisation.

Reimplemented from oomph::LinearSolver.

  {
    // Check that the factors have been stored
    if (Alpha_pt == 0)
    {
      throw OomphLibError("The required vectors have not been stored",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
 
    // Get the pointer to the problem
    Problem* const problem_pt = Problem_pt;
 
    FoldHandler* handler_pt =
      static_cast<FoldHandler*>(problem_pt->assembly_handler_pt());
 
    // Switch things to our block solver
    handler_pt->solve_augmented_block_system();
 
    // We need to find out the number of dofs in the problem
    unsigned n_dof = problem_pt->ndof();
 
#ifdef PARANOID
    // if the result is setup then it should not be distributed
    if (result.built())
    {
      if (result.distributed())
      {
        throw OomphLibError("The result vector must not be distributed",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
    // the rhs must be setup
    if (!rhs.built())
    {
      throw OomphLibError("The rhs vector must be setup",
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // if the result vector is not setup then rebuild with distribution = global
    if (!result.built())
    {
      result.build(rhs.distribution_pt(), 0.0);
    }
 
    // Setup storage
    DoubleVector a(this->distribution_pt(), 0.0),
      b(this->distribution_pt(), 0.0);
 
    // Set the values of the a vector
    for (unsigned n = 0; n < (n_dof - 1); n++)
    {
      a[n] = rhs[n];
    }
    // The entry associated with the additional parameter is zero
    a[n_dof - 1] = 0.0;
 
    Linear_solver_pt->enable_resolve();
 
    // Copy rhs vector into local storage so it doesn't get overwritten
    // if the linear solver decides to initialise the solution vector, say,
    // which it's quite entitled to do!
    DoubleVector input_a(a);
 
    Linear_solver_pt->resolve(input_a, a);
 
    // We can now construct our multipliers
    // Prepare to scale
    double dof_length = 0.0, a_length = 0.0;
    for (unsigned n = 0; n < n_dof; n++)
    {
      if (std::fabs(problem_pt->dof(n)) > dof_length)
      {
        dof_length = std::fabs(problem_pt->dof(n));
      }
 
      if (std::fabs(a[n]) > a_length)
      {
        a_length = std::fabs(a[n]);
      }
    }
    double a_mult = dof_length / a_length;
    const double FD_step = 1.0e-8;
    a_mult += FD_step;
    a_mult *= FD_step;
 
    DoubleVector Jprod_a(this->distribution_pt(), 0.0);
 
    unsigned long n_element = problem_pt->mesh_pt()->nelement();
    for (unsigned long e = 0; e < n_element; e++)
    {
      GeneralisedElement* elem_pt = problem_pt->mesh_pt()->element_pt(e);
      // Loop over the ndofs in each element
      unsigned n_var = handler_pt->ndof(elem_pt);
      // Get some jacobian matrices
      DenseMatrix<double> jac(n_var), jac_a(n_var);
      // the elemental residual
      Vector<double> res_elemental(n_var);
      // Get unperturbed jacobian
      handler_pt->get_jacobian(elem_pt, res_elemental, jac);
 
      // Backup the dofs
      Vector<double> dof_bac(n_var);
      // Perturb the dofs
      for (unsigned n = 0; n < n_var; n++)
      {
        unsigned eqn_number = handler_pt->eqn_number(elem_pt, n);
        dof_bac[n] = problem_pt->dof(eqn_number);
        // Pertub by vector a
        problem_pt->dof(eqn_number) += a_mult * a[eqn_number];
      }
 
      problem_pt->actions_after_change_in_bifurcation_parameter();
 
      // Now get the new jacobian
      handler_pt->get_jacobian(elem_pt, res_elemental, jac_a);
 
      // Reset the dofs
      for (unsigned n = 0; n < n_var; n++)
      {
        unsigned eqn_number = handler_pt->eqn_number(elem_pt, n);
        problem_pt->dof(eqn_number) = dof_bac[n];
      }
 
      problem_pt->actions_after_change_in_bifurcation_parameter();
 
      // OK, now work out the products
      for (unsigned n = 0; n < (n_var - 1); n++)
      {
        unsigned eqn_number = handler_pt->eqn_number(elem_pt, n);
        double prod_a = 0.0;
        for (unsigned m = 0; m < (n_var - 1); m++)
        {
          unsigned unknown = handler_pt->eqn_number(elem_pt, m);
          prod_a += (jac_a(n, m) - jac(n, m)) * handler_pt->Y[unknown];
        }
        Jprod_a[eqn_number] += prod_a / a_mult;
      }
    }
 
    Jprod_a[n_dof - 1] = 0.0;
 
    // OK, now we can formulate the next vectors
    for (unsigned n = 0; n < n_dof - 1; n++)
    {
      b[n] = rhs[n_dof + n] - Jprod_a[n];
    }
    // The residuals for the final entry should be those associated
    // with the parameter
    b[n_dof - 1] = rhs[n_dof - 1];
 
    DoubleVector f(this->distribution_pt(), 0.0);
 
    Linear_solver_pt->resolve(b, f);
 
    // Calculate the final entry in the vector d
    const double d_final = f[n_dof - 1] / (*E_pt)[n_dof - 1];
    // Assemble the final corrections
    for (unsigned n = 0; n < n_dof - 1; n++)
    {
      result[n] = a[n] - (*Alpha_pt)[n] * d_final + d_final * handler_pt->Y[n];
      result[n_dof + n] = f[n] - (*E_pt)[n] * d_final;
    }
    // The result corresponding to the paramater
    result[n_dof - 1] = a[n_dof - 1] - (*Alpha_pt)[n_dof - 1] * d_final;
 
    Linear_solver_pt->disable_resolve();
 
    // Switch things to our block solver
    handler_pt->solve_full_system();
  }

References a, oomph::Problem::actions_after_change_in_bifurcation_parameter(), Alpha_pt, oomph::Problem::assembly_handler_pt(), b, oomph::DoubleVector::build(), oomph::DoubleVector::built(), oomph::LinearSolver::disable_resolve(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::Problem::dof(), e(), oomph::Mesh::element_pt(), oomph::LinearSolver::enable_resolve(), oomph::FoldHandler::eqn_number(), f(), boost::multiprecision::fabs(), oomph::BlackBoxFDNewtonSolver::FD_step, oomph::FoldHandler::get_jacobian(), Linear_solver_pt, m, oomph::Problem::mesh_pt(), n, oomph::Problem::ndof(), oomph::FoldHandler::ndof(), oomph::Mesh::nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Problem_pt, oomph::LinearSolver::resolve(), oomph::FoldHandler::solve_augmented_block_system(), oomph::FoldHandler::solve_full_system(), and oomph::FoldHandler::Y.

solve() [1/3]

void oomph::AugmentedBlockFoldLinearSolver::solve ( DoubleMatrixBase *const &  matrix_pt, const DoubleVector &  rhs, DoubleVector &  result  )

inlinevirtual

The linear-algebra-type solver does not make sense. The interface is deliberately broken

Reimplemented from oomph::LinearSolver.

    {
      throw OomphLibError(
        "Linear-algebra interface does not make sense for this linear solver\n",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

solve() [2/3]

void oomph::AugmentedBlockFoldLinearSolver::solve ( DoubleMatrixBase *const &  matrix_pt, const Vector< double > &  rhs, Vector< double > &  result  )

inlinevirtual

The linear-algebra-type solver does not make sense. The interface is deliberately broken

Reimplemented from oomph::LinearSolver.

    {
      throw OomphLibError(
        "Linear-algebra interface does not make sense for this linear solver\n",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

solve() [3/3]

void oomph::AugmentedBlockFoldLinearSolver::solve ( Problem *const &  problem_pt, DoubleVector &  result  )

virtual

The solve function uses the block factorisation.

Use a block factorisation to solve the augmented system associated with a PitchFork bifurcation.

Implements oomph::LinearSolver.

  {
    // if the result is setup then it should not be distributed
#ifdef PARANOID
    if (result.built())
    {
      if (result.distributed())
      {
        throw OomphLibError("The result vector must not be distributed",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
#endif
 
    // Locally cache the pointer to the handler.
    FoldHandler* handler_pt =
      static_cast<FoldHandler*>(problem_pt->assembly_handler_pt());
 
    // Switch the handler to "block solver" mode
    handler_pt->solve_augmented_block_system();
 
    // We need to find out the number of dofs in the problem
    unsigned n_dof = problem_pt->ndof();
 
    // create the linear algebra distribution for this solver
    // currently only global (non-distributed) distributions are allowed
    LinearAlgebraDistribution dist(problem_pt->communicator_pt(), n_dof, false);
    this->build_distribution(dist);
 
    // if the result vector is not setup then rebuild with distribution = global
    if (!result.built())
    {
      result.build(this->distribution_pt(), 0.0);
    }
 
    // Setup storage for temporary vectors
    DoubleVector a(this->distribution_pt(), 0.0),
      b(this->distribution_pt(), 0.0);
 
    // Allocate storage for Alpha which can be used in the resolve
    if (Alpha_pt != 0)
    {
      delete Alpha_pt;
    }
    Alpha_pt = new DoubleVector(this->distribution_pt(), 0.0);
 
    // We are going to do resolves using the underlying linear solver
    Linear_solver_pt->enable_resolve();
 
    // Solve the first system Aa = R
    Linear_solver_pt->solve(problem_pt, a);
 
    // The vector in the top right-hand block is the jacobian multiplied
    // by the null vector
 
    // Get the present null vector from the handler
    DoubleVector y(this->distribution_pt(), 0.0);
    for (unsigned n = 0; n < (n_dof - 1); ++n)
    {
      y[n] = handler_pt->Y[n];
    }
    // For simplicity later, add a zero at the end
    y[n_dof - 1] = 0.0;
 
    // Loop over the elements and assemble the product
    // Local storage for the product terms
    DoubleVector Jy(this->distribution_pt(), 0.0);
 
    // Calculate the product of the jacobian matrices, etc
    unsigned long n_element = problem_pt->mesh_pt()->nelement();
    for (unsigned long e = 0; e < n_element; e++)
    {
      GeneralisedElement* elem_pt = problem_pt->mesh_pt()->element_pt(e);
      // Loop over the ndofs in each element
      unsigned n_var = elem_pt->ndof();
      // Get the jacobian matrix
      DenseMatrix<double> jac(n_var);
      // storage for the residual
      Vector<double> res(n_var);
      // Get unperturbed raw jacobian
      elem_pt->get_jacobian(res, jac);
 
      // Multiply the dofs
      for (unsigned n = 0; n < n_var; n++)
      {
        unsigned eqn_number = elem_pt->eqn_number(n);
        for (unsigned m = 0; m < n_var; m++)
        {
          unsigned unknown = elem_pt->eqn_number(m);
          Jy[eqn_number] += jac(n, m) * y[unknown];
        }
      }
    }
    // The final entry of the vector will be zero
 
    // Now resolve to find alpha
    Linear_solver_pt->resolve(Jy, *Alpha_pt);
 
    // The vector that multiplie the product matrix is actually y - alpha
    DoubleVector y_minus_alpha(this->distribution_pt(), 0.0);
    for (unsigned n = 0; n < n_dof; n++)
    {
      y_minus_alpha[n] = y[n] - (*Alpha_pt)[n];
    }
 
    // We can now construct our multipliers
    // Prepare to scale
    double dof_length = 0.0, a_length = 0.0, alpha_length = 0.0;
    for (unsigned n = 0; n < n_dof; n++)
    {
      if (std::fabs(problem_pt->dof(n)) > dof_length)
      {
        dof_length = std::fabs(problem_pt->dof(n));
      }
      if (std::fabs(a[n]) > a_length)
      {
        a_length = std::fabs(a[n]);
      }
      if (std::fabs(y_minus_alpha[n]) > alpha_length)
      {
        alpha_length = std::fabs(y_minus_alpha[n]);
      }
    }
 
    double a_mult = dof_length / a_length;
    double alpha_mult = dof_length / alpha_length;
    const double FD_step = 1.0e-8;
    a_mult += FD_step;
    alpha_mult += FD_step;
    a_mult *= FD_step;
    alpha_mult *= FD_step;
 
    // Local storage for the product terms
    DoubleVector Jprod_a(this->distribution_pt(), 0.0),
      Jprod_alpha(this->distribution_pt(), 0.0);
 
    // Calculate the product of the jacobian matrices, etc
    for (unsigned long e = 0; e < n_element; e++)
    {
      GeneralisedElement* elem_pt = problem_pt->mesh_pt()->element_pt(e);
      // Loop over the ndofs in each element
      unsigned n_var = handler_pt->ndof(elem_pt);
      // Get the jacobian matrices
      DenseMatrix<double> jac(n_var), jac_a(n_var), jac_alpha(n_var);
      // elemental residual storage
      Vector<double> res_elemental(n_var);
      // Get unperturbed jacobian
      handler_pt->get_jacobian(elem_pt, res_elemental, jac);
 
      // Backup the dofs
      Vector<double> dof_bac(n_var);
      // Perturb the dofs
      for (unsigned n = 0; n < n_var; n++)
      {
        unsigned eqn_number = handler_pt->eqn_number(elem_pt, n);
        dof_bac[n] = problem_pt->dof(eqn_number);
        // Pertub by vector a
        problem_pt->dof(eqn_number) += a_mult * a[eqn_number];
      }
 
      problem_pt->actions_after_change_in_bifurcation_parameter();
 
      // Now get the new jacobian
      handler_pt->get_jacobian(elem_pt, res_elemental, jac_a);
 
      // Perturb the dofs
      for (unsigned n = 0; n < n_var; n++)
      {
        unsigned eqn_number = handler_pt->eqn_number(elem_pt, n);
        problem_pt->dof(eqn_number) = dof_bac[n];
        // Pertub by vector a
        problem_pt->dof(eqn_number) += alpha_mult * y_minus_alpha[eqn_number];
      }
 
      problem_pt->actions_after_change_in_bifurcation_parameter();
 
      // Now get the new jacobian
      handler_pt->get_jacobian(elem_pt, res_elemental, jac_alpha);
 
      // Reset the dofs
      for (unsigned n = 0; n < n_var; n++)
      {
        unsigned eqn_number = handler_pt->eqn_number(elem_pt, n);
        problem_pt->dof(eqn_number) = dof_bac[n];
      }
 
      problem_pt->actions_after_change_in_bifurcation_parameter();
 
      // OK, now work out the products
      // Note the (n_var-1), we are only interested in the non-augmented
      // jacobian
      for (unsigned n = 0; n < (n_var - 1); n++)
      {
        unsigned eqn_number = handler_pt->eqn_number(elem_pt, n);
        double prod_a = 0.0, prod_alpha = 0.0;
        for (unsigned m = 0; m < (n_var - 1); m++)
        {
          unsigned unknown = handler_pt->eqn_number(elem_pt, m);
          prod_a += (jac_a(n, m) - jac(n, m)) * y[unknown];
          prod_alpha += (jac_alpha(n, m) - jac(n, m)) * y[unknown];
        }
        Jprod_a[eqn_number] += prod_a / a_mult;
        Jprod_alpha[eqn_number] += prod_alpha / alpha_mult;
      }
    }
 
    Jprod_alpha[n_dof - 1] = 0.0;
    Jprod_a[n_dof - 1] = 0.0;
 
    // OK, now we can formulate the next vectors
    // The assumption here is that the result has been set to the
    // residuals.
    for (unsigned n = 0; n < n_dof - 1; n++)
    {
      b[n] = result[n_dof + n] - Jprod_a[n];
    }
    // The final residual is the entry corresponding to the original parameter
    b[n_dof - 1] = result[n_dof - 1];
 
    // Allocate storage for E which can be used in the resolve
    if (E_pt != 0)
    {
      delete E_pt;
    }
    E_pt = new DoubleVector(this->distribution_pt(), 0.0);
    DoubleVector f(this->distribution_pt(), 0.0);
    Linear_solver_pt->resolve(b, f);
    Linear_solver_pt->resolve(Jprod_alpha, *E_pt);
 
    // Calculate the final entry in the vector e
    const double e_final = (*E_pt)[n_dof - 1];
    // Calculate the final entry in the vector d
    const double d_final = f[n_dof - 1] / e_final;
    // Assemble the final corrections
    for (unsigned n = 0; n < n_dof - 1; n++)
    {
      result[n] = a[n] - (*Alpha_pt)[n] * d_final + d_final * y[n];
      result[n_dof + n] = f[n] - (*E_pt)[n] * d_final;
    }
    // The result corresponding to the parameter
    result[n_dof - 1] = a[n_dof - 1] - (*Alpha_pt)[n_dof - 1] * d_final;
 
    // The sign of the jacobian is the sign of the final entry in e
    problem_pt->sign_of_jacobian() =
      static_cast<int>(std::fabs(e_final) / e_final);
 
    // Switch things to our block solver
    handler_pt->solve_full_system();
 
    // If we are not storing things, clear the results
    if (!Enable_resolve)
    {
      // We no longer need to store the matrix
      Linear_solver_pt->disable_resolve();
      delete Alpha_pt;
      Alpha_pt = 0;
      delete E_pt;
      E_pt = 0;
    }
    // Otherwise, also store the problem pointer
    else
    {
      Problem_pt = problem_pt;
    }
  }

References a, oomph::Problem::actions_after_change_in_bifurcation_parameter(), Alpha_pt, oomph::Problem::assembly_handler_pt(), b, oomph::DoubleVector::build(), oomph::DistributableLinearAlgebraObject::build_distribution(), oomph::DoubleVector::built(), oomph::Problem::communicator_pt(), oomph::LinearSolver::disable_resolve(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::Problem::dof(), e(), E_pt, oomph::Mesh::element_pt(), oomph::LinearSolver::Enable_resolve, oomph::LinearSolver::enable_resolve(), oomph::GeneralisedElement::eqn_number(), oomph::FoldHandler::eqn_number(), f(), boost::multiprecision::fabs(), oomph::BlackBoxFDNewtonSolver::FD_step, oomph::FoldHandler::get_jacobian(), oomph::GeneralisedElement::get_jacobian(), Linear_solver_pt, m, oomph::Problem::mesh_pt(), n, oomph::GeneralisedElement::ndof(), oomph::Problem::ndof(), oomph::FoldHandler::ndof(), oomph::Mesh::nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Problem_pt, res, oomph::LinearSolver::resolve(), oomph::Problem::sign_of_jacobian(), oomph::LinearSolver::solve(), oomph::FoldHandler::solve_augmented_block_system(), oomph::FoldHandler::solve_full_system(), y, and oomph::FoldHandler::Y.

Member Data Documentation

Alpha_pt

DoubleVector* oomph::AugmentedBlockFoldLinearSolver::Alpha_pt

private

Pointer to the storage for the vector alpha.

Referenced by resolve(), solve(), and ~AugmentedBlockFoldLinearSolver().

E_pt

DoubleVector* oomph::AugmentedBlockFoldLinearSolver::E_pt

private

Pointer to the storage for the vector e.

Referenced by solve(), and ~AugmentedBlockFoldLinearSolver().

Linear_solver_pt

LinearSolver* oomph::AugmentedBlockFoldLinearSolver::Linear_solver_pt

private

Pointer to the original linear solver.

Referenced by linear_solver_pt(), resolve(), and solve().

Problem_pt

Problem* oomph::AugmentedBlockFoldLinearSolver::Problem_pt

private

Referenced by resolve(), and solve().

---

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

• assembly_handler.h
• assembly_handler.cc