Automatically generates all variables, Kernels, and Materials to ensure the correct derivatives of the elastic free energy in a non-split Cahn-Hilliard simulation are assembled. More...

#include <DisplacementGradientsAction.h>

Inheritance diagram for DisplacementGradientsAction:

[legend]

Public Types
typedef DataFileName	DataFileParameterType

Public Member Functions
	DisplacementGradientsAction (const InputParameters &params)

virtual void	act ()

void	timedAct ()

virtual void	addRelationshipManagers (Moose::RelationshipManagerType when_type)

MooseObjectName	uniqueActionName () const

const std::string &	specificTaskName () const

const std::set< std::string > &	getAllTasks () const

void	appendTask (const std::string &task)

MooseApp &	getMooseApp () const

const std::string &	type () const

virtual const std::string &	name () const

std::string	typeAndName () const

std::string	errorPrefix (const std::string &error_type) const

void	callMooseError (std::string msg, const bool with_prefix) const

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

const InputParameters &	parameters () const

MooseObjectName	uniqueName () const

const T &	getParam (const std::string &name) const

std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const

const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const

T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const

bool	isParamValid (const std::string &name) const

bool	isParamSetByUser (const std::string &nm) const

void	paramError (const std::string &param, Args... args) const

void	paramWarning (const std::string &param, Args... args) const

void	paramInfo (const std::string &param, Args... args) const

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const

void	mooseError (Args &&... args) const

void	mooseErrorNonPrefixed (Args &&... args) const

void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

void	mooseWarning (Args &&... args) const

void	mooseWarningNonPrefixed (Args &&... args) const

void	mooseDeprecated (Args &&... args) const

void	mooseInfo (Args &&... args) const

PerfGraph &	perfGraph ()

std::string	getDataFileName (const std::string &param) const

std::string	getDataFileNameByName (const std::string &name, const std::string *param=nullptr) const

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

Static Public Member Functions
static InputParameters	validParams ()

Public Attributes
const ConsoleStream	_console

Static Public Attributes
static constexpr auto	SYSTEM

static constexpr auto	NAME

Protected Member Functions
bool	addRelationshipManagers (Moose::RelationshipManagerType when_type, const InputParameters &moose_object_pars)

void	associateWithParameter (const std::string &param_name, InputParameters &params) const

void	associateWithParameter (const InputParameters &from_params, const std::string &param_name, InputParameters &params) const

const T &	getMeshProperty (const std::string &data_name, const std::string &prefix)

const T &	getMeshProperty (const std::string &data_name)

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name, const std::string &prefix) const

bool	hasMeshProperty (const std::string &data_name) const

bool	hasMeshProperty (const std::string &data_name) const

std::string	meshPropertyName (const std::string &data_name) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const

std::string	timedSectionName (const std::string &section_name) const

Static Protected Member Functions
static std::string	meshPropertyName (const std::string &data_name, const std::string &prefix)

Protected Attributes
std::string	_registered_identifier

std::string	_specific_task_name

std::set< std::string >	_all_tasks

ActionWarehouse &	_awh

const std::string &	_current_task

std::shared_ptr< MooseMesh > &	_mesh

std::shared_ptr< MooseMesh > &	_displaced_mesh

std::shared_ptr< FEProblemBase > &	_problem

PerfID	_act_timer

MooseApp &	_app

const std::string	_type

const std::string	_name

const InputParameters &	_pars

Factory &	_factory

ActionFactory &	_action_factory

MooseApp &	_pg_moose_app

const std::string	_prefix

const Parallel::Communicator &	_communicator

Private Attributes
std::vector< VariableName >	_displacements

std::vector< VariableName >	_displacement_gradients

Detailed Description

Automatically generates all variables, Kernels, and Materials to ensure the correct derivatives of the elastic free energy in a non-split Cahn-Hilliard simulation are assembled.

Definition at line 20 of file DisplacementGradientsAction.h.

Constructor & Destructor Documentation

◆ DisplacementGradientsAction()

DisplacementGradientsAction::DisplacementGradientsAction ( const InputParameters & params )

Definition at line 40 of file DisplacementGradientsAction.C.

   : Action(params),
     _displacements(getParam<std::vector<VariableName>>("displacements")),
     _displacement_gradients(getParam<std::vector<VariableName>>("displacement_gradients"))
 {
 }

Member Function Documentation

◆ act()

void DisplacementGradientsAction::act ( )

virtual

Implements Action.

Definition at line 48 of file DisplacementGradientsAction.C.

 {
   unsigned int ngrad = _displacement_gradients.size();
 
   if (_current_task == "add_variable")
   {
     // Loop through the gij variables
     Real scaling = getParam<Real>("scaling");
     for (unsigned int i = 0; i < ngrad; ++i)
     {
       auto var_params = _factory.getValidParams("MooseVariable");
       var_params.set<MooseEnum>("family") = "LAGRANGE";
       var_params.set<MooseEnum>("order") = "FIRST";
       var_params.set<std::vector<Real>>("scaling") = {scaling};
       var_params.applySpecificParameters(_pars, {"block"});
 
       // Create displacement gradient variables
       _problem->addVariable("MooseVariable", _displacement_gradients[i], var_params);
     }
   }
   else if (_current_task == "add_material")
   {
     InputParameters params = _factory.getValidParams("StrainGradDispDerivatives");
     params.set<std::vector<VariableName>>("displacement_gradients") = _displacement_gradients;
     params.applySpecificParameters(parameters(), {"block"});
     _problem->addMaterial("StrainGradDispDerivatives", "strain_grad_disp_derivatives", params);
   }
   else if (_current_task == "add_kernel")
   {
     unsigned int ndisp = _displacements.size();
     if (ndisp * ndisp != ngrad)
       paramError("displacement_gradients",
                  "Number of displacement gradient variables must be the square of the number of "
                  "displacement variables.");
 
     // Loop through the displacements
     unsigned int i = 0;
     for (unsigned int j = 0; j < ndisp; ++j)
       for (unsigned int k = 0; k < ndisp; ++k)
       {
         InputParameters params = _factory.getValidParams("GradientComponent");
         params.set<NonlinearVariableName>("variable") = _displacement_gradients[i];
         params.set<std::vector<VariableName>>("v") = {_displacements[j]};
         params.set<unsigned int>("component") = k;
         _problem->addKernel(
             "GradientComponent", _displacement_gradients[i] + "_grad_kernel", params);
         ++i;
       }
   }
   else
     mooseError("Internal error.");
 }

◆ validParams()

InputParameters DisplacementGradientsAction::validParams ( )

static

Definition at line 23 of file DisplacementGradientsAction.C.

 {
   InputParameters params = Action::validParams();
   params.addClassDescription("Set up variables, kernels, and materials for a the displacement "
                              "gradients and their elastic free energy derivatives for non-split "
                              "Cahn-Hilliard problems.");
   params.addRequiredParam<std::vector<VariableName>>("displacements",
                                                      "Vector of displacement variables");
   params.addRequiredParam<std::vector<VariableName>>("displacement_gradients",
                                                      "Vector of displacement gradient variables");
   params.addParam<Real>(
       "scaling", 1.0, "Specifies a scaling factor to apply to the displacement gradient variables");
   params.addParam<std::vector<SubdomainName>>(
       "block", {}, "Block restriction for the variables and kernels");
   return params;
 }

Member Data Documentation

◆ _displacement_gradients

std::vector<VariableName> DisplacementGradientsAction::_displacement_gradients

private

Definition at line 31 of file DisplacementGradientsAction.h.

Referenced by act().

◆ _displacements

std::vector<VariableName> DisplacementGradientsAction::_displacements

private

Definition at line 30 of file DisplacementGradientsAction.h.

Referenced by act().

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

phase_field/include/actions/DisplacementGradientsAction.h
phase_field/src/actions/DisplacementGradientsAction.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Attributes