mesh_gen::anonymous_namespace{annulusMesh2D.cpp} Namespace Reference

Functions
void	assertRectangleAnnulusValid (const geom::Rectangle &outer, const geom::Rectangle &inner)
void	assertCircleAnnulusValid (const geom::Circle &outer, const geom::Circle &inner)
void	assertEllipseAnnulusValid (const geom::Ellipse &outer, const geom::Ellipse &inner)
int	addEllipseDiskOcc (const geom::Ellipse &e)
static int	firstTagOfDim (const std::vector< std::pair< int, int > > &ov, int dim)
util::Point	embedPointInAnnulus2D (const geom::AnnulusGeomObject &a)
void	finish2DCutEmbedSurface (const std::vector< std::pair< int, int > > &ov, const geom::AnnulusGeomObject &a, double h)
void	buildRectangleAnnulus2D (const geom::AnnulusGeomObject &a, double h)
void	buildCircleAnnulus2D (const geom::AnnulusGeomObject &a, double h)
void	buildEllipseAnnulus2D (const geom::AnnulusGeomObject &a, double h)

Function Documentation

addEllipseDiskOcc()

int mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::addEllipseDiskOcc

(

const geom::Ellipse &

e

)

OCC disk for geom::Ellipse (same axis convention as buildEllipseOcc), no mesh embed.

Definition at line 63 of file annulusMesh2D.cpp.

                                            {
  const double rx = std::max(e.d_a, e.d_b);
  const double ry = std::min(e.d_a, e.d_b);
  double theta = e.d_theta;
  if (e.d_a < e.d_b)
    theta += M_PI / 2.;
  return addDiskOcc(e.d_x.d_x, e.d_x.d_y, e.d_x.d_z, rx, ry, theta);
}

References mesh_gen::addDiskOcc(), addEllipseDiskOcc(), geom::Ellipse::d_a, geom::Ellipse::d_b, geom::Ellipse::d_theta, geom::Ellipse::d_x, util::Point::d_x, util::Point::d_y, and util::Point::d_z.

Referenced by addEllipseDiskOcc(), and buildEllipseAnnulus2D().

Here is the call graph for this function:

Here is the caller graph for this function:

assertCircleAnnulusValid()

void mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::assertCircleAnnulusValid	(	const geom::Circle &	outer,
		const geom::Circle &	inner
	)

Definition at line 39 of file annulusMesh2D.cpp.

                                                                                {
  constexpr double eps = 1.0e-10;
  if ((outer.d_x - inner.d_x).lengthSq() > eps)
    throw std::runtime_error(
        "buildAnnulus2DInCurrentModel: circle annulus requires coincident centers (concentric circles).");
  if (inner.d_r <= 0. || outer.d_r <= inner.d_r)
    throw std::runtime_error(
        "buildAnnulus2DInCurrentModel: require 0 < r_inner < r_outer for circle − circle.");
}

References assertCircleAnnulusValid(), geom::Circle::d_r, and geom::Circle::d_x.

Referenced by assertCircleAnnulusValid(), and buildCircleAnnulus2D().

Here is the call graph for this function:

Here is the caller graph for this function:

assertEllipseAnnulusValid()

void mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::assertEllipseAnnulusValid	(	const geom::Ellipse &	outer,
		const geom::Ellipse &	inner
	)

Definition at line 49 of file annulusMesh2D.cpp.

                                                                                   {
  constexpr double eps = 1.0e-10;
  if ((outer.d_x - inner.d_x).lengthSq() > eps)
    throw std::runtime_error(
        "buildAnnulus2DInCurrentModel: ellipse annulus requires coincident centers.");
  if (std::abs(outer.d_theta - inner.d_theta) > 1.0e-9)
    throw std::runtime_error(
        "buildAnnulus2DInCurrentModel: ellipse annulus requires the same orientation θ.");
  if (inner.d_a <= 0. || inner.d_b <= 0. || outer.d_a <= inner.d_a || outer.d_b <= inner.d_b)
    throw std::runtime_error(
        "buildAnnulus2DInCurrentModel: require 0 < a_in < a_out and 0 < b_in < b_out.");
}

References assertEllipseAnnulusValid(), geom::Ellipse::d_a, geom::Ellipse::d_b, geom::Ellipse::d_theta, and geom::Ellipse::d_x.

Referenced by assertEllipseAnnulusValid(), and buildEllipseAnnulus2D().

Here is the call graph for this function:

Here is the caller graph for this function:

assertRectangleAnnulusValid()

void mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::assertRectangleAnnulusValid	(	const geom::Rectangle &	outer,
		const geom::Rectangle &	inner
	)

Definition at line 23 of file annulusMesh2D.cpp.

                                                                                         {
  const auto &blo = outer.d_vertices[0];
  const auto &bhi = outer.d_vertices[2];
  const auto &bli = inner.d_vertices[0];
  const auto &bhi_i = inner.d_vertices[2];
 
  constexpr double eps = 1.0e-12;
  if (std::abs(blo.d_z - bli.d_z) > 1.0e-9 || std::abs(bhi.d_z - bhi_i.d_z) > 1.0e-9)
    throw std::runtime_error("buildAnnulus2DInCurrentModel: inner and outer rectangles must lie in the same z plane.");
 
  if (!(bli.d_x > blo.d_x + eps && bhi_i.d_x < bhi.d_x - eps && bli.d_y > blo.d_y + eps &&
        bhi_i.d_y < bhi.d_y - eps))
    throw std::runtime_error(
        "buildAnnulus2DInCurrentModel: inner rectangle must be strictly inside the outer rectangle.");
}

References assertRectangleAnnulusValid(), and geom::Rectangle::d_vertices.

Referenced by assertRectangleAnnulusValid(), and buildRectangleAnnulus2D().

Here is the call graph for this function:

Here is the caller graph for this function:

buildCircleAnnulus2D()

void mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::buildCircleAnnulus2D	(	const geom::AnnulusGeomObject &	a,
		double	h
	)

Definition at line 157 of file annulusMesh2D.cpp.

                                                                    {
  const auto &outer = *static_cast<const geom::Circle *>(a.d_outObj_p);
  const auto &inner = *static_cast<const geom::Circle *>(a.d_inObj_p);
  assertCircleAnnulusValid(outer, inner);
 
  const int out_surf = addDiskOcc(outer.d_x.d_x, outer.d_x.d_y, outer.d_x.d_z,
                                  outer.d_r, outer.d_r);
  gmsh::model::occ::synchronize();
  const int in_surf = addDiskOcc(inner.d_x.d_x, inner.d_x.d_y, inner.d_x.d_z,
                                 inner.d_r, inner.d_r);
  gmsh::model::occ::synchronize();
 
  std::vector<std::pair<int, int>> ov;
  std::vector<std::vector<std::pair<int, int>>> ovv;
  gmsh::model::occ::cut({{2, out_surf}}, {{2, in_surf}}, ov, ovv, -1, true, true);
  gmsh::model::occ::synchronize();
  gmsh::model::occ::removeAllDuplicates();
  gmsh::model::occ::synchronize();
 
  finish2DCutEmbedSurface(ov, a, h);
}

References mesh_gen::addDiskOcc(), assertCircleAnnulusValid(), buildCircleAnnulus2D(), geom::AnnulusGeomObject::d_inObj_p, geom::AnnulusGeomObject::d_outObj_p, and finish2DCutEmbedSurface().

Referenced by buildCircleAnnulus2D().

Here is the call graph for this function:

Here is the caller graph for this function:

buildEllipseAnnulus2D()

void mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::buildEllipseAnnulus2D	(	const geom::AnnulusGeomObject &	a,
		double	h
	)

Definition at line 179 of file annulusMesh2D.cpp.

                                                                     {
  const auto &outer = *static_cast<const geom::Ellipse *>(a.d_outObj_p);
  const auto &inner = *static_cast<const geom::Ellipse *>(a.d_inObj_p);
  assertEllipseAnnulusValid(outer, inner);
 
  const int out_surf = addEllipseDiskOcc(outer);
  gmsh::model::occ::synchronize();
  const int in_surf = addEllipseDiskOcc(inner);
  gmsh::model::occ::synchronize();
 
  std::vector<std::pair<int, int>> ov;
  std::vector<std::vector<std::pair<int, int>>> ovv;
  gmsh::model::occ::cut({{2, out_surf}}, {{2, in_surf}}, ov, ovv, -1, true, true);
  gmsh::model::occ::synchronize();
  gmsh::model::occ::removeAllDuplicates();
  gmsh::model::occ::synchronize();
 
  finish2DCutEmbedSurface(ov, a, h);
}

References addEllipseDiskOcc(), assertEllipseAnnulusValid(), buildEllipseAnnulus2D(), geom::AnnulusGeomObject::d_inObj_p, geom::AnnulusGeomObject::d_outObj_p, and finish2DCutEmbedSurface().

Referenced by buildEllipseAnnulus2D().

Here is the call graph for this function:

Here is the caller graph for this function:

buildRectangleAnnulus2D()

void mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::buildRectangleAnnulus2D	(	const geom::AnnulusGeomObject &	a,
		double	h
	)

Definition at line 133 of file annulusMesh2D.cpp.

                                                                       {
  const auto &outer = *static_cast<const geom::Rectangle *>(a.d_outObj_p);
  const auto &inner = *static_cast<const geom::Rectangle *>(a.d_inObj_p);
  assertRectangleAnnulusValid(outer, inner);
 
  const auto &lo = outer.d_vertices[0];
  const int out_surf = gmsh::model::occ::addRectangle(lo.d_x, lo.d_y, lo.d_z, outer.d_Lx, outer.d_Ly);
  gmsh::model::occ::synchronize();
 
  const auto &li = inner.d_vertices[0];
  const int in_surf =
      gmsh::model::occ::addRectangle(li.d_x, li.d_y, li.d_z, inner.d_Lx, inner.d_Ly);
  gmsh::model::occ::synchronize();
 
  std::vector<std::pair<int, int>> ov;
  std::vector<std::vector<std::pair<int, int>>> ovv;
  gmsh::model::occ::cut({{2, out_surf}}, {{2, in_surf}}, ov, ovv, -1, true, true);
  gmsh::model::occ::synchronize();
  gmsh::model::occ::removeAllDuplicates();
  gmsh::model::occ::synchronize();
 
  finish2DCutEmbedSurface(ov, a, h);
}

References assertRectangleAnnulusValid(), buildRectangleAnnulus2D(), geom::AnnulusGeomObject::d_inObj_p, geom::AnnulusGeomObject::d_outObj_p, and finish2DCutEmbedSurface().

Referenced by buildRectangleAnnulus2D().

Here is the call graph for this function:

Here is the caller graph for this function:

embedPointInAnnulus2D()

util::Point mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::embedPointInAnnulus2D

(

const geom::AnnulusGeomObject &

a

)

Point strictly inside the annulus for mesh embedding. Do not use AnnulusGeomObject::center(): for symmetric annuli the composite centroid lies in the void (hole), so Gmsh would mesh a node there with zero tributary volume.

Definition at line 84 of file annulusMesh2D.cpp.

                                                                {
  if (a.d_inObj_p->d_name == "circle" && a.d_outObj_p->d_name == "circle") {
    const auto &outer = *static_cast<const geom::Circle *>(a.d_outObj_p);
    const auto &inner = *static_cast<const geom::Circle *>(a.d_inObj_p);
    const double r_mid = 0.5 * (outer.d_r + inner.d_r);
    return {outer.d_x.d_x + r_mid, outer.d_x.d_y, outer.d_x.d_z};
  }
  if (a.d_inObj_p->d_name == "ellipse" && a.d_outObj_p->d_name == "ellipse") {
    const auto &outer = *static_cast<const geom::Ellipse *>(a.d_outObj_p);
    const auto &inner = *static_cast<const geom::Ellipse *>(a.d_inObj_p);
    // Mid-wall along the major axis direction in the ellipse frame.
    const double a_mid = 0.5 * (outer.d_a + inner.d_a);
    return {outer.d_x.d_x + a_mid * std::cos(outer.d_theta),
            outer.d_x.d_y + a_mid * std::sin(outer.d_theta), outer.d_x.d_z};
  }
  if (a.d_inObj_p->d_name == "rectangle" && a.d_outObj_p->d_name == "rectangle") {
    const auto &outer = *static_cast<const geom::Rectangle *>(a.d_outObj_p);
    const auto &inner = *static_cast<const geom::Rectangle *>(a.d_inObj_p);
    const auto &blo = outer.d_vertices[0];
    const auto &bli = inner.d_vertices[0];
    return {0.5 * (blo.d_x + bli.d_x), 0.5 * (blo.d_y + bli.d_y), blo.d_z};
  }
  return a.center();
}

References geom::AnnulusGeomObject::center(), geom::AnnulusGeomObject::d_inObj_p, geom::GeomObject::d_name, geom::AnnulusGeomObject::d_outObj_p, geom::Rectangle::d_vertices, geom::Circle::d_x, geom::Ellipse::d_x, util::Point::d_x, and embedPointInAnnulus2D().

Referenced by embedPointInAnnulus2D(), and finish2DCutEmbedSurface().

Here is the call graph for this function:

Here is the caller graph for this function:

finish2DCutEmbedSurface()

void mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::finish2DCutEmbedSurface	(	const std::vector< std::pair< int, int > > &	ov,
		const geom::AnnulusGeomObject &	a,
		double	h
	)

Definition at line 109 of file annulusMesh2D.cpp.

                                       {
 
  int surface_tag = firstTagOfDim(ov, 2);
  if (surface_tag < 0) {
    std::vector<std::pair<int, int>> ents;
    gmsh::model::getEntities(ents, 2);
    if (!ents.empty())
      surface_tag = ents.back().second;
  }
  if (surface_tag < 0) {
    std::ostringstream oss;
    oss << "buildAnnulus2DInCurrentModel: boolean cut did not produce a surface (ov size = "
        << ov.size() << ").";
    throw std::runtime_error(oss.str());
  }
 
  const util::Point c = embedPointInAnnulus2D(a);
  const int p = gmsh::model::occ::addPoint(c.d_x, c.d_y, c.d_z, h);
  gmsh::model::occ::synchronize();
  gmsh::model::mesh::embed(0, {p}, 2, surface_tag);
  gmsh::model::occ::synchronize();
}

References util::Point::d_x, util::Point::d_y, util::Point::d_z, embedPointInAnnulus2D(), finish2DCutEmbedSurface(), and firstTagOfDim().

Referenced by buildCircleAnnulus2D(), buildEllipseAnnulus2D(), buildRectangleAnnulus2D(), and finish2DCutEmbedSurface().

Here is the call graph for this function:

Here is the caller graph for this function:

firstTagOfDim()

static int mesh_gen::anonymous_namespace{annulusMesh2D.cpp}::firstTagOfDim ( const std::vector< std::pair< int, int > > &  ov, int  dim  )

static

Definition at line 72 of file annulusMesh2D.cpp.

                                                                          {
  for (const auto &pr : ov)
    if (pr.first == dim)
      return pr.second;
  return -1;
}

References firstTagOfDim().

Referenced by finish2DCutEmbedSurface(), and firstTagOfDim().

Here is the call graph for this function:

Here is the caller graph for this function: