oomph::DenseLU Class Reference

#include <linear_solver.h>

Inheritance diagram for oomph::DenseLU:

Public Member Functions
	DenseLU ()
	Constructor, initialise storage. More...
	DenseLU (const DenseLU &dummy)=delete
	Broken copy constructor. More...
void	operator= (const DenseLU &)=delete
	Broken assignment operator. More...
	~DenseLU ()
	Destructor, clean up the stored LU factors. More...
void	solve (Problem *const &problem_pt, DoubleVector &result)
void	solve (DoubleMatrixBase *const &matrix_pt, const DoubleVector &rhs, DoubleVector &result)
void	solve (DoubleMatrixBase *const &matrix_pt, const Vector< double > &rhs, Vector< double > &result)
double	jacobian_setup_time () const
virtual double	linear_solver_solution_time () const
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 (const DoubleVector &rhs, DoubleVector &result)
virtual void	resolve_transpose (const DoubleVector &rhs, DoubleVector &result)
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)

Protected Member Functions
void	factorise (DoubleMatrixBase *const &matrix_pt)
	Perform the LU decomposition of the matrix. More...
void	backsub (const DoubleVector &rhs, DoubleVector &result)
	Do the backsubstitution step to solve the system LU result = rhs. More...
void	backsub (const Vector< double > &rhs, Vector< double > &result)
	perform back substitution using Vector<double> More...
void	clean_up_memory ()
	Clean up the stored LU factors. More...
Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()

Protected Attributes
double	Jacobian_setup_time
	Jacobian setup time. More...
double	Solution_time
	Solution time. More...
int	Sign_of_determinant_of_matrix
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

Private Attributes
long *	Index
	Pointer to storage for the index of permutations in the LU solve. More...
double *	LU_factors
	Pointer to storage for the LU decomposition. More...

Friends
class	DenseDoubleMatrix
	The DenseDoubleMatrix class is a friend. More...

Detailed Description

Dense LU decomposition-based solve of full assembled linear system. VERY inefficient but useful to illustrate the principle. Only suitable for use with Serial matrices and vectors. This solver will only work with non-distributed matrices and vectors (note: DenseDoubleMatrix is not distributable)

Constructor & Destructor Documentation

DenseLU() [1/2]

oomph::DenseLU::DenseLU ( )

inline

Constructor, initialise storage.

      : Jacobian_setup_time(0.0),
        Solution_time(0.0),
        Sign_of_determinant_of_matrix(0),
        Index(0),
        LU_factors(0)
    {
      // Shut up!
      Doc_time = false;
    }

References oomph::LinearSolver::Doc_time.

DenseLU() [2/2]

oomph::DenseLU::DenseLU ( const DenseLU &  dummy )

delete

Broken copy constructor.

~DenseLU()

oomph::DenseLU::~DenseLU ( )

inline

Destructor, clean up the stored LU factors.

    {
      clean_up_memory();
    }

References clean_up_memory().

Member Function Documentation

backsub() [1/2]

void oomph::DenseLU::backsub ( const DoubleVector &  rhs, DoubleVector &  result  )

protected

Do the backsubstitution step to solve the system LU result = rhs.

Do the backsubstitution for the DenseLU solver. WARNING: this class does not perform any PARANOID checks on the vectors - these are all performed in the solve(...) method.

  {
    // Get pointers to first entries
    const double* rhs_pt = rhs.values_pt();
    double* result_pt = result.values_pt();
 
    // Copy the rhs vector into the result vector
    const unsigned long n = rhs.nrow();
    for (unsigned long i = 0; i < n; ++i)
    {
      result_pt[i] = rhs_pt[i];
    }
 
    // Loop over all rows for forward substition
    unsigned long k = 0;
    for (unsigned long i = 0; i < n; i++)
    {
      unsigned long ip = Index[i];
      double sum = result_pt[ip];
      result_pt[ip] = result_pt[i];
      if (k != 0)
      {
        for (unsigned long j = k - 1; j < i; j++)
        {
          sum -= LU_factors[n * i + j] * result_pt[j];
        }
      }
      else if (sum != 0.0)
      {
        k = i + 1;
      }
      result_pt[i] = sum;
    }
 
    // Now do the back substitution
    for (long i = long(n) - 1; i >= 0; i--)
    {
      double sum = result_pt[i];
      for (long j = i + 1; j < long(n); j++)
      {
        sum -= LU_factors[n * i + j] * result_pt[j];
      }
      result_pt[i] = sum / LU_factors[n * i + i];
    }
  }

References i, Index, j, k, LU_factors, n, oomph::DistributableLinearAlgebraObject::nrow(), and oomph::DoubleVector::values_pt().

Referenced by solve().

backsub() [2/2]

void oomph::DenseLU::backsub ( const Vector< double > &  rhs, Vector< double > &  result  )

protected

perform back substitution using Vector<double>

Do the backsubstitution for the DenseLU solver. WARNING: this class does not perform any PARANOID checks on the vectors - these are all performed in the solve(...) method. So, if you call backsub directly, you have been warned...

  {
    // Copy the rhs vector into the result vector
    const unsigned long n = rhs.size();
    for (unsigned long i = 0; i < n; ++i)
    {
      result[i] = rhs[i];
    }
 
    // Loop over all rows for forward substition
    unsigned long k = 0;
    for (unsigned long i = 0; i < n; i++)
    {
      unsigned long ip = Index[i];
      double sum = result[ip];
      result[ip] = result[i];
      if (k != 0)
      {
        for (unsigned long j = k - 1; j < i; j++)
        {
          sum -= LU_factors[n * i + j] * result[j];
        }
      }
      else if (sum != 0.0)
      {
        k = i + 1;
      }
      result[i] = sum;
    }
 
    // Now do the back substitution
    for (long i = long(n) - 1; i >= 0; i--)
    {
      double sum = result[i];
      for (long j = i + 1; j < long(n); j++)
      {
        sum -= LU_factors[n * i + j] * result[j];
      }
      result[i] = sum / LU_factors[n * i + i];
    }
  }

References i, Index, j, k, LU_factors, and n.

clean_up_memory()

void oomph::DenseLU::clean_up_memory ( )

protectedvirtual

Clean up the stored LU factors.

Delete the storage that has been allocated for the LU factors, if the matrix data is not itself being overwritten.

Reimplemented from oomph::LinearSolver.

  {
    // delete the Distribution_pt
    this->clear_distribution();
 
    // Clean up the LU factor storage, if it has been allocated
    // N.B. we don't need to check the index storage as well.
    if (LU_factors != 0)
    {
      // Delete the pointer to the LU factors
      delete[] LU_factors;
      // Null out the vector
      LU_factors = 0;
      // Delete the pointer to the Index
      delete[] Index;
      // Null out
      Index = 0;
    }
  }

References oomph::DistributableLinearAlgebraObject::clear_distribution(), Index, and LU_factors.

Referenced by factorise(), solve(), and ~DenseLU().

factorise()

void oomph::DenseLU::factorise ( DoubleMatrixBase *const &  matrix_pt )

protected

Perform the LU decomposition of the matrix.

LU decompose the matrix. WARNING: this class does not perform any PARANOID checks on the vectors - these are all performed in the solve(...) method.

  {
    // Set the number of unknowns
    const unsigned long n = matrix_pt->nrow();
 
    // Small constant
    const double small_number = 1.0e-20;
 
    // Vector scaling stores the implicit scaling of each row
    Vector<double> scaling(n);
 
    // Integer to store the sign that must multiply the determinant as
    // a consequence of the row/column interchanges
    int signature = 1;
 
    // Loop over rows to get implicit scaling information
    for (unsigned long i = 0; i < n; i++)
    {
      double largest_entry = 0.0;
      for (unsigned long j = 0; j < n; j++)
      {
        double tmp = std::fabs((*matrix_pt)(i, j));
        if (tmp > largest_entry) largest_entry = tmp;
      }
      if (largest_entry == 0.0)
      {
        throw OomphLibError(
          "Singular Matrix", OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
      // Save the scaling
      scaling[i] = 1.0 / largest_entry;
    }
 
    // Firsly, we shall delete any previous LU storage.
    // If the user calls this function twice without changing the matrix
    // then it is their own inefficiency, not ours (this time).
    clean_up_memory();
 
    // Allocate storage for the LU factors, the index and store
    // the number of unknowns
    LU_factors = new double[n * n];
    Index = new long[n];
 
    // Now we know that memory has been allocated, copy over
    // the matrix values
    unsigned count = 0;
    for (unsigned long i = 0; i < n; i++)
    {
      for (unsigned long j = 0; j < n; j++)
      {
        LU_factors[count] = (*matrix_pt)(i, j);
        ++count;
      }
    }
 
    // Loop over columns
    for (unsigned long j = 0; j < n; j++)
    {
      // Initialise imax
      unsigned long imax = 0;
 
      for (unsigned long i = 0; i < j; i++)
      {
        double sum = LU_factors[n * i + j];
        for (unsigned long k = 0; k < i; k++)
        {
          sum -= LU_factors[n * i + k] * LU_factors[n * k + j];
        }
        LU_factors[n * i + j] = sum;
      }
 
      // Initialise search for largest pivot element
      double largest_entry = 0.0;
      for (unsigned long i = j; i < n; i++)
      {
        double sum = LU_factors[n * i + j];
        for (unsigned long k = 0; k < j; k++)
        {
          sum -= LU_factors[n * i + k] * LU_factors[n * k + j];
        }
        LU_factors[n * i + j] = sum;
        // Set temporary
        double tmp = scaling[i] * std::fabs(sum);
        if (tmp >= largest_entry)
        {
          largest_entry = tmp;
          imax = i;
        }
      }
 
      // Test to see if we need to interchange rows
      if (j != imax)
      {
        for (unsigned long k = 0; k < n; k++)
        {
          double tmp = LU_factors[n * imax + k];
          LU_factors[n * imax + k] = LU_factors[n * j + k];
          LU_factors[n * j + k] = tmp;
        }
        // Change the parity of signature
        signature = -signature;
 
        // Interchange scale factor
        scaling[imax] = scaling[j];
      }
 
      // Set the index
      Index[j] = imax;
      if (LU_factors[n * j + j] == 0.0)
      {
        LU_factors[n * j + j] = small_number;
      }
      // Divide by pivot element
      if (j != n - 1)
      {
        double tmp = 1.0 / LU_factors[n * j + j];
        for (unsigned long i = j + 1; i < n; i++)
        {
          LU_factors[n * i + j] *= tmp;
        }
      }
 
    } // End of loop over columns
 
 
    // Now multiply all the diagonal terms together to get the determinant
    // Note that we need to use the mantissa, exponent formulation to
    // avoid underflow errors
    double determinant_mantissa = 1.0;
    int determinant_exponent = 0, iexp;
    for (unsigned i = 0; i < n; i++)
    {
      // Multiply by the next diagonal entry's mantissa
      // and return the exponent
      determinant_mantissa *= frexp(LU_factors[n * i + i], &iexp);
 
      // Add the new exponent to the current exponent
      determinant_exponent += iexp;
 
      // normalise
      determinant_mantissa = frexp(determinant_mantissa, &iexp);
      determinant_exponent += iexp;
    }
 
    // If paranoid issue a warning that the matrix is near singular
    // #ifdef PARANOID
    //  int tiny_exponent = -60;
    //  if(determinant_exponent < tiny_exponent)
    //   {
    //    std::ostringstream warning_stream;
    //    warning_stream << "The determinant of the matrix is very close to
    //    zero.\n"
    //                   << "It is " << determinant_mantissa << " x 2^"
    //                   << determinant_exponent << "\n";
    //    warning_stream << "The results will depend on the exact details of
    //    the\n"
    //                   << "floating point implementation ... just to let you
    //                   know\n";
    //    OomphLibWarning(warning_stream.str(),
    //                    "DenseLU::factorise()",
    //                    OOMPH_EXCEPTION_LOCATION);
    //   }
    // #endif
 
    // Integer to store the sign of the determinant
    int sign = 0;
 
    // Find the sign of the determinant
    if (determinant_mantissa > 0.0)
    {
      sign = 1;
    }
    if (determinant_mantissa < 0.0)
    {
      sign = -1;
    }
 
    // Multiply the sign by the signature
    sign *= signature;
 
    // Return the sign of the determinant
    Sign_of_determinant_of_matrix = sign;
  }

References clean_up_memory(), boost::multiprecision::fabs(), i, Index, j, k, LU_factors, n, oomph::DoubleMatrixBase::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, SYCL::sign(), Sign_of_determinant_of_matrix, and tmp.

Referenced by solve().

jacobian_setup_time()

double oomph::DenseLU::jacobian_setup_time ( ) const

inlinevirtual

returns the time taken to assemble the jacobian matrix and residual vector

Reimplemented from oomph::LinearSolver.

    {
      return Jacobian_setup_time;
    }

References Jacobian_setup_time.

linear_solver_solution_time()

virtual double oomph::DenseLU::linear_solver_solution_time ( ) const

inlinevirtual

return the time taken to solve the linear system (needs to be overloaded for each linear solver)

Reimplemented from oomph::LinearSolver.

    {
      return Solution_time;
    }

References Solution_time.

operator=()

void oomph::DenseLU::operator= ( const DenseLU &  )

delete

Broken assignment operator.

solve() [1/3]

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

virtual

Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system.

Reimplemented from oomph::LinearSolver.

Reimplemented in oomph::FD_LU.

  {
#ifdef PARANOID
    // check that the rhs vector is not distributed
    if (rhs.distribution_pt()->distributed())
    {
      std::ostringstream error_message_stream;
      error_message_stream
        << "The vectors rhs and result must not be distributed";
      throw OomphLibError(error_message_stream.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
 
    // check that the matrix is square
    if (matrix_pt->nrow() != matrix_pt->ncol())
    {
      std::ostringstream error_message_stream;
      error_message_stream << "The matrix at matrix_pt must be square.";
      throw OomphLibError(error_message_stream.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
    // check that the matrix and the rhs vector have the same nrow()
    if (matrix_pt->nrow() != rhs.nrow())
    {
      std::ostringstream error_message_stream;
      error_message_stream
        << "The matrix and the rhs vector must have the same number of rows.";
      throw OomphLibError(error_message_stream.str(),
                          OOMPH_CURRENT_FUNCTION,
                          OOMPH_EXCEPTION_LOCATION);
    }
 
    // if the matrix is distributable then it too should have the same
    // communicator as the rhs vector and should not be distributed
    DistributableLinearAlgebraObject* dist_matrix_pt =
      dynamic_cast<DistributableLinearAlgebraObject*>(matrix_pt);
    if (dist_matrix_pt != 0)
    {
      if (dist_matrix_pt->distribution_pt()->communicator_pt()->nproc() > 1 &&
          dist_matrix_pt->distribution_pt()->distributed() == true)
      {
        throw OomphLibError(
          "Matrix must not be distributed or only one processor",
          OOMPH_CURRENT_FUNCTION,
          OOMPH_EXCEPTION_LOCATION);
      }
      OomphCommunicator temp_comm(*rhs.distribution_pt()->communicator_pt());
      if (!(temp_comm == *dist_matrix_pt->distribution_pt()->communicator_pt()))
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "The matrix matrix_pt must have the same communicator as the "
             "vectors"
          << " rhs and result must have the same communicator";
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
    // if the result vector is setup then check it is not distributed and has
    // the same communicator as the rhs vector
    if (result.distribution_built())
    {
      if (!(*result.distribution_pt() == *rhs.distribution_pt()))
      {
        std::ostringstream error_message_stream;
        error_message_stream
          << "The result vector distribution has been setup; it must have the "
          << "same distribution as the rhs vector.";
        throw OomphLibError(error_message_stream.str(),
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
    }
#endif
 
    if (!result.distribution_built())
    {
      result.build(rhs.distribution_pt(), 0.0);
    }
 
    // set the distribution
    this->build_distribution(rhs.distribution_pt());
 
    // Time the solver
    double t_start = TimingHelpers::timer();
 
    // factorise
    factorise(matrix_pt);
 
    // backsubstitute
    backsub(rhs, result);
 
    // Doc time for solver
    double t_end = TimingHelpers::timer();
 
    Solution_time = t_end - t_start;
    if (Doc_time)
    {
      oomph_info << std::endl
                 << "CPU for solve with DenseLU   : "
                 << TimingHelpers::convert_secs_to_formatted_string(
                      Solution_time)
                 << std::endl
                 << std::endl;
    }
 
    // If we are not resolving then delete storage
    if (!Enable_resolve)
    {
      clean_up_memory();
    }
  }

References backsub(), oomph::DoubleVector::build(), oomph::DistributableLinearAlgebraObject::build_distribution(), clean_up_memory(), oomph::LinearAlgebraDistribution::communicator_pt(), oomph::TimingHelpers::convert_secs_to_formatted_string(), oomph::LinearAlgebraDistribution::distributed(), oomph::DistributableLinearAlgebraObject::distribution_built(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::LinearSolver::Doc_time, oomph::LinearSolver::Enable_resolve, factorise(), oomph::DoubleMatrixBase::ncol(), oomph::OomphCommunicator::nproc(), oomph::DistributableLinearAlgebraObject::nrow(), oomph::DoubleMatrixBase::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::oomph_info, Solution_time, and oomph::TimingHelpers::timer().

solve() [2/3]

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

virtual

Linear-algebra-type solver: Takes pointer to a matrix and rhs vector and returns the solution of the linear system.

Reimplemented from oomph::LinearSolver.

Reimplemented in oomph::FD_LU.

  {
    // Time the solver
    clock_t t_start = clock();
 
    factorise(matrix_pt);
    backsub(rhs, result);
 
    // Doc time for solver
    clock_t t_end = clock();
 
    Solution_time = double(t_end - t_start) / CLOCKS_PER_SEC;
    if (Doc_time)
    {
      oomph_info << "CPU for solve with DenseLU   : "
                 << TimingHelpers::convert_secs_to_formatted_string(
                      Solution_time)
                 << std::endl;
    }
 
    // If we are not resolving then delete storage
    if (!Enable_resolve)
    {
      clean_up_memory();
    }
  }

References backsub(), clean_up_memory(), oomph::TimingHelpers::convert_secs_to_formatted_string(), oomph::LinearSolver::Doc_time, oomph::LinearSolver::Enable_resolve, factorise(), oomph::oomph_info, and Solution_time.

solve() [3/3]

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

virtual

Solver: Takes pointer to problem and returns the results Vector which contains the solution of the linear system defined by the problem's fully assembled Jacobian and residual Vector.

Implements oomph::LinearSolver.

Reimplemented in oomph::FD_LU.

  {
    // Initialise timer
    double t_start = TimingHelpers::timer();
 
    // Find # of degrees of freedom (variables)
    const unsigned n_dof = problem_pt->ndof();
 
    // Allocate storage for the residuals vector and the jacobian matrix
    DoubleVector residuals;
    DenseDoubleMatrix jacobian(n_dof);
 
    // initialise timer
    double t_start_jacobian = TimingHelpers::timer();
 
    // Get the full jacobian and residuals of the problem
    problem_pt->get_jacobian(residuals, jacobian);
 
    // compute jacobian setup time
    double t_end_jacobian = TimingHelpers::timer();
    Jacobian_setup_time = t_end_jacobian - t_start_jacobian;
 
    // Report the time
    if (Doc_time)
    {
      oomph_info << std::endl
                 << "CPU for setup of Dense Jacobian: "
                 << TimingHelpers::convert_secs_to_formatted_string(
                      Jacobian_setup_time)
                 << std::endl;
    }
 
    // Solve by dense LU decomposition VERY INEFFICIENT!
    solve(&jacobian, residuals, result);
 
    // Set the sign of the determinant of the jacobian
    problem_pt->sign_of_jacobian() = Sign_of_determinant_of_matrix;
 
    // Finalise/doc timings
    double t_end = TimingHelpers::timer();
    double total_time = t_end - t_start;
    if (Doc_time)
    {
      oomph_info << "CPU for DenseLU LinearSolver: "
                 << TimingHelpers::convert_secs_to_formatted_string(total_time)
                 << std::endl
                 << std::endl;
    }
  }

References oomph::TimingHelpers::convert_secs_to_formatted_string(), oomph::LinearSolver::Doc_time, oomph::Problem::get_jacobian(), Jacobian_setup_time, oomph::Problem::ndof(), oomph::oomph_info, Sign_of_determinant_of_matrix, oomph::Problem::sign_of_jacobian(), and oomph::TimingHelpers::timer().

Referenced by oomph::FD_LU::solve().

Friends And Related Function Documentation

DenseDoubleMatrix

friend class DenseDoubleMatrix

friend

The DenseDoubleMatrix class is a friend.

Member Data Documentation

Index

long* oomph::DenseLU::Index

private

Pointer to storage for the index of permutations in the LU solve.

Referenced by backsub(), clean_up_memory(), and factorise().

Jacobian_setup_time

double oomph::DenseLU::Jacobian_setup_time

protected

Jacobian setup time.

Referenced by jacobian_setup_time(), solve(), and oomph::FD_LU::solve().

LU_factors

double* oomph::DenseLU::LU_factors

private

Pointer to storage for the LU decomposition.

Referenced by backsub(), clean_up_memory(), and factorise().

Sign_of_determinant_of_matrix

int oomph::DenseLU::Sign_of_determinant_of_matrix

protected

Sign of the determinant of the matrix (obtained during the LU decomposition)

Referenced by factorise(), solve(), and oomph::FD_LU::solve().

Solution_time

double oomph::DenseLU::Solution_time

protected

Solution time.

Referenced by linear_solver_solution_time(), and solve().

---

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

• linear_solver.h
• linear_solver.cc