oomph::ILUZeroPreconditioner< CCDoubleMatrix > Class Reference

ILU(0) Preconditioner for matrices of CCDoubleMatrix Format. More...

#include <general_purpose_preconditioners.h>

Inheritance diagram for oomph::ILUZeroPreconditioner< CCDoubleMatrix >:

Public Member Functions
	ILUZeroPreconditioner ()
	Constructor (empty) More...
	~ILUZeroPreconditioner ()
	Destructor (empty) More...
	ILUZeroPreconditioner (const ILUZeroPreconditioner &)=delete
	Broken copy constructor. More...
void	operator= (const ILUZeroPreconditioner &)=delete
	Broken assignment operator. More...
void	preconditioner_solve (const DoubleVector &r, DoubleVector &z)
	Apply preconditioner to r. More...
void	setup ()
	setup ILU(0) preconditioner for Matrices of CCDoubleMatrix type More...
Public Member Functions inherited from oomph::Preconditioner
	Preconditioner ()
	Constructor. More...
	Preconditioner (const Preconditioner &)=delete
	Broken copy constructor. More...
void	operator= (const Preconditioner &)=delete
	Broken assignment operator. More...
virtual	~Preconditioner ()
	Destructor (empty) More...
virtual void	preconditioner_solve_transpose (const DoubleVector &r, DoubleVector &z)
void	setup (DoubleMatrixBase *matrix_pt)
void	setup (const Problem *problem_pt, DoubleMatrixBase *matrix_pt)
void	enable_silent_preconditioner_setup ()
	Set up the block preconditioner quietly! More...
void	disable_silent_preconditioner_setup ()
	Be verbose in the block preconditioner setup. More...
virtual void	clean_up_memory ()
	Clean up memory (empty). Generic interface function. More...
virtual DoubleMatrixBase *	matrix_pt () const
	Get function for matrix pointer. More...
virtual void	set_matrix_pt (DoubleMatrixBase *matrix_pt)
	Set the matrix pointer. More...
virtual const OomphCommunicator *	comm_pt () const
	Get function for comm pointer. More...
virtual void	set_comm_pt (const OomphCommunicator *const comm_pt)
	Set the communicator pointer. More...
double	setup_time () const
	Returns the time to setup the preconditioner. More...
virtual void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse)
virtual void	turn_into_subsidiary_block_preconditioner (BlockPreconditioner< CRDoubleMatrix > *master_block_prec_pt, const Vector< unsigned > &doftype_in_master_preconditioner_coarse, const Vector< Vector< unsigned >> &doftype_coarsen_map_coarse)
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
Vector< unsigned >	U_column_start
	Column start for upper triangular matrix. More...
Vector< CompressedMatrixCoefficient >	U_row_entry
Vector< unsigned >	L_column_start
	Column start for lower triangular matrix. More...
Vector< CompressedMatrixCoefficient >	L_row_entry

Additional Inherited Members
Protected Member Functions inherited from oomph::DistributableLinearAlgebraObject
void	clear_distribution ()
Protected Attributes inherited from oomph::Preconditioner
bool	Silent_preconditioner_setup
	Boolean to indicate whether or not the build should be done silently. More...
std::ostream *	Stream_pt
	Pointer to the output stream – defaults to std::cout. More...

Detailed Description

ILU(0) Preconditioner for matrices of CCDoubleMatrix Format.

Constructor & Destructor Documentation

ILUZeroPreconditioner() [1/2]

oomph::ILUZeroPreconditioner< CCDoubleMatrix >::ILUZeroPreconditioner ( )

inline

Constructor (empty)

{};

~ILUZeroPreconditioner()

oomph::ILUZeroPreconditioner< CCDoubleMatrix >::~ILUZeroPreconditioner ( )

inline

Destructor (empty)

{};

ILUZeroPreconditioner() [2/2]

oomph::ILUZeroPreconditioner< CCDoubleMatrix >::ILUZeroPreconditioner ( const ILUZeroPreconditioner< CCDoubleMatrix > &  )

delete

Broken copy constructor.

Member Function Documentation

operator=()

void oomph::ILUZeroPreconditioner< CCDoubleMatrix >::operator= ( const ILUZeroPreconditioner< CCDoubleMatrix > &  )

delete

Broken assignment operator.

preconditioner_solve()

void oomph::ILUZeroPreconditioner< CCDoubleMatrix >::preconditioner_solve ( const DoubleVector &  r, DoubleVector &  z  )

virtual

Apply preconditioner to r.

Apply ILU(0) preconditioner for CCDoubleMatrix: Solve Ly=r then Uz=y and return z

Implements oomph::Preconditioner.

  {
    // # of rows in the matrix
    int n_row = r.nrow();
 
    // store the distribution of z
    LinearAlgebraDistribution* z_dist = 0;
    if (z.built())
    {
      z_dist = new LinearAlgebraDistribution(z.distribution_pt());
    }
 
    // copy r to z
    z = r;
 
    // if z is distributed then change to global
    if (z.distributed())
    {
      z.redistribute(this->distribution_pt());
    }
 
    // solve Ly=r (note L matrix is unit and diagonal is not stored)
    for (unsigned i = 0; i < static_cast<unsigned>(n_row); i++)
    {
      for (unsigned j = L_column_start[i]; j < L_column_start[i + 1]; j++)
      {
        z[L_row_entry[j].index()] =
          z[L_row_entry[j].index()] - z[i] * L_row_entry[j].value();
      }
    }
 
    // solve Uz=y
    double x;
    for (int i = n_row - 1; i >= 0; i--)
    {
      x = z[i] / U_row_entry[U_column_start[i + 1] - 1].value();
      z[i] = x;
      for (unsigned j = U_column_start[i]; j < U_column_start[i + 1] - 1; j++)
      {
        z[U_row_entry[j].index()] =
          z[U_row_entry[j].index()] - x * U_row_entry[j].value();
      }
    }
 
    // if the distribution of z was preset the redistribute to original
    if (z_dist != 0)
    {
      z.redistribute(z_dist);
      delete z_dist;
    }
  }

References oomph::DoubleVector::built(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), i, j, UniformPSDSelfTest::r, oomph::DoubleVector::redistribute(), and plotDoE::x.

setup()

void oomph::ILUZeroPreconditioner< CCDoubleMatrix >::setup ( )

virtual

setup ILU(0) preconditioner for Matrices of CCDoubleMatrix type

Setup the preconditioner (store diagonal) from the fully assembled matrix. Problem pointer is ignored.

Implements oomph::Preconditioner.

  {
    // cast the Double Base Matrix to Compressed Column Double Matrix
    CCDoubleMatrix* cc_matrix_pt = dynamic_cast<CCDoubleMatrix*>(matrix_pt());
 
#ifdef PARANOID
    if (cc_matrix_pt == 0)
    {
      std::ostringstream error_msg;
      error_msg << "Failed to conver matrix_pt to CCDoubleMatrix*.";
      throw OomphLibError(
        error_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // number of rows in matrix
    int n_row = cc_matrix_pt->nrow();
 
    // set the distribution
    LinearAlgebraDistribution dist(comm_pt(), n_row, false);
    this->build_distribution(dist);
 
    // declares variables to store number of non zero entires in L and U
    int l_nz = 0;
    int u_nz = 0;
 
    // create space for m matrix
    int* m_column_start;
    int* m_row_index;
    double* m_value;
 
    // get the m matrix
    m_column_start = cc_matrix_pt->column_start();
    m_row_index = cc_matrix_pt->row_index();
    m_value = cc_matrix_pt->value();
 
    // find number non zero entries in L and U
    for (int i = 0; i < n_row; i++)
    {
      for (int j = m_column_start[i]; j < m_column_start[i + 1]; j++)
      {
        if (m_row_index[j] > i)
        {
          l_nz++;
        }
        else
        {
          u_nz++;
        }
      }
    }
 
    // resize vectors to store the data for the lower prior to building the
    // matrices
    L_column_start.resize(n_row + 1);
    L_row_entry.resize(l_nz);
 
    // and the upper matrix
    U_column_start.resize(n_row + 1);
    U_row_entry.resize(u_nz);
 
    // set first column pointers to zero
    L_column_start[0] = 0;
    U_column_start[0] = 0;
 
    // split the matrix into L and U
    for (int i = 0; i < n_row; i++)
    {
      L_column_start[i + 1] = L_column_start[i];
      U_column_start[i + 1] = U_column_start[i];
      for (int j = m_column_start[i]; j < m_column_start[i + 1]; j++)
      {
        if (m_row_index[j] > i)
        {
          int k = L_column_start[i + 1]++;
          L_row_entry[k].index() = m_row_index[j];
          L_row_entry[k].value() = m_value[j];
        }
        else
        {
          int k = U_column_start[i + 1]++;
          U_row_entry[k].index() = m_row_index[j];
          U_row_entry[k].value() = m_value[j];
        }
      }
    }
 
    // sort each row entry vector into row index order for each column
 
    // loop over the columns
    for (unsigned i = 0; i < unsigned(n_row); i++)
    {
      // sort the columns of the L matrix
      std::sort(L_row_entry.begin() + L_column_start[i],
                L_row_entry.begin() + L_column_start[i + 1]);
 
      // sort the columns of the U matrix
      std::sort(U_row_entry.begin() + U_column_start[i],
                U_row_entry.begin() + U_column_start[i + 1]);
    }
 
 
    // factorise matrix
    int i;
    unsigned j, pn, qn, rn;
    pn = 0;
    qn = 0;
    rn = 0;
    double multiplier;
    for (i = 0; i < n_row - 1; i++)
    {
      multiplier = U_row_entry[U_column_start[i + 1] - 1].value();
      for (j = L_column_start[i]; j < L_column_start[i + 1]; j++)
        L_row_entry[j].value() /= multiplier;
      for (j = U_column_start[i + 1]; j < U_column_start[i + 2] - 1; j++)
      {
        multiplier = U_row_entry[j].value();
        qn = j + 1;
        rn = L_column_start[i + 1];
        for (pn = L_column_start[U_row_entry[j].index()];
             pn < L_column_start[U_row_entry[j].index() + 1] &&
             static_cast<int>(L_row_entry[pn].index()) <= i + 1;
             pn++)
        {
          while (qn < U_column_start[i + 2] &&
                 U_row_entry[qn].index() < L_row_entry[pn].index())
            qn++;
          if (qn < U_column_start[i + 2] &&
              L_row_entry[pn].index() == U_row_entry[qn].index())
            U_row_entry[qn].value() -= multiplier * L_row_entry[pn].value();
        }
        for (; pn < L_column_start[U_row_entry[j].index() + 1]; pn++)
        {
          while (rn < L_column_start[i + 2] &&
                 L_row_entry[rn].index() < L_row_entry[pn].index())
            rn++;
          if (rn < L_column_start[i + 2] &&
              L_row_entry[pn].index() == L_row_entry[rn].index())
            L_row_entry[rn].value() -= multiplier * L_row_entry[pn].value();
        }
      }
    }
  }

References oomph::DistributableLinearAlgebraObject::build_distribution(), oomph::CCMatrix< T >::column_start(), oomph::Preconditioner::comm_pt(), i, j, k, oomph::Preconditioner::matrix_pt(), Global_Physical_Variables::multiplier(), oomph::CCDoubleMatrix::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::CCMatrix< T >::row_index(), Eigen::value, and oomph::SparseMatrix< T, MATRIX_TYPE >::value().

Member Data Documentation

L_column_start

Vector<unsigned> oomph::ILUZeroPreconditioner< CCDoubleMatrix >::L_column_start

private

Column start for lower triangular matrix.

L_row_entry

Vector<CompressedMatrixCoefficient> oomph::ILUZeroPreconditioner< CCDoubleMatrix >::L_row_entry

private

Row entry for the lower triangular matrix (each element of the vector contains the row index and coefficient)

U_column_start

Vector<unsigned> oomph::ILUZeroPreconditioner< CCDoubleMatrix >::U_column_start

private

Column start for upper triangular matrix.

U_row_entry

Vector<CompressedMatrixCoefficient> oomph::ILUZeroPreconditioner< CCDoubleMatrix >::U_row_entry

private

Row entry for the upper triangular matrix (each element of the vector contains the row index and coefficient)

---

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

• general_purpose_preconditioners.h
• general_purpose_preconditioners.cc