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();
}
}
}
