libMesh::CouplingAccessor Class Reference

#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 190 of file coupling_matrix.h.

Constructor & Destructor Documentation

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

inline

Definition at line 193 of file coupling_matrix.h.

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

Member Function Documentation

libMesh::ConstCouplingAccessor::operator bool ( ) const

inlineinherited

Definition at line 144 of file coupling_matrix.h.

References std::max(), and libMesh::MeshTools::Subdivision::next.

                        {
    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);
  }

template<typename T >

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

inline

Definition at line 198 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;
  }

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

inline

Definition at line 209 of file coupling_matrix.h.

References std::max(), and libMesh::MeshTools::Subdivision::next.

  {
    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.insert(_my_mat._ranges.begin(),
                                 std::make_pair(_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.insert
                  (lb, std::make_pair(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.insert
                        (next, std::make_pair(_location, _location));
                  }
              }
          }
      }

    return *this;
  }

Member Data Documentation

std::size_t libMesh::ConstCouplingAccessor::_location

protectedinherited

Definition at line 182 of file coupling_matrix.h.

const CouplingMatrix& libMesh::ConstCouplingAccessor::_mat

protectedinherited

Definition at line 183 of file coupling_matrix.h.

CouplingMatrix& libMesh::CouplingAccessor::_my_mat

private

Definition at line 326 of file coupling_matrix.h.

---

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

• coupling_matrix.h