ElementsIntersectedByPlane.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 "ElementsIntersectedByPlane.h"

#include "libmesh/plane.h"
#include "libmesh/point.h"
#include "libmesh/mesh.h"
#include "libmesh/elem.h"

#include <algorithm>

using namespace libMesh;

namespace Moose
{

void
findElementsIntersectedByPlane(const libMesh::Plane & plane,
                               const MeshBase & mesh,
                               std::vector<const Elem *> & intersected_elems)
{
  // Loop over all elements to find elements intersected by the plane
  for (const auto & elem : mesh.element_ptr_range())
  {
    bool intersected = false;

    // Check whether the first node of this element is below or above the plane
    const Node & node0 = elem->node_ref(0);
    bool node0_above_plane = plane.above_surface(node0);

    // Loop over the rest of the nodes and check if any node is on the other side of the plane
    for (unsigned int i = 1; i < elem->n_nodes(); ++i)
    {
      const Node & node = elem->node_ref(i);

      bool node_above_plane = plane.above_surface(node);
      if (node0_above_plane != node_above_plane)
        intersected = true;
    }

    if (intersected)
      intersected_elems.push_back(elem);
  }
}

void
elementsIntersectedByPlane(const Point & p0,
                           const Point & normal,
                           const MeshBase & mesh,
                           std::vector<const Elem *> & intersected_elems)
{
  // Make sure our list is clear
  intersected_elems.clear();

  // Create plane from point and normal:
  libMesh::Plane plane(p0, normal);

  // Find 'em!
  findElementsIntersectedByPlane(plane, mesh, intersected_elems);
}

void
elementsIntersectedByPlane(const Point & p0,
                           const Point & p1,
                           const Point & p2,
                           const MeshBase & mesh,
                           std::vector<const Elem *> & intersected_elems)
{
  // Make sure our list is clear
  intersected_elems.clear();

  // Create plane from three points:
  libMesh::Plane plane(p0, p1, p2);

  // Find 'em!
  findElementsIntersectedByPlane(plane, mesh, intersected_elems);
}
}