Interface for objects that use the homogenization constraint. More...

#include <HomogenizationInterface.h>

Inheritance diagram for HomogenizationInterface< T >:

Public Member Functions
	HomogenizationInterface (const InputParameters &parameters)

Static Public Member Functions
static InputParameters	validParams ()

Protected Member Functions
const Homogenization::ConstraintMap &	cmap () const
	Get the constraint map.

Private Attributes
Homogenization::ConstraintMap	_cmap
	Constraint map.

Detailed Description

template<class T>
class HomogenizationInterface< T >

Interface for objects that use the homogenization constraint.

Definition at line 37 of file HomogenizationInterface.h.

Constructor & Destructor Documentation

◆ HomogenizationInterface()

template<class T >

HomogenizationInterface< T >::HomogenizationInterface ( const InputParameters & parameters )

Definition at line 69 of file HomogenizationInterface.h.

  : T(parameters)
{
  // Constraint types
  auto types = parameters.get<MultiMooseEnum>("constraint_types");
  if (types.size() != Moose::dim * Moose::dim)
    this->paramError("constraint_types",
                     "Number of constraint types must equal ",
                     Moose::dim * Moose::dim,
                     ", but ",
                     types.size(),
                     " are provided.");
 
  // Targets to hit
  const std::vector<FunctionName> & fnames = parameters.get<std::vector<FunctionName>>("targets");
 
  // Prepare the constraint map
  unsigned int fcount = 0;
  for (const auto j : make_range(Moose::dim))
    for (const auto i : make_range(Moose::dim))
    {
      const auto idx = i + Moose::dim * j;
      const auto ctype = static_cast<Homogenization::ConstraintType>(types.get(idx));
      if (ctype != Homogenization::ConstraintType::None)
      {
        if (fcount >= fnames.size())
          this->paramError(
              "targets",
              "Number of target functions must equal the number of non-none constraint "
              "types. Only ",
              fnames.size(),
              " are provided.");
        const Function * const f = &this->getFunctionByName(fnames[fcount++]);
        _cmap[{i, j}] = {ctype, f};
      }
    }
 
  // Make sure there aren't unused targets
  if (fcount != fnames.size())
    this->paramError(
        "targets",
        "Number of target functions must equal the number of non-none constraint types. ",
        fnames.size(),
        " are provided, but ",
        fcount,
        " are used.");
}

Member Function Documentation

◆ cmap()

template<class T >

const Homogenization::ConstraintMap & HomogenizationInterface< T >::cmap ( ) const

inlineprotected

Get the constraint map.

Definition at line 46 of file HomogenizationInterface.h.

46{ return _cmap; }

◆ validParams()

template<class T >

InputParameters HomogenizationInterface< T >::validParams ( )

static

Definition at line 55 of file HomogenizationInterface.h.

{
  InputParameters params = T::validParams();
  params.addRequiredParam<MultiMooseEnum>(
      "constraint_types",
      Homogenization::constraintType,
      "Type of each constraint: strain, stress, or none. The types are specified in the "
      "column-major order, and there must be 9 entries in total.");
  params.addRequiredParam<std::vector<FunctionName>>(
      "targets", "Functions giving the targets to hit for constraint types that are not none.");
  return params;
}