libMesh::CouplingAccessor Class Reference

This accessor class allows simple setting of CouplingMatrix values. More...

#include <coupling_matrix.h>

Inheritance diagram for libMesh::CouplingAccessor:

Public Member Functions
	CouplingAccessor (std::size_t loc_in, CouplingMatrix &mat_in)
template<typename T >
CouplingAccessor &	operator= (T new_value)
CouplingAccessor &	operator= (bool new_value)
	operator bool () const

Protected Attributes
std::size_t	_location
const CouplingMatrix &	_mat

Private Attributes
CouplingMatrix &	_my_mat

Detailed Description

This accessor class allows simple setting of CouplingMatrix values.

Definition at line 191 of file coupling_matrix.h.

Constructor & Destructor Documentation

CouplingAccessor()

libMesh::CouplingAccessor::CouplingAccessor ( std::size_t  loc_in, CouplingMatrix &  mat_in  )

inline

Definition at line 194 of file coupling_matrix.h.

                                            :
    ConstCouplingAccessor(loc_in, mat_in), _my_mat(mat_in) {}

Member Function Documentation

operator bool()

libMesh::ConstCouplingAccessor::operator bool ( ) const

inlineinherited

Definition at line 144 of file coupling_matrix.h.

  {
    const std::size_t max_size = std::numeric_limits<std::size_t>::max();
 
    // Find the range that might contain i,j
    // lower_bound isn't *quite* what we want
    CouplingMatrix::rc_type::const_iterator lb = std::upper_bound
      (_mat._ranges.begin(), _mat._ranges.end(),
       std::make_pair(_location, max_size));
    if (lb!=_mat._ranges.begin())
      --lb;
    else
      lb=_mat._ranges.end();
 
    // If no range might contain i,j then it's 0
    if (lb == _mat._ranges.end())
      return false;
 
    const std::size_t lastloc  = lb->second;
 
#ifdef DEBUG
    const std::size_t firstloc = lb->first;
    libmesh_assert_less_equal(firstloc, lastloc);
    libmesh_assert_less_equal(firstloc, _location);
 
    CouplingMatrix::rc_type::const_iterator next = lb;
    next++;
    if (next != _mat._ranges.end())
      {
        // Ranges should be sorted and should not touch
        libmesh_assert_greater(next->first, lastloc+1);
      }
#endif
 
    return (lastloc >= _location);
  }

References libMesh::ConstCouplingAccessor::_location, libMesh::ConstCouplingAccessor::_mat, and libMesh::CouplingMatrix::_ranges.

operator=() [1/2]

CouplingAccessor & libMesh::CouplingAccessor::operator= ( bool  new_value )

inline

Definition at line 210 of file coupling_matrix.h.

  {
    const std::size_t max_size = std::numeric_limits<std::size_t>::max();
 
    // Find the range that might contain i,j
    // lower_bound isn't *quite* what we want
    CouplingMatrix::rc_type::iterator lb =
      std::upper_bound (_my_mat._ranges.begin(), _my_mat._ranges.end(),
                        std::make_pair(_location, max_size));
    if (lb!=_my_mat._ranges.begin())
      --lb;
    else
      lb=_my_mat._ranges.end();
 
    // If no range might contain i,j then we might need to make a new
    // one.
    if (lb == _my_mat._ranges.end())
      {
        if (new_value == true)
          _my_mat._ranges.emplace
            (_my_mat._ranges.begin(), _location, _location);
      }
    else
      {
        const std::size_t firstloc = lb->first;
        const std::size_t lastloc  = lb->second;
        libmesh_assert_less_equal(firstloc, lastloc);
        libmesh_assert_less_equal(firstloc, _location);
 
#ifdef DEBUG
        {
          CouplingMatrix::rc_type::const_iterator next = lb;
          next++;
          if (next != _my_mat._ranges.end())
            {
              // Ranges should be sorted and should not touch
              libmesh_assert_greater(next->first, lastloc+1);
            }
        }
#endif
 
        // If we're in this range, we might need to shorten or remove
        // or split it
        if (new_value == false)
          {
            if (_location == firstloc)
              {
                if (_location == lastloc)
                  {
                    _my_mat._ranges.erase(lb);
                  }
                else
                  {
                    libmesh_assert_less (lb->first, lastloc);
                    lb->first++;
                  }
              }
            else if (_location == lastloc)
              {
                libmesh_assert_less (firstloc, lb->second);
 
                lb->second--;
              }
            else if (_location < lastloc)
              {
                libmesh_assert_less_equal(_location+1, lastloc);
 
                lb->first = _location+1;
 
                libmesh_assert_less_equal(firstloc, _location-1);
 
                _my_mat._ranges.emplace(lb, firstloc, _location-1);
              }
          }
 
        // If we're not in this range, we might need to extend it or
        // join it with its neighbor or add a new one.
        else // new_value == true
          {
            CouplingMatrix::rc_type::iterator next = lb;
            next++;
            const std::size_t nextloc =
              (next == _my_mat._ranges.end()) ?
              std::numeric_limits<std::size_t>::max() :
              next->first;
 
            // Ranges should be sorted and should not touch
            libmesh_assert_greater(nextloc, lastloc+1);
 
            if (_location > lastloc)
              {
                if (_location == lastloc + 1)
                  {
                    if (_location == nextloc - 1)
                      {
                        next->first = firstloc;
                        _my_mat._ranges.erase(lb);
                      }
                    else
                      lb->second++;
                  }
                else
                  {
                    if (_location == nextloc - 1)
                      next->first--;
                    else
                      _my_mat._ranges.emplace(next, _location, _location);
                  }
              }
          }
      }
 
    return *this;
  }

References libMesh::ConstCouplingAccessor::_location, _my_mat, and libMesh::CouplingMatrix::_ranges.

operator=() [2/2]

template<typename T >

CouplingAccessor & libMesh::CouplingAccessor::operator= ( T  new_value )

inline

Definition at line 199 of file coupling_matrix.h.

  {
    // For backwards compatibility we take integer arguments,
    // but coupling matrix entries are really all zero or one.
    const bool as_bool = new_value;
    libmesh_assert_equal_to(new_value, as_bool);
 
    *this = as_bool;
    return *this;
  }

Member Data Documentation

_location

std::size_t libMesh::ConstCouplingAccessor::_location

protectedinherited

Definition at line 183 of file coupling_matrix.h.

Referenced by libMesh::ConstCouplingAccessor::ConstCouplingAccessor(), libMesh::ConstCouplingAccessor::operator bool(), and operator=().

_mat

const CouplingMatrix& libMesh::ConstCouplingAccessor::_mat

protectedinherited

Definition at line 184 of file coupling_matrix.h.

Referenced by libMesh::ConstCouplingAccessor::ConstCouplingAccessor(), and libMesh::ConstCouplingAccessor::operator bool().

_my_mat

CouplingMatrix& libMesh::CouplingAccessor::_my_mat

private

Definition at line 327 of file coupling_matrix.h.

Referenced by operator=().

---

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

• include/numerics/coupling_matrix.h