libMesh::SystemNorm Class Reference

#include <system_norm.h>

Public Member Functions
	SystemNorm ()
	SystemNorm (const FEMNormType &t)
	SystemNorm (const std::vector< FEMNormType > &norms)
	SystemNorm (const std::vector< FEMNormType > &norms, std::vector< Real > &weights)
	SystemNorm (const std::vector< FEMNormType > &norms, std::vector< std::vector< Real >> &weights)
	SystemNorm (const SystemNorm &)=default
	SystemNorm (SystemNorm &&)=default
SystemNorm &	operator= (const SystemNorm &)=default
SystemNorm &	operator= (SystemNorm &&)=default
virtual	~SystemNorm ()=default
bool	is_discrete () const
Real	calculate_norm (const std::vector< Real > &v)
Real	calculate_norm (const std::vector< Real > &v1, const std::vector< Real > &v2)
bool	is_identity ()
FEMNormType	type (unsigned int var) const
void	set_type (unsigned int var, const FEMNormType &t)
Real	weight (unsigned int var) const
void	set_weight (unsigned int var, Real w)
void	set_off_diagonal_weight (unsigned int i, unsigned int j, Real w)
Real	weight_sq (unsigned int var) const

Private Attributes
std::vector< FEMNormType >	_norms
std::vector< Real >	_weights
std::vector< Real >	_weights_sq
std::vector< std::vector< Real > >	_off_diagonal_weights

Detailed Description

This class defines a norm/seminorm to be applied to a NumericVector which contains coefficients in a finite element space.

Discrete vector norms and weighted l2 combinations of Sobolev norms and seminorms are representable.

Author

Roy H. Stogner

Date

2008

Definition at line 51 of file system_norm.h.

Constructor & Destructor Documentation

SystemNorm() [1/7]

libMesh::SystemNorm::SystemNorm

(

)

Constructor, defaults to DISCRETE_L2

Definition at line 26 of file system_norm.C.

                       :
  _norms(1, DISCRETE_L2), _weights(1, 1.0), _weights_sq(1, 1.0)
{
}

SystemNorm() [2/7]

libMesh::SystemNorm::SystemNorm

(

const FEMNormType &

t

)

Constructor, for discrete vector norms, systems with one variable, and systems for which the same norm type should be used with a weight of one on each variable.

This is deliberately an implicit constructor; we want user code to be able to include lines like "error_norm = L2"

Definition at line 32 of file system_norm.C.

                                            :
  _norms(1, t), _weights(1, 1.0), _weights_sq(1, 1.0)
{
}

SystemNorm() [3/7]

libMesh::SystemNorm::SystemNorm ( const std::vector< FEMNormType > &  norms )

explicit

Constructor, for unweighted sobolev norms on systems with multiple variables.

For a system with n variables, the final norm will be the l2 norm of the n-vector of the norms in each variable.

Definition at line 38 of file system_norm.C.

References _norms, and libMesh::DISCRETE_L2.

                                                           :
  _norms(norms), _weights(1, 1.0), _weights_sq(1, 1.0)
{
  if (_norms.empty())
    _norms.push_back(DISCRETE_L2);
}

SystemNorm() [4/7]

libMesh::SystemNorm::SystemNorm	(	const std::vector< FEMNormType > &	norms,
		std::vector< Real > &	weights
	)

Constructor, for weighted sobolev norms on systems with multiple variables.

For a system with n variables, the final norm will be the l2 norm of the n-vector of the norms in each variable, each multiplied by weight.

Definition at line 46 of file system_norm.C.

References _norms, _weights, _weights_sq, and libMesh::DISCRETE_L2.

                                                  :
  _norms(norms), _weights(weights), _weights_sq(_weights.size(), 0.0)
{
  if (_norms.empty())
    _norms.push_back(DISCRETE_L2);

  if (_weights.empty())
    {
      _weights.push_back(1.0);
      _weights_sq.push_back(1.0);
    }
  else
    for (std::size_t i=0; i != _weights.size(); ++i)
      _weights_sq[i] = _weights[i] * _weights[i];
}

SystemNorm() [5/7]

libMesh::SystemNorm::SystemNorm	(	const std::vector< FEMNormType > &	norms,
		std::vector< std::vector< Real >> &	weights
	)

Constructor, for weighted sobolev norms on systems with multiple variables and their adjoints

For a system with n variables, the final norm computed will be of the form norm_u^T*R*norm_z where R is a scaling matrix

Definition at line 63 of file system_norm.C.

References _norms, _off_diagonal_weights, _weights, _weights_sq, and libMesh::DISCRETE_L2.

                                                            :
  _norms(norms),
  _weights(weights.size()),
  _weights_sq(weights.size()),
  _off_diagonal_weights(weights)
{
  if (_norms.empty())
    _norms.push_back(DISCRETE_L2);

  if (_weights.empty())
    {
      _weights.push_back(1.0);
      _weights_sq.push_back(1.0);
    }
  else
    {
      // Loop over the entries of the user provided matrix and store its entries in
      // the _off_diagonal_weights or _diagonal_weights
      for (std::size_t i=0; i!=_off_diagonal_weights.size(); ++i)
        {
          if (_off_diagonal_weights[i].size() > i)
            {
              _weights[i] = _off_diagonal_weights[i][i];
              _off_diagonal_weights[i][i] = 0;
            }
          else
            _weights[i] = 1.0;
        }
      for (std::size_t i=0; i != _weights.size(); ++i)
        _weights_sq[i] = _weights[i] * _weights[i];
    }
}

SystemNorm() [6/7]

libMesh::SystemNorm::SystemNorm ( const SystemNorm &  )

default

Copy/move ctor, copy/move assignment operator, and destructor are all explicitly defaulted for this simple class.

SystemNorm() [7/7]

libMesh::SystemNorm::SystemNorm ( SystemNorm &&  )

default

~SystemNorm()

virtual libMesh::SystemNorm::~SystemNorm ( )

virtualdefault

Member Function Documentation

calculate_norm() [1/2]

Real libMesh::SystemNorm::calculate_norm

(

const std::vector< Real > &

v

)

Returns

The weighted norm v^T*W*v where W represents our weights matrix or weights vector times identity matrix.

Definition at line 230 of file system_norm.C.

Referenced by libMesh::AdjointResidualErrorEstimator::estimate_error().

{
  return this->calculate_norm(v1,v1);
}

calculate_norm() [2/2]

Real libMesh::SystemNorm::calculate_norm	(	const std::vector< Real > &	v1,
		const std::vector< Real > &	v2
	)

Returns

The weighted inner product v1^T*W*v2 where R is our weights

Definition at line 183 of file system_norm.C.

References _off_diagonal_weights, _weights, and libMesh::Real.

{
  // The vectors are assumed to both be vectors of the (same number
  // of) components
  std::size_t vsize = v1.size();
  libmesh_assert_equal_to (vsize, v2.size());

  // We'll support implicitly defining weights, but if the user sets
  // more weights than he uses then something's probably wrong
  std::size_t diagsize = this->_weights.size();
  libmesh_assert_greater_equal (vsize, diagsize);

  // Initialize the variable val
  Real val = 0.;

  // Loop over all the components of the system with explicit
  // weights
  for (std::size_t i = 0; i != diagsize; i++)
    {
      val += this->_weights[i] * v1[i] * v2[i];
    }
  // Loop over all the components of the system with implicit
  // weights
  for (std::size_t i = diagsize; i < vsize; i++)
    {
      val += v1[i] * v2[i];
    }

  // Loop over the components of the system
  std::size_t nrows = this->_off_diagonal_weights.size();
  libmesh_assert_less_equal (vsize, nrows);

  for (std::size_t i = 0; i != nrows; i++)
    {
      std::size_t ncols = this->_off_diagonal_weights[i].size();
      for (std::size_t j=0; j != ncols; j++)
        {
          // The diagonal weights here were set to zero in the
          // constructor.
          val += this->_off_diagonal_weights[i][j] * v1[i] * v2[j];
        }
    }

  return(val);
}

is_discrete()

bool libMesh::SystemNorm::is_discrete

(

)

const

Returns

true if this is purely a discrete norm

Definition at line 97 of file system_norm.C.

References _norms, libMesh::DISCRETE_L1, libMesh::DISCRETE_L2, and libMesh::DISCRETE_L_INF.

Referenced by libMesh::System::calculate_norm().

{
  libmesh_assert (!_norms.empty());

  if (_norms[0] == DISCRETE_L1 ||
      _norms[0] == DISCRETE_L2 ||
      _norms[0] == DISCRETE_L_INF)
    return true;

  return false;
}

is_identity()

bool libMesh::SystemNorm::is_identity

(

)

Returns

true if no weight matrix W is specified or an identity matrix is specified, otherwise returns false

Definition at line 235 of file system_norm.C.

References _off_diagonal_weights, and _weights.

Referenced by libMesh::AdjointResidualErrorEstimator::estimate_error().

{
  std::size_t nrows = this->_off_diagonal_weights.size();

  // If any of the off-diagonal elements is not 0, then we are in the non-identity case
  for (std::size_t i = 0; i != nrows; i++)
    {
      std::size_t ncols = this->_off_diagonal_weights[i].size();
      for (std::size_t j = 0; j != ncols; j++)
        {
          if (_off_diagonal_weights[i][j] != 0)
            {
              return(false);
            }
        }
    }

  // If any of the diagonal elements is not 1, then we are in the non-identity case
  nrows = this->_weights.size();
  for (std::size_t i = 0; i != nrows; i++)
    if (_weights[i] != 1)
      return(false);

  // If all the off-diagonals elements are 0, and diagonal elements 1, then we are in an identity case
  return(true);
}

operator=() [1/2]

SystemNorm& libMesh::SystemNorm::operator= ( const SystemNorm &  )

default

operator=() [2/2]

SystemNorm& libMesh::SystemNorm::operator= ( SystemNorm &&  )

default

set_off_diagonal_weight()

void libMesh::SystemNorm::set_off_diagonal_weight	(	unsigned int	i,
		unsigned int	j,
		Real	w
	)

Sets the weight corresponding to the norm from the variable pair v1(var1) coming from v2(var2). See calculate_norm

Definition at line 154 of file system_norm.C.

References _off_diagonal_weights, and _weights.

{
  libmesh_assert (!_weights.empty());

  if (i >= _off_diagonal_weights.size())
    {
      _off_diagonal_weights.resize(i+1);
    }

  if (j >= _off_diagonal_weights[i].size())
    {
      _off_diagonal_weights[i].resize(j+1, 0.);
    }

  _off_diagonal_weights[i][j] = w;

}

set_type()

void libMesh::SystemNorm::set_type	(	unsigned int	var,
		const FEMNormType &	t
	)

Sets the type of the norm in variable var

Definition at line 121 of file system_norm.C.

References _norms.

{
  libmesh_assert (!_norms.empty());

  if (var >= _norms.size())
    _norms.resize(var+1, t);

  _norms[var] = t;
}

set_weight()

void libMesh::SystemNorm::set_weight	(	unsigned int	var,
		Real	w
	)

Sets the weight corresponding to the norm in variable var

Definition at line 140 of file system_norm.C.

References _weights, and _weights_sq.

{
  libmesh_assert (!_weights.empty());

  if (var >= _weights.size())
    {
      _weights.resize(var+1, 1.0);
      _weights_sq.resize(var+1, 1.0);
    }

  _weights[var] = w;
  _weights_sq[var] = w*w;
}

type()

FEMNormType libMesh::SystemNorm::type

(

unsigned int

var

)

const

Returns

The type of the norm in variable var

Definition at line 110 of file system_norm.C.

References _norms.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::System::calculate_norm(), libMesh::ErrorEstimator::estimate_errors(), libMesh::ExactErrorEstimator::find_squared_element_error(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), and libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()().

{
  libmesh_assert (!_norms.empty());

  std::size_t i = (var < _norms.size()) ? var : _norms.size() - 1;

  return _norms[i];
}

weight()

Real libMesh::SystemNorm::weight

(

unsigned int

var

)

const

Returns

The weight corresponding to the norm in variable var

Definition at line 132 of file system_norm.C.

References _weights.

Referenced by libMesh::DiscontinuityMeasure::boundary_side_integration(), libMesh::KellyErrorEstimator::boundary_side_integration(), libMesh::System::calculate_norm(), libMesh::JumpErrorEstimator::estimate_error(), libMesh::ExactErrorEstimator::estimate_error(), libMesh::LaplacianErrorEstimator::init_context(), libMesh::DiscontinuityMeasure::init_context(), libMesh::KellyErrorEstimator::init_context(), libMesh::LaplacianErrorEstimator::internal_side_integration(), libMesh::DiscontinuityMeasure::internal_side_integration(), libMesh::KellyErrorEstimator::internal_side_integration(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()(), and libMesh::JumpErrorEstimator::reinit_sides().

{
  libmesh_assert (!_weights.empty());

  return (var < _weights.size()) ? _weights[var] : 1.0;
}

weight_sq()

Real libMesh::SystemNorm::weight_sq

(

unsigned int

var

)

const

Returns

The squared weight corresponding to the norm in variable var. We cache that at construction time to save a few flops.

Definition at line 175 of file system_norm.C.

References _weights_sq.

Referenced by libMesh::UniformRefinementEstimator::_estimate_error(), libMesh::System::calculate_norm(), libMesh::WeightedPatchRecoveryErrorEstimator::EstimateError::operator()(), and libMesh::PatchRecoveryErrorEstimator::EstimateError::operator()().

{
  libmesh_assert (!_weights_sq.empty());

  return (var < _weights_sq.size()) ? _weights_sq[var] : 1.0;
}

Member Data Documentation

_norms

std::vector<FEMNormType> libMesh::SystemNorm::_norms

private

Definition at line 166 of file system_norm.h.

Referenced by is_discrete(), set_type(), SystemNorm(), and type().

_off_diagonal_weights

std::vector<std::vector<Real> > libMesh::SystemNorm::_off_diagonal_weights

private

One more data structure needed to store the off diagonal components for the generalize SystemNorm case

Definition at line 175 of file system_norm.h.

Referenced by calculate_norm(), is_identity(), set_off_diagonal_weight(), and SystemNorm().

_weights

std::vector<Real> libMesh::SystemNorm::_weights

private

Definition at line 168 of file system_norm.h.

Referenced by calculate_norm(), is_identity(), set_off_diagonal_weight(), set_weight(), SystemNorm(), and weight().

_weights_sq

std::vector<Real> libMesh::SystemNorm::_weights_sq

private

Definition at line 169 of file system_norm.h.

Referenced by set_weight(), SystemNorm(), and weight_sq().

---

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

• system_norm.h
• system_norm.C