ComputeElemDampingThread.C

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
// MOOSE includes
#include "ComputeElemDampingThread.h"
#include "NonlinearSystemBase.h"
#include "NonlinearSystem.h"
#include "Problem.h"
#include "ElementDamper.h"
 
#include "libmesh/threads.h"
 
ComputeElemDampingThread::ComputeElemDampingThread(FEProblemBase & feproblem,
                                                   NonlinearSystemBase & nl)
  : ThreadedElementLoop<ConstElemRange>(feproblem),
    _damping(1.0),
    _nl(nl),
    _element_dampers(_nl.getElementDamperWarehouse())
{
}
 
// Splitting Constructor
ComputeElemDampingThread::ComputeElemDampingThread(ComputeElemDampingThread & x,
                                                   Threads::split split)
  : ThreadedElementLoop<ConstElemRange>(x, split),
    _damping(1.0),
    _nl(x._nl),
    _element_dampers(x._element_dampers)
{
}
 
ComputeElemDampingThread::~ComputeElemDampingThread() {}
 
void
ComputeElemDampingThread::onElement(const Elem * elem)
{
  _fe_problem.prepare(elem, _tid);
  _fe_problem.reinitElem(elem, _tid);
 
  std::set<MooseVariable *> damped_vars;
 
  const auto & edampers = _element_dampers.getActiveObjects(_tid);
  for (const auto & damper : edampers)
    if (damper->variableDefinedOnElement(elem))
      damped_vars.insert(damper->getVariable());
 
  if (!damped_vars.empty())
    _nl.reinitIncrementAtQpsForDampers(_tid, damped_vars);
 
  for (const auto & damper : edampers)
  {
    if (!damper->variableDefinedOnElement(elem))
      continue;
 
    Real cur_damping = damper->computeDamping();
    damper->checkMinDamping(cur_damping);
    if (cur_damping < _damping)
      _damping = cur_damping;
  }
}
 
Real
ComputeElemDampingThread::damping()
{
  return _damping;
}
 
void
ComputeElemDampingThread::join(const ComputeElemDampingThread & y)
{
  if (y._damping < _damping)
    _damping = y._damping;
}
 
void
ComputeElemDampingThread::printGeneralExecutionInformation() const
{
  const auto & damper_wh = _nl.getElementDamperWarehouse();
  if (!_fe_problem.shouldPrintExecution(_tid) || !damper_wh.hasActiveObjects())
    return;
 
  const auto & console = _fe_problem.console();
  const auto & execute_on = _fe_problem.getCurrentExecuteOnFlag();
  console << "[DBG] Beginning elemental loop to compute damping on " << execute_on << std::endl;
  // Dampers are currently not block restricted
  console << "[DBG] Ordering of dampers " << std::endl;
  console << damper_wh.activeObjectsToFormattedString() << std::endl;
}