oomph::ILUZeroPreconditioner< CRDoubleMatrix > Class Reference

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

#include <general_purpose_preconditioners.h>

Inheritance diagram for oomph::ILUZeroPreconditioner< CRDoubleMatrix >:

Public Member Functions
	ILUZeroPreconditioner ()
	Constructor (empty) More...
	ILUZeroPreconditioner (const ILUZeroPreconditioner &)=delete
	Broken copy constructor. More...
void	operator= (const ILUZeroPreconditioner &)=delete
	Broken assignment operator. More...
	~ILUZeroPreconditioner ()
	Destructor (empty) More...
void	preconditioner_solve (const DoubleVector &r, DoubleVector &z)
	Apply preconditioner to r. More...
void	setup ()
	setup ILU(0) preconditioner for Matrices of CRDoubleMatrix 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_row_start
	Row start for upper triangular matrix. More...
Vector< CompressedMatrixCoefficient >	U_row_entry
Vector< unsigned >	L_row_start
	Row 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 CRDoubleMatrix Format.

Constructor & Destructor Documentation

ILUZeroPreconditioner() [1/2]

oomph::ILUZeroPreconditioner< CRDoubleMatrix >::ILUZeroPreconditioner ( )

inline

Constructor (empty)

{};

ILUZeroPreconditioner() [2/2]

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

delete

Broken copy constructor.

~ILUZeroPreconditioner()

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

inline

Destructor (empty)

{};

Member Function Documentation

operator=()

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

delete

Broken assignment operator.

preconditioner_solve()

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

virtual

Apply preconditioner to r.

Apply ILU(0) preconditioner for CRDoubleMatrix: 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)
    double t;
    for (int i = 0; i < n_row; i++)
    {
      t = 0;
      for (unsigned j = L_row_start[i]; j < L_row_start[i + 1]; j++)
      {
        t = t + L_row_entry[j].value() * z[L_row_entry[j].index()];
      }
      z[i] = z[i] - t;
    }
 
    // solve Uz=y
    for (int i = n_row - 1; i >= 0; i--)
    {
      t = 0;
      for (unsigned j = U_row_start[i] + 1; j < U_row_start[i + 1]; j++)
      {
        t = t + U_row_entry[j].value() * z[U_row_entry[j].index()];
      }
      z[i] = z[i] - t;
      z[i] = z[i] / U_row_entry[U_row_start[i]].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 plotPSD::t.

setup()

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

virtual

setup ILU(0) preconditioner for Matrices of CRDoubleMatrix 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
    CRDoubleMatrix* cr_matrix_pt = dynamic_cast<CRDoubleMatrix*>(matrix_pt());
 
#ifdef PARANOID
    if (cr_matrix_pt == 0)
    {
      std::ostringstream error_msg;
      error_msg << "Failed to conver matrix_pt to CRDoubleMatrix*.";
      throw OomphLibError(
        error_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
    }
#endif
 
    // if the matrix is distributed then build global version
    bool built_global = false;
    if (cr_matrix_pt->distributed())
    {
      // get the global matrix
      CRDoubleMatrix* global_matrix_pt = cr_matrix_pt->global_matrix();
 
      // store at cr_matrix pointer
      cr_matrix_pt = global_matrix_pt;
 
      // set the flag so we can delete later
      built_global = true;
    }
 
    // store the Distribution
    this->build_distribution(cr_matrix_pt->distribution_pt());
 
    // number of rows in matrix
    int n_row = cr_matrix_pt->nrow();
 
    // 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_row_start;
    int* m_column_index;
    double* m_value;
 
    // get the m matrix
    m_row_start = cr_matrix_pt->row_start();
    m_column_index = cr_matrix_pt->column_index();
    m_value = cr_matrix_pt->value();
 
    // find number non zero entries in L and U
    for (int i = 0; i < n_row; i++)
    {
      for (int j = m_row_start[i]; j < m_row_start[i + 1]; j++)
      {
        if (m_column_index[j] < i)
        {
          l_nz++;
        }
        else
        {
          u_nz++;
        }
      }
    }
 
    // resize vectors to store the data for the lower prior to building the
    // matrices
    L_row_start.resize(n_row + 1);
    L_row_entry.resize(l_nz);
 
    // and the upper matrix
    U_row_start.resize(n_row + 1);
    U_row_entry.resize(u_nz);
 
    // set first column pointers to zero
    L_row_start[0] = 0;
    U_row_start[0] = 0;
 
    // split the matrix into L and U
    for (int i = 0; i < n_row; i++)
    {
      L_row_start[i + 1] = L_row_start[i];
      U_row_start[i + 1] = U_row_start[i];
      for (int j = m_row_start[i]; j < m_row_start[i + 1]; j++)
      {
        if (m_column_index[j] < i)
        {
          int k = L_row_start[i + 1]++;
          L_row_entry[k].value() = m_value[j];
          L_row_entry[k].index() = m_column_index[j];
        }
        else
        {
          int k = U_row_start[i + 1]++;
          U_row_entry[k].value() = m_value[j];
          U_row_entry[k].index() = m_column_index[j];
        }
      }
    }
 
 
    // factorise matrix
    unsigned i, j, pn, qn, rn;
    pn = 0;
    qn = 0;
    rn = 0;
    double multiplier;
    for (i = 1; i < static_cast<unsigned>(n_row); i++)
    {
      for (j = L_row_start[i]; j < L_row_start[i + 1]; j++)
      {
        pn = U_row_start[L_row_entry[j].index()];
        multiplier = (L_row_entry[j].value() /= U_row_entry[pn].value());
        qn = j + 1;
        rn = U_row_start[i];
        for (pn++; pn < U_row_start[L_row_entry[j].index() + 1] &&
                   U_row_entry[pn].index() < i;
             pn++)
        {
          while (qn < L_row_start[i + 1] &&
                 L_row_entry[qn].index() < U_row_entry[pn].index())
            qn++;
          if (qn < L_row_start[i + 1] &&
              U_row_entry[pn].index() == L_row_entry[qn].index())
            L_row_entry[qn].value() -= multiplier * U_row_entry[pn].value();
        }
        for (; pn < U_row_start[L_row_entry[j].index() + 1]; pn++)
        {
          while (rn < U_row_start[i + 1] &&
                 U_row_entry[rn].index() < U_row_entry[pn].index())
            rn++;
          if (rn < U_row_start[i + 1] &&
              U_row_entry[pn].index() == U_row_entry[rn].index())
            U_row_entry[rn].value() -= multiplier * U_row_entry[pn].value();
        }
      }
    }
 
    // if we built the global matrix then delete it
    if (built_global)
    {
      delete cr_matrix_pt;
    }
  }

References oomph::DistributableLinearAlgebraObject::build_distribution(), oomph::CRDoubleMatrix::column_index(), oomph::DistributableLinearAlgebraObject::distributed(), oomph::DistributableLinearAlgebraObject::distribution_pt(), oomph::CRDoubleMatrix::global_matrix(), i, j, k, oomph::Preconditioner::matrix_pt(), Global_Physical_Variables::multiplier(), oomph::CRDoubleMatrix::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::CRDoubleMatrix::row_start(), Eigen::value, and oomph::CRDoubleMatrix::value().

Member Data Documentation

L_row_entry

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

private

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

L_row_start

Vector<unsigned> oomph::ILUZeroPreconditioner< CRDoubleMatrix >::L_row_start

private

Row start for lower triangular matrix.

U_row_entry

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

private

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

U_row_start

Vector<unsigned> oomph::ILUZeroPreconditioner< CRDoubleMatrix >::U_row_start

private

Row start for upper triangular matrix.

---

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

• general_purpose_preconditioners.h
• general_purpose_preconditioners.cc