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