#include <PointValueAtXFEMInterface.h>

Inheritance diagram for PointValueAtXFEMInterface:

Public Member Functions
	PointValueAtXFEMInterface (const InputParameters &parameters)

virtual	~PointValueAtXFEMInterface ()

virtual void	initialize () override

virtual void	execute () override

virtual void	finalize () override

std::map< unsigned int, Real >	getValueAtPositiveLevelSet () const
	get the map that stores the point index and its values at the positive level set side More...

std::map< unsigned int, Real >	getValueAtNegativeLevelSet () const
	get the map that stores the point index and its values at the negative level set side More...

std::map< unsigned int, RealVectorValue >	getGradientAtPositiveLevelSet () const
	get the map that stores the point index and its gradient at the positive level set side More...

std::map< unsigned int, RealVectorValue >	getGradientAtNegativeLevelSet () const
	get the map that stores the point index and its graident at the negative level set side More...

unsigned int	numberPoints () const

Protected Member Functions
const Elem *	getElemContainingPoint (const Point &p, bool positive_level_set)
	Find the element in the element pairs that contains the point in its physical domain. More...

Protected Attributes
MooseMesh &	_mesh
	The Mesh we're using. More...

std::vector< Point >	_points
	The points to evaluate at. More...

std::unique_ptr< PointLocatorBase >	_pl
	Pointer to PointLocatorBase object. More...

std::shared_ptr< XFEM >	_xfem
	Pointer to the XFEM controller object. More...

const ElementPairLocator::ElementPairList *	_elem_pairs
	Pointer to ElementPairList object. More...

const LineSegmentCutSetUserObject *	_geo_cut
	Pointer to LineSegmentCutSetUserObject object. More...

MooseVariableFEBase *	_var
	Pointer to MooseVariableFEBase object. More...

const unsigned int	_level_set_var_number
	The variable number of the level set variable we are operating on. More...

const System &	_system
	System reference. More...

const NumericVector< Number > *	_solution
	The subproblem solution vector. More...

std::map< unsigned int, Real >	_values_positive_level_set_side
	Mapping from point index and its values at the positive level set side. More...

std::map< unsigned int, Real >	_values_negative_level_set_side
	Mapping from point index and its values at the negative level set side. More...

std::map< unsigned int, RealVectorValue >	_grad_values_positive_level_set_side
	Mapping from point index and its gradient at the positive level set side. More...

std::map< unsigned int, RealVectorValue >	_grad_values_negative_level_set_side
	Mapping from point index and its gradient at the negative level set side. More...

Detailed Description

Definition at line 26 of file PointValueAtXFEMInterface.h.

Constructor & Destructor Documentation

◆ PointValueAtXFEMInterface()

PointValueAtXFEMInterface::PointValueAtXFEMInterface ( const InputParameters & parameters )

Definition at line 38 of file PointValueAtXFEMInterface.C.

   : 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())
 {
 }

◆ ~PointValueAtXFEMInterface()

virtual PointValueAtXFEMInterface::~PointValueAtXFEMInterface ( )

inlinevirtual

Definition at line 31 of file PointValueAtXFEMInterface.h.

31 {}

Member Function Documentation

◆ execute()

void PointValueAtXFEMInterface::execute ( )

overridevirtual

Definition at line 70 of file PointValueAtXFEMInterface.C.

 {
   _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();
   _points.clear();
  
   std::vector<Real> cut_data = _geo_cut->getCutData();
  
   const int line_cut_data_len = 6;
   for (unsigned int i = 0; i < cut_data.size() / line_cut_data_len; ++i)
   {
     _points.push_back(
         Point(cut_data[i * line_cut_data_len + 0], cut_data[i * line_cut_data_len + 1]));
     if (i == cut_data.size() / line_cut_data_len - 1)
       _points.push_back(
           Point(cut_data[i * line_cut_data_len + 2], cut_data[i * line_cut_data_len + 3]));
   }
  
   BoundingBox bbox = _mesh.getInflatedProcessorBoundingBox();
  
   std::vector<Point> point_vec(1);
  
   for (MooseIndex(_points) i = 0; i < _points.size(); ++i)
   {
     Point p = _points[i];
  
     if (bbox.contains_point(p))
     {
       const Elem * elem = getElemContainingPoint(p, true);
  
       if (elem != nullptr)
       {
         point_vec[0] = p;
  
         _subproblem.setCurrentSubdomainID(elem, 0);
         _subproblem.reinitElemPhys(elem, point_vec, 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(p, false);
       if (elem2 != nullptr)
       {
         point_vec[0] = p;
  
         _subproblem.setCurrentSubdomainID(elem2, 0);
         _subproblem.reinitElemPhys(elem2, point_vec, 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];
       }
     }
   }
 }

◆ finalize()

void PointValueAtXFEMInterface::finalize ( )

overridevirtual

Definition at line 131 of file PointValueAtXFEMInterface.C.

 {
   _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);
 }

◆ getElemContainingPoint()

const Elem * PointValueAtXFEMInterface::getElemContainingPoint	(	const Point &	p,
		bool	positive_level_set
	)

protected

Find the element in the element pairs that contains the point in its physical domain.

Parameters

p	The point in physical space
positive_level_set	True if the physical domain is in positive level set region

Returns: The Elem containing the point or NULL if this processor doesn't contain an element that contains this point.

Definition at line 140 of file PointValueAtXFEMInterface.C.

 {
   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 = true;
   }
  
   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(
         "PointValueAtXFEMInterface: The interface points 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;
 }

Referenced by execute().

◆ getGradientAtNegativeLevelSet()

std::map<unsigned int, RealVectorValue> PointValueAtXFEMInterface::getGradientAtNegativeLevelSet ( ) const

inline

get the map that stores the point index and its graident at the negative level set side

Definition at line 64 of file PointValueAtXFEMInterface.h.

   {
     return _grad_values_negative_level_set_side;
   };

Referenced by XFEMPhaseTransitionMovingInterfaceVelocity::computeMovingInterfaceVelocity().

◆ getGradientAtPositiveLevelSet()

std::map<unsigned int, RealVectorValue> PointValueAtXFEMInterface::getGradientAtPositiveLevelSet ( ) const

inline

get the map that stores the point index and its gradient at the positive level set side

Definition at line 56 of file PointValueAtXFEMInterface.h.

   {
     return _grad_values_positive_level_set_side;
   };

Referenced by XFEMPhaseTransitionMovingInterfaceVelocity::computeMovingInterfaceVelocity().

◆ getValueAtNegativeLevelSet()

std::map<unsigned int, Real> PointValueAtXFEMInterface::getValueAtNegativeLevelSet ( ) const

inline

get the map that stores the point index and its values at the negative level set side

Definition at line 48 of file PointValueAtXFEMInterface.h.

   {
     return _values_negative_level_set_side;
   };

Referenced by XFEMPhaseTransitionMovingInterfaceVelocity::computeMovingInterfaceVelocity().

◆ getValueAtPositiveLevelSet()

std::map<unsigned int, Real> PointValueAtXFEMInterface::getValueAtPositiveLevelSet ( ) const

inline

get the map that stores the point index and its values at the positive level set side

Definition at line 40 of file PointValueAtXFEMInterface.h.

   {
     return _values_positive_level_set_side;
   };

Referenced by XFEMPhaseTransitionMovingInterfaceVelocity::computeMovingInterfaceVelocity().

◆ initialize()

void PointValueAtXFEMInterface::initialize ( )

overridevirtual

Definition at line 50 of file PointValueAtXFEMInterface.C.

 {
   _pl = _mesh.getPointLocator();
  
   const UserObject * uo =
       &(_fe_problem.getUserObjectBase(getParam<UserObjectName>("geometric_cut_userobject")));
  
   if (dynamic_cast<const LineSegmentCutSetUserObject *>(uo) == nullptr)
     mooseError("UserObject casting to GeometricCutUserObject in XFEMSingleVariableConstraint");
  
   _geo_cut = dynamic_cast<const LineSegmentCutSetUserObject *>(uo);
  
   _xfem = MooseSharedNamespace::dynamic_pointer_cast<XFEM>(_fe_problem.getXFEM());
   if (_xfem == nullptr)
     mooseError("Problem casting to XFEM in PointValueAtXFEMInterface");
  
   _elem_pairs = _xfem->getXFEMCutElemPairs(_xfem->getGeometricCutID(_geo_cut));
 }