VariableSecond & Coupleable::coupledSecondOld(const std::string & var_name, unsigned int comp) { coupledCallback(var_name, true); if (_nodal) mooseError("Nodal variables do not have second derivatives"); validateExecutionerType(var_name); MooseVariable * var = getVar(var_name, comp); return (_c_is_implicit) ? var->secondSlnOld() : var->secondSlnOlder(); }
void SystemBase::reinitNodesNeighbor(const std::vector<dof_id_type> & nodes, THREAD_ID tid) { const std::vector<MooseVariable *> & vars = _vars[tid].variables(); for (std::vector<MooseVariable *>::const_iterator it = vars.begin(); it != vars.end(); ++it) { MooseVariable *var = *it; var->reinitNodesNeighbor(nodes); var->computeNodalNeighborValues(); } }
const VariableValue & NeighborCoupleable::coupledNeighborValueOld(const std::string & var_name, unsigned int comp) { validateExecutionerType(var_name, "coupledNeighborValueOld"); MooseVariable * var = getVar(var_name, comp); if (_neighbor_nodal) return (_c_is_implicit) ? var->nodalValueOldNeighbor() : var->nodalValueOlderNeighbor(); else return (_c_is_implicit) ? var->slnOldNeighbor() : var->slnOlderNeighbor(); }
VariableValue & Coupleable::coupledDotDu(const std::string & var_name, unsigned int comp) { MooseVariable * var = getVar(var_name, comp); if (var->kind() == Moose::VAR_AUXILIARY) mooseError("Coupling time derivative of an auxiliary variable is not allowed."); if (_nodal) return var->nodalSlnDuDotDu(); else return var->duDotDu(); }
VariableSecond & Coupleable::coupledSecond(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) // Return default 0 return _default_second; coupledCallback(var_name, false); if (_nodal) mooseError("Nodal variables do not have second derivatives"); MooseVariable * var = getVar(var_name, comp); return (_c_is_implicit) ? var->secondSln() : var->secondSlnOlder(); }
const VariableGradient & NeighborCoupleable::coupledNeighborGradientOlder(const std::string & var_name, unsigned int comp) { if (_neighbor_nodal) mooseError("Nodal variables do not have gradients"); validateExecutionerType(var_name, "coupledNeighborGradientOlder"); MooseVariable * var = getVar(var_name, comp); if (_c_is_implicit) return var->gradSlnOlderNeighbor(); else mooseError("Older values not available for explicit schemes"); }
VariableGradient & Coupleable::coupledGradient(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) // Return default 0 return _default_gradient; coupledCallback(var_name, false); if (_nodal) mooseError("Nodal variables do not have gradients"); MooseVariable * var = getVar(var_name, comp); return (_c_is_implicit) ? var->gradSln() : var->gradSlnOld(); }
VariableValue & Coupleable::coupledDotDu(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) // Return default 0 return _default_value_zero; MooseVariable * var = getVar(var_name, comp); if (_nodal) return var->nodalSlnDuDotDu(); else return var->duDotDu(); }
unsigned int Coupleable::coupled(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) return _optional_var_index[var_name]; MooseVariable * var = getVar(var_name, comp); switch (var->kind()) { case Moose::VAR_NONLINEAR: return getVar(var_name, comp)->number(); case Moose::VAR_AUXILIARY: return std::numeric_limits<unsigned int>::max() - getVar(var_name, comp)->number(); } mooseError("Unknown variable kind. Corrupted binary?"); }
const DenseVector<Number> & NeighborCoupleable::coupledNeighborSolutionDoFsOlder(const std::string & var_name, unsigned int comp) { if (_neighbor_nodal) mooseError("nodal objects should not call coupledSolutionDoFsOlder"); validateExecutionerType(var_name, "coupledNeighborSolutionDoFsOlder"); MooseVariable * var = getVar(var_name, comp); if (_c_is_implicit) return var->solutionDoFsOlderNeighbor(); else mooseError("Older values not available for explicit schemes"); }
void SystemBase::reinitNodeNeighbor(const Node * /*node*/, THREAD_ID tid) { const std::vector<MooseVariable *> & vars = _vars[tid].variables(); for (std::vector<MooseVariable *>::const_iterator it = vars.begin(); it != vars.end(); ++it) { MooseVariable *var = *it; if (var->isNodal()) { var->reinitNodeNeighbor(); var->computeNodalNeighborValues(); } } }
const VariableValue & Coupleable::coupledNodalValue(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) return *getDefaultValue(var_name); coupledCallback(var_name, false); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) return (_c_is_implicit) ? var->nodalValue() : var->nodalValueOld(); else return (_c_is_implicit) ? var->nodalValueNeighbor() : var->nodalValueOldNeighbor(); }
const VariableValue & Coupleable::coupledNodalDot(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) // Return default 0 return _default_value_zero; coupledCallback(var_name, false); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) return var->nodalValueDot(); else return var->nodalValueDotNeighbor(); }
const VariableValue & Coupleable::coupledNodalValuePreviousNL(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) return *getDefaultValue(var_name); _c_fe_problem.needsPreviousNewtonIteration(true); coupledCallback(var_name, true); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) return var->nodalValuePreviousNL(); else return var->nodalValuePreviousNLNeighbor(); }
void ComputeElemAuxBcsThread::operator() (const ConstBndElemRange & range) { ParallelUniqueId puid; _tid = puid.id; for (ConstBndElemRange::const_iterator elem_it = range.begin() ; elem_it != range.end(); ++elem_it) { const BndElement * belem = *elem_it; const Elem * elem = belem->_elem; unsigned short int side = belem->_side; BoundaryID boundary_id = belem->_bnd_id; if (elem->processor_id() == _problem.processor_id()) { // prepare variables for (std::map<std::string, MooseVariable *>::iterator it = _sys._elem_vars[_tid].begin(); it != _sys._elem_vars[_tid].end(); ++it) { MooseVariable * var = it->second; var->prepareAux(); } if (_auxs[_tid].elementalBCs(boundary_id).size() > 0) { _problem.prepare(elem, _tid); _problem.reinitElemFace(elem, side, boundary_id, _tid); _problem.reinitMaterialsBoundary(boundary_id, _tid); const std::vector<AuxKernel*> & bcs = _auxs[_tid].elementalBCs(boundary_id); for (std::vector<AuxKernel*>::const_iterator element_bc_it = bcs.begin(); element_bc_it != bcs.end(); ++element_bc_it) (*element_bc_it)->compute(); _problem.swapBackMaterialsFace(_tid); } // update the solution vector { Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx); for (std::map<std::string, MooseVariable *>::iterator it = _sys._elem_vars[_tid].begin(); it != _sys._elem_vars[_tid].end(); ++it) { MooseVariable * var = it->second; var->insert(_sys.solution()); } } } } }
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::reinitElem(const Elem * /*elem*/, THREAD_ID tid) { for (std::map<std::string, MooseVariable *>::iterator it = _nodal_vars[tid].begin(); it != _nodal_vars[tid].end(); ++it) { MooseVariable *var = it->second; var->computeElemValues(); } for (std::map<std::string, MooseVariable *>::iterator it = _elem_vars[tid].begin(); it != _elem_vars[tid].end(); ++it) { MooseVariable *var = it->second; var->reinitAux(); var->computeElemValues(); } }
void AuxiliarySystem::reinitElem(const Elem * /*elem*/, THREAD_ID tid) { for (const auto & it : _nodal_vars[tid]) { MooseVariable * var = it.second; var->computeElemValues(); } for (const auto & it : _elem_vars[tid]) { MooseVariable * var = it.second; var->reinitAux(); var->computeElemValues(); } }
unsigned int PolycrystalICTools::assignPointToGrain(const Point & p, const std::vector<Point> & centerpoints, const MooseMesh & mesh, const MooseVariable & var, const Real maxsize) { unsigned int grain_num = centerpoints.size(); Real min_distance = maxsize; unsigned int min_index = grain_num; // Loops through all of the grain centers and finds the center that is closest to the point p for (unsigned int grain = 0; grain < grain_num; grain++) { Real distance = mesh.minPeriodicDistance(var.number(), centerpoints[grain], p); if (min_distance > distance) { min_distance = distance; min_index = grain; } } if (min_index >= grain_num) mooseError("ERROR in PolycrystalVoronoiVoidIC: didn't find minimum values in grain_value_calc"); return min_index; }
const VariableSecond & Coupleable::coupledSecondPreviousNL(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) // Return default 0 return _default_second; _c_fe_problem.needsPreviousNewtonIteration(true); coupledCallback(var_name, true); if (_nodal) mooseError("Nodal variables do not have second derivatives"); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) return var->secondSlnPreviousNL(); else return var->secondSlnPreviousNLNeighbor(); }
const VariableSecond & Coupleable::coupledSecondOld(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) // Return default 0 return _default_second; coupledCallback(var_name, true); if (_nodal) mooseError("Nodal variables do not have second derivatives"); validateExecutionerType(var_name); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) return (_c_is_implicit) ? var->secondSlnOld() : var->secondSlnOlder(); else return (_c_is_implicit) ? var->secondSlnOldNeighbor() : var->secondSlnOlderNeighbor(); }
VariableSecond & Coupleable::coupledSecondOlder(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) // Return default 0 return _default_second; coupledCallback(var_name, true); if (_nodal) mooseError("Nodal variables do not have second derivatives"); validateExecutionerType(var_name); MooseVariable * var = getVar(var_name, comp); if (_c_is_implicit) return var->secondSlnOlder(); else mooseError("Older values not available for explicit schemes"); }
const VariableValue & Coupleable::coupledValueOlder(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) return *getDefaultValue(var_name); validateExecutionerType(var_name); coupledCallback(var_name, true); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) { if (_nodal) { if (_c_is_implicit) return var->nodalSlnOlder(); else mooseError("Older values not available for explicit schemes"); } else { if (_c_is_implicit) return var->slnOlder(); else mooseError("Older values not available for explicit schemes"); } } else { if (_nodal) { if (_c_is_implicit) return var->nodalSlnOlderNeighbor(); else mooseError("Older values not available for explicit schemes"); } else { if (_c_is_implicit) return var->slnOlderNeighbor(); else mooseError("Older values not available for explicit schemes"); } } }
void MultiAppCopyTransfer::transferDofObject(libMesh::DofObject * to_object, libMesh::DofObject * from_object, MooseVariable & to_var, MooseVariable & from_var) { if (to_object->n_dofs(to_var.sys().number(), to_var.number()) > 0) // If this variable has dofs at this node for (unsigned int comp = 0; comp < to_object->n_comp(to_var.sys().number(), to_var.number()); ++comp) { dof_id_type dof = to_object->dof_number(to_var.sys().number(), to_var.number(), comp); dof_id_type from_dof = from_object->dof_number(from_var.sys().number(), from_var.number(), comp); Real from_value = from_var.sys().solution()(from_dof); to_var.sys().solution().set(dof, from_value); } }
VariableValue & Coupleable::coupledNodalValue(const std::string & var_name, unsigned int comp) { if (!isCoupled(var_name)) // Need to generate a "default value" filled VariableValue { VariableValue * value = _default_value[var_name]; if (value == NULL) { value = new VariableValue(_coupleable_max_qps, _coupleable_params.defaultCoupledValue(var_name)); _default_value[var_name] = value; } return *_default_value[var_name]; } coupledCallback(var_name, false); MooseVariable * var = getVar(var_name, comp); return (_c_is_implicit) ? var->nodalValue() : var->nodalValueOld(); }
const DenseVector<Number> & Coupleable::coupledSolutionDoFs(const std::string & var_name, unsigned int comp) { // default coupling is not available for elemental solutions if (!isCoupled(var_name)) mooseError("invalid variable name for coupledSolutionDoFs"); if (_nodal) mooseError("nodal objects should not call coupledSolutionDoFs"); coupledCallback(var_name, false); MooseVariable * var = getVar(var_name, comp); if (!_coupleable_neighbor) return (_c_is_implicit) ? var->solutionDoFs() : var->solutionDoFsOld(); else return (_c_is_implicit) ? var->solutionDoFsNeighbor() : var->solutionDoFsOldNeighbor(); }
void ComputeElemAuxVarsThread::subdomainChanged() { // prepare variables for (std::map<std::string, MooseVariable *>::iterator it = _aux_sys._elem_vars[_tid].begin(); it != _aux_sys._elem_vars[_tid].end(); ++it) { MooseVariable * var = it->second; var->prepareAux(); } // block setup for(std::vector<AuxKernel *>::const_iterator aux_it=_auxs[_tid].activeBlockElementKernels(_subdomain).begin(); aux_it != _auxs[_tid].activeBlockElementKernels(_subdomain).end(); aux_it++) (*aux_it)->subdomainSetup(); // global setup for(std::vector<AuxKernel *>::const_iterator aux_it=_auxs[_tid].activeElementKernels().begin(); aux_it != _auxs[_tid].activeElementKernels().end(); aux_it++) (*aux_it)->subdomainSetup(); std::set<MooseVariable *> needed_moose_vars; // block for(std::vector<AuxKernel*>::const_iterator block_element_aux_it = _auxs[_tid].activeBlockElementKernels(_subdomain).begin(); block_element_aux_it != _auxs[_tid].activeBlockElementKernels(_subdomain).end(); ++block_element_aux_it) { const std::set<MooseVariable *> & mv_deps = (*block_element_aux_it)->getMooseVariableDependencies(); needed_moose_vars.insert(mv_deps.begin(), mv_deps.end()); } // global for(std::vector<AuxKernel *>::const_iterator aux_it = _auxs[_tid].activeElementKernels().begin(); aux_it!=_auxs[_tid].activeElementKernels().end(); aux_it++) { const std::set<MooseVariable *> & mv_deps = (*aux_it)->getMooseVariableDependencies(); needed_moose_vars.insert(mv_deps.begin(), mv_deps.end()); } _fe_problem.setActiveElementalMooseVariables(needed_moose_vars, _tid); _fe_problem.prepareMaterials(_subdomain, _tid); }
void ComputeIndicatorThread::onElement(const Elem *elem) { for (std::map<std::string, MooseVariable *>::iterator it = _aux_sys._elem_vars[_tid].begin(); it != _aux_sys._elem_vars[_tid].end(); ++it) { MooseVariable * var = it->second; var->prepareAux(); } _fe_problem.prepare(elem, _tid); _fe_problem.reinitElem(elem, _tid); _fe_problem.reinitMaterials(_subdomain, _tid); const std::vector<Indicator *> & indicators = _indicator_whs[_tid].active(); if (!_finalize) for (std::vector<Indicator *>::const_iterator it = indicators.begin(); it != indicators.end(); ++it) (*it)->computeIndicator(); else { for (std::vector<Indicator *>::const_iterator it = indicators.begin(); it != indicators.end(); ++it) (*it)->finalize(); // Now finalize the side integral side_indicators as well { const std::vector<Indicator *> & side_indicators = _indicator_whs[_tid].activeInternalSideIndicators(); for (std::vector<Indicator *>::const_iterator it = side_indicators.begin(); it != side_indicators.end(); ++it) (*it)->finalize(); } } _fe_problem.swapBackMaterials(_tid); if (!_finalize) // During finalize the Indicators should be setting values in the vectors manually { Threads::spin_mutex::scoped_lock lock(Threads::spin_mtx); for (std::map<std::string, MooseVariable *>::iterator it = _aux_sys._elem_vars[_tid].begin(); it != _aux_sys._elem_vars[_tid].end(); ++it) { MooseVariable * var = it->second; var->add(_aux_sys.solution()); } } }
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; } } }
void ComputeIndicatorThread::onInternalSide(const Elem * elem, unsigned int side) { if (_finalize) // If finalizing we only do something on the elements return; // Pointer to the neighbor we are currently working on. const Elem * neighbor = elem->neighbor_ptr(side); // Get the global id of the element and the neighbor const dof_id_type elem_id = elem->id(), neighbor_id = neighbor->id(); if ((neighbor->active() && (neighbor->level() == elem->level()) && (elem_id < neighbor_id)) || (neighbor->level() < elem->level())) { for (const auto & it : _aux_sys._elem_vars[_tid]) { MooseVariable * var = it.second; var->prepareAux(); } SubdomainID block_id = elem->subdomain_id(); if (_internal_side_indicators.hasActiveBlockObjects(block_id, _tid)) { _fe_problem.reinitNeighbor(elem, side, _tid); // Set up Sentinels so that, even if one of the reinitMaterialsXXX() calls throws, we // still remember to swap back during stack unwinding. SwapBackSentinel face_sentinel(_fe_problem, &FEProblemBase::swapBackMaterialsFace, _tid); _fe_problem.reinitMaterialsFace(block_id, _tid); SwapBackSentinel neighbor_sentinel( _fe_problem, &FEProblemBase::swapBackMaterialsNeighbor, _tid); _fe_problem.reinitMaterialsNeighbor(neighbor->subdomain_id(), _tid); const std::vector<std::shared_ptr<InternalSideIndicator>> & indicators = _internal_side_indicators.getActiveBlockObjects(block_id, _tid); for (const auto & indicator : indicators) indicator->computeIndicator(); } } }