NEM::NUCMESH Namespace Reference

Classes
class	Circles
	A set of concentric circles and the faces they enclose. More...
class	CirclesAndPolys
	A set of concentric circles and polygons and the faces they enclose. More...
class	CopyOverrideShapeData
	CRTP pattern to implement NEM::GEO::ShapeData::updateModified by copying. More...
class	EdgeSegments
	Class to describe meshing an edge by StdMeshers_NumberOfSegments. More...
class	GroupData
	Class to hold the material/physical group of a geometry. More...
class	HexagonalArray
class	NucMeshGeo
class	NucMeshShapeData
class	PolarArray
	Arrange a series of other ShapeBase objects along a circular arc. More...
struct	PolyRing
class	QuadMeshSurface
	Structured quad mesh (assuming edges meshed appropriately) or quad-dominant mesh. More...
class	RectangularArray
struct	Ring
struct	RingMeshOption
class	ShapeBase
	Abstract base class for types that create NEM::GEO::GeoManager. More...
class	ShapesArray
	Abstract base class representing a set of other ShapeBase objects, with a transformation applied to each. More...
class	SideSetEdge
class	TriMeshSurface
	Apply a tri mesh to a face. More...

Functions
template<typename RingT , typename FVertCirc >
NEM::GEO::GeoManager	drawNested (int numSides, const std::vector< RingT > &rings, const std::array< double, 3 > &center, FVertCirc funcVertsCircEdges)

Function Documentation

drawNested()

template<typename RingT , typename FVertCirc >

NEM::GEO::GeoManager NEM::NUCMESH::drawNested	(	int	numSides,
		const std::vector< RingT > &	rings,
		const std::array< double, 3 > &	center,
		FVertCirc	funcVertsCircEdges
	)

Definition at line 172 of file CirclesAndPolys.C.

References NEM::NUCMESH::RingMeshOption::QUAD, NEM::NUCMESH::RingMeshOption::STRUCT, and NEM::NUCMESH::RingMeshOption::TRI.

Referenced by NEM::NUCMESH::CirclesAndPolys::createGeo(), and NEM::NUCMESH::Circles::createGeo().

                                                              {
  NEM::GEO::GeoManager output{2};
  if (rings.empty()) { return output; }

  TopoDS_Vertex centerVert{BRepBuilderAPI_MakeVertex{coords2Point(center)}};

  std::vector<std::vector<TopoDS_Vertex>> vertices{};  // along the rings
  vertices.reserve(rings.size());
  std::vector<std::vector<TopoDS_Edge>> circumferentialEdges{};
  circumferentialEdges.reserve(rings.size());
  for (const auto &ring : rings) {
    auto vertsAndEdges = funcVertsCircEdges(ring);
    vertices.emplace_back(std::move(vertsAndEdges.first));
    circumferentialEdges.emplace_back(std::move(vertsAndEdges.second));
  }

  std::vector<std::vector<TopoDS_Edge>> radialEdges{};
  radialEdges.reserve(rings.size());
  std::vector<std::vector<TopoDS_Face>> faces{};
  faces.reserve(rings.size());
  {
    auto prevVerts = vertices.begin();
    auto iterVerts = rings.size() >= 2 ? prevVerts + 1 : vertices.end();
    auto prevCircEdges = circumferentialEdges.begin();
    auto iterCircEdges =
        rings.size() >= 2 ? prevCircEdges + 1 : circumferentialEdges.end();
    {
      radialEdges.emplace_back();
      faces.emplace_back();
      auto &innerEdges = circumferentialEdges[0];
      BRepBuilderAPI_MakeWire wireBuilder{};
      for (const auto &edge : innerEdges) { wireBuilder.Add(edge); }
      faces.back().emplace_back(BRepBuilderAPI_MakeFace{wireBuilder});
    }
    for (; iterVerts != vertices.end();
         ++prevVerts, ++iterVerts, ++prevCircEdges, ++iterCircEdges) {
      radialEdges.emplace_back(getRadialEdges(*prevVerts, *iterVerts));
      faces.emplace_back(
          getFaces(*prevCircEdges, *iterCircEdges, radialEdges.back()));
    }
  }

  {
    {  // innermost ring
      switch (rings[0].meshType.meshingType) {
        case RingMeshOption::MeshingType::STRUCT:
        case RingMeshOption::MeshingType::QUAD:
          output.insertConstruct<QuadMeshSurface>(faces[0][0],
                                                  rings[0].material);
          break;
        case RingMeshOption::MeshingType::TRI:
        default:
          output.insertConstruct<TriMeshSurface>(faces[0][0],
                                                 rings[0].material);
          break;
      }
      if (!rings[0].sideset.empty()) {
        auto &ssetName = rings[0].sideset;
        for (int i = 0; i < numSides; ++i) {
          output.insertConstruct<SideSetEdge>(circumferentialEdges[0][i],
                                              ssetName);
        }
      }
    }
    auto prevCircEdges = circumferentialEdges.begin();
    auto iterCircEdges =
        rings.size() >= 2 ? prevCircEdges + 1 : circumferentialEdges.end();
    auto iterRadialEdges = radialEdges.begin() + 1;
    auto iterFaces = faces.begin() + 1;
    auto prevRing = rings.begin();
    auto iterRing = rings.size() >= 2 ? prevRing + 1 : rings.end();
    for (; iterRing != rings.end(); prevCircEdges = iterCircEdges,
                                    ++iterCircEdges, ++iterRadialEdges,
                                    ++iterFaces, ++iterRing, ++prevRing) {
      auto &meshingParams = iterRing->meshType;
      auto meshingType = meshingParams.meshingType;
      auto &prevMeshingParams = prevRing->meshType;
      for (int i = 0; i < numSides; ++i) {
        switch (meshingType) {
          case RingMeshOption::MeshingType::STRUCT:
          case RingMeshOption::MeshingType::QUAD:
            output.insertConstruct<QuadMeshSurface>(iterFaces->at(i),
                                                    iterRing->material);
            break;
          case RingMeshOption::MeshingType::TRI:
          default:
            output.insertConstruct<TriMeshSurface>(iterFaces->at(i),
                                                   iterRing->material);
        }
      }
      if (meshingType == RingMeshOption::MeshingType::STRUCT) {
        if (prevMeshingParams.meshingType ==
                RingMeshOption::MeshingType::STRUCT &&
            prevMeshingParams.numSegments[1] != meshingParams.numSegments[1]) {
          std::cerr << "Different number of nodes in circumferential direction "
                       "in adjacent rings may cause mesh errors.\n";
        }
        for (int i = 0; i < numSides; ++i) {
          // If previous ring is NOT struct mesh, ensure
          if (prevMeshingParams.meshingType !=
              RingMeshOption::MeshingType::STRUCT) {
            // In case added to map previously, override it
            output.getMap()[prevCircEdges->at(i)].reset(new EdgeSegments{
                prevRing->sideset, meshingParams.numSegments[1]});
          }
          output.insertConstruct<EdgeSegments>(iterCircEdges->at(i),
                                               iterRing->sideset,
                                               meshingParams.numSegments[1]);
          output.insertConstruct<EdgeSegments>(iterRadialEdges->at(i), "",
                                               meshingParams.numSegments[0]);
        }
      } else {
        if (!iterRing->sideset.empty()) {
          auto &ssetName = iterRing->sideset;
          for (int i = 0; i < numSides; ++i) {
            output.insertConstruct<SideSetEdge>(iterCircEdges->at(i), ssetName);
          }
        }
      }
    }
  }
  return output;
}