oomph::SumOfMatrices Class Reference

#include <sum_of_matrices.h>

Inheritance diagram for oomph::SumOfMatrices:

Public Member Functions
	SumOfMatrices ()
	Default constructor. More...
	SumOfMatrices (DoubleMatrixBase *main_matrix_pt)
	Constructor taking a pointer to the main matrix as input. More...
	SumOfMatrices (const SumOfMatrices &matrix)=delete
	Broken copy constructor. More...
void	operator= (const SumOfMatrices &)=delete
	Broken assignment operator. More...
	~SumOfMatrices ()
const DoubleMatrixBase *	main_matrix_pt () const
	Access to the main matrix. More...
DoubleMatrixBase *&	main_matrix_pt ()
void	set_delete_main_matrix ()
void	output_bottom_right_zero_helper (std::ostream &outfile) const
void	sparse_indexed_output_helper (std::ostream &outfile) const
void	get_as_indices (Vector< int > &row, Vector< int > &col, Vector< double > &values)
void	add_matrix (DoubleMatrixBase *added_matrix_pt_in, const AddedMainNumberingLookup *main_to_added_rows_pt, const AddedMainNumberingLookup *main_to_added_cols_pt, bool should_delete_matrix=false)
DoubleMatrixBase *	added_matrix_pt (const unsigned &i) const
const AddedMainNumberingLookup *	row_map_pt (const unsigned &i) const
	Access to the maps. More...
const AddedMainNumberingLookup *	col_map_pt (const unsigned &i) const
unsigned long	nrow () const
	Return the number of rows of the main matrix. More...
unsigned long	ncol () const
	Return the number of columns of the main matrix. More...
unsigned	n_added_matrix () const
	Return the number of added matrices in the sum. More...
void	multiply (const DoubleVector &x, DoubleVector &soln) const
double &	entry (const unsigned long &i, const unsigned long &j) const
double	operator() (const unsigned long &i, const unsigned long &j) const
virtual void	multiply_transpose (const DoubleVector &x, DoubleVector &soln) const
Public Member Functions inherited from oomph::DoubleMatrixBase
	DoubleMatrixBase ()
	(Empty) constructor. More...
	DoubleMatrixBase (const DoubleMatrixBase &matrix)=delete
	Broken copy constructor. More...
void	operator= (const DoubleMatrixBase &)=delete
	Broken assignment operator. More...
virtual	~DoubleMatrixBase ()
	virtual (empty) destructor More...
LinearSolver *&	linear_solver_pt ()
	Return a pointer to the linear solver object. More...
LinearSolver *const &	linear_solver_pt () const
	Return a pointer to the linear solver object (const version) More...
void	solve (DoubleVector &rhs)
void	solve (const DoubleVector &rhs, DoubleVector &soln)
void	solve (Vector< double > &rhs)
void	solve (const Vector< double > &rhs, Vector< double > &soln)
virtual void	residual (const DoubleVector &x, const DoubleVector &b, DoubleVector &residual_)
	Find the residual, i.e. r=b-Ax the residual. More...
virtual double	max_residual (const DoubleVector &x, const DoubleVector &rhs)
Public Member Functions inherited from oomph::Matrix< double, SumOfMatrices >
	Matrix ()
	(Empty) constructor More...
	Matrix (const Matrix &matrix)=delete
	Broken copy constructor. More...
void	operator= (const Matrix &)=delete
	Broken assignment operator. More...
virtual	~Matrix ()
	Virtual (empty) destructor. More...
double	operator() (const unsigned long &i, const unsigned long &j) const
double &	operator() (const unsigned long &i, const unsigned long &j)
virtual void	output (std::ostream &outfile) const
void	sparse_indexed_output (std::ostream &outfile, const unsigned &precision=0, const bool &output_bottom_right_zero=false) const
void	sparse_indexed_output (std::string filename, const unsigned &precision=0, const bool &output_bottom_right_zero=false) const

Private Attributes
DoubleMatrixBase *	Main_matrix_pt
	Pointer to the matrix which we are adding the others to. More...
Vector< DoubleMatrixBase * >	Added_matrix_pt
	List of pointers to the matrices that are added to the main matrix. More...
Vector< const AddedMainNumberingLookup * >	Row_map_pt
Vector< const AddedMainNumberingLookup * >	Col_map_pt
Vector< unsigned >	Should_delete_added_matrix
	Should we delete the sub matrices when destructor is called? More...
bool	Should_delete_main_matrix

Additional Inherited Members
Protected Member Functions inherited from oomph::Matrix< double, SumOfMatrices >
void	range_check (const unsigned long &i, const unsigned long &j) const
Protected Attributes inherited from oomph::DoubleMatrixBase
LinearSolver *	Linear_solver_pt
LinearSolver *	Default_linear_solver_pt

Detailed Description

Class for a matrix of the form M = S + G + H + ... where S is the main matrix and G,H etc. are matrices of size S or smaller. This may be useful if, for example, G,H etc. are subblocks of M that must be stored in a different format to S. Maps mut be provided which gives a map from the rows/cols of the main matrix to the rows/cols of each of the added matrices.

Constructor & Destructor Documentation

SumOfMatrices() [1/3]

oomph::SumOfMatrices::SumOfMatrices ( )

inline

Default constructor.

      : Main_matrix_pt(0),
        Added_matrix_pt(0),
        Row_map_pt(0),
        Col_map_pt(0),
        Should_delete_added_matrix(0),
        Should_delete_main_matrix(0)
    {
    }

SumOfMatrices() [2/3]

oomph::SumOfMatrices::SumOfMatrices ( DoubleMatrixBase *  main_matrix_pt )

inline

Constructor taking a pointer to the main matrix as input.

      : Main_matrix_pt(main_matrix_pt),
        Added_matrix_pt(0),
        Row_map_pt(0),
        Col_map_pt(0),
        Should_delete_added_matrix(0),
        Should_delete_main_matrix(0)
    {
    }

SumOfMatrices() [3/3]

oomph::SumOfMatrices::SumOfMatrices ( const SumOfMatrices &  matrix )

delete

Broken copy constructor.

~SumOfMatrices()

oomph::SumOfMatrices::~SumOfMatrices ( )

inline

Destructor: delete matrices as instructed by Should_delete_added_matrix vector and Should_delete_main_matrix.

    {
      for (unsigned i_matrix = 0; i_matrix < Added_matrix_pt.size(); i_matrix++)
      {
        if (Should_delete_added_matrix[i_matrix] == 1)
        {
          delete Added_matrix_pt[i_matrix];
        }
      }
 
      if (Should_delete_main_matrix)
      {
        delete Main_matrix_pt;
      }
    }

Member Function Documentation

add_matrix()

void oomph::SumOfMatrices::add_matrix ( DoubleMatrixBase *  added_matrix_pt_in, const AddedMainNumberingLookup *  main_to_added_rows_pt, const AddedMainNumberingLookup *  main_to_added_cols_pt, bool  should_delete_matrix = false  )

inline

Add a new matrix to the sum by giving a matrix pointer and a mapping from the main matrix numbering to the added matrix's numbering.

    {
#ifdef PARANOID
      // Check that row mapping has correct size
      if (main_to_added_rows_pt->main_to_added_mapping_pt()->size() >
          added_matrix_pt_in->nrow())
      {
        throw OomphLibError(
          "Row mapping size should be less than or equal to nrow (less than if "
          "it is a sparse matrix and there are some empty rows).",
          OOMPH_CURRENT_FUNCTION,
          OOMPH_EXCEPTION_LOCATION);
      }
 
      // Check that col mapping has correct size
      if (main_to_added_cols_pt->main_to_added_mapping_pt()->size() >
          added_matrix_pt_in->ncol())
      {
        throw OomphLibError(
          "Col mapping size should be less than or equal to ncol (less than if "
          "it is a sparse matrix and there are some empty cols).",
          OOMPH_CURRENT_FUNCTION,
          OOMPH_EXCEPTION_LOCATION);
      }
#endif
#ifdef RANGE_CHECKING
      // Check that all entries in the row mapping are "in range" for the
      // main matrix.
      const Vector<unsigned>* rowmap_pt =
        main_to_added_rows_pt->added_to_main_mapping_pt();
      unsigned max_row =
        *std::max_element(rowmap_pt->begin(), rowmap_pt->end());
      if (max_row > main_matrix_pt()->nrow())
      {
        std::string err =
          "Trying to add a matrix with a mapping which specifices";
        err += " a max row of " + to_string(max_row) + " but the main matrix ";
        err += "only has " + to_string(main_matrix_pt()->nrow()) + " rows!";
        throw OomphLibError(
          err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
      }
 
      // Check that all entries in the row mapping are "in range" for the
      // main matrix.
      const Vector<unsigned>* colmap_pt =
        main_to_added_cols_pt->added_to_main_mapping_pt();
      unsigned max_col =
        *std::max_element(colmap_pt->begin(), colmap_pt->end());
      if (max_col > main_matrix_pt()->ncol())
      {
        std::string err =
          "Trying to add a matrix with a mapping which specifices";
        err += " a max col of " + to_string(max_col) + " but the main matrix ";
        err += "only has " + to_string(main_matrix_pt()->ncol()) + " cols!";
        throw OomphLibError(
          err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
      }
#endif
 
      Added_matrix_pt.push_back(added_matrix_pt_in);
      Row_map_pt.push_back(main_to_added_rows_pt);
      Col_map_pt.push_back(main_to_added_cols_pt);
      Should_delete_added_matrix.push_back(unsigned(should_delete_matrix));
    }

References oomph::AddedMainNumberingLookup::added_to_main_mapping_pt(), oomph::AddedMainNumberingLookup::main_to_added_mapping_pt(), oomph::DoubleMatrixBase::ncol(), oomph::DoubleMatrixBase::nrow(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Global_string_for_annotation::string(), and oomph::StringConversion::to_string().

added_matrix_pt()

DoubleMatrixBase* oomph::SumOfMatrices::added_matrix_pt ( const unsigned &  i ) const

inline

Access function for ith added matrix (main matrix not included in numbering).

    {
      return Added_matrix_pt[i];
    }

References i.

Referenced by multiply().

col_map_pt()

const AddedMainNumberingLookup* oomph::SumOfMatrices::col_map_pt ( const unsigned &  i ) const

inline

    {
      return Col_map_pt[i];
    }

References i.

entry()

double& oomph::SumOfMatrices::entry ( const unsigned long &  i, const unsigned long &  j  ) const

inline

Broken operator() because it does not make sense to return anything by reference.

    {
      throw OomphLibError(
        "Broken write to entry: it does not make sense to write to a sum, you "
        "must write to one of the component matrices.",
        OOMPH_CURRENT_FUNCTION,
        OOMPH_EXCEPTION_LOCATION);
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

get_as_indices()

void oomph::SumOfMatrices::get_as_indices ( Vector< int > &  row, Vector< int > &  col, Vector< double > &  values  )

inline

Get a list of row/col indices and total entry for non-zeros in the matrix. e.g. for use as input to other matrix classes. Warning this is SLOW! for sparse matrices.

    {
      row.clear();
      col.clear();
      values.clear();
 
      for (int i = 0; i < int(nrow()); i++)
      {
        for (int j = 0; j < int(ncol()); j++)
        {
          double entry = operator()(i, j);
          // Output if non-zero entry
          if (entry != 0.0)
          {
            row.push_back(i);
            col.push_back(j);
            values.push_back(entry);
          }
        }
      }
    }

References col(), i, int(), j, and row().

main_matrix_pt() [1/2]

DoubleMatrixBase*& oomph::SumOfMatrices::main_matrix_pt ( )

inline

    {
      return Main_matrix_pt;
    }

main_matrix_pt() [2/2]

const DoubleMatrixBase* oomph::SumOfMatrices::main_matrix_pt ( ) const

inline

Access to the main matrix.

    {
      return Main_matrix_pt;
    }

multiply()

void oomph::SumOfMatrices::multiply ( const DoubleVector &  x, DoubleVector &  soln  ) const

virtual

Multiply: just call multiply on each of the matrices and add up the results (with appropriate bookeeping of the relative positions).

Matrix-vector multiplication for a sumofmatrices class. Just delegate each multiplication to the appropriate class then add up the results.

Implements oomph::DoubleMatrixBase.

  {
    // We assume that appropriate checks and initialisation on x and soln are
    // carried out within the individual matrix multiplys.
 
    // Multiply for the main matrix
    Main_matrix_pt->multiply(x, soln);
 
    // Now add contribution for the added matrices
    for (unsigned i_matrix = 0; i_matrix < Added_matrix_pt.size(); i_matrix++)
    {
      // If possible copy the matrix distribution, otherwise it isn't
      // distributed so make a serial LinearAlgebraDistribution object.
      LinearAlgebraDistribution col_dist, row_dist;
      OomphCommunicator serial_comm; // Serial communcator (does nothing)
      col_dist.build(&serial_comm, added_matrix_pt(i_matrix)->ncol(), false);
      row_dist.build(&serial_comm, added_matrix_pt(i_matrix)->nrow(), false);
 
      // Create temporary output DoubleVector
      DoubleVector temp_soln(row_dist);
 
      // Create a const iterator for the map (faster than .find() or []
      // access, const means can't change the map via the iterator).
      std::map<unsigned, unsigned>::const_iterator it;
 
      // Pull out the appropriate values into a temp vector
      //??ds not parallel
      DoubleVector temp_x(col_dist);
      for (it = Col_map_pt[i_matrix]->main_to_added_mapping_pt()->begin();
           it != Col_map_pt[i_matrix]->main_to_added_mapping_pt()->end();
           it++)
      {
        temp_x[it->second] = x[it->first];
      }
 
      // Perform the multiplication
      Added_matrix_pt[i_matrix]->multiply(temp_x, temp_soln);
 
      // Add result to solution vector
      //??ds not parallel
      for (it = Row_map_pt[i_matrix]->main_to_added_mapping_pt()->begin();
           it != Row_map_pt[i_matrix]->main_to_added_mapping_pt()->end();
           it++)
      {
        soln[it->first] += temp_soln[it->second];
      }
    }
  }

References Added_matrix_pt, added_matrix_pt(), oomph::LinearAlgebraDistribution::build(), Col_map_pt, Eigen::placeholders::end, Main_matrix_pt, oomph::DoubleMatrixBase::multiply(), ncol(), nrow(), Row_map_pt, and plotDoE::x.

multiply_transpose()

virtual void oomph::SumOfMatrices::multiply_transpose ( const DoubleVector &  x, DoubleVector &  soln  ) const

inlinevirtual

Dummy overload of a pure virtual function. I'm not sure how best to implement this and I don't think I need it.

Implements oomph::DoubleMatrixBase.

    {
      std::ostringstream error_msg;
      error_msg << "Function not yet implemented.";
      throw OomphLibError(
        error_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
 
      // Possible implementations (not really thought through):
      // - just call multiply transpose on submatrices?
      // - do something funny with switching row and column maps?
    }

References OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

n_added_matrix()

unsigned oomph::SumOfMatrices::n_added_matrix ( ) const

inline

Return the number of added matrices in the sum.

    {
      return Added_matrix_pt.size();
    }

ncol()

unsigned long oomph::SumOfMatrices::ncol ( ) const

inlinevirtual

Return the number of columns of the main matrix.

Implements oomph::DoubleMatrixBase.

    {
#ifdef PARANOID
      if (Main_matrix_pt == 0)
      {
        throw OomphLibError("Main_matrix_pt not set",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return Main_matrix_pt->ncol();
    }

References oomph::DoubleMatrixBase::ncol(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by multiply().

nrow()

unsigned long oomph::SumOfMatrices::nrow ( ) const

inlinevirtual

Return the number of rows of the main matrix.

Implements oomph::DoubleMatrixBase.

    {
#ifdef PARANOID
      if (Main_matrix_pt == 0)
      {
        throw OomphLibError("Main_matrix_pt not set",
                            OOMPH_CURRENT_FUNCTION,
                            OOMPH_EXCEPTION_LOCATION);
      }
#endif
      return Main_matrix_pt->nrow();
    }

References oomph::DoubleMatrixBase::nrow(), OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

Referenced by multiply().

operator()()

double oomph::SumOfMatrices::operator() ( const unsigned long &  i, const unsigned long &  j  ) const

inlinevirtual

Access function to get the total value of entries in position (i,j). Warning: this way of getting entries is far too slow to use inside of loops.

Implements oomph::DoubleMatrixBase.

    {
      // Get contributions from all matrices
      double sum = main_matrix_pt()->operator()(i, j);
      for (unsigned i_matrix = 0; i_matrix < n_added_matrix(); i_matrix++)
      {
        int li = Row_map_pt[i_matrix]->unsafe_main_to_added(i);
        int lj = Col_map_pt[i_matrix]->unsafe_main_to_added(j);
 
        // If the added matrix contributes to this entry then add it
        if ((li != -1) && (lj != -1))
        {
          sum += added_matrix_pt(i_matrix)->operator()(li, lj);
        }
      }
 
      return sum;
    }

References i, and j.

operator=()

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

delete

Broken assignment operator.

output_bottom_right_zero_helper()

void oomph::SumOfMatrices::output_bottom_right_zero_helper ( std::ostream &  outfile ) const

inlinevirtual

Output the "bottom right" entry regardless of it being zero or not (this allows automatic detection of matrix size in e.g. matlab, python).

Implements oomph::Matrix< double, SumOfMatrices >.

    {
      int last_row = this->nrow() - 1;
      int last_col = this->ncol() - 1;
 
      double last_value = operator()(last_row, last_col);
 
      if (last_value == 0.0)
      {
        outfile << last_row << " " << last_col << " " << 0.0 << std::endl;
      }
    }

row_map_pt()

const AddedMainNumberingLookup* oomph::SumOfMatrices::row_map_pt ( const unsigned &  i ) const

inline

Access to the maps.

    {
      return Row_map_pt[i];
    }

References i.

set_delete_main_matrix()

void oomph::SumOfMatrices::set_delete_main_matrix ( )

inline

Set the main matrix to be deleted by the destructor of the SumOfMatrices (default is to not delete it).

    {
      Should_delete_main_matrix = true;
    }

sparse_indexed_output_helper()

void oomph::SumOfMatrices::sparse_indexed_output_helper ( std::ostream &  outfile ) const

inlinevirtual

Output the matrix in sparse format. Note that this is going to be slow because we have to check every entry of every matrix for non-zeros.

Implements oomph::Matrix< double, SumOfMatrices >.

    {
      for (unsigned long i = 0; i < nrow(); i++)
      {
        for (unsigned long j = 0; j < ncol(); j++)
        {
          double entry = operator()(i, j);
          // Output if non-zero entry
          if (entry != 0.0)
          {
            outfile << i << " " << j << " " << entry << std::endl;
          }
        }
      }
    }

References i, and j.

Member Data Documentation

Added_matrix_pt

Vector<DoubleMatrixBase*> oomph::SumOfMatrices::Added_matrix_pt

private

List of pointers to the matrices that are added to the main matrix.

Referenced by multiply().

Col_map_pt

Vector<const AddedMainNumberingLookup*> oomph::SumOfMatrices::Col_map_pt

private

List of maps between col numbers of the main matrix and the added matrices.

Referenced by multiply().

Main_matrix_pt

DoubleMatrixBase* oomph::SumOfMatrices::Main_matrix_pt

private

Pointer to the matrix which we are adding the others to.

Referenced by multiply().

Row_map_pt

Vector<const AddedMainNumberingLookup*> oomph::SumOfMatrices::Row_map_pt

private

List of maps between row numbers of the main matrix and the added matrices.

Referenced by multiply().

Should_delete_added_matrix

Vector<unsigned> oomph::SumOfMatrices::Should_delete_added_matrix

private

Should we delete the sub matrices when destructor is called?

Should_delete_main_matrix

bool oomph::SumOfMatrices::Should_delete_main_matrix

private

Should we delete the main matrix when destructor is called? Default is no.

---

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

• sum_of_matrices.h
• sum_of_matrices.cc