oomph::BlockSelector Class Reference

#include <block_preconditioner.h>

Public Member Functions
	BlockSelector ()
	BlockSelector (const unsigned &row_index, const unsigned &column_index, const bool &wanted, CRDoubleMatrix *replacement_block_pt=0)
virtual	~BlockSelector ()
	Default destructor. More...
void	select_block (const unsigned &row_index, const unsigned &column_index, const bool &wanted, CRDoubleMatrix *replacement_block_pt=0)
	Select a block. More...
void	want_block ()
	Indicate that we require the block (set Wanted to true). More...
void	do_not_want_block ()
	Indicate that we do not want the block (set Wanted to false). More...
void	null_replacement_block_pt ()
	Set Replacement_block_pt to null. More...
void	set_replacement_block_pt (CRDoubleMatrix *replacement_block_pt)
	set Replacement_block_pt. More...
CRDoubleMatrix *	replacement_block_pt () const
	Returns Replacement_block_pt. More...
void	set_row_index (const unsigned &row_index)
	Set the row index. More...
const unsigned &	row_index () const
	returns the row index. More...
void	set_column_index (const unsigned &column_index)
	Set the column index. More...
const unsigned &	column_index () const
	returns the column index. More...
const bool &	wanted () const
	returns whether the block is wanted or not. More...

Private Member Functions
void	build (const unsigned &row_index, const unsigned &column_index, const bool &wanted, CRDoubleMatrix *replacement_block_pt=0)

Private Attributes
unsigned	Row_index
	Row index of the block. More...
unsigned	Column_index
	Column index of the block. More...
bool	Wanted
	Bool to indicate if we require this block. More...
CRDoubleMatrix *	Replacement_block_pt
	Pointer to the block. More...

Friends
std::ostream &	operator<< (std::ostream &o_stream, const BlockSelector &block_selector)

Detailed Description

Data structure to store information about a certain "block" or sub-matrix from the overall matrix in the block preconditioning framework.

Example of use: Let's assume we want to form a concatenated matrix from the blocks of a Jacobian matrix that contains the following blocks:

[J_00, J_01, J_02 J_10, J_11, J_12 J_20, J_21, J_22]

so that the new matrix has the entries

[ J_01, J_00 J_21, 0 ]

where "0" indicates zero matrix of the required size.

To do this we create a 2x2 (the block size of the new concatenated matrix) VectorMatrix of BlockSelectors and then declare for each entry the block indices in the original matrix and if the entry is to be included (and copied from the corresponding entry in the Jacobian (final boolean argument true) or if the block is to be omitted and replaced by an appropriately sized zero matrix. For the example above this would be done as follows:

VectorMatrix<BlockSelector> required_block(2,2); required_block[0][0].select_block(0,1,true); required_block[0][1].select_block(0,0,true); required_block[1][0].select_block(2,1,true); required_block[1][1].select_block(2,0,false);

and the concatenated matrix would then be built as

CRDoubleMatrix concatenated_block1 = get_concatenated_block(required_block);

Note that it is necessary to identify the row and column indices of any omitted blocks (here block J_20 in the original matrix) to enable the correct setup of the sparse matrix storage.

The initial assignment of the boolean may be over-written with the do_not_want_block() member function; this can again be reversed with the want_block() counterpart. So if we call

required_block[0][0].do_not_want_block();

and the build a new conctatenated matrix with

CRDoubleMatrix concatenated_block2 = get_concatenated_block(required_block);

the resulting matrix would the anti-diagonal matrix

[ 0 , J_00 J_21 , 0 ]

Finally it is possible to specify a replacement block by specifying a pointer to an appropriately sized matrix that is to be used instead of the block in the Jacobian matrix, so if replacement_block_pt points to a matrix, R, say, of the same size as J_01, then

selected_block[0][0].select_block(0,1,true,replacement_block_pt);

then the resulting concatenated matrix would contain

[ R , J_00 J_21 , 0 ]

Constructor & Destructor Documentation

BlockSelector() [1/2]

oomph::BlockSelector::BlockSelector ( )

inline

Default constructor, initialise block index i, j to 0 and bool to false.

    {
      // Needs to be set to zero because if the build function leaves the
      // Replacement_block_pt alone if replacement_block_pt = 0 (the default
      // argument).
      Replacement_block_pt = 0;
      this->build(0, 0, false);
    }

References build(), and Replacement_block_pt.

BlockSelector() [2/2]

oomph::BlockSelector::BlockSelector ( const unsigned &  row_index, const unsigned &  column_index, const bool &  wanted, CRDoubleMatrix *  replacement_block_pt = 0  )

inline

Constructor, takes the row and column indices and a boolean indicating if the block is required or not. The optional parameter replacement_block_pt is set to null. If the block is not required a block of the correct dimensions full of 0s is used.

    {
#ifdef PARANOID
      if ((wanted == false) && (replacement_block_pt != 0))
      {
        std::ostringstream err_msg;
        err_msg << "Trying to construct a BlockSelector object with:\n"
                << "replacement_block_pt != 0 and wanted == false"
                << "If you require the block, please set wanted == true.\n";
        throw OomphLibError(
          err_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      // Needs to be set to zero because if the build function leaves the
      // Replacement_block_pt alone if replacement_block_pt = 0 (the default
      // argument). Thus if it is not set here, it would not be initialised to
      // null.
      Replacement_block_pt = 0;
 
      this->build(row_index, column_index, wanted, replacement_block_pt);
    }

References build(), column_index(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, replacement_block_pt(), Replacement_block_pt, and wanted().

~BlockSelector()

virtual oomph::BlockSelector::~BlockSelector ( )

inlinevirtual

Default destructor.

    {
#ifdef PARANOID
      if (Replacement_block_pt != 0)
      {
        std::ostringstream warning_msg;
        warning_msg << "Warning: BlockSelector destructor is called but...\n"
                    << "replacement_block_pt() is not null.\n"
                    << "Please remember to null this via the function\n"
                    << "BlockSelector::null_replacement_block_pt()\n"
                    << "Row_index: " << Row_index << "\n"
                    << "Column_index: " << Column_index << std::endl;
 
        OomphLibWarning(
          warning_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
    }

References Column_index, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Replacement_block_pt, and Row_index.

Member Function Documentation

build()

void oomph::BlockSelector::build ( const unsigned &  row_index, const unsigned &  column_index, const bool &  wanted, CRDoubleMatrix *  replacement_block_pt = 0  )

inlineprivate

Build function, sets the Row_index, Column_index and Wanted variables. the Replacement_block_pt is only set if it is not null. Otherwise it is left alone.

    {
      Row_index = row_index;
      Column_index = column_index;
      Wanted = wanted;
 
      // Only set the replacement_block_pt if it is wanted. Otherwise we leave
      // it alone. All constructors should set Replacement_block_pt to 0.
      if (replacement_block_pt != 0)
      {
#ifdef PARANOID
        if (Wanted == false)
        {
          std::ostringstream err_msg;
          err_msg
            << "Trying to set replacement_block_pt, but Wanted == false.\n"
            << "Please either not set the replacement_block_pt or call the "
               "function\n"
            << "do_not_want_block()\n"
            << "Row_index: " << Row_index << "\n"
            << "Column_index: " << Column_index << "\n";
          throw OomphLibError(
            err_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
        }
#endif
 
        Replacement_block_pt = replacement_block_pt;
      }
    }

References column_index(), Column_index, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, replacement_block_pt(), Replacement_block_pt, row_index(), Row_index, wanted(), and Wanted.

Referenced by BlockSelector(), and select_block().

column_index()

const unsigned& oomph::BlockSelector::column_index ( ) const

inline

returns the column index.

    {
      return Column_index;
    }

References Column_index.

Referenced by BlockSelector(), build(), select_block(), and set_column_index().

do_not_want_block()

void oomph::BlockSelector::do_not_want_block ( )

inline

Indicate that we do not want the block (set Wanted to false).

    {
#ifdef PARANOID
      if (Replacement_block_pt != 0)
      {
        std::ostringstream warning_msg;
        warning_msg << "Trying to set Wanted = false, but replacement_block_pt "
                       "is not null.\n"
                    << "Please call null_replacement_block_pt()\n"
                    << "(remember to free memory if necessary)\n"
                    << "Row_index: " << Row_index << "\n"
                    << "Column_index: " << Column_index << "\n";
        OomphLibWarning(
          warning_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      null_replacement_block_pt();
 
      Wanted = false;
    }

References Column_index, null_replacement_block_pt(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, Replacement_block_pt, Row_index, and Wanted.

Referenced by main().

null_replacement_block_pt()

void oomph::BlockSelector::null_replacement_block_pt ( )

inline

Set Replacement_block_pt to null.

    {
      Replacement_block_pt = 0;
    }

References Replacement_block_pt.

Referenced by do_not_want_block(), and main().

replacement_block_pt()

CRDoubleMatrix* oomph::BlockSelector::replacement_block_pt ( ) const

inline

Returns Replacement_block_pt.

    {
      return Replacement_block_pt;
    }

References Replacement_block_pt.

Referenced by BlockSelector(), build(), select_block(), and set_replacement_block_pt().

row_index()

const unsigned& oomph::BlockSelector::row_index ( ) const

inline

returns the row index.

    {
      return Row_index;
    }

References Row_index.

Referenced by build(), select_block(), and set_row_index().

select_block()

void oomph::BlockSelector::select_block ( const unsigned &  row_index, const unsigned &  column_index, const bool &  wanted, CRDoubleMatrix *  replacement_block_pt = 0  )

inline

Select a block.

    {
#ifdef PARANOID
      if ((wanted == false) && (replacement_block_pt != 0))
      {
        std::ostringstream err_msg;
        err_msg << "Trying to select block with:\n"
                << "replacement_block_pt != 0 and wanted == false"
                << "If you require the block, please set wanted == true.\n"
                << "row_index: " << row_index << "\n"
                << "column_index: " << column_index << "\n";
        throw OomphLibError(
          err_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      this->build(row_index, column_index, wanted, replacement_block_pt);
    }

References build(), column_index(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, replacement_block_pt(), row_index(), and wanted().

Referenced by main().

set_column_index()

void oomph::BlockSelector::set_column_index ( const unsigned &  column_index )

inline

Set the column index.

    {
      Column_index = column_index;
    }

References column_index(), and Column_index.

Referenced by main().

set_replacement_block_pt()

void oomph::BlockSelector::set_replacement_block_pt ( CRDoubleMatrix *  replacement_block_pt )

inline

set Replacement_block_pt.

    {
#ifdef PARANOID
      if (Wanted == false)
      {
        std::ostringstream err_msg;
        err_msg << "Trying to set replacement_block_pt, but Wanted == false.\n"
                << "Please call want_block()\n"
                << "Row_index: " << Row_index << "\n"
                << "Column_index: " << Column_index << "\n";
        throw OomphLibError(
          err_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      Replacement_block_pt = replacement_block_pt;
    }

References Column_index, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, replacement_block_pt(), Replacement_block_pt, Row_index, and Wanted.

set_row_index()

void oomph::BlockSelector::set_row_index ( const unsigned &  row_index )

inline

Set the row index.

    {
      Row_index = row_index;
    }

References row_index(), and Row_index.

Referenced by main().

want_block()

void oomph::BlockSelector::want_block ( )

inline

Indicate that we require the block (set Wanted to true).

    {
      Wanted = true;
    }

References Wanted.

Referenced by main().

wanted()

const bool& oomph::BlockSelector::wanted ( ) const

inline

returns whether the block is wanted or not.

    {
      return Wanted;
    }

References Wanted.

Referenced by BlockSelector(), build(), and select_block().

Friends And Related Function Documentation

operator<<

std::ostream& operator<< ( std::ostream &  o_stream, const BlockSelector &  block_selector  )

friend

Output function, outputs the Row_index, Column_index, Wanted and the address of the Replacement_block_pt. P.M.: The address of a null pointer on a Mac is 0x0 but for self-tests the address needs to be simply 0. Easy (but hacky) check sorts that out...

    {
      o_stream << "Row_index = " << block_selector.row_index() << "\n"
               << "Column_index = " << block_selector.column_index() << "\n"
               << "Wanted = " << block_selector.wanted() << "\n"
               << "Replacement_block_pt = ";
      if (block_selector.replacement_block_pt() == 0)
      {
        o_stream << 0;
      }
 
      return o_stream;
    }

Member Data Documentation

Column_index

unsigned oomph::BlockSelector::Column_index

private

Column index of the block.

Referenced by build(), column_index(), do_not_want_block(), set_column_index(), set_replacement_block_pt(), and ~BlockSelector().

Replacement_block_pt

CRDoubleMatrix* oomph::BlockSelector::Replacement_block_pt

private

Pointer to the block.

Referenced by BlockSelector(), build(), do_not_want_block(), null_replacement_block_pt(), replacement_block_pt(), set_replacement_block_pt(), and ~BlockSelector().

Row_index

unsigned oomph::BlockSelector::Row_index

private

Row index of the block.

Referenced by build(), do_not_want_block(), row_index(), set_replacement_block_pt(), set_row_index(), and ~BlockSelector().

Wanted

bool oomph::BlockSelector::Wanted

private

Bool to indicate if we require this block.

Referenced by build(), do_not_want_block(), set_replacement_block_pt(), want_block(), and wanted().

---

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

• block_preconditioner.h