ElemExtrema.h

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
 
#pragma once
 
#include "RayTracingCommon.h"
 
// MOOSE includes
#include "MooseTypes.h"
 
namespace libMesh
{
class Elem;
}
 
struct ElemExtrema : std::pair<unsigned short, unsigned short>
{
  ElemExtrema()
    : std::pair<unsigned short, unsigned short>(RayTracingCommon::invalid_vertex,
                                                RayTracingCommon::invalid_vertex)
  {
  }
 
  ElemExtrema(const unsigned short v1, const unsigned short v2)
    : std::pair<unsigned short, unsigned short>(v1, v2)
  {
  }
 
  bool atExtrema() const { return first != RayTracingCommon::invalid_vertex; }
  bool isInvalid() const
  {
    return first == RayTracingCommon::invalid_vertex && second == RayTracingCommon::invalid_vertex;
  }
 
  bool atVertex() const
  {
    return first != RayTracingCommon::invalid_vertex && second == RayTracingCommon::invalid_vertex;
  }
  bool atVertex(const unsigned short v) const
  {
    return first == v && second == RayTracingCommon::invalid_vertex;
  }
 
  bool atEdge() const
  {
    return first != RayTracingCommon::invalid_vertex && second != RayTracingCommon::invalid_vertex;
  }
  bool atEdge(const unsigned short v1, const unsigned short v2) const
  {
    return second != RayTracingCommon::invalid_vertex &&
           ((first == v1 && second == v2) || (first == v2 && second == v1));
  }
 
  void invalidate()
  {
    first = RayTracingCommon::invalid_vertex;
    second = RayTracingCommon::invalid_vertex;
  }
 
  unsigned short vertex() const
  {
    mooseAssert(atVertex(), "Not at a vertex");
    return first;
  }
  const std::pair<unsigned short, unsigned short> & edgeVertices() const
  {
    mooseAssert(atEdge(), "Not at an edge");
    return *this;
  }
 
  std::string print() const;
 
  void setVertex(const unsigned short vertex)
  {
    mooseAssert(vertex != RayTracingCommon::invalid_vertex, "Setting invalid vertex");
    first = vertex;
    second = RayTracingCommon::invalid_vertex;
  }
  void setEdge(const unsigned short v1, const unsigned short v2)
  {
    mooseAssert(v1 != RayTracingCommon::invalid_vertex, "Setting invalid vertex");
    mooseAssert(v2 != RayTracingCommon::invalid_vertex, "Setting invalid vertex");
    first = v1;
    second = v2;
  }
  void setEdge(const std::pair<unsigned short, unsigned short> & vertices)
  {
    setEdge(vertices.first, vertices.second);
  }
 
  const Point & vertexPoint(const libMesh::Elem * elem) const;
  std::unique_ptr<const libMesh::Elem> buildEdge(const Elem * elem) const;
  bool isValid(const Elem * const elem, const Point & point) const;
};
 
std::ostream & operator<<(std::ostream & os, const ElemExtrema & elem_extrema);