libMesh::ParameterVector Class Reference

Data structure for specifying which Parameters should be independent variables in a parameter sensitivity calculation. More...

#include <parameter_vector.h>

Public Member Functions
	ParameterVector ()
	Default constructor: "no parameters". More...
	ParameterVector (const std::vector< Number * > &params)
	Constructor-from-vector-of-Number*: each points to a parameter. More...
	~ParameterVector ()
	Destructor - deletes ParameterAccessor objects. More...
void	deep_copy (ParameterVector &target) const
	Deep copy constructor: the target will now own new copies of all the parameter values I'm pointing to. More...
void	shallow_copy (ParameterVector &target) const
	Shallow copy constructor: the target will now point to all the parameter values I'm pointing to. More...
void	value_copy (ParameterVector &target) const
	Value copy method: the target, which should already have as many parameters as I do, will now have those parameters set to my values. More...
void	clear ()
	Resets to "no parameters". More...
std::size_t	size () const
void	resize (std::size_t s)
	Sets the number of parameters to be used. More...
void	push_back (std::unique_ptr< ParameterAccessor< Number >> new_accessor)
	Adds an additional parameter accessor to the end of the vector. More...
void	deep_resize (std::size_t s)
	Sets the number of parameters to be used. More...
const ParameterAccessor< Number > &	operator[] (std::size_t i) const
ParameterAccessor< Number > &	operator[] (std::size_t i)
ParameterVector &	operator*= (const Number a)
	Multiplication operator; acts individually on each parameter. More...
ParameterVector &	operator+= (const ParameterVector &a)
	Addition operator. More...

Private Attributes
std::vector< ParameterAccessor< Number > * >	_params
	Pointers to parameters which may exist elsewhere. More...
std::vector< Number >	_my_data
	Parameters which I own; e.g. More...
bool	_is_shallow_copy
	Am I a shallow copy? If so then I shouldn't be deleting my ParameterAccessors. More...

Detailed Description

Data structure for specifying which Parameters should be independent variables in a parameter sensitivity calculation.

Author

Roy Stogner

Date

2009

Specifies parameters for parameter sensitivity calculations.

Definition at line 44 of file parameter_vector.h.

Constructor & Destructor Documentation

ParameterVector() [1/2]

libMesh::ParameterVector::ParameterVector ( )

inline

Default constructor: "no parameters".

Definition at line 50 of file parameter_vector.h.

: _is_shallow_copy(false) {}

ParameterVector() [2/2]

libMesh::ParameterVector::ParameterVector ( const std::vector< Number * > &  params )

explicit

Constructor-from-vector-of-Number*: each points to a parameter.

Definition at line 27 of file parameter_vector.C.

  : _is_shallow_copy(false)
{
  _params.reserve(params.size());
 
  for (auto p : params)
    _params.push_back(new ParameterPointer<Number>(p));
}

References _params.

~ParameterVector()

libMesh::ParameterVector::~ParameterVector ( )

inline

Destructor - deletes ParameterAccessor objects.

Definition at line 162 of file parameter_vector.h.

{
  this->clear();
}

References clear().

Member Function Documentation

clear()

void libMesh::ParameterVector::clear ( )

inline

Resets to "no parameters".

Definition at line 170 of file parameter_vector.h.

{
  if (!_is_shallow_copy)
    for (auto & param : _params)
      delete param;
 
  _params.clear();
  _my_data.clear();
}

References _is_shallow_copy, _my_data, and _params.

Referenced by deep_copy(), LaplaceSystem::get_parameter_vector(), and ~ParameterVector().

deep_copy()

void libMesh::ParameterVector::deep_copy

(

ParameterVector &

target

)

const

Deep copy constructor: the target will now own new copies of all the parameter values I'm pointing to.

Definition at line 38 of file parameter_vector.C.

{
  const std::size_t Np = this->_params.size();
  target.clear();
  target._params.resize(Np);
  target._my_data.resize(Np);
  for (std::size_t i=0; i != Np; ++i)
    {
      target._params[i] =
        new ParameterPointer<Number>(&target._my_data[i]);
      target._my_data[i] = *(*this)[i];
    }
}

References _my_data, _params, and clear().

Referenced by libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

deep_resize()

void libMesh::ParameterVector::deep_resize

(

std::size_t

s

)

Sets the number of parameters to be used.

This method is for resizing a ParameterVector that owns its own parameter values

Definition at line 95 of file parameter_vector.C.

{
  libmesh_assert(!_is_shallow_copy);
 
  this->_params.resize(s);
  this->_my_data.resize(s);
  for (std::size_t i=0; i != s; ++i)
    this->_params[i] =
      new ParameterPointer<Number>(&this->_my_data[i]);
}

References _is_shallow_copy, _my_data, _params, and libMesh::libmesh_assert().

operator*=()

ParameterVector & libMesh::ParameterVector::operator*=

(

const Number

a

)

Multiplication operator; acts individually on each parameter.

Definition at line 108 of file parameter_vector.C.

{
  const std::size_t Np = this->_params.size();
  for (std::size_t i=0; i != Np; ++i)
    *(*this)[i] *= a;
  return *this;
}

References _params.

operator+=()

ParameterVector & libMesh::ParameterVector::operator+=

(

const ParameterVector &

a

)

Addition operator.

The parameter vector to be added in must have the same number of values.

Definition at line 118 of file parameter_vector.C.

{
  const std::size_t Np = this->_params.size();
  libmesh_assert_equal_to (a._params.size(), Np);
  for (std::size_t i=0; i != Np; ++i)
    *(*this)[i] += *a[i];
  return *this;
}

References _params.

operator[]() [1/2]

ParameterAccessor< Number > & libMesh::ParameterVector::operator[] ( std::size_t  i )

inline

Returns

A reference to a smart-pointer to a parameter value, suitable for repointing it to a different address. This method is deprecated and may not work with more sophisticated ParameterAccessor subclasses.

Definition at line 204 of file parameter_vector.h.

{
  libmesh_assert_greater (_params.size(), i);
 
  return *_params[i];
}

References _params.

operator[]() [2/2]

const ParameterAccessor< Number > & libMesh::ParameterVector::operator[] ( std::size_t  i ) const

inline

Returns

A smart-pointer to a parameter value

Definition at line 194 of file parameter_vector.h.

{
  libmesh_assert_greater (_params.size(), i);
 
  return *_params[i];
}

References _params.

push_back()

void libMesh::ParameterVector::push_back ( std::unique_ptr< ParameterAccessor< Number >>  new_accessor )

inline

Adds an additional parameter accessor to the end of the vector.

We will free this accessor when we are finished with it; we request that it be passed to us as a std::unique_ptr to reflect that fact in the API.

Definition at line 183 of file parameter_vector.h.

{
  // Can't append stuff we are responsible for if we're already a shallow copy.
  libmesh_assert(!_is_shallow_copy);
  libmesh_assert(new_accessor.get());
  _params.push_back(new_accessor.release());
}

References _is_shallow_copy, _params, and libMesh::libmesh_assert().

Referenced by CoupledSystem::get_parameter_vector(), and HeatSystem::get_parameter_vector().

resize()

void libMesh::ParameterVector::resize

(

std::size_t

s

)

Sets the number of parameters to be used.

If the new size is larger than the old, empty ParameterPointer accessors fill the new entries.

Definition at line 74 of file parameter_vector.C.

{
  libmesh_assert(!_is_shallow_copy);
 
  const std::size_t old_size = this->_params.size();
 
  // If we're shrinking the vector, we don't want to leak memory.
  // Note that we're using < in these for loops, not !=
  // We don't know a priori if we're shrinking or growing
  for (std::size_t i=s; i < old_size; ++i)
    delete _params[i];
 
  this->_params.resize(s);
 
  for (std::size_t i=old_size; i < s; ++i)
    this->_params[i] =
      new ParameterPointer<Number>(nullptr);
}

References _is_shallow_copy, _params, and libMesh::libmesh_assert().

shallow_copy()

void libMesh::ParameterVector::shallow_copy

(

ParameterVector &

target

)

const

Shallow copy constructor: the target will now point to all the parameter values I'm pointing to.

Definition at line 54 of file parameter_vector.C.

{
  target._my_data.clear();
  target._params = this->_params;
  target._is_shallow_copy = true;
}

References _is_shallow_copy, _my_data, and _params.

size()

std::size_t libMesh::ParameterVector::size ( ) const

inline

Returns

The number of parameters to be used

Definition at line 90 of file parameter_vector.h.

{ return _params.size(); }

References _params.

Referenced by libMesh::ImplicitSystem::adjoint_qoi_parameter_sensitivity(), libMesh::SensitivityData::allocate_data(), libMesh::SensitivityData::allocate_hessian_data(), libMesh::ImplicitSystem::assemble_residual_derivatives(), libMesh::ImplicitSystem::forward_qoi_parameter_sensitivity(), libMesh::ImplicitSystem::qoi_parameter_hessian(), libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::System::qoi_parameter_sensitivity(), and libMesh::ImplicitSystem::sensitivity_solve().

value_copy()

void libMesh::ParameterVector::value_copy

(

ParameterVector &

target

)

const

Value copy method: the target, which should already have as many parameters as I do, will now have those parameters set to my values.

Definition at line 63 of file parameter_vector.C.

{
  const std::size_t Np = this->_params.size();
  libmesh_assert_equal_to (target._params.size(), Np);
 
  for (std::size_t i=0; i != Np; ++i)
    *target[i] = *(*this)[i];
}

References _params.

Referenced by libMesh::ImplicitSystem::qoi_parameter_hessian_vector_product(), libMesh::ImplicitSystem::weighted_sensitivity_adjoint_solve(), and libMesh::ImplicitSystem::weighted_sensitivity_solve().

Member Data Documentation

_is_shallow_copy

bool libMesh::ParameterVector::_is_shallow_copy

private

Am I a shallow copy? If so then I shouldn't be deleting my ParameterAccessors.

Definition at line 153 of file parameter_vector.h.

Referenced by clear(), deep_resize(), push_back(), resize(), and shallow_copy().

_my_data

std::vector<Number> libMesh::ParameterVector::_my_data

private

Parameters which I own; e.g.

as the result of a deep copy

Definition at line 147 of file parameter_vector.h.

Referenced by clear(), deep_copy(), deep_resize(), and shallow_copy().

_params

std::vector<ParameterAccessor<Number> *> libMesh::ParameterVector::_params

private

Pointers to parameters which may exist elsewhere.

Definition at line 142 of file parameter_vector.h.

Referenced by clear(), deep_copy(), deep_resize(), operator*=(), operator+=(), operator[](), ParameterVector(), push_back(), resize(), shallow_copy(), size(), and value_copy().

---

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

• include/systems/parameter_vector.h
• src/systems/parameter_vector.C