Line data    Source code

       1             : //* This file is part of the MOOSE framework
       2             : //* https://mooseframework.inl.gov
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "NearestNodeNumberUO.h"
      11             : #include <limits>
      12             : 
      13             : registerMooseObject("MooseApp", NearestNodeNumberUO);
      14             : 
      15             : InputParameters
      16       14507 : NearestNodeNumberUO::validParams()
      17             : {
      18       14507 :   InputParameters params = NodalUserObject::validParams();
      19       14507 :   params.addRequiredParam<Point>("point", "The point");
      20       14507 :   params.addClassDescription("Finds and outputs the nearest node number to a point");
      21       14507 :   return params;
      22           0 : }
      23             : 
      24         126 : NearestNodeNumberUO::NearestNodeNumberUO(const InputParameters & parameters)
      25             :   : NodalUserObject(parameters),
      26         252 :     _my_pid(processor_id()),
      27         126 :     _point(getParam<Point>("point")),
      28         126 :     _node_found(false),
      29         126 :     _min_distance(std::numeric_limits<Real>::max()),
      30         126 :     _closest_node(nullptr),
      31         126 :     _overall_best_id(0)
      32             : {
      33         126 : }
      34             : 
      35             : void
      36          12 : NearestNodeNumberUO::meshChanged()
      37             : {
      38          12 :   _node_found = false;
      39          12 :   _min_distance = std::numeric_limits<Real>::max();
      40          12 :   _min_distance = std::numeric_limits<Real>::max();
      41          12 :   _closest_node = nullptr;
      42          12 : }
      43             : 
      44             : void
      45         217 : NearestNodeNumberUO::initialize()
      46             : {
      47         217 :   if (!_node_found)
      48             :   {
      49         144 :     _min_distance = std::numeric_limits<Real>::max();
      50         144 :     _closest_node = nullptr;
      51             :   }
      52         217 : }
      53             : 
      54             : void
      55       10676 : NearestNodeNumberUO::execute()
      56             : {
      57       10676 :   if (_node_found)
      58        2138 :     return;
      59        8538 :   const Real dist = ((*_current_node) - _point).norm();
      60        8538 :   if (dist < _min_distance || (dist == _min_distance && _current_node->id() < _closest_node->id()))
      61             :   {
      62         351 :     _min_distance = dist;
      63         351 :     _closest_node = _current_node;
      64             :   }
      65             : }
      66             : 
      67             : void
      68         199 : NearestNodeNumberUO::finalize()
      69             : {
      70         199 :   Real overall_min_distance = _min_distance;
      71         199 :   gatherMin(overall_min_distance);
      72         398 :   _overall_best_id = (overall_min_distance == _min_distance)
      73         199 :                          ? _closest_node->id()
      74          48 :                          : std::numeric_limits<dof_id_type>::max();
      75         199 :   gatherMin(_overall_best_id);
      76         199 :   _node_found = true;
      77         199 : }
      78             : 
      79             : dof_id_type
      80          99 : NearestNodeNumberUO::getClosestNodeId() const
      81             : {
      82          99 :   return _overall_best_id;
      83             : }
      84             : 
      85             : const Node *
      86           0 : NearestNodeNumberUO::getClosestNode() const
      87             : {
      88           0 :   if (!_closest_node) // probably no evaluation has occurred
      89           0 :     return nullptr;
      90           0 :   if (_closest_node->id() == _overall_best_id && _closest_node->processor_id() == _my_pid)
      91           0 :     return _closest_node;
      92           0 :   return nullptr;
      93             : }
      94             : 
      95             : void
      96          18 : NearestNodeNumberUO::threadJoin(const UserObject & y)
      97             : {
      98          18 :   const auto & nnn = static_cast<const NearestNodeNumberUO &>(y);
      99          18 :   if (!nnn._closest_node)
     100           0 :     return;
     101          36 :   if (nnn._min_distance < _min_distance ||
     102          18 :       (nnn._min_distance == _min_distance && nnn._closest_node->id() < _closest_node->id()))
     103             :   {
     104           0 :     _min_distance = nnn._min_distance;
     105           0 :     _closest_node = nnn._closest_node;
     106             :   }
     107             : }