libMesh::ParameterVector Class Reference

Specifies parameters for parameter sensitivity calculations. More...

#include <parameter_vector.h>

Public Member Functions
	ParameterVector ()
	ParameterVector (const std::vector< Number *> &params)
	~ParameterVector ()
void	deep_copy (ParameterVector &target) const
void	shallow_copy (ParameterVector &target) const
void	value_copy (ParameterVector &target) const
void	clear ()
std::size_t	size () const
void	resize (std::size_t s)
void	push_back (std::unique_ptr< ParameterAccessor< Number >> new_accessor)
void	deep_resize (std::size_t s)
const ParameterAccessor< Number > &	operator[] (std::size_t i) const
ParameterAccessor< Number > &	operator[] (std::size_t i)
ParameterVector &	operator*= (const Number a)
ParameterVector &	operator+= (const ParameterVector &a)

Private Attributes
std::vector< ParameterAccessor< Number > * >	_params
std::vector< Number >	_my_data
bool	_is_shallow_copy

Detailed Description

Specifies parameters for parameter sensitivity calculations.

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

Author

Roy Stogner

Date

2009

Definition at line 45 of file parameter_vector.h.

Constructor & Destructor Documentation

ParameterVector() [1/2]

libMesh::ParameterVector::ParameterVector ( )

inline

Default constructor: "no parameters"

Definition at line 51 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.

References _params.

  : _is_shallow_copy(false)
{
  _params.reserve(params.size());

  for (std::size_t i=0; i != params.size(); ++i)
    _params.push_back(new ParameterPointer<Number>(params[i]));
}

~ParameterVector()

libMesh::ParameterVector::~ParameterVector ( )

inline

Destructor - deletes ParameterAccessor objects

Definition at line 163 of file parameter_vector.h.

References clear().

{
  this->clear();
}

Member Function Documentation

clear()

void libMesh::ParameterVector::clear ( )

inline

Resets to "no parameters"

Definition at line 171 of file parameter_vector.h.

References _is_shallow_copy, _my_data, and _params.

Referenced by deep_copy(), and ~ParameterVector().

{
  if (!_is_shallow_copy)
    for (auto & param : _params)
      delete param;

  _params.clear();
  _my_data.clear();
}

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.

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().

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

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.

References _is_shallow_copy, _my_data, and _params.

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

operator*=()

ParameterVector & libMesh::ParameterVector::operator*=

(

const Number

a

)

Multiplication operator; acts individually on each parameter.

Definition at line 108 of file parameter_vector.C.

References _params.

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

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.

References _params.

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

operator[]() [1/2]

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

inline

Returns

A smart-pointer to a parameter value

Definition at line 195 of file parameter_vector.h.

References _params.

{
  libmesh_assert_greater (_params.size(), i);

  return *_params[i];
}

operator[]() [2/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 205 of file parameter_vector.h.

References _params.

{
  libmesh_assert_greater (_params.size(), i);

  return *_params[i];
}

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 184 of file parameter_vector.h.

References _is_shallow_copy, and _params.

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

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.

References _is_shallow_copy, and _params.

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

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.

References _is_shallow_copy, _my_data, and _params.

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

size()

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

inline

Returns

The number of parameters to be used

Definition at line 91 of file parameter_vector.h.

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().

{ return _params.size(); }

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.

References _params.

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

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

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 154 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 148 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 143 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:

• parameter_vector.h
• parameter_vector.C