NodeValueAtXFEMInterface.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
 
#include "NodeValueAtXFEMInterface.h"
#include "MooseVariableFE.h"
#include "XFEM.h"
#include "InterfaceMeshCutUserObjectBase.h"
#include "libmesh/parallel_algebra.h"
#include "libmesh/parallel.h"
 
registerMooseObject("XFEMApp", NodeValueAtXFEMInterface);
 
InputParameters
NodeValueAtXFEMInterface::validParams()
{
  InputParameters params = GeneralUserObject::validParams();
  params.addRequiredParam<VariableName>(
      "variable", "The name of the variable that this UserObject operates on");
  params.addParam<UserObjectName>(
      "interface_mesh_cut_userobject",
      "Name of InterfaceMeshCutUserObject that provides cut locations to this UserObject.");
  params.addRequiredParam<VariableName>(
      "level_set_var", "The name of level set variable used to represent the interface");
  params.addClassDescription("Obtain field values and gradients on the interface.");
  return params;
}
 
NodeValueAtXFEMInterface::NodeValueAtXFEMInterface(const InputParameters & parameters)
  : GeneralUserObject(parameters),
    _mesh(_subproblem.mesh()),
    _var(&_subproblem.getVariable(_tid, parameters.get<VariableName>("variable"))),
    _level_set_var_number(
        _subproblem.getVariable(_tid, parameters.get<VariableName>("level_set_var")).number()),
    _system(_subproblem.getSystem(getParam<VariableName>("level_set_var"))),
    _solution(*_system.current_local_solution.get())
{
}
 
void
NodeValueAtXFEMInterface::initialize()
{
  _pl = _mesh.getPointLocator();
  _xfem = MooseSharedNamespace::dynamic_pointer_cast<XFEM>(_fe_problem.getXFEM());
  if (_xfem == nullptr)
    mooseError("Problem casting to XFEM in NodeValueAtXFEMInterface");
 
  const UserObject * uo =
      &(_fe_problem.getUserObjectBase(getParam<UserObjectName>("interface_mesh_cut_userobject")));
 
  if (dynamic_cast<const InterfaceMeshCutUserObjectBase *>(uo) == nullptr)
    mooseError("UserObject casting to InterfaceMeshCutUserObjectBase in NodeValueAtXFEMInterface");
 
  _mesh_cut = dynamic_cast<const InterfaceMeshCutUserObjectBase *>(uo);
  _elem_pairs = _xfem->getXFEMCutElemPairs(_xfem->getGeometricCutID(_mesh_cut));
}
 
void
NodeValueAtXFEMInterface::execute()
{
  _values_positive_level_set_side.clear();
  _values_negative_level_set_side.clear();
  _grad_values_positive_level_set_side.clear();
  _grad_values_negative_level_set_side.clear();
  _nodes.clear();
 
  std::shared_ptr<MeshBase> cutter_mesh = _mesh_cut->getCutterMesh();
 
  for (const auto & node : cutter_mesh->node_ptr_range())
    _nodes.push_back(*node);
 
  _pl->enable_out_of_mesh_mode();
 
  for (const auto & node : cutter_mesh->node_ptr_range())
  {
    unsigned int i = node->id();
 
    if ((*_pl)(*node) != nullptr)
    {
      const Elem * elem = getElemContainingPoint(*node, /*positive_level_set = */ true);
 
      if (elem != nullptr)
      {
        _subproblem.setCurrentSubdomainID(elem, /*_tid */ 0);
        _subproblem.reinitElemPhys(elem, {*node}, 0);
 
        _values_positive_level_set_side[i] = (dynamic_cast<MooseVariable *>(_var))->sln()[0];
        _grad_values_positive_level_set_side[i] =
            ((dynamic_cast<MooseVariable *>(_var))->gradSln())[0];
      }
 
      const Elem * elem2 = getElemContainingPoint(*node, false);
      if (elem2 != nullptr)
      {
        _subproblem.setCurrentSubdomainID(elem2, /*_tid */ 0);
        _subproblem.reinitElemPhys(elem2, {*node}, 0);
 
        _values_negative_level_set_side[i] = (dynamic_cast<MooseVariable *>(_var))->sln()[0];
        _grad_values_negative_level_set_side[i] =
            ((dynamic_cast<MooseVariable *>(_var))->gradSln())[0];
      }
    }
    else // When node is outside of computation domain
    {
      _values_positive_level_set_side[i] = 0;
      _values_negative_level_set_side[i] = 0;
      _grad_values_positive_level_set_side[i] = RealVectorValue(0);
      _grad_values_negative_level_set_side[i] = RealVectorValue(0);
    }
  }
}
 
void
NodeValueAtXFEMInterface::finalize()
{
  _communicator.set_union(_values_positive_level_set_side);
  _communicator.set_union(_grad_values_positive_level_set_side);
  _communicator.set_union(_values_negative_level_set_side);
  _communicator.set_union(_grad_values_negative_level_set_side);
}
 
const Elem *
NodeValueAtXFEMInterface::getElemContainingPoint(const Node & p, bool positive_level_set)
{
  const Elem * elem1 = (*_pl)(p);
 
  if (elem1->processor_id() != processor_id())
    return nullptr;
 
  const Node * node = elem1->node_ptr(0);
 
  dof_id_type ls_dof_id = node->dof_number(_system.number(), _level_set_var_number, 0);
 
  Number ls_node_value = _solution(ls_dof_id);
 
  bool positive = false;
 
  if (_xfem->isPointInsidePhysicalDomain(elem1, *node))
  {
    if (ls_node_value > 0.0)
      positive = true;
  }
  else
  {
    if (ls_node_value < 0.0)
      positive = false;
  }
 
  const Elem * elem2 = nullptr;
  bool found = false;
  for (auto & pair : *_elem_pairs)
  {
    if (pair.first == elem1)
    {
      elem2 = pair.second;
      found = true;
    }
    else if (pair.second == elem1)
    {
      elem2 = pair.first;
      found = true;
    }
  }
 
  if (!found)
    mooseError("NodeValueAtXFEMInterface: The interface node ",
               p,
               " are not found by element pair locator.");
 
  if ((positive && positive_level_set) || (!positive && !positive_level_set))
    return elem1;
  else if ((!positive && positive_level_set) || (positive && !positive_level_set))
    return elem2;
  else
    return nullptr;
}