Nektar++
Public Member Functions | Static Public Member Functions | Static Public Attributes | List of all members
Nektar::Utilities::ProcessBL Class Reference

This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian. More...

#include <ProcessBL.h>

Inheritance diagram for Nektar::Utilities::ProcessBL:
[legend]

Public Member Functions

 ProcessBL (NekMeshUtils::MeshSharedPtr m)
 
virtual ~ProcessBL ()
 
void BoundaryLayer2D ()
 
void BoundaryLayer3D ()
 
virtual void Process ()
 Write mesh to output file. More...
 
- Public Member Functions inherited from Nektar::NekMeshUtils::ProcessModule
NEKMESHUTILS_EXPORT ProcessModule (MeshSharedPtr p_m)
 
- Public Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT Module (MeshSharedPtr p_m)
 
NEKMESHUTILS_EXPORT void RegisterConfig (std::string key, std::string value=std::string())
 Register a configuration option with a module. More...
 
NEKMESHUTILS_EXPORT void PrintConfig ()
 Print out all configuration options for a module. More...
 
NEKMESHUTILS_EXPORT void SetDefaults ()
 Sets default configuration options for those which have not been set. More...
 
NEKMESHUTILS_EXPORT MeshSharedPtr GetMesh ()
 
virtual NEKMESHUTILS_EXPORT void ProcessVertices ()
 Extract element vertices. More...
 
virtual NEKMESHUTILS_EXPORT void ProcessEdges (bool ReprocessEdges=true)
 Extract element edges. More...
 
virtual NEKMESHUTILS_EXPORT void ProcessFaces (bool ReprocessFaces=true)
 Extract element faces. More...
 
virtual NEKMESHUTILS_EXPORT void ProcessElements ()
 Generate element IDs. More...
 
virtual NEKMESHUTILS_EXPORT void ProcessComposites ()
 Generate composites. More...
 
virtual NEKMESHUTILS_EXPORT void ClearElementLinks ()
 

Static Public Member Functions

static std::shared_ptr< Module > create (NekMeshUtils::MeshSharedPtr m)
 Creates an instance of this class. More...
 

Static Public Attributes

static NekMeshUtils::ModuleKey className
 

Additional Inherited Members

- Protected Member Functions inherited from Nektar::NekMeshUtils::Module
NEKMESHUTILS_EXPORT void ReorderPrisms (PerMap &perFaces)
 Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...
 
NEKMESHUTILS_EXPORT void PrismLines (int prism, PerMap &perFaces, std::set< int > &prismsDone, std::vector< ElementSharedPtr > &line)
 
- Protected Attributes inherited from Nektar::NekMeshUtils::Module
MeshSharedPtr m_mesh
 Mesh object. More...
 
std::map< std::string, ConfigOption > m_config
 List of configuration values. More...
 

Detailed Description

This processing module calculates the Jacobian of elements using SpatialDomains::GeomFactors and the Element::GetGeom method. For now it simply prints a list of elements which have negative Jacobian.

Definition at line 51 of file ProcessBL.h.

Constructor & Destructor Documentation

◆ ProcessBL()

Nektar::Utilities::ProcessBL::ProcessBL ( NekMeshUtils::MeshSharedPtr  m)

Definition at line 108 of file ProcessBL.cpp.

References Nektar::NekMeshUtils::Module::m_config.

108  : ProcessModule(m)
109 {
110  // BL mesh configuration.
111  m_config["layers"] =
112  ConfigOption(false, "2", "Number of layers to refine.");
113  m_config["nq"] =
114  ConfigOption(false, "5", "Number of points in high order elements.");
115  m_config["surf"] =
116  ConfigOption(false, "", "Tag identifying surface connected to prism.");
117  m_config["r"] =
118  ConfigOption(false, "2.0", "Ratio to use in geometry progression.");
119 }
Nektar::NekMeshUtils::ConfigOption
Represents a command-line configuration option.
Definition: NekMeshUtils/Module/Module.h:82
Nektar::NekMeshUtils::ProcessModule::ProcessModule
NEKMESHUTILS_EXPORT ProcessModule(MeshSharedPtr p_m)
Definition: NekMeshUtils/Module/Module.h:232
Nektar::NekMeshUtils::Module::m_config
std::map< std::string, ConfigOption > m_config
List of configuration values.
Definition: NekMeshUtils/Module/Module.h:188

◆ ~ProcessBL()

Nektar::Utilities::ProcessBL::~ProcessBL ( )
virtual

Definition at line 121 of file ProcessBL.cpp.

122 {
123 }

Member Function Documentation

◆ BoundaryLayer2D()

void Nektar::Utilities::ProcessBL::BoundaryLayer2D ( )

Definition at line 159 of file ProcessBL.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::LibUtilities::eBoundaryLayerPoints, Nektar::LibUtilities::eBoundaryLayerPointsRev, Nektar::ErrorUtil::efatal, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eQuadrilateral, Nektar::LibUtilities::eSegment, Nektar::ParseUtils::GenerateSeqVector(), Nektar::NekMeshUtils::GetElementFactory(), Nektar::NekMeshUtils::Module::m_config, Nektar::NekMeshUtils::Module::m_mesh, NEKERROR, class_topology::Node, and Nektar::LibUtilities::PointsManager().

Referenced by Process().

160 {
161  int nodeId = m_mesh->m_vertexSet.size();
162  int nl = m_config["layers"].as<int>();
163  int nq = m_config["nq"]. as<int>();
164 
165  // determine if geometric ratio is string or a constant.
166  LibUtilities::Interpreter rEval;
167  NekDouble r = 1;
168  int rExprId = -1;
169  bool ratioIsString = false;
170 
171  if (m_config["r"].isType<NekDouble>())
172  {
173  r = m_config["r"].as<NekDouble>();
174  }
175  else
176  {
177  std::string rstr = m_config["r"].as<string>();
178  rExprId = rEval.DefineFunction("x y z", rstr);
179  ratioIsString = true;
180  }
181 
182  // Default PointsType.
183  LibUtilities::PointsType pt = LibUtilities::eGaussLobattoLegendre;
184 
185  // Map which takes element ID to edge on surface. This enables
186  // splitting to occur in either y-direction of the prism.
187  map<int, int> splitEls;
188 
189  // edgeMap associates geometry edge IDs to the (nl+1) vertices which
190  // are generated along that edge when a prism is split, and is used
191  // to avoid generation of duplicate vertices. It is stored as an
192  // unordered map for speed.
193  std::unordered_map<int, vector<NodeSharedPtr> > edgeMap;
194 
195  string surf = m_config["surf"].as<string>();
196  if (surf.size() > 0)
197  {
198  vector<unsigned int> surfs;
199  ParseUtils::GenerateSeqVector(surf, surfs);
200  sort(surfs.begin(), surfs.end());
201 
202  // If surface is defined, process list of elements to find those
203  // that are connected to it.
204  for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); ++i)
205  {
206  ElementSharedPtr el = m_mesh->m_element[m_mesh->m_expDim][i];
207  int nSurf = el->GetEdgeCount();
208 
209  for (int j = 0; j < nSurf; ++j)
210  {
211  int bl = el->GetBoundaryLink(j);
212  if (bl == -1)
213  {
214  continue;
215  }
216 
217  ElementSharedPtr bEl = m_mesh->m_element[m_mesh->m_expDim-1][bl];
218  vector<int> tags = bEl->GetTagList();
219  vector<int> inter;
220 
221  sort(tags.begin(), tags.end());
222  set_intersection(surfs.begin(), surfs.end(),
223  tags .begin(), tags .end(),
224  back_inserter(inter));
225  ASSERTL0(inter.size() <= 1,
226  "Intersection of surfaces wrong");
227 
228  if (inter.size() == 1)
229  {
230  if (el->GetConf().m_e != LibUtilities::eQuadrilateral)
231  {
232  cerr << "WARNING: Found non-quad element "
233  << "to split in surface " << surf
234  << "; ignoring" << endl;
235  continue;
236  }
237 
238  if (splitEls.count(el->GetId()) > 0)
239  {
240  cerr << "WARNING: quad already found; "
241  << "ignoring" << endl;
242  continue;
243  }
244 
245  splitEls[el->GetId()] = j;
246  }
247  }
248  }
249  }
250  else
251  {
252  ASSERTL0(false, "Surface must be specified.");
253  }
254 
255  if (splitEls.size() == 0)
256  {
257  cerr << "WARNING: No elements detected to split." << endl;
258  return;
259  }
260 
261  // Erase all elements from the element list. Elements will be
262  // re-added as they are split.
263  vector<ElementSharedPtr> el = m_mesh->m_element[m_mesh->m_expDim];
264  m_mesh->m_element[m_mesh->m_expDim].clear();
265 
266  // Iterate over list of elements of expansion dimension.
267  for (int i = 0; i < el.size(); ++i)
268  {
269 
270 
271  if (splitEls.count(el[i]->GetId()) == 0)
272  {
273  m_mesh->m_element[m_mesh->m_expDim].push_back(el[i]);
274  continue;
275  }
276 
277  // Find other boundary faces if any
278  std::map<int, int> bLink;
279  for (int j = 0; j < 4; j++)
280  {
281  int bl = el[i]->GetBoundaryLink(j);
282  if ( (bl != -1) && ( j != splitEls[el[i]->GetId()]) )
283  {
284  bLink[j] = bl;
285  }
286  }
287 
288  // Get elemental geometry object.
289  SpatialDomains::QuadGeomSharedPtr geom =
290  std::dynamic_pointer_cast<SpatialDomains::QuadGeom>(
291  el[i]->GetGeom(m_mesh->m_spaceDim));
292 
293  // Determine whether to use reverse points.
294  // (if edges 1 or 2 are on the surface)
295  LibUtilities::PointsType t = ( (splitEls[el[i]->GetId()]+1) %4) < 2 ?
296  LibUtilities::eBoundaryLayerPoints :
297  LibUtilities::eBoundaryLayerPointsRev;
298 
299 
300  if(ratioIsString) // determine value of r base on geom
301  {
302  NekDouble x,y,z;
303  NekDouble x1,y1,z1;
304  int nverts = geom->GetNumVerts();
305 
306  x = y = z = 0.0;
307 
308  for(int i = 0; i < nverts; ++i)
309  {
310  geom->GetVertex(i)->GetCoords(x1,y1,z1);
311  x += x1; y += y1; z += z1;
312  }
313  x /= (NekDouble) nverts;
314  y /= (NekDouble) nverts;
315  z /= (NekDouble) nverts;
316  r = rEval.Evaluate(rExprId,x,y,z,0.0);
317  }
318 
319  // Create basis.
320  LibUtilities::BasisKey B0(
321  LibUtilities::eModified_A, nq,
322  LibUtilities::PointsKey(nq,pt));
323  LibUtilities::BasisKey B1(
324  LibUtilities::eModified_A, 2,
325  LibUtilities::PointsKey(nl+1, t, r));
326 
327  // Create local region.
328  LocalRegions::QuadExpSharedPtr q;
329  if (splitEls[el[i]->GetId()] % 2)
330  {
331  q = MemoryManager<LocalRegions::QuadExp>::AllocateSharedPtr(
332  B1,B0,geom);
333  }
334  else
335  {
336  q = MemoryManager<LocalRegions::QuadExp>::AllocateSharedPtr(
337  B0,B1,geom);
338  }
339 
340  // Grab co-ordinates.
341  Array<OneD, NekDouble> x(nq*(nl+1), 0.0);
342  Array<OneD, NekDouble> y(nq*(nl+1), 0.0);
343  Array<OneD, NekDouble> z(nq*(nl+1), 0.0);
344  q->GetCoords(x,y,z);
345 
346  vector<vector<NodeSharedPtr> > edgeNodes(2);
347 
348  // Loop over edges to be split.
349  for (int j = 0; j < 2; ++j)
350  {
351  int locEdge = (splitEls[el[i]->GetId()]+1+2*j)%4;
352  int edgeId = el[i]->GetEdge(locEdge)->m_id;
353 
354  // Determine whether we have already generated vertices
355  // along this edge.
356  auto eIt = edgeMap.find(edgeId);
357 
358  if (eIt == edgeMap.end())
359  {
360  // If not then resize storage to hold new points.
361  edgeNodes[j].resize(nl+1);
362 
363  // Re-use existing vertices at endpoints of edge to
364  // avoid duplicating the existing vertices.
365  edgeNodes[j][0] = el[i]->GetVertex(locEdge);
366  edgeNodes[j][nl] = el[i]->GetVertex((locEdge+1)%4);
367 
368  // Variable geometric ratio
369  if(ratioIsString)
370  {
371  NekDouble x0,y0;
372  NekDouble x1,y1;
373  NekDouble xm,ym,zm=0.0;
374 
375  // -> Find edge end and mid points
376  x0 = edgeNodes[j][0]->m_x;
377  y0 = edgeNodes[j][0]->m_y;
378 
379  x1 = edgeNodes[j][nl]->m_x;
380  y1 = edgeNodes[j][nl]->m_y;
381 
382  xm = 0.5*(x0+x1);
383  ym = 0.5*(y0+y1);
384 
385  // evaluate r factor based on mid point value
386  NekDouble rnew;
387  rnew = rEval.Evaluate(rExprId,xm,ym,zm,0.0);
388 
389  // Get basis with new r;
390  t = (j==0) ? LibUtilities::eBoundaryLayerPoints :
391  LibUtilities::eBoundaryLayerPointsRev;
392  LibUtilities::PointsKey Pkey(nl+1, t, rnew);
393  LibUtilities::PointsSharedPtr newP
394  = LibUtilities::PointsManager()[Pkey];
395 
396  const Array<OneD, const NekDouble> z = newP->GetZ();
397 
398  // Create new interior nodes based on this new blend
399  for (int k = 1; k < nl; ++k)
400  {
401  xm = 0.5*(1+z[k])*(x1-x0) + x0;
402  ym = 0.5*(1+z[k])*(y1-y0) + y0;
403  zm = 0.0;
404  edgeNodes[j][k] = NodeSharedPtr(
405  new Node(nodeId++, xm,ym,zm));
406  }
407  }
408  else
409  {
410  // Create new interior nodes.
411  int pos = 0;
412  for (int k = 1; k < nl; ++k)
413  {
414  switch (locEdge)
415  {
416  case 0:
417  pos = k;
418  break;
419  case 1:
420  pos = nq -1 + k*nq;
421  break;
422  case 2:
423  pos = nq*(nl+1) -1 - k;
424  break;
425  case 3:
426  pos = nq*nl - k*nq;
427  break;
428  default:
429  NEKERROR(ErrorUtil::efatal,
430  "Quad edge should be < 4.");
431  break;
432  }
433  edgeNodes[j][k] = NodeSharedPtr(
434  new Node(nodeId++, x[pos], y[pos], z[pos]));
435  }
436  }
437 
438  // Store these edges in edgeMap.
439  edgeMap[edgeId] = edgeNodes[j];
440  }
441  else
442  {
443  // Check orientation
444  if (eIt->second[0] == el[i]->GetVertex(locEdge))
445  {
446  // Same orientation: copy nodes
447  edgeNodes[j] = eIt->second;
448  }
449  else
450  {
451  // Reversed orientation: copy in reversed order
452  edgeNodes[j].resize(nl+1);
453  for (int k = 0; k < nl+1; ++k)
454  {
455  edgeNodes[j][k] = eIt->second[nl-k];
456  }
457  }
458 
459  }
460  }
461 
462  // Create element layers.
463  for (int j = 0; j < nl; ++j)
464  {
465  // Get corner vertices.
466  vector<NodeSharedPtr> nodeList(4);
467  switch (splitEls[el[i]->GetId()])
468  {
469  case 0:
470  {
471  nodeList[0] = edgeNodes[1][nl-j ];
472  nodeList[1] = edgeNodes[0][j ];
473  nodeList[2] = edgeNodes[0][j+1];
474  nodeList[3] = edgeNodes[1][nl-j-1];
475  break;
476  }
477  case 1:
478  {
479  nodeList[0] = edgeNodes[1][j];
480  nodeList[1] = edgeNodes[1][j+1];
481  nodeList[2] = edgeNodes[0][nl-j-1];
482  nodeList[3] = edgeNodes[0][nl-j];
483  break;
484  }
485  case 2:
486  {
487  nodeList[0] = edgeNodes[0][nl-j ];
488  nodeList[1] = edgeNodes[1][j ];
489  nodeList[2] = edgeNodes[1][j+1];
490  nodeList[3] = edgeNodes[0][nl-j-1];
491  break;
492  }
493  case 3:
494  {
495  nodeList[0] = edgeNodes[0][j];
496  nodeList[1] = edgeNodes[0][j+1];
497  nodeList[2] = edgeNodes[1][nl-j-1];
498  nodeList[3] = edgeNodes[1][nl-j];
499  break;
500  }
501  }
502  // Create the element.
503  ElmtConfig conf(LibUtilities::eQuadrilateral, 1, true, false, true);
504  ElementSharedPtr elmt = GetElementFactory().
505  CreateInstance(
506  LibUtilities::eQuadrilateral,conf,nodeList,el[i]->GetTagList());
507 
508  // Add high order nodes to split edges.
509  for (int l = 0; l < 2; ++l)
510  {
511  int locEdge = (splitEls[el[i]->GetId()]+2*l)%4;
512  EdgeSharedPtr HOedge = elmt->GetEdge(
513  locEdge);
514  int pos = 0;
515  for (int k = 1; k < nq-1; ++k)
516  {
517  switch (locEdge)
518  {
519  case 0:
520  pos = j*nq+ k;
521  break;
522  case 1:
523  pos = j+1 + k*(nl+1);
524  break;
525  case 2:
526  pos = (j+1)*nq + (nq-1) - k;
527  break;
528  case 3:
529  pos = (nl+1)*(nq-1) + j - k*(nl+1);
530  break;
531  default:
532  NEKERROR(ErrorUtil::efatal,
533  "Quad edge should be < 4.");
534  break;
535  }
536  HOedge->m_edgeNodes.push_back(
537  NodeSharedPtr(
538  new Node(nodeId++,x[pos],y[pos],0.0)));
539  }
540  HOedge->m_curveType = pt;
541  }
542 
543  // Change the elements on the boundary
544  // to match the layers
545  for (auto &it : bLink)
546  {
547  int eid = it.first;
548  int bl = it.second;
549 
550  if (j == 0)
551  {
552  // For first layer reuse existing 2D element.
553  ElementSharedPtr e = m_mesh->m_element[m_mesh->m_expDim-1][bl];
554  for (int k = 0; k < 2; ++k)
555  {
556  e->SetVertex(
557  k, nodeList[(eid+k)%4]);
558  }
559  }
560  else
561  {
562  // For all other layers create new element.
563  vector<NodeSharedPtr> qNodeList(2);
564  for (int k = 0; k < 2; ++k)
565  {
566  qNodeList[k] = nodeList[(eid+k)%4];
567  }
568  vector<int> tagBE;
569  tagBE = m_mesh->m_element[m_mesh->m_expDim-1][bl]->GetTagList();
570  ElmtConfig bconf(LibUtilities::eSegment,1,true,true,false);
571  ElementSharedPtr boundaryElmt = GetElementFactory().
572  CreateInstance(LibUtilities::eSegment,bconf,
573  qNodeList,tagBE);
574  m_mesh->m_element[m_mesh->m_expDim-1].push_back(boundaryElmt);
575  }
576  }
577 
578  m_mesh->m_element[m_mesh->m_expDim].push_back(elmt);
579  }
580  }
581 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::NekMeshUtils::ElmtConfig
Basic information about an element.
Definition: ElementConfig.h:49
NEKERROR
#define NEKERROR(type, msg)
Assert Level 0 – Fundamental assert which is used whether in FULLDEBUG, DEBUG or OPT compilation mod...
Definition: ErrorUtil.hpp:209
class_topology.Node
Node
Definition: class_topology.py:44
Nektar::SpatialDomains::QuadGeomSharedPtr
std::shared_ptr< QuadGeom > QuadGeomSharedPtr
Definition: HexGeom.h:46
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
Nektar::NekMeshUtils::EdgeSharedPtr
std::shared_ptr< Edge > EdgeSharedPtr
Shared pointer to an edge.
Definition: Edge.h:136
Nektar::NekMeshUtils::GetElementFactory
ElementFactory & GetElementFactory()
Definition: Element.cpp:44
Nektar::NekMeshUtils::NodeSharedPtr
std::shared_ptr< Node > NodeSharedPtr
Definition: CADVert.h:49
Nektar::LibUtilities::PointsSharedPtr
std::shared_ptr< Points< NekDouble > > PointsSharedPtr
Definition: FoundationsFwd.hpp:78
Nektar::NekMeshUtils::ElementSharedPtr
std::shared_ptr< Element > ElementSharedPtr
Definition: Edge.h:49
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:161
Nektar::LibUtilities::PointsManager
PointsManagerT & PointsManager(void)
Definition: ManagerAccess.cpp:42
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::NekMeshUtils::Module::m_config
std::map< std::string, ConfigOption > m_config
List of configuration values.
Definition: NekMeshUtils/Module/Module.h:188
Nektar::LibUtilities::eBoundaryLayerPointsRev
1D power law distribution for boundary layer points
Definition: PointsType.h:68
Nektar::LibUtilities::eBoundaryLayerPoints
1D power law distribution for boundary layer points
Definition: PointsType.h:67
Nektar::LocalRegions::QuadExpSharedPtr
std::shared_ptr< QuadExp > QuadExpSharedPtr
Definition: QuadExp.h:293
Nektar::LibUtilities::eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:51
Nektar::ParseUtils::GenerateSeqVector
static bool GenerateSeqVector(const std::string &str, std::vector< unsigned int > &out)
Takes a comma-separated compressed string and converts it to entries in a vector. ...
Definition: ParseUtils.cpp:108

◆ BoundaryLayer3D()

void Nektar::Utilities::ProcessBL::BoundaryLayer3D ( )

Definition at line 583 of file ProcessBL.cpp.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr(), ASSERTL0, Nektar::Utilities::SplitMapHelper::bfaces, Nektar::Utilities::SplitMapHelper::bfacesSize, Nektar::Utilities::SplitMapHelper::conn, Nektar::LibUtilities::NekFactory< tKey, tBase, tParam >::CreateInstance(), Nektar::LibUtilities::eBoundaryLayerPoints, Nektar::LibUtilities::eBoundaryLayerPointsRev, Nektar::Utilities::SplitMapHelper::edge, Nektar::Utilities::SplitEdgeHelper::edge, Nektar::Utilities::SplitEdgeHelper::edgeVert, Nektar::LibUtilities::eGaussLobattoLegendre, Nektar::LibUtilities::eHexahedron, Nektar::LibUtilities::eModified_A, Nektar::LibUtilities::eModified_B, Nektar::LibUtilities::ePrism, Nektar::LibUtilities::eQuadrilateral, Nektar::ParseUtils::GenerateVector(), Nektar::NekMeshUtils::GetElementFactory(), Nektar::Utilities::helper2d(), Nektar::Utilities::SplitMapHelper::inc, Nektar::Utilities::SplitEdgeHelper::inc, Nektar::Utilities::SplitMapHelper::layerOff, Nektar::NekMeshUtils::Module::m_config, Nektar::NekMeshUtils::Module::m_mesh, class_topology::Node, Nektar::Utilities::SplitMapHelper::offset, Nektar::Utilities::SplitEdgeHelper::offset, Nektar::LibUtilities::PointsManager(), Nektar::Utilities::SplitMapHelper::size, and Nektar::Utilities::SplitEdgeHelper::size.

Referenced by Process().

584 {
585  // A set containing all element types which are valid.
586  set<LibUtilities::ShapeType> validElTypes;
587  validElTypes.insert(LibUtilities::ePrism);
588  validElTypes.insert(LibUtilities::eHexahedron);
589 
590  int nodeId = m_mesh->m_vertexSet.size();
591  int nl = m_config["layers"].as<int>();
592  int nq = m_config["nq"].as<int>();
593 
594  // determine if geometric ratio is string or a constant.
595  LibUtilities::Interpreter rEval;
596  NekDouble r = 1;
597  int rExprId = -1;
598  bool ratioIsString = false;
599 
600  if (m_config["r"].isType<NekDouble>())
601  {
602  r = m_config["r"].as<NekDouble>();
603  }
604  else
605  {
606  std::string rstr = m_config["r"].as<string>();
607  rExprId = rEval.DefineFunction("x y z", rstr);
608  ratioIsString = true;
609  }
610 
611  // Prismatic node -> face map.
612  int prismFaceNodes[5][4] = {
613  {0, 1, 2, 3}, {0, 1, 4, -1}, {1, 2, 5, 4}, {3, 2, 5, -1}, {0, 3, 5, 4}};
614  int hexFaceNodes[6][4] = {{0, 1, 2, 3},
615  {0, 1, 5, 4},
616  {1, 2, 6, 5},
617  {3, 2, 6, 7},
618  {0, 3, 7, 4},
619  {4, 5, 6, 7}};
620  map<LibUtilities::ShapeType, int **> faceNodeMap;
621  faceNodeMap[LibUtilities::ePrism] = helper2d(5, prismFaceNodes);
622  faceNodeMap[LibUtilities::eHexahedron] = helper2d(6, hexFaceNodes);
623 
624  // Default PointsType.
625  LibUtilities::PointsType pt = LibUtilities::eGaussLobattoLegendre;
626 
627  // Map which takes element ID to face on surface. This enables
628  // splitting to occur in either y-direction of the prism.
629  std::unordered_map<int, int> splitEls;
630 
631  // Set up maps which takes an edge (in nektar++ ordering) and return
632  // their offset and stride in the 3d array of collapsed quadrature
633  // points. Note that this map includes only the edges that are on
634  // the triangular faces as the edges in the normal direction are
635  // linear.
636  map<LibUtilities::ShapeType, map<int, SplitMapHelper> > splitMap;
637  int po = nq * (nl + 1);
638 
639  SplitMapHelper splitPrism;
640  int splitMapEdgePrism[6] = {0, 2, 4, 5, 6, 7};
641  int splitMapOffsetPrism[6] = {0, nq, 0, nq - 1, nq + nq - 1, nq};
642  int splitMapIncPrism[6] = {1, 1, po, po, po, po};
643  int splitMapBFacesPrism[3] = {0, 2, 4};
644  int splitMapConnPrism[6][2] = {
645  {0, 0}, {1, 0}, {1, 1}, {0, 1}, {2, 0}, {2, 1}};
646  splitPrism.size = 6;
647  splitPrism.layerOff = nq;
648  splitPrism.edge = splitMapEdgePrism;
649  splitPrism.offset = splitMapOffsetPrism;
650  splitPrism.inc = splitMapIncPrism;
651  splitPrism.conn = helper2d(6, splitMapConnPrism);
652  splitPrism.bfacesSize = 3;
653  splitPrism.bfaces = splitMapBFacesPrism;
654  splitMap[LibUtilities::ePrism][1] = splitPrism;
655  splitMap[LibUtilities::ePrism][3] = splitPrism;
656 
657  int ho = nq * (nq - 1);
658  int tl = nq * nq;
659  SplitMapHelper splitHex0;
660  int splitMapEdgeHex0[8] = {0, 1, 2, 3, 8, 9, 10, 11};
661  int splitMapOffsetHex0[8] = {
662  0, nq - 1, tl - 1, ho, tl, tl + nq - 1, 2 * tl - 1, tl + ho};
663  int splitMapIncHex0[8] = {1, nq, -1, -nq, 1, nq, -1, -nq};
664  int splitMapBFacesHex0[4] = {1, 2, 3, 4};
665  int splitMapConnHex0[8][2] = {
666  {0, 0}, {1, 0}, {2, 0}, {3, 0}, {0, 1}, {1, 1}, {2, 1}, {3, 1}};
667  splitHex0.size = 8;
668  splitHex0.layerOff = nq * nq;
669  splitHex0.edge = splitMapEdgeHex0;
670  splitHex0.offset = splitMapOffsetHex0;
671  splitHex0.inc = splitMapIncHex0;
672  splitHex0.conn = helper2d(8, splitMapConnHex0);
673  splitHex0.bfacesSize = 4;
674  splitHex0.bfaces = splitMapBFacesHex0;
675  splitMap[LibUtilities::eHexahedron][0] = splitHex0;
676  splitMap[LibUtilities::eHexahedron][5] = splitHex0;
677 
678  // splitEdge enumerates the edges in the standard prism along which
679  // new nodes should be generated. These edges are the three between
680  // the two triangular faces.
681  //
682  // edgeVertMap specifies the vertices which comprise those edges in
683  // splitEdge; for example splitEdge[0] = 3 which connects vertices 0
684  // and 3.
685  //
686  // edgeOffset holds the offset of each of edges 3, 1 and 8
687  // respectively inside the collapsed coordinate system.
688  map<LibUtilities::ShapeType, map<int, SplitEdgeHelper> > splitEdge;
689 
690  int splitPrismEdges[3] = {3, 1, 8};
691  int splitPrismEdgeVert[3][2] = {{0, 3}, {1, 2}, {4, 5}};
692  int splitPrismOffset[3] = {0, nq - 1, nq * (nl + 1) * (nq - 1)};
693  int splitPrismInc[3] = {nq, nq, nq};
694  SplitEdgeHelper splitPrismEdge;
695  splitPrismEdge.size = 3;
696  splitPrismEdge.edge = splitPrismEdges;
697  splitPrismEdge.edgeVert = helper2d(3, splitPrismEdgeVert);
698  splitPrismEdge.offset = splitPrismOffset;
699  splitPrismEdge.inc = splitPrismInc;
700  splitEdge[LibUtilities::ePrism][1] = splitPrismEdge;
701  splitEdge[LibUtilities::ePrism][3] = splitPrismEdge;
702 
703  int splitHex0Edges[4] = {4, 5, 6, 7};
704  int splitHex0EdgeVert[4][2] = {{0, 4}, {1, 5}, {2, 6}, {3, 7}};
705  int splitHex0Offset[4] = {0, nq - 1, nq * nq - 1, nq * (nq - 1)};
706  int splitHex0Inc[4] = {nq * nq, nq * nq, nq * nq, nq * nq};
707  SplitEdgeHelper splitHex0Edge;
708  splitHex0Edge.size = 4;
709  splitHex0Edge.edge = splitHex0Edges;
710  splitHex0Edge.edgeVert = helper2d(4, splitHex0EdgeVert);
711  splitHex0Edge.offset = splitHex0Offset;
712  splitHex0Edge.inc = splitHex0Inc;
713  splitEdge[LibUtilities::eHexahedron][0] = splitHex0Edge;
714  splitEdge[LibUtilities::eHexahedron][5] = splitHex0Edge;
715 
716  map<LibUtilities::ShapeType, map<int, bool> > revPoints;
717  revPoints[LibUtilities::ePrism][1] = true;
718  revPoints[LibUtilities::ePrism][3] = false;
719 
720  revPoints[LibUtilities::eHexahedron][0] = true;
721  revPoints[LibUtilities::eHexahedron][5] = false;
722 
723  // edgeMap associates geometry edge IDs to the (nl+1) vertices which
724  // are generated along that edge when a prism is split, and is used
725  // to avoid generation of duplicate vertices. It is stored as an
726  // unordered map for speed.
727  std::unordered_map<int, vector<NodeSharedPtr> > edgeMap;
728 
729  string surf = m_config["surf"].as<string>();
730  if (surf.size() > 0)
731  {
732  vector<unsigned int> surfs;
733  ParseUtils::GenerateVector(surf, surfs);
734  sort(surfs.begin(), surfs.end());
735 
736  // If surface is defined, process list of elements to find those
737  // that are connected to it.
738  for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); ++i)
739  {
740  ElementSharedPtr el = m_mesh->m_element[m_mesh->m_expDim][i];
741  int nSurf = el->GetFaceCount();
742 
743  for (int j = 0; j < nSurf; ++j)
744  {
745  int bl = el->GetBoundaryLink(j);
746  if (bl == -1)
747  {
748  continue;
749  }
750 
751  ElementSharedPtr bEl =
752  m_mesh->m_element[m_mesh->m_expDim - 1][bl];
753  vector<int> tags = bEl->GetTagList();
754  vector<int> inter;
755 
756  sort(tags.begin(), tags.end());
757  set_intersection(surfs.begin(),
758  surfs.end(),
759  tags.begin(),
760  tags.end(),
761  back_inserter(inter));
762  ASSERTL0(inter.size() <= 1, "Intersection of surfaces wrong");
763 
764  if (inter.size() == 1)
765  {
766  if (el->GetConf().m_e == LibUtilities::ePrism)
767  {
768  if (j % 2 == 0)
769  {
770  cerr << "WARNING: Found quadrilateral face " << j
771  << " on surface " << surf
772  << " connected to prism; ignoring." << endl;
773  continue;
774  }
775 
776  if (splitEls.count(el->GetId()) > 0)
777  {
778  cerr << "WARNING: prism already found; "
779  << "ignoring" << endl;
780  }
781 
782  splitEls[el->GetId()] = j;
783  }
784  else if (validElTypes.count(el->GetConf().m_e) == 0)
785  {
786  cerr << "WARNING: Unsupported element type "
787  << "found in surface " << j << "; "
788  << "ignoring" << endl;
789  continue;
790  }
791  }
792  }
793  }
794  }
795  else
796  {
797  // Otherwise, add all prismatic elements and assume face 1 of
798  // the prism lies on the surface.
799  for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); ++i)
800  {
801  ElementSharedPtr el = m_mesh->m_element[m_mesh->m_expDim][i];
802 
803  if (el->GetConf().m_e == LibUtilities::ePrism)
804  {
805  splitEls[el->GetId()] = 1;
806  }
807  else if (validElTypes.count(el->GetConf().m_e) > 0)
808  {
809  splitEls[el->GetId()] = 0;
810  }
811  else
812  {
813  continue;
814  }
815  }
816  }
817 
818  if (splitEls.size() == 0)
819  {
820  cerr << "WARNING: No elements detected to split." << endl;
821  return;
822  }
823 
824  // Erase all elements from the element list. Elements will be
825  // re-added as they are split.
826  vector<ElementSharedPtr> el = m_mesh->m_element[m_mesh->m_expDim];
827  m_mesh->m_element[m_mesh->m_expDim].clear();
828 
829  map<int, SpatialDomains::Geometry3DSharedPtr> geomMap;
830  for (int i = 0; i < el.size(); ++i)
831  {
832  const int elId = el[i]->GetId();
833  if (splitEls.find(elId) == splitEls.end())
834  {
835  continue;
836  }
837 
838  // Get elemental geometry object and put into map.
839  geomMap[elId] = std::dynamic_pointer_cast<SpatialDomains::Geometry3D>(
840  el[i]->GetGeom(m_mesh->m_spaceDim));
841  }
842 
843  // Iterate over list of elements of expansion dimension.
844  for (int i = 0; i < el.size(); ++i)
845  {
846  const int elId = el[i]->GetId();
847  auto sIt = splitEls.find(elId);
848 
849  if (sIt == splitEls.end())
850  {
851  m_mesh->m_element[m_mesh->m_expDim].push_back(el[i]);
852  continue;
853  }
854 
855  SpatialDomains::Geometry3DSharedPtr geom = geomMap[elId];
856 
857  const int faceNum = sIt->second;
858  LibUtilities::ShapeType elType = el[i]->GetConf().m_e;
859 
860  SplitMapHelper &sMap = splitMap[elType][faceNum];
861  SplitEdgeHelper &sEdge = splitEdge[elType][faceNum];
862 
863  // Find quadrilateral boundary faces if any
864  std::map<int, int> bLink;
865  for (int j = 0; j < sMap.bfacesSize; ++j)
866  {
867  int bl = el[i]->GetBoundaryLink(sMap.bfaces[j]);
868  if (bl != -1)
869  {
870  bLink[sMap.bfaces[j]] = bl;
871  }
872  }
873 
874  // Determine whether to use reverse points.
875  LibUtilities::PointsType t =
876  revPoints[elType][faceNum] ? LibUtilities::eBoundaryLayerPoints
877  : LibUtilities::eBoundaryLayerPointsRev;
878 
879  // Determine value of r based on geometry.
880  if (ratioIsString)
881  {
882  NekDouble x, y, z;
883  NekDouble x1, y1, z1;
884  int nverts = geom->GetNumVerts();
885 
886  x = y = z = 0.0;
887 
888  for (int i = 0; i < nverts; ++i)
889  {
890  geom->GetVertex(i)->GetCoords(x1, y1, z1);
891  x += x1;
892  y += y1;
893  z += z1;
894  }
895  x /= (NekDouble)nverts;
896  y /= (NekDouble)nverts;
897  z /= (NekDouble)nverts;
898  r = rEval.Evaluate(rExprId, x, y, z, 0.0);
899  }
900 
901  LocalRegions::ExpansionSharedPtr q;
902 
903  if (elType == LibUtilities::ePrism)
904  {
905  // Create basis.
906  LibUtilities::BasisKey B0(
907  LibUtilities::eModified_A, nq, LibUtilities::PointsKey(nq, pt));
908  LibUtilities::BasisKey B1(LibUtilities::eModified_A,
909  2,
910  LibUtilities::PointsKey(nl + 1, t, r));
911  LibUtilities::BasisKey B2(
912  LibUtilities::eModified_B, nq, LibUtilities::PointsKey(nq, pt));
913 
914  // Create local region.
915  SpatialDomains::PrismGeomSharedPtr g =
916  std::dynamic_pointer_cast<SpatialDomains::PrismGeom>(geom);
917  q = MemoryManager<LocalRegions::PrismExp>::AllocateSharedPtr(
918  B0, B1, B2, g);
919  }
920  else if (elType == LibUtilities::eHexahedron)
921  {
922  // Create basis.
923  LibUtilities::BasisKey B0(
924  LibUtilities::eModified_A, nq, LibUtilities::PointsKey(nq, pt));
925  LibUtilities::BasisKey B1(LibUtilities::eModified_A,
926  2,
927  LibUtilities::PointsKey(nl + 1, t, r));
928 
929  // Create local region.
930  SpatialDomains::HexGeomSharedPtr g =
931  std::dynamic_pointer_cast<SpatialDomains::HexGeom>(geom);
932  q = MemoryManager<LocalRegions::HexExp>::AllocateSharedPtr(
933  B0, B0, B1, g);
934  }
935 
936  // Grab co-ordinates.
937  Array<OneD, NekDouble> x(nq * nq * (nl + 1));
938  Array<OneD, NekDouble> y(nq * nq * (nl + 1));
939  Array<OneD, NekDouble> z(nq * nq * (nl + 1));
940  q->GetCoords(x, y, z);
941 
942  int nSplitEdge = sEdge.size;
943  vector<vector<NodeSharedPtr> > edgeNodes(nSplitEdge);
944 
945  // Loop over edges to be split.
946  for (int j = 0; j < nSplitEdge; ++j)
947  {
948  int locEdge = sEdge.edge[j];
949  int edgeId = el[i]->GetEdge(locEdge)->m_id;
950 
951  // Determine whether we have already generated vertices
952  // along this edge.
953  auto eIt = edgeMap.find(edgeId);
954 
955  if (eIt == edgeMap.end())
956  {
957  // If not then resize storage to hold new points.
958  edgeNodes[j].resize(nl + 1);
959 
960  // Re-use existing vertices at endpoints of edge to
961  // avoid duplicating the existing vertices.
962  edgeNodes[j][0] = el[i]->GetVertex(sEdge.edgeVert[j][0]);
963  edgeNodes[j][nl] = el[i]->GetVertex(sEdge.edgeVert[j][1]);
964 
965  // Variable geometric ratio
966  if (ratioIsString)
967  {
968  NekDouble x0, y0, z0;
969  NekDouble x1, y1, z1;
970  NekDouble xm, ym, zm;
971 
972  // -> Find edge end and mid points
973  x0 = x[sEdge.offset[j]];
974  y0 = y[sEdge.offset[j]];
975  z0 = z[sEdge.offset[j]];
976 
977  x1 = x[sEdge.offset[j] + nl * nq];
978  y1 = y[sEdge.offset[j] + nl * nq];
979  z1 = z[sEdge.offset[j] + nl * nq];
980 
981  xm = 0.5 * (x0 + x1);
982  ym = 0.5 * (y0 + y1);
983  zm = 0.5 * (z0 + z1);
984 
985  // evaluate r factor based on mid point value
986  NekDouble rnew;
987  rnew = rEval.Evaluate(rExprId, xm, ym, zm, 0.0);
988 
989  // Get basis with new r;
990  LibUtilities::PointsKey Pkey(nl + 1, t, rnew);
991  LibUtilities::PointsSharedPtr newP =
992  LibUtilities::PointsManager()[Pkey];
993 
994  const Array<OneD, const NekDouble> z = newP->GetZ();
995 
996  // Create new interior nodes based on this new blend
997  for (int k = 1; k < nl; ++k)
998  {
999  xm = 0.5 * (1 + z[k]) * (x1 - x0) + x0;
1000  ym = 0.5 * (1 + z[k]) * (y1 - y0) + y0;
1001  zm = 0.5 * (1 + z[k]) * (z1 - z0) + z0;
1002  edgeNodes[j][k] =
1003  NodeSharedPtr(new Node(nodeId++, xm, ym, zm));
1004  }
1005  }
1006  else
1007  {
1008  // Create new interior nodes.
1009  for (int k = 1; k < nl; ++k)
1010  {
1011  int pos = sEdge.offset[j] + k * sEdge.inc[j];
1012  edgeNodes[j][k] = NodeSharedPtr(
1013  new Node(nodeId++, x[pos], y[pos], z[pos]));
1014  }
1015  }
1016 
1017  // Store these edges in edgeMap.
1018  edgeMap[edgeId] = edgeNodes[j];
1019  }
1020  else
1021  {
1022  edgeNodes[j] = eIt->second;
1023  }
1024  }
1025 
1026  // Create element layers.
1027  for (int j = 0; j < nl; ++j)
1028  {
1029  // Offset of this layer within the collapsed coordinate
1030  // system.
1031  int offset = j * sMap.layerOff;
1032 
1033  // Get corner vertices.
1034  vector<NodeSharedPtr> nodeList(sMap.size);
1035  for (int k = 0; k < sMap.size; ++k)
1036  {
1037  nodeList[k] = edgeNodes[sMap.conn[k][0]][j + sMap.conn[k][1]];
1038  }
1039 
1040  // Create the element.
1041  ElmtConfig conf(elType, 1, true, true, false);
1042  ElementSharedPtr elmt = GetElementFactory().CreateInstance(
1043  elType, conf, nodeList, el[i]->GetTagList());
1044 
1045  // Add high order nodes to split prismatic edges.
1046  for (int l = 0; l < sMap.size; ++l)
1047  {
1048  EdgeSharedPtr HOedge = elmt->GetEdge(sMap.edge[l]);
1049  for (int k = 1; k < nq - 1; ++k)
1050  {
1051  int pos = offset + sMap.offset[l] + k * sMap.inc[l];
1052  HOedge->m_edgeNodes.push_back(NodeSharedPtr(
1053  new Node(nodeId++, x[pos], y[pos], z[pos])));
1054  }
1055  HOedge->m_curveType = pt;
1056  }
1057 
1058  // Change the surface elements to match the layers of
1059  // elements on the boundary of the domain.
1060  for (auto &it : bLink)
1061  {
1062  int fid = it.first;
1063  int bl = it.second;
1064 
1065  vector<NodeSharedPtr> qNodeList(4);
1066  for (int k = 0; k < 4; ++k)
1067  {
1068  qNodeList[k] = nodeList[faceNodeMap[elType][fid][k]];
1069  }
1070  vector<int> tagBE;
1071  tagBE =
1072  m_mesh->m_element[m_mesh->m_expDim - 1][bl]->GetTagList();
1073  ElmtConfig bconf(
1074  LibUtilities::eQuadrilateral, 1, true, true, false);
1075  ElementSharedPtr boundaryElmt =
1076  GetElementFactory().CreateInstance(
1077  LibUtilities::eQuadrilateral, bconf, qNodeList, tagBE);
1078 
1079  // Overwrite first layer boundary element with new
1080  // boundary element, otherwise push this back to end of
1081  // the boundary list
1082  if (j == 0)
1083  {
1084  m_mesh->m_element[m_mesh->m_expDim - 1][bl] = boundaryElmt;
1085  }
1086  else
1087  {
1088  m_mesh->m_element[m_mesh->m_expDim - 1].push_back(
1089  boundaryElmt);
1090  }
1091  }
1092 
1093  m_mesh->m_element[m_mesh->m_expDim].push_back(elmt);
1094  }
1095  }
1096 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::NekMeshUtils::ElmtConfig
Basic information about an element.
Definition: ElementConfig.h:49
Nektar::SpatialDomains::Geometry3DSharedPtr
std::shared_ptr< Geometry3D > Geometry3DSharedPtr
Definition: Geometry3D.h:52
class_topology.Node
Node
Definition: class_topology.py:44
Nektar::LibUtilities::eModified_A
Principle Modified Functions .
Definition: BasisType.h:48
Nektar::NekMeshUtils::EdgeSharedPtr
std::shared_ptr< Edge > EdgeSharedPtr
Shared pointer to an edge.
Definition: Edge.h:136
Nektar::Utilities::helper2d
int ** helper2d(int lda, int arr[][2])
Definition: ProcessBL.cpp:61
Nektar::NekMeshUtils::GetElementFactory
ElementFactory & GetElementFactory()
Definition: Element.cpp:44
Nektar::NekMeshUtils::NodeSharedPtr
std::shared_ptr< Node > NodeSharedPtr
Definition: CADVert.h:49
Nektar::LibUtilities::NekFactory::CreateInstance
tBaseSharedPtr CreateInstance(tKey idKey, tParam... args)
Create an instance of the class referred to by idKey.
Definition: NekFactory.hpp:144
Nektar::LibUtilities::PointsSharedPtr
std::shared_ptr< Points< NekDouble > > PointsSharedPtr
Definition: FoundationsFwd.hpp:78
Nektar::LibUtilities::eModified_B
Principle Modified Functions .
Definition: BasisType.h:49
Nektar::NekMeshUtils::ElementSharedPtr
std::shared_ptr< Element > ElementSharedPtr
Definition: Edge.h:49
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:161
Nektar::LibUtilities::PointsManager
PointsManagerT & PointsManager(void)
Definition: ManagerAccess.cpp:42
Nektar::NekDouble
double NekDouble
Definition: NektarUnivTypeDefs.hpp:43
Nektar::NekMeshUtils::Module::m_config
std::map< std::string, ConfigOption > m_config
List of configuration values.
Definition: NekMeshUtils/Module/Module.h:188
Nektar::ParseUtils::GenerateVector
static bool GenerateVector(const std::string &str, std::vector< T > &out)
Takes a comma-separated string and converts it to entries in a vector.
Definition: ParseUtils.cpp:135
Nektar::LocalRegions::ExpansionSharedPtr
std::shared_ptr< Expansion > ExpansionSharedPtr
Definition: Expansion.h:65
Nektar::LibUtilities::eBoundaryLayerPointsRev
1D power law distribution for boundary layer points
Definition: PointsType.h:68
Nektar::SpatialDomains::HexGeomSharedPtr
std::shared_ptr< HexGeom > HexGeomSharedPtr
Definition: HexGeom.h:90
Nektar::LibUtilities::eBoundaryLayerPoints
1D power law distribution for boundary layer points
Definition: PointsType.h:67
Nektar::SpatialDomains::PrismGeomSharedPtr
std::shared_ptr< PrismGeom > PrismGeomSharedPtr
Definition: PrismGeom.h:88
Nektar::LibUtilities::eGaussLobattoLegendre
1D Gauss-Lobatto-Legendre quadrature points
Definition: PointsType.h:51

◆ create()

static std::shared_ptr<Module> Nektar::Utilities::ProcessBL::create ( NekMeshUtils::MeshSharedPtr  m)
inlinestatic

Creates an instance of this class.

Definition at line 55 of file ProcessBL.h.

References Nektar::MemoryManager< DataType >::AllocateSharedPtr().

56  {
57  return MemoryManager<ProcessBL>::AllocateSharedPtr(m);
58  }
Nektar::MemoryManager::AllocateSharedPtr
static std::shared_ptr< DataType > AllocateSharedPtr(const Args &...args)
Allocate a shared pointer from the memory pool.
Definition: NekMemoryManager.hpp:161

◆ Process()

void Nektar::Utilities::ProcessBL::Process ( )
virtual

Write mesh to output file.

Implements Nektar::NekMeshUtils::Module.

Definition at line 125 of file ProcessBL.cpp.

References ASSERTL0, BoundaryLayer2D(), BoundaryLayer3D(), Nektar::NekMeshUtils::Module::m_mesh, Nektar::NekMeshUtils::Module::ProcessComposites(), Nektar::NekMeshUtils::Module::ProcessEdges(), Nektar::NekMeshUtils::Module::ProcessElements(), Nektar::NekMeshUtils::Module::ProcessFaces(), and Nektar::NekMeshUtils::Module::ProcessVertices().

126 {
127  if (m_mesh->m_verbose)
128  {
129  cout << "ProcessBL: Refining boundary layer..." << endl;
130  }
131  int dim = m_mesh->m_expDim;
132  switch (dim)
133  {
134  case 2:
135  {
136  BoundaryLayer2D();
137  }
138  break;
139 
140  case 3:
141  {
142  BoundaryLayer3D();
143  }
144  break;
145 
146  default:
147  ASSERTL0(0,"Dimension not supported");
148  break;
149  }
150 
151  // Re-process mesh to eliminate duplicate vertices and edges.
152  ProcessVertices();
153  ProcessEdges();
154  ProcessFaces();
155  ProcessElements();
156  ProcessComposites();
157 }
ASSERTL0
#define ASSERTL0(condition, msg)
Definition: ErrorUtil.hpp:216
Nektar::NekMeshUtils::Module::ProcessFaces
virtual NEKMESHUTILS_EXPORT void ProcessFaces(bool ReprocessFaces=true)
Extract element faces.
Definition: NekMeshUtils/Module/Module.cpp:286
Nektar::NekMeshUtils::Module::ProcessElements
virtual NEKMESHUTILS_EXPORT void ProcessElements()
Generate element IDs.
Definition: NekMeshUtils/Module/Module.cpp:382
Nektar::NekMeshUtils::Module::ProcessVertices
virtual NEKMESHUTILS_EXPORT void ProcessVertices()
Extract element vertices.
Definition: NekMeshUtils/Module/Module.cpp:134
Nektar::NekMeshUtils::Module::ProcessEdges
virtual NEKMESHUTILS_EXPORT void ProcessEdges(bool ReprocessEdges=true)
Extract element edges.
Definition: NekMeshUtils/Module/Module.cpp:174
Nektar::NekMeshUtils::Module::ProcessComposites
virtual NEKMESHUTILS_EXPORT void ProcessComposites()
Generate composites.
Definition: NekMeshUtils/Module/Module.cpp:400

Member Data Documentation

◆ className

ModuleKey Nektar::Utilities::ProcessBL::className
static
Initial value:
= GetModuleFactory().RegisterCreatorFunction(
ModuleKey(eProcessModule, "bl"),
ProcessBL::create,
"Refines a prismatic or quadrilateral boundary layer.")

Definition at line 59 of file ProcessBL.h.

Generated on Wed Jan 20 2021 03:34:22 for Nektar++ by   doxygen 1.8.13