#include <assembly_handler.h>

Inheritance diagram for oomph::AugmentedBlockPitchForkLinearSolver:

Public Member Functions
	AugmentedBlockPitchForkLinearSolver (LinearSolver *const linear_solver_pt)
	Constructor, inherits the original linear solver. More...

	~AugmentedBlockPitchForkLinearSolver ()
	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
	Pointer to the problem, used in the resolve. More...

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 PitchFork bifurcation detection problem.

Constructor & Destructor Documentation

◆ AugmentedBlockPitchForkLinearSolver()

oomph::AugmentedBlockPitchForkLinearSolver::AugmentedBlockPitchForkLinearSolver ( 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)
     {
     }

◆ ~AugmentedBlockPitchForkLinearSolver()

oomph::AugmentedBlockPitchForkLinearSolver::~AugmentedBlockPitchForkLinearSolver ( )

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::AugmentedBlockPitchForkLinearSolver::linear_solver_pt ( ) const

inline

Access function to the original linear solver.

     {
       return Linear_solver_pt;
     }

References Linear_solver_pt.

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

◆ resolve()

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

virtual

The resolve function also uses the block factorisation.

Reimplemented from oomph::LinearSolver.

   {
     std::cout << "Augmented pitchfork resolve" << std::endl;
     // 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;
  
     PitchForkHandler* handler_pt =
       static_cast<PitchForkHandler*>(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
     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
     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; n++)
     {
       a[n] = rhs[n];
     }
  
     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
       DoubleVector dof_bac(this->distribution_pt(), 0.0);
       // 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];
     }
     b[n_dof - 1] = rhs[2 * 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;
       result[n_dof + n] = f[n] + (*E_pt)[n] * d_final;
     }
  
     result[n_dof - 1] = a[n_dof - 1] - (*Alpha_pt)[n_dof - 1] * d_final;
     result[2 * 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::DistributableLinearAlgebraObject::build_distribution(), oomph::DoubleVector::built(), oomph::Problem::communicator_pt(), oomph::LinearSolver::disable_resolve(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::Problem::dof(), e(), oomph::Mesh::element_pt(), oomph::LinearSolver::enable_resolve(), oomph::PitchForkHandler::eqn_number(), f(), boost::multiprecision::fabs(), oomph::BlackBoxFDNewtonSolver::FD_step, oomph::PitchForkHandler::get_jacobian(), Linear_solver_pt, m, oomph::Problem::mesh_pt(), n, oomph::Problem::ndof(), oomph::PitchForkHandler::ndof(), oomph::Mesh::nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Problem_pt, oomph::LinearSolver::resolve(), oomph::PitchForkHandler::solve_augmented_block_system(), oomph::PitchForkHandler::solve_full_system(), and oomph::PitchForkHandler::Y.

◆ solve() [1/3]

void oomph::AugmentedBlockPitchForkLinearSolver::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::AugmentedBlockPitchForkLinearSolver::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::AugmentedBlockPitchForkLinearSolver::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.

   {
     std::cout << "Augmented pitchfork solve" << std::endl;
     // 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.
     PitchForkHandler* handler_pt =
       static_cast<PitchForkHandler*>(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);
  
     // Get the symmetry vector from the handler
     DoubleVector psi(this->distribution_pt(), 0.0);
     for (unsigned n = 0; n < (n_dof - 1); ++n)
     {
       psi[n] = handler_pt->Psi[n];
     }
     // Set the final entry to zero
     psi[n_dof - 1] = 0.0;
  
     // Now resolve to find alpha
     Linear_solver_pt->resolve(psi, *Alpha_pt);
  
     // 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((*Alpha_pt)[n]) > alpha_length)
       {
         alpha_length = std::fabs((*Alpha_pt)[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
     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 the jacobian matrices
       DenseMatrix<double> jac(n_var), jac_a(n_var), jac_alpha(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);
  
       // 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 * (*Alpha_pt)[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
       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)) * handler_pt->Y[unknown];
           prod_alpha += (jac_alpha(n, m) - jac(n, m)) * handler_pt->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];
     }
     b[n_dof - 1] = result[2 * 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;
       result[n_dof + n] = f[n] + (*E_pt)[n] * d_final;
     }
  
     result[n_dof - 1] = a[n_dof - 1] - (*Alpha_pt)[n_dof - 1] * d_final;
     result[2 * 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 pointer to the problem
     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::PitchForkHandler::eqn_number(), f(), boost::multiprecision::fabs(), oomph::BlackBoxFDNewtonSolver::FD_step, oomph::PitchForkHandler::get_jacobian(), Linear_solver_pt, m, oomph::Problem::mesh_pt(), n, oomph::Problem::ndof(), oomph::PitchForkHandler::ndof(), oomph::Mesh::nelement(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Problem_pt, oomph::PitchForkHandler::Psi, oomph::LinearSolver::resolve(), oomph::Problem::sign_of_jacobian(), oomph::LinearSolver::solve(), oomph::PitchForkHandler::solve_augmented_block_system(), oomph::PitchForkHandler::solve_full_system(), and oomph::PitchForkHandler::Y.

Member Data Documentation

◆ Alpha_pt

DoubleVector* oomph::AugmentedBlockPitchForkLinearSolver::Alpha_pt

private

Pointer to the storage for the vector alpha.

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

◆ E_pt

DoubleVector* oomph::AugmentedBlockPitchForkLinearSolver::E_pt

private

Pointer to the storage for the vector e.

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

◆ Linear_solver_pt

LinearSolver* oomph::AugmentedBlockPitchForkLinearSolver::Linear_solver_pt

private

Pointer to the original linear solver.

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

◆ Problem_pt

Problem* oomph::AugmentedBlockPitchForkLinearSolver::Problem_pt

private

Pointer to the problem, used in the resolve.

Referenced by resolve(), and solve().

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

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ AugmentedBlockPitchForkLinearSolver()

◆ ~AugmentedBlockPitchForkLinearSolver()

Member Function Documentation

◆ linear_solver_pt()

◆ resolve()

◆ solve() [1/3]

◆ solve() [2/3]

◆ solve() [3/3]

Member Data Documentation

◆ Alpha_pt

◆ E_pt

◆ Linear_solver_pt

◆ Problem_pt