GlobalDisplacementAux::GlobalDisplacementAux(const InputParameters & parameters)
: AuxKernel(parameters),
_scalar_global_strain(coupledScalarValue("scalar_global_strain")),
_component(getParam<unsigned int>("component")),
_output_global_disp(getParam<bool>("output_global_displacement")),
_pst(getUserObject<GlobalStrainUserObjectInterface>("global_strain_uo")),
_periodic_dir(_pst.getPeriodicDirections()),
_dim(_mesh.dimension()),
_ndisp(coupledComponents("displacements")),
_disp(_ndisp)
{
if (!isNodal())
paramError("variable", "GlobalDisplacementAux must be used on a nodal auxiliary variable");
if (_component >= _dim)
paramError("component",
"The component ",
_component,
" does not exist for ",
_dim,
" dimensional problems");
for (unsigned int i = 0; i < _ndisp; ++i)
_disp[i] = &coupledValue("displacements", i);
}
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"))
{
}
ScalarDirichletBC::ScalarDirichletBC(const InputParameters & parameters) :
NodalBC(parameters),
/**
* Get a reference to the coupled variable's values.
*/
_scalar_val(coupledScalarValue("scalar_var"))
{}
CoupledScalarAux::CoupledScalarAux(const InputParameters & parameters) :
AuxKernel(parameters),
_coupled_val(coupledScalarValue("coupled")),
_component(getParam<unsigned int>("component"))
{
if (_component >= coupledScalarOrder("coupled"))
mooseError("component is higher than or equal to the scalar variable order");
}
ReportingConstantSource::ReportingConstantSource(const InputParameters & parameters) :
DiracKernel(parameters),
_shared_var(coupledScalarValue("shared")),
_point_param(getParam<std::vector<Real> >("point")),
_factor(getParam<Real>("factor"))
{
_p(0) = _point_param[0];
if (_point_param.size() > 1)
{
_p(1) = _point_param[1];
if (_point_param.size() > 2)
_p(2) = _point_param[2];
}
}
NonlinearPlaneStrain::NonlinearPlaneStrain( SolidModel & solid_model,
const std::string & name,
const InputParameters & parameters )
:Nonlinear( solid_model, name, parameters ),
ScalarCoupleable(parameters),
_grad_disp_x(coupledGradient("disp_x")),
_grad_disp_y(coupledGradient("disp_y")),
_have_strain_zz(isCoupled("strain_zz")),
_strain_zz(_have_strain_zz?coupledValue("strain_zz"):_zero),
_have_scalar_strain_zz(isCoupledScalar("scalar_strain_zz")),
_scalar_strain_zz(_have_scalar_strain_zz?coupledScalarValue("scalar_strain_zz"):_zero),
_grad_disp_x_old(coupledGradientOld("disp_x")),
_grad_disp_y_old(coupledGradientOld("disp_y")),
_strain_zz_old(_have_strain_zz?coupledValueOld("strain_zz"):_zero),
_scalar_strain_zz_old(_have_scalar_strain_zz?coupledScalarValueOld("scalar_strain_zz"):_zero)
{
}
PlaneStrain::PlaneStrain(SolidModel & solid_model,
const std::string & name,
const InputParameters & parameters)
:Element(solid_model, name, parameters),
ScalarCoupleable(&solid_model),
_large_strain(solid_model.getParam<bool>("large_strain")),
_grad_disp_x(coupledGradient("disp_x")),
_grad_disp_y(coupledGradient("disp_y")),
_have_strain_zz(isCoupled("strain_zz")),
_strain_zz(_have_strain_zz?coupledValue("strain_zz"):_zero),
_have_scalar_strain_zz(isCoupledScalar("scalar_strain_zz")),
_scalar_strain_zz(_have_scalar_strain_zz?coupledScalarValue("scalar_strain_zz"):_zero),
_volumetric_locking_correction(solid_model.getParam<bool>("volumetric_locking_correction"))
{
if (_have_strain_zz && _have_scalar_strain_zz)
mooseError("Must define only one of strain_zz or scalar_strain_zz");
}
ComputePlaneIncrementalStrain::ComputePlaneIncrementalStrain(const InputParameters & parameters)
: Compute2DIncrementalStrain(parameters),
_scalar_out_of_plane_strain_coupled(isCoupledScalar("scalar_out_of_plane_strain")),
_scalar_out_of_plane_strain(_scalar_out_of_plane_strain_coupled
? coupledScalarValue("scalar_out_of_plane_strain")
: _zero),
_scalar_out_of_plane_strain_old(_scalar_out_of_plane_strain_coupled
? coupledScalarValueOld("scalar_out_of_plane_strain")
: _zero),
_out_of_plane_strain_coupled(isCoupled("out_of_plane_strain")),
_out_of_plane_strain(_out_of_plane_strain_coupled ? coupledValue("out_of_plane_strain")
: _zero),
_out_of_plane_strain_old(_out_of_plane_strain_coupled ? coupledValueOld("out_of_plane_strain")
: _zero)
{
if (_out_of_plane_strain_coupled && _scalar_out_of_plane_strain_coupled)
mooseError("Must define only one of out_of_plane_strain or scalar_out_of_plane_strain");
}
stzplasticrateAux_s0::stzplasticrateAux_s0(const InputParameters & parameters)
: AuxKernel(parameters),
// We can couple in a value from one of our kernels with a call to coupledValueAux
_e0(getParam<Real>("e0")),
_ez(getParam<Real>("ez")),
_e1(getParam<Real>("e1")),
_p(getParam<Real>("p")),
_a(getParam<Real>("a")),
_density(getParam<Real>("density")),
_rho(getParam<Real>("rho")),
_s1l(getParam<Real>("s1l")),
_s2l(getParam<Real>("s2l")),
_R0(getParam<Real>("R0")),
_alpha_biot(getParam<Real>("alpha_biot")),
_s0expswtich(getParam<Real>("s0expswitch")),
_chihat_const(getParam<Real>("chihat_const")),
_coupled_s(coupledScalarValue("coupled_s")),
_coupled_chi(coupledValue("coupled_chi")),
_coupled_pf(coupledValue("coupled_pf"))
{
}
ComputeAxisymmetric1DIncrementalStrain::ComputeAxisymmetric1DIncrementalStrain(
const InputParameters & parameters)
: Compute1DIncrementalStrain(parameters),
_disp_old_0(coupledValueOld("displacements", 0)),
_subblock_id_provider(isParamValid("subblock_index_provider")
? &getUserObject<SubblockIndexProvider>("subblock_index_provider")
: nullptr),
_has_out_of_plane_strain(isParamValid("out_of_plane_strain")),
_out_of_plane_strain(_has_out_of_plane_strain ? coupledValue("out_of_plane_strain") : _zero),
_out_of_plane_strain_old(_has_out_of_plane_strain ? coupledValueOld("out_of_plane_strain")
: _zero),
_has_scalar_out_of_plane_strain(isParamValid("scalar_out_of_plane_strain")),
_nscalar_strains(
_has_scalar_out_of_plane_strain ? coupledScalarComponents("scalar_out_of_plane_strain") : 0)
{
if (_has_out_of_plane_strain && _has_scalar_out_of_plane_strain)
mooseError("Must define only one of out_of_plane_strain or scalar_out_of_plane_strain");
if (!_has_out_of_plane_strain && !_has_scalar_out_of_plane_strain)
mooseError("Must define either out_of_plane_strain or scalar_out_of_plane_strain");
// in case when the provided scalar_out_of_plane_strain is not a coupled
// scalar variable, still set _nscalar_strains = 1 but return its default value 0
if (coupledScalarComponents("scalar_out_of_plane_strain") == 0)
_nscalar_strains = 1;
if (_has_scalar_out_of_plane_strain)
{
_scalar_out_of_plane_strain.resize(_nscalar_strains);
_scalar_out_of_plane_strain_old.resize(_nscalar_strains);
for (unsigned int i = 0; i < _nscalar_strains; ++i)
{
_scalar_out_of_plane_strain[i] = &coupledScalarValue("scalar_out_of_plane_strain", i);
_scalar_out_of_plane_strain_old[i] = &coupledScalarValueOld("scalar_out_of_plane_strain", i);
}
}
}
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"))
{
}
ComputePlaneFiniteStrain::ComputePlaneFiniteStrain(const InputParameters & parameters) :
Compute2DFiniteStrain(parameters),
_scalar_strain_zz(isCoupledScalar("scalar_strain_zz") ? coupledScalarValue("scalar_strain_zz") : _zero),
_scalar_strain_zz_old(isCoupledScalar("scalar_strain_zz") ? coupledScalarValueOld("scalar_strain_zz") : _zero)
{
}
