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. More...

Private Attributes
Homogenization::ConstraintMap	_cmap
	Constraint map. More...

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

HomogenizationInterface::_cmap

Homogenization::ConstraintMap _cmap

Constraint map.

Definition: HomogenizationInterface.h:50

◆ validParams()

template<class T >

InputParameters HomogenizationInterface< T >::validParams ( )

static

Definition at line 55 of file HomogenizationInterface.h.

Referenced by HomogenizedTotalLagrangianStressDivergence::validParams(), and ComputeHomogenizedLagrangianStrain::validParams().

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