NodalKernel::NodalKernel(const InputParameters & parameters) : MooseObject(parameters), BlockRestrictable(parameters), SetupInterface(parameters), FunctionInterface(parameters), UserObjectInterface(parameters), TransientInterface(parameters, "bcs"), PostprocessorInterface(parameters), GeometricSearchInterface(parameters), Restartable(parameters, "BCs"), ZeroInterface(parameters), MeshChangedInterface(parameters), RandomInterface(parameters, *parameters.get<FEProblem *>("_fe_problem"), parameters.get<THREAD_ID>("_tid"), true), CoupleableMooseVariableDependencyIntermediateInterface(parameters, true), _subproblem(*parameters.get<SubProblem *>("_subproblem")), _fe_problem(*parameters.get<FEProblem *>("_fe_problem")), _sys(*parameters.get<SystemBase *>("_sys")), _tid(parameters.get<THREAD_ID>("_tid")), _assembly(_subproblem.assembly(_tid)), _var(_sys.getVariable(_tid, parameters.get<NonlinearVariableName>("variable"))), _mesh(_subproblem.mesh()), _current_node(_var.node()), _u(_var.nodalSln()), _u_dot(_var.nodalSlnDot()), _du_dot_du(_var.nodalSlnDuDotDu()), _save_in_strings(parameters.get<std::vector<AuxVariableName> >("save_in")), _diag_save_in_strings(parameters.get<std::vector<AuxVariableName> >("diag_save_in")) { _save_in.resize(_save_in_strings.size()); _diag_save_in.resize(_diag_save_in_strings.size()); for (unsigned int i=0; i<_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getVariable(_tid, _save_in_strings[i]); if (var->feType() != _var.feType()) mooseError("Error in " + name() + ". When saving residual values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on."); _save_in[i] = var; var->sys().addVariableToZeroOnResidual(_save_in_strings[i]); addMooseVariableDependency(var); } _has_save_in = _save_in.size() > 0; for (unsigned int i=0; i<_diag_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getVariable(_tid, _diag_save_in_strings[i]); if (var->feType() != _var.feType()) mooseError("Error in " + name() + ". When saving diagonal Jacobian values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on."); _diag_save_in[i] = var; var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]); addMooseVariableDependency(var); } _has_diag_save_in = _diag_save_in.size() > 0; }
Kernel::Kernel(const InputParameters & parameters) : KernelBase(parameters), MooseVariableInterface<Real>(this, false), _var(*mooseVariable()), _test(_var.phi()), _grad_test(_var.gradPhi()), _phi(_assembly.phi(_var)), _grad_phi(_assembly.gradPhi(_var)), _u(_is_implicit ? _var.sln() : _var.slnOld()), _grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld()), _u_dot(_var.uDot()), _du_dot_du(_var.duDotDu()) { addMooseVariableDependency(mooseVariable()); _save_in.resize(_save_in_strings.size()); _diag_save_in.resize(_diag_save_in_strings.size()); for (unsigned int i = 0; i < _save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]); if (_fe_problem.getNonlinearSystemBase().hasVariable(_save_in_strings[i])) paramError("save_in", "cannot use solution variable as save-in variable"); if (var->feType() != _var.feType()) paramError( "save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _save_in[i] = var; var->sys().addVariableToZeroOnResidual(_save_in_strings[i]); addMooseVariableDependency(var); } _has_save_in = _save_in.size() > 0; for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]); if (_fe_problem.getNonlinearSystemBase().hasVariable(_diag_save_in_strings[i])) paramError("diag_save_in", "cannot use solution variable as diag save-in variable"); if (var->feType() != _var.feType()) paramError( "diag_save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _diag_save_in[i] = var; var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]); addMooseVariableDependency(var); } _has_diag_save_in = _diag_save_in.size() > 0; }
ADIntegratedBCTempl<T, compute_stage>::ADIntegratedBCTempl(const InputParameters & parameters) : IntegratedBCBase(parameters), MooseVariableInterface<T>(this, false, "variable", Moose::VarKindType::VAR_NONLINEAR, std::is_same<T, Real>::value ? Moose::VarFieldType::VAR_FIELD_STANDARD : Moose::VarFieldType::VAR_FIELD_VECTOR), _var(*this->mooseVariable()), _normals(_assembly.adNormals<compute_stage>()), _ad_q_points(_assembly.adQPointsFace<compute_stage>()), _test(_var.phiFace()), _grad_test(_var.template adGradPhiFace<compute_stage>()), _u(_var.template adSln<compute_stage>()), _grad_u(_var.template adGradSln<compute_stage>()), _ad_JxW(_assembly.adJxWFace<compute_stage>()) { addMooseVariableDependency(this->mooseVariable()); _save_in.resize(_save_in_strings.size()); _diag_save_in.resize(_diag_save_in_strings.size()); for (unsigned int i = 0; i < _save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]); if (var->feType() != _var.feType()) paramError( "save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _save_in[i] = var; var->sys().addVariableToZeroOnResidual(_save_in_strings[i]); addMooseVariableDependency(var); } _has_save_in = _save_in.size() > 0; for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]); if (var->feType() != _var.feType()) paramError( "diag_save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _diag_save_in[i] = var; var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]); addMooseVariableDependency(var); } _has_diag_save_in = _diag_save_in.size() > 0; }
IntegratedBC::IntegratedBC(const InputParameters & parameters) : IntegratedBCBase(parameters), MooseVariableInterface<Real>(this, false, "variable", Moose::VarKindType::VAR_NONLINEAR, Moose::VarFieldType::VAR_FIELD_STANDARD), _var(*mooseVariable()), _normals(_var.normals()), _phi(_assembly.phiFace(_var)), _grad_phi(_assembly.gradPhiFace(_var)), _test(_var.phiFace()), _grad_test(_var.gradPhiFace()), _u(_is_implicit ? _var.sln() : _var.slnOld()), _grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld()) { addMooseVariableDependency(mooseVariable()); _save_in.resize(_save_in_strings.size()); _diag_save_in.resize(_diag_save_in_strings.size()); for (unsigned int i = 0; i < _save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]); if (var->feType() != _var.feType()) paramError( "save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _save_in[i] = var; var->sys().addVariableToZeroOnResidual(_save_in_strings[i]); addMooseVariableDependency(var); } _has_save_in = _save_in.size() > 0; for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]); if (var->feType() != _var.feType()) paramError( "diag_save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _diag_save_in[i] = var; var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]); addMooseVariableDependency(var); } _has_diag_save_in = _diag_save_in.size() > 0; }
NodalBC::NodalBC(const InputParameters & parameters) : NodalBCBase(parameters), MooseVariableInterface<Real>(this, true, "variable", Moose::VarKindType::VAR_NONLINEAR, Moose::VarFieldType::VAR_FIELD_STANDARD), _var(*mooseVariable()), _current_node(_var.node()), _u(_var.dofValues()) { addMooseVariableDependency(mooseVariable()); _save_in.resize(_save_in_strings.size()); _diag_save_in.resize(_diag_save_in_strings.size()); for (unsigned int i = 0; i < _save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]); if (var->feType() != _var.feType()) paramError( "save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _save_in[i] = var; var->sys().addVariableToZeroOnResidual(_save_in_strings[i]); addMooseVariableDependency(var); } _has_save_in = _save_in.size() > 0; for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]); if (var->feType() != _var.feType()) paramError( "diag_save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _diag_save_in[i] = var; var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]); addMooseVariableDependency(var); } _has_diag_save_in = _diag_save_in.size() > 0; }
NodalBC::NodalBC(const InputParameters & parameters) : BoundaryCondition(parameters), RandomInterface(parameters, _fe_problem, _tid, true), CoupleableMooseVariableDependencyIntermediateInterface(parameters, true), _current_node(_var.node()), _u(_var.nodalSln()), _save_in_strings(parameters.get<std::vector<AuxVariableName> >("save_in")), _diag_save_in_strings(parameters.get<std::vector<AuxVariableName> >("diag_save_in")) { _save_in.resize(_save_in_strings.size()); _diag_save_in.resize(_diag_save_in_strings.size()); for (unsigned int i=0; i<_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getVariable(_tid, _save_in_strings[i]); if (var->feType() != _var.feType()) mooseError("Error in " + name() + ". When saving residual values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on."); _save_in[i] = var; var->sys().addVariableToZeroOnResidual(_save_in_strings[i]); addMooseVariableDependency(var); } _has_save_in = _save_in.size() > 0; for (unsigned int i=0; i<_diag_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getVariable(_tid, _diag_save_in_strings[i]); if (var->feType() != _var.feType()) mooseError("Error in " + name() + ". When saving diagonal Jacobian values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on."); _diag_save_in[i] = var; var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]); addMooseVariableDependency(var); } _has_diag_save_in = _diag_save_in.size() > 0; }
void AuxiliarySystem::addVariable(const std::string & var_name, const FEType & type, Real scale_factor, const std::set< SubdomainID > * const active_subdomains/* = NULL*/) { SystemTempl<TransientExplicitSystem>::addVariable(var_name, type, scale_factor, active_subdomains); for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++) { MooseVariable * var = dynamic_cast<MooseVariable *>(_vars[tid].getVariable(var_name)); if (var != NULL) { if (var->feType().family == LAGRANGE) _nodal_vars[tid][var_name] = var; else _elem_vars[tid][var_name] = var; } } }
void AuxiliarySystem::addVariable(const std::string & var_name, const FEType & type, Real scale_factor, const std::set<SubdomainID> * const active_subdomains /* = NULL*/) { SystemBase::addVariable(var_name, type, scale_factor, active_subdomains); for (THREAD_ID tid = 0; tid < libMesh::n_threads(); tid++) { MooseVariable * var = _vars[tid].getFieldVariable<Real>(var_name); if (var != NULL) { if (var->feType().family == LAGRANGE) _nodal_vars[tid][var_name] = var; else _elem_vars[tid][var_name] = var; } } }
IntegratedBC::IntegratedBC(const std::string & name, InputParameters parameters) : BoundaryCondition(name, parameters), RandomInterface(name, parameters, _fe_problem, _tid, false), CoupleableMooseVariableDependencyIntermediateInterface(parameters, false), MaterialPropertyInterface(parameters), _current_elem(_assembly.elem()), _current_elem_volume(_assembly.elemVolume()), _current_side(_assembly.side()), _current_side_elem(_assembly.sideElem()), _current_side_volume(_assembly.sideElemVolume()), _normals(_var.normals()), _qrule(_assembly.qRuleFace()), _q_point(_assembly.qPointsFace()), _JxW(_assembly.JxWFace()), _coord(_assembly.coordTransformation()), _phi(_assembly.phiFace()), _grad_phi(_assembly.gradPhiFace()), _test(_var.phiFace()), _grad_test(_var.gradPhiFace()), _u(_is_implicit ? _var.sln() : _var.slnOld()), _grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld()), _save_in_strings(parameters.get<std::vector<AuxVariableName> >("save_in")), _diag_save_in_strings(parameters.get<std::vector<AuxVariableName> >("diag_save_in")) { _save_in.resize(_save_in_strings.size()); _diag_save_in.resize(_diag_save_in_strings.size()); for (unsigned int i=0; i<_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getVariable(_tid, _save_in_strings[i]); if (var->feType() != _var.feType()) mooseError("Error in " + _name + ". When saving residual values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on."); _save_in[i] = var; var->sys().addVariableToZeroOnResidual(_save_in_strings[i]); addMooseVariableDependency(var); } _has_save_in = _save_in.size() > 0; for (unsigned int i=0; i<_diag_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getVariable(_tid, _diag_save_in_strings[i]); if (var->feType() != _var.feType()) mooseError("Error in " + _name + ". When saving diagonal Jacobian values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on."); _diag_save_in[i] = var; var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]); addMooseVariableDependency(var); } _has_diag_save_in = _diag_save_in.size() > 0; }
KernelBase::KernelBase(const InputParameters & parameters) : MooseObject(parameters), BlockRestrictable(parameters), SetupInterface(this), CoupleableMooseVariableDependencyIntermediateInterface(parameters, false), FunctionInterface(this), UserObjectInterface(this), TransientInterface(this), PostprocessorInterface(this), MaterialPropertyInterface(this, blockIDs()), RandomInterface(parameters, *parameters.get<FEProblem *>("_fe_problem"), parameters.get<THREAD_ID>("_tid"), false), GeometricSearchInterface(this), Restartable(parameters, "Kernels"), ZeroInterface(parameters), MeshChangedInterface(parameters), _subproblem(*parameters.get<SubProblem *>("_subproblem")), _fe_problem(*parameters.get<FEProblem *>("_fe_problem")), _sys(*parameters.get<SystemBase *>("_sys")), _tid(parameters.get<THREAD_ID>("_tid")), _assembly(_subproblem.assembly(_tid)), _var(_sys.getVariable(_tid, parameters.get<NonlinearVariableName>("variable"))), _mesh(_subproblem.mesh()), _current_elem(_var.currentElem()), _current_elem_volume(_assembly.elemVolume()), _q_point(_assembly.qPoints()), _qrule(_assembly.qRule()), _JxW(_assembly.JxW()), _coord(_assembly.coordTransformation()), _test(_var.phi()), _grad_test(_var.gradPhi()), _phi(_assembly.phi()), _grad_phi(_assembly.gradPhi()), _save_in_strings(parameters.get<std::vector<AuxVariableName> >("save_in")), _diag_save_in_strings(parameters.get<std::vector<AuxVariableName> >("diag_save_in")) { _save_in.resize(_save_in_strings.size()); _diag_save_in.resize(_diag_save_in_strings.size()); for (unsigned int i=0; i<_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getVariable(_tid, _save_in_strings[i]); if (_fe_problem.getNonlinearSystem().hasVariable(_save_in_strings[i])) mooseError("Trying to use solution variable "+_save_in_strings[i]+" as a save_in variable in "+name()); if (var->feType() != _var.feType()) mooseError("Error in " + name() + ". When saving residual values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on."); _save_in[i] = var; var->sys().addVariableToZeroOnResidual(_save_in_strings[i]); addMooseVariableDependency(var); } _has_save_in = _save_in.size() > 0; for (unsigned int i=0; i<_diag_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getVariable(_tid, _diag_save_in_strings[i]); if (_fe_problem.getNonlinearSystem().hasVariable(_diag_save_in_strings[i])) mooseError("Trying to use solution variable "+_diag_save_in_strings[i]+" as a diag_save_in variable in "+name()); if (var->feType() != _var.feType()) mooseError("Error in " + name() + ". When saving diagonal Jacobian values in an Auxiliary variable the AuxVariable must be the same type as the nonlinear variable the object is acting on."); _diag_save_in[i] = var; var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]); addMooseVariableDependency(var); } _has_diag_save_in = _diag_save_in.size() > 0; }
NodalKernel::NodalKernel(const InputParameters & parameters) : MooseObject(parameters), BlockRestrictable(this), BoundaryRestrictable(this, true), // true for applying to nodesets SetupInterface(this), FunctionInterface(this), UserObjectInterface(this), TransientInterface(this), PostprocessorInterface(this), GeometricSearchInterface(this), Restartable(this, "BCs"), MeshChangedInterface(parameters), RandomInterface(parameters, *parameters.getCheckedPointerParam<FEProblemBase *>("_fe_problem_base"), parameters.get<THREAD_ID>("_tid"), true), CoupleableMooseVariableDependencyIntermediateInterface(this, true), MooseVariableInterface<Real>(this, true, "variable", Moose::VarKindType::VAR_NONLINEAR, Moose::VarFieldType::VAR_FIELD_STANDARD), TaggingInterface(this), _subproblem(*getCheckedPointerParam<SubProblem *>("_subproblem")), _fe_problem(*getCheckedPointerParam<FEProblemBase *>("_fe_problem_base")), _sys(*getCheckedPointerParam<SystemBase *>("_sys")), _tid(parameters.get<THREAD_ID>("_tid")), _assembly(_subproblem.assembly(_tid)), _var(*mooseVariable()), _mesh(_subproblem.mesh()), _current_node(_var.node()), _u(_var.dofValues()), _save_in_strings(parameters.get<std::vector<AuxVariableName>>("save_in")), _diag_save_in_strings(parameters.get<std::vector<AuxVariableName>>("diag_save_in")) { _save_in.resize(_save_in_strings.size()); _diag_save_in.resize(_diag_save_in_strings.size()); for (unsigned int i = 0; i < _save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _save_in_strings[i]); if (var->feType() != _var.feType()) paramError( "save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _save_in[i] = var; var->sys().addVariableToZeroOnResidual(_save_in_strings[i]); addMooseVariableDependency(var); } _has_save_in = _save_in.size() > 0; for (unsigned int i = 0; i < _diag_save_in_strings.size(); i++) { MooseVariable * var = &_subproblem.getStandardVariable(_tid, _diag_save_in_strings[i]); if (var->feType() != _var.feType()) paramError( "diag_save_in", "saved-in auxiliary variable is incompatible with the object's nonlinear variable: ", moose::internal::incompatVarMsg(*var, _var)); _diag_save_in[i] = var; var->sys().addVariableToZeroOnJacobian(_diag_save_in_strings[i]); addMooseVariableDependency(var); } _has_diag_save_in = _diag_save_in.size() > 0; }