UpdateErrorVectorsThread::UpdateErrorVectorsThread(
FEProblemBase & fe_problem,
const std::map<std::string, std::unique_ptr<ErrorVector>> & indicator_field_to_error_vector)
: ThreadedElementLoop<ConstElemRange>(fe_problem),
_indicator_field_to_error_vector(indicator_field_to_error_vector),
_aux_sys(fe_problem.getAuxiliarySystem()),
_system_number(_aux_sys.number()),
_adaptivity(fe_problem.adaptivity()),
_solution(_aux_sys.solution())
{
// Build up this map once so we don't have to do these lookups over and over again
for (const auto & it : _indicator_field_to_error_vector)
{
unsigned int var_num = _aux_sys.getVariable(0, it.first).number();
_indicator_field_number_to_error_vector.emplace(var_num, it.second.get());
}
}
ComputeIndicatorThread::ComputeIndicatorThread(FEProblemBase & fe_problem, bool finalize)
: ThreadedElementLoop<ConstElemRange>(fe_problem),
_fe_problem(fe_problem),
_aux_sys(fe_problem.getAuxiliarySystem()),
_indicator_whs(_fe_problem.getIndicatorWarehouse()),
_internal_side_indicators(_fe_problem.getInternalSideIndicatorWarehouse()),
_finalize(finalize)
{
}
ComputeElemAuxVarsThread::ComputeElemAuxVarsThread(FEProblemBase & problem,
const MooseObjectWarehouse<AuxKernel> & storage,
bool need_materials)
: ThreadedElementLoop<ConstElemRange>(problem),
_aux_sys(problem.getAuxiliarySystem()),
_aux_kernels(storage),
_need_materials(need_materials)
{
}
ComputeNodalKernelBCJacobiansThread::ComputeNodalKernelBCJacobiansThread(FEProblemBase & fe_problem,
const MooseObjectWarehouse<NodalKernel> & nodal_kernels,
SparseMatrix<Number> & jacobian) :
ThreadedNodeLoop<ConstBndNodeRange, ConstBndNodeRange::const_iterator>(fe_problem),
_aux_sys(fe_problem.getAuxiliarySystem()),
_nodal_kernels(nodal_kernels),
_jacobian(jacobian),
_num_cached(0)
{
}
RandomData::RandomData(FEProblemBase & problem, const RandomInterface & random_interface)
: _rd_problem(problem),
_rd_mesh(problem.mesh()),
_is_nodal(random_interface.isNodal()),
_reset_on(random_interface.getResetOnTime()),
_master_seed(random_interface.getMasterSeed()),
_current_master_seed(std::numeric_limits<unsigned int>::max()),
_new_seed(0)
{
}
void
MultiAppCopyTransfer::transfer(FEProblemBase & to_problem, FEProblemBase & from_problem)
{
// Populate the to/from variables needed to perform the transfer
MooseVariableFE & to_var = to_problem.getVariable(0, _to_var_name);
MeshBase & to_mesh = to_problem.mesh().getMesh();
MooseVariableFE & from_var = from_problem.getVariable(0, _from_var_name);
MeshBase & from_mesh = from_problem.mesh().getMesh();
// Check integrity
if (to_var.feType() != from_var.feType())
paramError("variable",
"'variable' and 'source_variable' must be the same type (order and family): ",
libMesh::Utility::enum_to_string<FEFamily>(to_var.feType().family),
moose::internal::incompatVarMsg(to_var, from_var));
if ((to_mesh.n_nodes() != from_mesh.n_nodes()) || (to_mesh.n_elem() != from_mesh.n_elem()))
mooseError("The meshes must be identical to utilize MultiAppCopyTransfer.");
// Transfer node dofs
MeshBase::const_node_iterator node_it = to_mesh.local_nodes_begin();
MeshBase::const_node_iterator node_end = to_mesh.local_nodes_end();
for (; node_it != node_end; ++node_it)
transferDofObject(*node_it, from_mesh.node_ptr((*node_it)->id()), to_var, from_var);
// Transfer elem dofs
MeshBase::const_element_iterator elem_it = to_mesh.local_elements_begin();
MeshBase::const_element_iterator elem_end = to_mesh.local_elements_end();
Elem * to_elem;
Elem * from_elem;
for (; elem_it != elem_end; ++elem_it)
{
to_elem = *elem_it;
from_elem = from_mesh.elem_ptr(to_elem->id());
mooseAssert(to_elem->type() == from_elem->type(), "The elements must be the same type.");
transferDofObject(to_elem, from_elem, to_var, from_var);
}
to_var.sys().solution().close();
to_var.sys().update();
}
AuxiliarySystem::AuxiliarySystem(FEProblemBase & subproblem, const std::string & name) :
SystemBase(subproblem, name, Moose::VAR_AUXILIARY),
_fe_problem(subproblem),
_sys(subproblem.es().add_system<TransientExplicitSystem>(name)),
_serialized_solution(*NumericVector<Number>::build(_fe_problem.comm()).release()),
_u_dot(addVector("u_dot", true, GHOSTED)),
_need_serialized_solution(false)
{
_nodal_vars.resize(libMesh::n_threads());
_elem_vars.resize(libMesh::n_threads());
}
ComputeResidualThread::ComputeResidualThread(FEProblemBase & fe_problem, Moose::KernelType type)
: ThreadedElementLoop<ConstElemRange>(fe_problem),
_nl(fe_problem.getNonlinearSystemBase()),
_kernel_type(type),
_num_cached(0),
_integrated_bcs(_nl.getIntegratedBCWarehouse()),
_dg_kernels(_nl.getDGKernelWarehouse()),
_interface_kernels(_nl.getInterfaceKernelWarehouse()),
_kernels(_nl.getKernelWarehouse())
{
}
ComputeNodalKernelBcsThread::ComputeNodalKernelBcsThread(
FEProblemBase & fe_problem,
MooseObjectTagWarehouse<NodalKernel> & nodal_kernels,
const std::set<TagID> & tags)
: ThreadedNodeLoop<ConstBndNodeRange, ConstBndNodeRange::const_iterator>(fe_problem),
_fe_problem(fe_problem),
_aux_sys(fe_problem.getAuxiliarySystem()),
_tags(tags),
_nodal_kernels(nodal_kernels),
_num_cached(0)
{
}
AuxiliarySystem::AuxiliarySystem(FEProblemBase & subproblem, const std::string & name)
: SystemBase(subproblem, name, Moose::VAR_AUXILIARY),
PerfGraphInterface(subproblem.getMooseApp().perfGraph(), "AuxiliarySystem"),
_fe_problem(subproblem),
_sys(subproblem.es().add_system<TransientExplicitSystem>(name)),
_current_solution(NULL),
_serialized_solution(*NumericVector<Number>::build(_fe_problem.comm()).release()),
_solution_previous_nl(NULL),
_u_dot(NULL),
_u_dotdot(NULL),
_u_dot_old(NULL),
_u_dotdot_old(NULL),
_need_serialized_solution(false),
_aux_scalar_storage(_app.getExecuteOnEnum()),
_nodal_aux_storage(_app.getExecuteOnEnum()),
_elemental_aux_storage(_app.getExecuteOnEnum()),
_compute_scalar_vars_timer(registerTimedSection("computeScalarVars", 1)),
_compute_nodal_vars_timer(registerTimedSection("computeNodalVars", 1)),
_compute_elemental_vars_timer(registerTimedSection("computeElementalVars", 1))
{
_nodal_vars.resize(libMesh::n_threads());
_elem_vars.resize(libMesh::n_threads());
}
VectorPostprocessorData::VectorPostprocessorData(FEProblemBase & fe_problem)
: Restartable(fe_problem.getMooseApp(), "values", "VectorPostprocessorData", 0),
ParallelObject(fe_problem)
{
}
