SBMBndElementTest.C File Reference

Go to the source code of this file.

Classes
class	SBMBndUnsupportedForTest

Functions
	TEST (SBMBndElementTest, Edge2Normal)
	TEST (SBMBndElementTest, Tri3Normal)
	TEST (SBMBndElementTest, Edge2NormalTilted)
	TEST (SBMBndElementTest, Edge2DistanceNodeFallback)
	TEST (SBMBndElementTest, Tri3NormalTilted)
	TEST (SBMBndElementTest, ProjectedBoundingBoxDiagonal)
	TEST (SBMBndElementTest, BaseDynamicDispatcherIntersectAndBoundingBall)
	TEST (SBMBndElementTest, ConstructionRejectsUnsupportedSideType)
	TEST (SBMBndElementTest, UnsupportedGeometryDispatchersThrow)

Function Documentation

TEST() [1/9]

TEST	(	SBMBndElementTest	,
		BaseDynamicDispatcherIntersectAndBoundingBall
	)

Definition at line 242 of file SBMBndElementTest.C.

{
  // Exercise SBMBndElementBase::intersect / computeBoundingBall through a
  // base-class reference; the `using` declarations in the derived classes
  // otherwise route direct calls to LineSegment/Triangle and bypass these
  // dispatchers.
  std::unique_ptr<Edge2> edge(new Edge2());
  std::unique_ptr<Node> e0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> e1(new Node(Point(1.0, 0.0, 0.0), 1));
  edge->set_node(0) = e0.get();
  edge->set_node(1) = e1.get();
  SBMBndEdge2 bnd_edge(edge.get());
  const SBMBndElementBase & edge_base = bnd_edge;
 
  LineSegment crossing(Point(0.5, -1.0, 0.0), Point(0.5, 1.0, 0.0));
  LineSegment parallel(Point(0.0, 1.0, 0.0), Point(1.0, 1.0, 0.0));
  EXPECT_TRUE(edge_base.intersect(crossing));
  EXPECT_FALSE(edge_base.intersect(parallel));
 
  const Ball edge_ball = edge_base.computeBoundingBall();
  EXPECT_NEAR(edge_ball.center()(0), 0.5, 1e-12);
  EXPECT_NEAR(edge_ball.radius(), 0.5, 1e-12);
 
  std::unique_ptr<Tri3> tri(new Tri3());
  std::unique_ptr<Node> t0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> t1(new Node(Point(1.0, 0.0, 0.0), 1));
  std::unique_ptr<Node> t2(new Node(Point(0.0, 1.0, 0.0), 2));
  tri->set_node(0) = t0.get();
  tri->set_node(1) = t1.get();
  tri->set_node(2) = t2.get();
  SBMBndTri3 bnd_tri(tri.get());
  const SBMBndElementBase & tri_base = bnd_tri;
 
  LineSegment piercing(Point(0.3, 0.3, -1.0), Point(0.3, 0.3, 1.0));
  LineSegment missing(Point(2.0, 2.0, -1.0), Point(2.0, 2.0, 1.0));
  EXPECT_TRUE(tri_base.intersect(piercing));
  EXPECT_FALSE(tri_base.intersect(missing));
 
  const Ball tri_ball = tri_base.computeBoundingBall();
  EXPECT_GT(tri_ball.radius(), 0.0);
}

TEST() [2/9]

TEST	(	SBMBndElementTest	,
		ConstructionRejectsUnsupportedSideType
	)

Definition at line 284 of file SBMBndElementTest.C.

{
  // SBMBndElementBase validates side(0)->type() in its ctor so misconfigured
  // SBMBnd* subclasses fail to construct rather than producing wrong answers
  // later. Tet4 has Tri3 sides (neither EDGE2 nor NODEELEM) and must throw.
  std::unique_ptr<Tet4> tet(new Tet4());
  std::unique_ptr<Node> n0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> n1(new Node(Point(1.0, 0.0, 0.0), 1));
  std::unique_ptr<Node> n2(new Node(Point(0.0, 1.0, 0.0), 2));
  std::unique_ptr<Node> n3(new Node(Point(0.0, 0.0, 1.0), 3));
  tet->set_node(0) = n0.get();
  tet->set_node(1) = n1.get();
  tet->set_node(2) = n2.get();
  tet->set_node(3) = n3.get();
 
  EXPECT_THROW(
      {
        try
        {
          SBMBndUnsupportedForTest bnd(tet.get(), Point(0.0, 0.0, 1.0));
        }
        catch (const std::exception & e)
        {
          EXPECT_NE(std::string(e.what()).find("unsupported side type"), std::string::npos);
          throw;
        }
      },
      std::exception);
}

TEST() [3/9]

TEST	(	SBMBndElementTest	,
		Edge2DistanceNodeFallback
	)

Definition at line 145 of file SBMBndElementTest.C.

{
  // Edge from (0,0,0) to (1,0,0); query point lies far off the line axis so
  // its projection onto the edge falls outside the segment, forcing the side
  // loop in distanceFrom() to take the NODEELEM switch case.
  std::unique_ptr<Edge2> edge(new Edge2());
  std::unique_ptr<Node> n0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> n1(new Node(Point(1.0, 0.0, 0.0), 1));
  edge->set_node(0) = n0.get();
  edge->set_node(1) = n1.get();
 
  SBMBndEdge2 bnd_edge(edge.get());
 
  // Projection of (2, 1, 0) onto the line is (2, 0, 0) which is outside [0,1].
  // Nearest entity is node (1, 0, 0).
  Point pt(2.0, 1.0, 0.0);
  Point dist = bnd_edge.distanceFrom(pt);
  EXPECT_NEAR(dist(0), -1.0, 1e-12);
  EXPECT_NEAR(dist(1), -1.0, 1e-12);
  EXPECT_NEAR(dist(2), 0.0, 1e-12);
}

TEST() [4/9]

TEST	(	SBMBndElementTest	,
		Edge2Normal
	)

Definition at line 34 of file SBMBndElementTest.C.

{
  std::unique_ptr<Edge2> edge(new Edge2());
 
  std::unique_ptr<Node> n0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> n1(new Node(Point(1.0, 0.0, 0.0), 1));
 
  edge->set_node(0) = n0.get();
  edge->set_node(1) = n1.get();
 
  SBMBndEdge2 bnd_edge(edge.get());
  Point n = bnd_edge.normal();
 
  EXPECT_NEAR(n(0), 0.0, 1e-12);
  EXPECT_NEAR(n(2), 0.0, 1e-12);
  EXPECT_NEAR(std::abs(n(1)), 1.0, 1e-12);
 
  // Line crossing through (0.5, -1) to (0.5, 1)
  Point a(0.5, -1.0, 0.0);
  Point b(0.5, 1.0, 0.0);
  LineSegment line_segment_ab(a, b);
  EXPECT_TRUE(bnd_edge.intersect(line_segment_ab));
 
  // Line parallel, no intercept
  Point c(0.0, 1.0, 0.0);
  Point d(1.0, 1.0, 0.0);
  LineSegment line_segment_cd(c, d);
  EXPECT_FALSE(bnd_edge.intersect(line_segment_cd));
 
  // Check distance vector
  Point pt(0.5, 1.0, 0.0);
  Point dist = bnd_edge.distanceFrom(pt);
  EXPECT_NEAR(dist(1), -1.0, 1e-12);
}

TEST() [5/9]

TEST	(	SBMBndElementTest	,
		Edge2NormalTilted
	)

Definition at line 106 of file SBMBndElementTest.C.

{
  std::unique_ptr<Edge2> edge(new Edge2());
 
  std::unique_ptr<Node> n0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> n1(new Node(Point(1.0, 1.0, 0.0), 1));
 
  edge->set_node(0) = n0.get();
  edge->set_node(1) = n1.get();
 
  SBMBndEdge2 bnd_edge(edge.get());
  Point n = bnd_edge.normal();
 
  // Expected normal
  const double inv_sqrt2 = 1.0 / std::sqrt(2.0);
  EXPECT_NEAR(n(0), -inv_sqrt2, 1e-12);
  EXPECT_NEAR(n(1), inv_sqrt2, 1e-12);
  EXPECT_NEAR(n(2), 0.0, 1e-12);
 
  // Line crossing
  Point a(0.5, 0.0, 0.0);
  Point b(0.5, 1.0, 0.0);
  LineSegment line_segment_ab(a, b);
  EXPECT_TRUE(bnd_edge.intersect(line_segment_ab));
 
  // Line outside
  Point c(1.5, 1.0, 0.0);
  Point d(1.5, 2.0, 0.0);
  LineSegment line_segment_cd(c, d);
  EXPECT_FALSE(bnd_edge.intersect(line_segment_cd));
 
  // Check distance vector direction
  Point pt(0.5, 0.0, 0.0); // Point below edge
  Point dist = bnd_edge.distanceFrom(pt);
  // Should be mostly pointing along normal
  double dot = dist(0) * n(0) + dist(1) * n(1);
  EXPECT_GT(dot, 0.0); // Same direction
}

TEST() [6/9]

TEST	(	SBMBndElementTest	,
		ProjectedBoundingBoxDiagonal
	)

Definition at line 214 of file SBMBndElementTest.C.

{
  // Tri3 spanning [0,1] x [0,1] in the z=0 plane. Bounding-box diagonal is
  // (1,1,0); projected onto a plane orthogonal to z (i.e. removing the
  // z-component, which is already zero) the tangential diagonal has norm
  // sqrt(2). Projecting onto a plane orthogonal to the diagonal direction
  // itself zeroes out the projection.
  std::unique_ptr<Tri3> tri(new Tri3());
  std::unique_ptr<Node> n0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> n1(new Node(Point(1.0, 0.0, 0.0), 1));
  std::unique_ptr<Node> n2(new Node(Point(0.0, 1.0, 0.0), 2));
  tri->set_node(0) = n0.get();
  tri->set_node(1) = n1.get();
  tri->set_node(2) = n2.get();
 
  SBMBndTri3 bnd_tri(tri.get());
 
  EXPECT_NEAR(bnd_tri.getProjectedBoundingBoxDiagonal(Point(0.0, 0.0, 1.0) /*normal_dir*/),
              std::sqrt(2.0),
              1e-12);
 
  const double inv_sqrt2 = 1.0 / std::sqrt(2.0);
  EXPECT_NEAR(
      bnd_tri.getProjectedBoundingBoxDiagonal(Point(inv_sqrt2, inv_sqrt2, 0.0) /*normal_dir*/),
      0.0,
      1e-12);
}

TEST() [7/9]

TEST	(	SBMBndElementTest	,
		Tri3Normal
	)

Definition at line 69 of file SBMBndElementTest.C.

{
  std::unique_ptr<Tri3> tri(new Tri3());
 
  std::unique_ptr<Node> n0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> n1(new Node(Point(1.0, 0.0, 0.0), 1));
  std::unique_ptr<Node> n2(new Node(Point(0.0, 1.0, 0.0), 2));
 
  tri->set_node(0) = n0.get();
  tri->set_node(1) = n1.get();
  tri->set_node(2) = n2.get();
 
  SBMBndTri3 bnd_tri(tri.get());
  Point n = bnd_tri.normal();
 
  EXPECT_NEAR(n(0), 0.0, 1e-12);
  EXPECT_NEAR(n(1), 0.0, 1e-12);
  EXPECT_NEAR(std::abs(n(2)), 1.0, 1e-12);
 
  // Line from below passing through triangle center
  Point a(0.3, 0.3, -1.0);
  Point b(0.3, 0.3, 1.0);
  LineSegment line_segment_ab(a, b);
  EXPECT_TRUE(bnd_tri.intersect(line_segment_ab));
 
  // Line away from triangle
  Point c(2.0, 2.0, -1.0);
  Point d(2.0, 2.0, 1.0);
  LineSegment line_segment_cd(c, d);
  EXPECT_FALSE(bnd_tri.intersect(line_segment_cd));
 
  // Check distance vector roughly in +Z
  Point pt(0.3, 0.3, 1.0);
  Point dist = bnd_tri.distanceFrom(pt);
  EXPECT_NEAR(dist(2), -1.0, 1e-12);
}

TEST() [8/9]

TEST	(	SBMBndElementTest	,
		Tri3NormalTilted
	)

Definition at line 167 of file SBMBndElementTest.C.

{
  std::unique_ptr<Tri3> tri(new Tri3());
 
  std::unique_ptr<Node> n0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> n1(new Node(Point(1.0, 0.0, 1.0), 1));
  std::unique_ptr<Node> n2(new Node(Point(0.0, 1.0, 1.0), 2));
 
  tri->set_node(0) = n0.get();
  tri->set_node(1) = n1.get();
  tri->set_node(2) = n2.get();
 
  SBMBndTri3 bnd_tri(tri.get());
  Point n = bnd_tri.normal();
 
  // Expected normal
  const double inv_sqrt3 = 1.0 / std::sqrt(3.0);
  EXPECT_NEAR(n(0), -inv_sqrt3, 1e-12);
  EXPECT_NEAR(n(1), -inv_sqrt3, 1e-12);
  EXPECT_NEAR(n(2), inv_sqrt3, 1e-12);
 
  // Line from below passing through triangle center
  Point a(0.3, 0.3, -1.0);
  Point b(0.3, 0.3, 2.0);
  LineSegment line_segment_ab(a, b);
  EXPECT_TRUE(bnd_tri.intersect(line_segment_ab));
 
  // Line away from triangle
  Point c(2.0, 2.0, -1.0);
  Point d(2.0, 2.0, 2.0);
  LineSegment line_segment_cd(c, d);
  EXPECT_FALSE(bnd_tri.intersect(line_segment_cd));
 
  // Check distance vector
  Point pt(2.0, 0.0, 2.0);
  Point dist = bnd_tri.distanceFrom(pt);
  EXPECT_NEAR(dist(0), -1.0, 1e-12);
  EXPECT_NEAR(dist(1), 0.0, 1e-12);
  EXPECT_NEAR(dist(2), -1.0, 1e-12);
 
  Point pt2(0.0, 0.0, 0.0);
  Point dist2 = bnd_tri.distanceFrom(pt2);
  EXPECT_NEAR(dist2(0), 0.0, 1e-12);
  EXPECT_NEAR(dist2(1), 0.0, 1e-12);
  EXPECT_NEAR(dist2(2), 0.0, 1e-12);
}

TEST() [9/9]

TEST	(	SBMBndElementTest	,
		UnsupportedGeometryDispatchersThrow
	)

Definition at line 314 of file SBMBndElementTest.C.

{
  // Drive a SBMBndElementBase subclass that is neither LineSegment nor
  // Triangle through the base-class dispatchers; both intersect() and
  // computeBoundingBall() must mooseError on the unsupported geometry type.
  std::unique_ptr<Edge2> edge(new Edge2());
  std::unique_ptr<Node> n0(new Node(Point(0.0, 0.0, 0.0), 0));
  std::unique_ptr<Node> n1(new Node(Point(1.0, 0.0, 0.0), 1));
  edge->set_node(0) = n0.get();
  edge->set_node(1) = n1.get();
 
  // Placeholder unit normal; the dispatchers under test never consult it.
  SBMBndUnsupportedForTest bnd(edge.get(), Point(0.0, 0.0, 1.0));
  const SBMBndElementBase & base = bnd;
 
  LineSegment line(Point(0.5, -1.0, 0.0), Point(0.5, 1.0, 0.0));
  EXPECT_THROW(
      {
        try
        {
          base.intersect(line);
        }
        catch (const std::exception & e)
        {
          EXPECT_NE(std::string(e.what()).find("unsupported geometry type"), std::string::npos);
          throw;
        }
      },
      std::exception);
 
  EXPECT_THROW(
      {
        try
        {
          base.computeBoundingBall();
        }
        catch (const std::exception & e)
        {
          EXPECT_NE(std::string(e.what()).find("unsupported geometry type"), std::string::npos);
          throw;
        }
      },
      std::exception);
}