oomph::AddedMainNumberingLookup Class Reference

#include <sum_of_matrices.h>

Public Member Functions
	AddedMainNumberingLookup ()
	Default constructor. More...
	AddedMainNumberingLookup (const Mesh *mesh_pt, const unsigned &dof_index)
	AddedMainNumberingLookup (const int *lookup_array, const unsigned &length)
	~AddedMainNumberingLookup ()
	Destructor. More...
unsigned	main_to_added (const int &main) const
int	unsafe_main_to_added (const int &main) const
unsigned	added_to_main (const unsigned &added) const
void	build (const Mesh *mesh_pt, const unsigned &dof_index)
void	build (const int *lookup_array, const unsigned &length)
void	build (const Vector< const Node * > &bem_lookup, const unsigned &dof_index)
	Construct lookup using node vector. More...
void	build_identity_map (const unsigned &n)
	Construct an identity map (mostly for testing). More...
const Vector< unsigned > *	added_to_main_mapping_pt () const
	Const access function for mapping. More...
const std::map< unsigned, unsigned > *	main_to_added_mapping_pt () const
	Const access function for mapping. More...

Private Member Functions
void	construct_added_to_main_mapping (const Mesh *mesh_pt, const unsigned &dof_index)
	Set up the lookup from added matrix row/col to main matrix. More...
void	construct_reverse_mapping ()
	Set up the main to added mapping using the added to main mapping. More...
	AddedMainNumberingLookup (const AddedMainNumberingLookup &dummy)=delete
	Inaccessible copy constructor. More...
void	operator= (const AddedMainNumberingLookup &dummy)=delete
	Inaccessible assignment operator. More...

Private Attributes
Vector< unsigned >	Added_to_main_mapping
std::map< unsigned, unsigned >	Main_to_added_mapping

Detailed Description

Class to store bi-directional lookup between added matrix row/col numbers to main matrix (SumOfMatrix) row/col numbers.

Constructor & Destructor Documentation

AddedMainNumberingLookup() [1/4]

oomph::AddedMainNumberingLookup::AddedMainNumberingLookup ( )

inline

Default constructor.

{}

AddedMainNumberingLookup() [2/4]

oomph::AddedMainNumberingLookup::AddedMainNumberingLookup ( const Mesh *  mesh_pt, const unsigned &  dof_index  )

inline

Real constructor: construct lookup from node numbers in mesh and global equation numbers. Useful for the case when the main matrix is a Jacobian and the added matrix is a contribution only on a certain mesh.

    {
      this->build(mesh_pt, dof_index);
    }

AddedMainNumberingLookup() [3/4]

oomph::AddedMainNumberingLookup::AddedMainNumberingLookup ( const int *  lookup_array, const unsigned &  length  )

inline

Construct lookup schemes from int array (HLib's format for this data).

    {
      this->build(lookup_array, length);
    }

~AddedMainNumberingLookup()

oomph::AddedMainNumberingLookup::~AddedMainNumberingLookup ( )

inline

Destructor.

{}

AddedMainNumberingLookup() [4/4]

oomph::AddedMainNumberingLookup::AddedMainNumberingLookup ( const AddedMainNumberingLookup &  dummy )

privatedelete

Inaccessible copy constructor.

Member Function Documentation

added_to_main()

unsigned oomph::AddedMainNumberingLookup::added_to_main ( const unsigned &  added ) const

inline

Given a row/col number in the added matrix return the equivalent row/col number in the main matrix.

    {
      return Added_to_main_mapping[added];
    }

added_to_main_mapping_pt()

const Vector<unsigned>* oomph::AddedMainNumberingLookup::added_to_main_mapping_pt ( ) const

inline

Const access function for mapping.

    {
      return &Added_to_main_mapping;
    }

Referenced by oomph::SumOfMatrices::add_matrix().

build() [1/3]

void oomph::AddedMainNumberingLookup::build ( const int *  lookup_array, const unsigned &  length  )

inline

Construct lookup schemes from int array (HLib's format for this data).

    {
#ifdef PARANOID
      // Check for negative entries just in case (since it's an integer
      // array).
      for (unsigned j = 0; j < length; j++)
      {
        if (lookup_array[j] < 0)
        {
          std::string err = "negative entry in lookup array!";
          throw OomphLibError(
            err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
        }
      }
#endif
 
      // Copy array into mapping and generate the inverse lookup
      Added_to_main_mapping.assign(lookup_array, lookup_array + length);
      construct_reverse_mapping();
    }

References j, OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, and oomph::Global_string_for_annotation::string().

build() [2/3]

void oomph::AddedMainNumberingLookup::build ( const Mesh *  mesh_pt, const unsigned &  dof_index  )

inline

Construct the lookup schemes given a mesh and the degree of freedom to lookup main equation numbers for.

    {
      construct_added_to_main_mapping(mesh_pt, dof_index);
      construct_reverse_mapping();
    }

build() [3/3]

void oomph::AddedMainNumberingLookup::build ( const Vector< const Node * > &  bem_lookup, const unsigned &  dof_index  )

inline

Construct lookup using node vector.

    {
      const unsigned ni = bem_lookup.size();
      Added_to_main_mapping.assign(ni, -1);
 
      for (unsigned i = 0; i < ni; i++)
      {
        Added_to_main_mapping[i] = bem_lookup[i]->eqn_number(dof_index);
      }
 
      construct_reverse_mapping();
    }

References i.

build_identity_map()

void oomph::AddedMainNumberingLookup::build_identity_map ( const unsigned &  n )

inline

Construct an identity map (mostly for testing).

    {
      Added_to_main_mapping.assign(n, 0);
      for (unsigned j = 0; j < n; j++)
      {
        Added_to_main_mapping[j] = j;
      }
      construct_reverse_mapping();
    }

References j, and n.

construct_added_to_main_mapping()

void oomph::AddedMainNumberingLookup::construct_added_to_main_mapping ( const Mesh *  mesh_pt, const unsigned &  dof_index  )

inlineprivate

Set up the lookup from added matrix row/col to main matrix.

    {
      // Basically just copy from the node data.
      Added_to_main_mapping.resize(mesh_pt->nnode());
      for (unsigned nd = 0, nnode = mesh_pt->nnode(); nd < nnode; nd++)
      {
        Added_to_main_mapping[nd] = mesh_pt->node_pt(nd)->eqn_number(dof_index);
      }
    }

References oomph::Data::eqn_number(), oomph::Mesh::nnode(), and oomph::Mesh::node_pt().

construct_reverse_mapping()

void oomph::AddedMainNumberingLookup::construct_reverse_mapping ( )

inlineprivate

Set up the main to added mapping using the added to main mapping.

    {
#ifdef PARANOID
      if (Added_to_main_mapping.size() == 0)
      {
        std::ostringstream error_msg;
        error_msg << "Must set up Added_to_main_mapping first.";
        throw OomphLibError(
          error_msg.str(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION);
      }
#endif
 
      // Clear old data
      Main_to_added_mapping.clear();
 
      // Copy from Added_to_main_mapping with order reversed.
      for (unsigned j = 0; j < Added_to_main_mapping.size(); j++)
      {
        Main_to_added_mapping.insert(
          std::make_pair(Added_to_main_mapping[j], j));
      }
    }

References j, OOMPH_CURRENT_FUNCTION, and OOMPH_EXCEPTION_LOCATION.

main_to_added()

unsigned oomph::AddedMainNumberingLookup::main_to_added ( const int &  main ) const

inline

Given a main matrix row/col number get the equivalent row/col in the added matrix. Throw an error if not found.

    {
      int result = unsafe_main_to_added(main);
#ifdef PARANOID
      // If it's -1 then we failed to find it:
      if (result == -1)
      {
        std::string err = "Main matrix row/col number " + to_string(main) +
                          " not found in lookup.";
        throw OomphLibError(
          err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
      }
 
      if (result < 0)
      {
        std::string err = "Something crazy went wrong here.";
        throw OomphLibError(
          err, OOMPH_EXCEPTION_LOCATION, OOMPH_CURRENT_FUNCTION);
      }
#endif
 
      return unsigned(result);
    }

References main(), OOMPH_CURRENT_FUNCTION, OOMPH_EXCEPTION_LOCATION, oomph::Global_string_for_annotation::string(), and oomph::StringConversion::to_string().

main_to_added_mapping_pt()

const std::map<unsigned, unsigned>* oomph::AddedMainNumberingLookup::main_to_added_mapping_pt ( ) const

inline

Const access function for mapping.

    {
      return &Main_to_added_mapping;
    }

Referenced by oomph::SumOfMatrices::add_matrix().

operator=()

void oomph::AddedMainNumberingLookup::operator= ( const AddedMainNumberingLookup &  dummy )

privatedelete

Inaccessible assignment operator.

unsafe_main_to_added()

int oomph::AddedMainNumberingLookup::unsafe_main_to_added ( const int &  main ) const

inline

Given a main matrix row/col number get the equivalent row/col in the added matrix. Return -1 if not found.

    {
      // Find the entry
      std::map<unsigned, unsigned>::const_iterator it =
        Main_to_added_mapping.find(unsigned(main));
 
      // Check the entry existed, it not then return -1.
      if (it == main_to_added_mapping_pt()->end())
      {
        return -1;
      }
      else
      {
        return it->second;
      }
    }

References Eigen::placeholders::end, and main().

Member Data Documentation

Added_to_main_mapping

Vector<unsigned> oomph::AddedMainNumberingLookup::Added_to_main_mapping

private

Mapping from added matrix row/col numbers to main matrix row/col numbers.

Main_to_added_mapping

std::map<unsigned, unsigned> oomph::AddedMainNumberingLookup::Main_to_added_mapping

private

Mapping from main matrix row/col numbers to added matrix row/col numbers. Note that we cannot use a vector here because the main matrix rows/cols mapped onto are probably not contiguous. Access times are O(log N) so if you need to iterate over all elements then use the pointer access functions and use stl iterators properly.

---

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

• sum_of_matrices.h