ImplicitODEy::ImplicitODEy(const InputParameters & parameters)
: // You must call the constructor of the base class first
ODEKernel(parameters),
// get the coupled variable number and values
_x_var(coupledScalar("x")),
_x(coupledScalarValue("x"))
{
}
OneDEqualValueConstraintBC::OneDEqualValueConstraintBC(const InputParameters & parameters) :
IntegratedBC(parameters),
_lambda(coupledScalarValue("lambda")),
_lambda_var_number(coupledScalar("lambda")),
_component(getParam<unsigned int>("component")),
_vg(getParam<Real>("vg"))
{
}
GeneralizedPlaneStrainOffDiag::GeneralizedPlaneStrainOffDiag(const InputParameters & parameters)
: DerivativeMaterialInterface<Kernel>(parameters),
_base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
_Jacobian_mult(getMaterialProperty<RankFourTensor>(_base_name + "Jacobian_mult")),
_eigenstrain_names(getParam<std::vector<MaterialPropertyName>>("eigenstrain_names")),
_deigenstrain_dT(_eigenstrain_names.size()),
_scalar_out_of_plane_strain_var(coupledScalar("scalar_out_of_plane_strain")),
_temp_var(isParamValid("temperature")
? &_subproblem.getVariable(_tid, getParam<NonlinearVariableName>("temperature"))
: NULL)
{
const std::vector<NonlinearVariableName> & nl_vnames(
getParam<std::vector<NonlinearVariableName>>("displacements"));
if (nl_vnames.size() > 2)
mooseError("GeneralizedPlaneStrainOffDiag only works for 1D axisymmetric or 2D Cartesian "
"generalized plane strain cases!");
for (unsigned int i = 0; i < nl_vnames.size(); ++i)
_disp_var.push_back(&_subproblem.getVariable(_tid, nl_vnames[i]));
for (unsigned int i = 0; i < _deigenstrain_dT.size(); ++i)
_deigenstrain_dT[i] = &getMaterialPropertyDerivative<RankTwoTensor>(
_base_name + _eigenstrain_names[i], _temp_var->name());
}
ParsedODEKernel::ParsedODEKernel(const InputParameters & parameters)
: ODEKernel(parameters),
FunctionParserUtils(parameters),
_function(getParam<std::string>("function")),
_nargs(coupledScalarComponents("args")),
_args(_nargs),
_arg_names(_nargs),
_func_dFdarg(_nargs),
_number_of_nl_variables(_sys.nVariables()),
_arg_index(_number_of_nl_variables, -1)
{
// build variables argument (start with variable the kernel is operating on)
std::string variables = _var.name();
// add additional coupled variables
for (unsigned int i = 0; i < _nargs; ++i)
{
_arg_names[i] = getScalarVar("args", i)->name();
variables += "," + _arg_names[i];
_args[i] = &coupledScalarValue("args", i);
// populate number -> arg index lookup table skipping aux variables
unsigned int number = coupledScalar("args", i);
if (number < _number_of_nl_variables)
_arg_index[number] = i;
}
// base function object
_func_F = ADFunctionPtr(new ADFunction());
// set FParser interneal feature flags
setParserFeatureFlags(_func_F);
// add the constant expressions
addFParserConstants(_func_F,
getParam<std::vector<std::string>>("constant_names"),
getParam<std::vector<std::string>>("constant_expressions"));
// parse function
if (_func_F->Parse(_function, variables) >= 0)
mooseError("Invalid function\n",
_function,
"\nin ParsedODEKernel ",
name(),
".\n",
_func_F->ErrorMsg());
// on-diagonal derivative
_func_dFdu = ADFunctionPtr(new ADFunction(*_func_F));
if (_func_dFdu->AutoDiff(_var.name()) != -1)
mooseError("Failed to take first derivative w.r.t. ", _var.name());
// off-diagonal derivatives
for (unsigned int i = 0; i < _nargs; ++i)
{
_func_dFdarg[i] = ADFunctionPtr(new ADFunction(*_func_F));
if (_func_dFdarg[i]->AutoDiff(_arg_names[i]) != -1)
mooseError("Failed to take first derivative w.r.t. ", _arg_names[i]);
}
// optimize
if (!_disable_fpoptimizer)
{
_func_F->Optimize();
_func_dFdu->Optimize();
for (unsigned int i = 0; i < _nargs; ++i)
_func_dFdarg[i]->Optimize();
}
// just-in-time compile
if (_enable_jit)
{
_func_F->JITCompile();
_func_dFdu->JITCompile();
for (unsigned int i = 0; i < _nargs; ++i)
_func_dFdarg[i]->JITCompile();
}
// reserve storage for parameter passing buffer
_func_params.resize(_nargs + 1);
}
ScalarVarBC::ScalarVarBC(const InputParameters & parameters) :
IntegratedBC(parameters),
_alpha_var(coupledScalar("alpha")),
_alpha(coupledScalarValue("alpha"))
{
}
ScalarVarBC::ScalarVarBC(const std::string & name, InputParameters parameters) :
IntegratedBC(name, parameters),
_alpha_var(coupledScalar("alpha")),
_alpha(coupledScalarValue("alpha"))
{
}
