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]

Collaboration diagram for Nektar::Utilities::ProcessBL:

[legend]

Public Member Functions
	ProcessBL (MeshSharedPtr m)

virtual	~ProcessBL ()

virtual void	Process ()
	Write mesh to output file. More...

Public Member Functions inherited from Nektar::Utilities::ProcessModule
	ProcessModule ()

	ProcessModule (FieldSharedPtr p_f)

	ProcessModule (MeshSharedPtr p_m)

Public Member Functions inherited from Nektar::Utilities::Module
	Module (FieldSharedPtr p_f)

virtual void	Process (po::variables_map &vm)=0

virtual std::string	GetModuleName ()=0

void	RegisterConfig (string key, string value)
	Register a configuration option with a module. More...

void	PrintConfig ()
	Print out all configuration options for a module. More...

void	SetDefaults ()
	Sets default configuration options for those which have not been set. More...

bool	GetRequireEquiSpaced (void)

void	SetRequireEquiSpaced (bool pVal)

void	EvaluateTriFieldAtEquiSpacedPts (LocalRegions::ExpansionSharedPtr &exp, const Array< OneD, const NekDouble > &infield, Array< OneD, NekDouble > &outfield)

	Module (MeshSharedPtr p_m)

void	RegisterConfig (std::string key, std::string value)

void	PrintConfig ()

void	SetDefaults ()

MeshSharedPtr	GetMesh ()

virtual void	ProcessVertices ()
	Extract element vertices. More...

virtual void	ProcessEdges (bool ReprocessEdges=true)
	Extract element edges. More...

virtual void	ProcessFaces (bool ReprocessFaces=true)
	Extract element faces. More...

virtual void	ProcessElements ()
	Generate element IDs. More...

virtual void	ProcessComposites ()
	Generate composites. More...

virtual void	ClearElementLinks ()

Static Public Member Functions
static boost::shared_ptr< Module >	create (MeshSharedPtr m)
	Creates an instance of this class. More...

Static Public Attributes
static ModuleKey	className

Additional Inherited Members
Protected Member Functions inherited from Nektar::Utilities::Module
	Module ()

void	ReorderPrisms (PerMap &perFaces)
	Reorder node IDs so that prisms and tetrahedra are aligned correctly. More...

void	PrismLines (int prism, PerMap &perFaces, std::set< int > &prismsDone, std::vector< ElementSharedPtr > &line)

Protected Attributes inherited from Nektar::Utilities::Module
FieldSharedPtr	m_f
	Field object. More...

map< string, ConfigOption >	m_config
	List of configuration values. More...

bool	m_requireEquiSpaced

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 52 of file ProcessBL.h.

Constructor & Destructor Documentation

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

Definition at line 108 of file ProcessBL.cpp.

References Nektar::Utilities::Module::m_config.

                                     : ProcessModule(m)
 {
     // BL mesh configuration.
     m_config["layers"] =
         ConfigOption(false, "2", "Number of layers to refine.");
     m_config["nq"] =
         ConfigOption(false, "5", "Number of points in high order elements.");
     m_config["surf"] =
         ConfigOption(false, "", "Tag identifying surface connected to prism.");
     m_config["r"] =
         ConfigOption(false, "2.0", "Ratio to use in geometry progression.");
 }

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

virtual

Definition at line 121 of file ProcessBL.cpp.

122 {

123 }

Member Function Documentation

static boost::shared_ptr<Module> Nektar::Utilities::ProcessBL::create ( MeshSharedPtr m )

inlinestatic

Creates an instance of this class.

Definition at line 56 of file ProcessBL.h.

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

     {
         return MemoryManager<ProcessBL>::AllocateSharedPtr(m);
     }

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

virtual

Write mesh to output file.

Implements Nektar::Utilities::Module.

Definition at line 125 of file ProcessBL.cpp.

 {
     if (m_mesh->m_verbose)
     {
         cout << "ProcessBL: Refining prismatic boundary layer..." << endl;
     }
 
     // A set containing all element types which are valid.
     set<LibUtilities::ShapeType> validElTypes;
     validElTypes.insert(LibUtilities::ePrism);
     validElTypes.insert(LibUtilities::eHexahedron);
 
     int nodeId = m_mesh->m_vertexSet.size();
     int nl     = m_config["layers"].as<int>();
     int nq     = m_config["nq"].as<int>();
 
     // determine if geometric ratio is string or a constant.
     LibUtilities::AnalyticExpressionEvaluator rEval;
     NekDouble r        = 1;
     int rExprId        = -1;
     bool ratioIsString = false;
 
     if (m_config["r"].isType<NekDouble>())
     {
         r = m_config["r"].as<NekDouble>();
     }
     else
     {
         std::string rstr = m_config["r"].as<string>();
         rExprId          = rEval.DefineFunction("x y z", rstr);
         ratioIsString    = true;
     }
 
     // Prismatic node -> face map.
     int prismFaceNodes[5][4] = {
         {0, 1, 2, 3}, {0, 1, 4, -1}, {1, 2, 5, 4}, {3, 2, 5, -1}, {0, 3, 5, 4}};
     int hexFaceNodes[6][4] = {{0, 1, 2, 3},
                               {0, 1, 5, 4},
                               {1, 2, 6, 5},
                               {3, 2, 6, 7},
                               {0, 3, 7, 4},
                               {4, 5, 6, 7}};
     map<LibUtilities::ShapeType, int **> faceNodeMap;
     faceNodeMap[LibUtilities::ePrism]      = helper2d(5, prismFaceNodes);
     faceNodeMap[LibUtilities::eHexahedron] = helper2d(6, hexFaceNodes);
 
     // Default PointsType.
     LibUtilities::PointsType pt = LibUtilities::eGaussLobattoLegendre;
 
     // Map which takes element ID to face on surface. This enables
     // splitting to occur in either y-direction of the prism.
     boost::unordered_map<int, int> splitEls;
     boost::unordered_map<int, int>::iterator sIt;
 
     // Set up maps which takes an edge (in nektar++ ordering) and return
     // their offset and stride in the 3d array of collapsed quadrature
     // points. Note that this map includes only the edges that are on
     // the triangular faces as the edges in the normal direction are
     // linear.
     map<LibUtilities::ShapeType, map<int, SplitMapHelper> > splitMap;
     int po = nq * (nl + 1);
 
     SplitMapHelper splitPrism;
     int splitMapEdgePrism[6]    = {0, 2, 4, 5, 6, 7};
     int splitMapOffsetPrism[6]  = {0, nq, 0, nq - 1, nq + nq - 1, nq};
     int splitMapIncPrism[6]     = {1, 1, po, po, po, po};
     int splitMapBFacesPrism[3]  = {0, 2, 4};
     int splitMapConnPrism[6][2] = {
         {0, 0}, {1, 0}, {1, 1}, {0, 1}, {2, 0}, {2, 1}};
     splitPrism.size                   = 6;
     splitPrism.layerOff               = nq;
     splitPrism.edge                   = splitMapEdgePrism;
     splitPrism.offset                 = splitMapOffsetPrism;
     splitPrism.inc                    = splitMapIncPrism;
     splitPrism.conn                   = helper2d(6, splitMapConnPrism);
     splitPrism.bfacesSize             = 3;
     splitPrism.bfaces                 = splitMapBFacesPrism;
     splitMap[LibUtilities::ePrism][1] = splitPrism;
     splitMap[LibUtilities::ePrism][3] = splitPrism;
 
     int ho = nq * (nq - 1);
     int tl = nq * nq;
     SplitMapHelper splitHex0;
     int splitMapEdgeHex0[8]   = {0, 1, 2, 3, 8, 9, 10, 11};
     int splitMapOffsetHex0[8] = {
         0, nq - 1, tl - 1, ho, tl, tl + nq - 1, 2 * tl - 1, tl + ho};
     int splitMapIncHex0[8]     = {1, nq, -1, -nq, 1, nq, -1, -nq};
     int splitMapBFacesHex0[4]  = {1, 2, 3, 4};
     int splitMapConnHex0[8][2] = {
         {0, 0}, {1, 0}, {2, 0}, {3, 0}, {0, 1}, {1, 1}, {2, 1}, {3, 1}};
     splitHex0.size                         = 8;
     splitHex0.layerOff                     = nq * nq;
     splitHex0.edge                         = splitMapEdgeHex0;
     splitHex0.offset                       = splitMapOffsetHex0;
     splitHex0.inc                          = splitMapIncHex0;
     splitHex0.conn                         = helper2d(8, splitMapConnHex0);
     splitHex0.bfacesSize                   = 4;
     splitHex0.bfaces                       = splitMapBFacesHex0;
     splitMap[LibUtilities::eHexahedron][0] = splitHex0;
     splitMap[LibUtilities::eHexahedron][5] = splitHex0;
 
     // splitEdge enumerates the edges in the standard prism along which
     // new nodes should be generated. These edges are the three between
     // the two triangular faces.
     //
     // edgeVertMap specifies the vertices which comprise those edges in
     // splitEdge; for example splitEdge[0] = 3 which connects vertices 0
     // and 3.
     //
     // edgeOffset holds the offset of each of edges 3, 1 and 8
     // respectively inside the collapsed coordinate system.
     map<LibUtilities::ShapeType, map<int, SplitEdgeHelper> > splitEdge;
 
     int splitPrismEdges[3]       = {3, 1, 8};
     int splitPrismEdgeVert[3][2] = {{0, 3}, {1, 2}, {4, 5}};
     int splitPrismOffset[3]      = {0, nq - 1, nq * (nl + 1) * (nq - 1)};
     int splitPrismInc[3]         = {nq, nq, nq};
     SplitEdgeHelper splitPrismEdge;
     splitPrismEdge.size                = 3;
     splitPrismEdge.edge                = splitPrismEdges;
     splitPrismEdge.edgeVert            = helper2d(3, splitPrismEdgeVert);
     splitPrismEdge.offset              = splitPrismOffset;
     splitPrismEdge.inc                 = splitPrismInc;
     splitEdge[LibUtilities::ePrism][1] = splitPrismEdge;
     splitEdge[LibUtilities::ePrism][3] = splitPrismEdge;
 
     int splitHex0Edges[4]       = {4, 5, 6, 7};
     int splitHex0EdgeVert[4][2] = {{0, 4}, {1, 5}, {2, 6}, {3, 7}};
     int splitHex0Offset[4]      = {0, nq - 1, nq * nq - 1, nq * (nq - 1)};
     int splitHex0Inc[4]         = {nq * nq, nq * nq, nq * nq, nq * nq};
     SplitEdgeHelper splitHex0Edge;
     splitHex0Edge.size                      = 4;
     splitHex0Edge.edge                      = splitHex0Edges;
     splitHex0Edge.edgeVert                  = helper2d(4, splitHex0EdgeVert);
     splitHex0Edge.offset                    = splitHex0Offset;
     splitHex0Edge.inc                       = splitHex0Inc;
     splitEdge[LibUtilities::eHexahedron][0] = splitHex0Edge;
     splitEdge[LibUtilities::eHexahedron][5] = splitHex0Edge;
 
     map<LibUtilities::ShapeType, map<int, bool> > revPoints;
     revPoints[LibUtilities::ePrism][1] = true;
     revPoints[LibUtilities::ePrism][3] = false;
 
     revPoints[LibUtilities::eHexahedron][0] = true;
     revPoints[LibUtilities::eHexahedron][5] = false;
 
     // edgeMap associates geometry edge IDs to the (nl+1) vertices which
     // are generated along that edge when a prism is split, and is used
     // to avoid generation of duplicate vertices. It is stored as an
     // unordered map for speed.
     boost::unordered_map<int, vector<NodeSharedPtr> > edgeMap;
     boost::unordered_map<int, vector<NodeSharedPtr> >::iterator eIt;
 
     string surf = m_config["surf"].as<string>();
     if (surf.size() > 0)
     {
         vector<unsigned int> surfs;
         ParseUtils::GenerateSeqVector(surf.c_str(), surfs);
         sort(surfs.begin(), surfs.end());
 
         // If surface is defined, process list of elements to find those
         // that are connected to it.
         for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); ++i)
         {
             ElementSharedPtr el = m_mesh->m_element[m_mesh->m_expDim][i];
             int nSurf           = el->GetFaceCount();
 
             for (int j = 0; j < nSurf; ++j)
             {
                 int bl = el->GetBoundaryLink(j);
                 if (bl == -1)
                 {
                     continue;
                 }
 
                 ElementSharedPtr bEl =
                     m_mesh->m_element[m_mesh->m_expDim - 1][bl];
                 vector<int> tags = bEl->GetTagList();
                 vector<int> inter;
 
                 sort(tags.begin(), tags.end());
                 set_intersection(surfs.begin(),
                                  surfs.end(),
                                  tags.begin(),
                                  tags.end(),
                                  back_inserter(inter));
                 ASSERTL0(inter.size() <= 1, "Intersection of surfaces wrong");
 
                 if (inter.size() == 1)
                 {
                     if (el->GetConf().m_e == LibUtilities::ePrism)
                     {
                         if (j % 2 == 0)
                         {
                             cerr << "WARNING: Found quadrilateral face " << j
                                  << " on surface " << surf
                                  << " connected to prism; ignoring." << endl;
                             continue;
                         }
 
                         if (splitEls.count(el->GetId()) > 0)
                         {
                             cerr << "WARNING: prism already found; "
                                  << "ignoring" << endl;
                         }
 
                         splitEls[el->GetId()] = j;
                     }
                     else if (validElTypes.count(el->GetConf().m_e) == 0)
                     {
                         cerr << "WARNING: Unsupported element type "
                              << "found in surface " << j << "; "
                              << "ignoring" << endl;
                         continue;
                     }
                 }
             }
         }
     }
     else
     {
         // Otherwise, add all prismatic elements and assume face 1 of
         // the prism lies on the surface.
         for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); ++i)
         {
             ElementSharedPtr el = m_mesh->m_element[m_mesh->m_expDim][i];
 
             if (el->GetConf().m_e == LibUtilities::ePrism)
             {
                 splitEls[el->GetId()] = 1;
             }
             else if (validElTypes.count(el->GetConf().m_e) > 0)
             {
                 splitEls[el->GetId()] = 0;
             }
             else
             {
                 continue;
             }
         }
     }
 
     if (splitEls.size() == 0)
     {
         cerr << "WARNING: No elements detected to split." << endl;
         return;
     }
 
     // Erase all elements from the element list. Elements will be
     // re-added as they are split.
     vector<ElementSharedPtr> el = m_mesh->m_element[m_mesh->m_expDim];
     m_mesh->m_element[m_mesh->m_expDim].clear();
 
     map<int, SpatialDomains::Geometry3DSharedPtr> geomMap;
     for (int i = 0; i < el.size(); ++i)
     {
         const int elId = el[i]->GetId();
         sIt = splitEls.find(elId);
         if (sIt == splitEls.end())
         {
             continue;
         }
 
         // Get elemental geometry object and put into map.
         geomMap[elId] = boost::dynamic_pointer_cast<SpatialDomains::Geometry3D>(
             el[i]->GetGeom(m_mesh->m_spaceDim));
     }
 
     // Iterate over list of elements of expansion dimension.
     for (int i = 0; i < el.size(); ++i)
     {
         const int elId = el[i]->GetId();
         sIt            = splitEls.find(elId);
 
         if (sIt == splitEls.end())
         {
             m_mesh->m_element[m_mesh->m_expDim].push_back(el[i]);
             continue;
         }
 
         SpatialDomains::Geometry3DSharedPtr geom = geomMap[elId];
 
         const int faceNum              = sIt->second;
         LibUtilities::ShapeType elType = el[i]->GetConf().m_e;
 
         SplitMapHelper &sMap   = splitMap[elType][faceNum];
         SplitEdgeHelper &sEdge = splitEdge[elType][faceNum];
 
         // Find quadrilateral boundary faces if any
         std::map<int, int> bLink;
         for (int j = 0; j < sMap.bfacesSize; ++j)
         {
             int bl = el[i]->GetBoundaryLink(sMap.bfaces[j]);
             if (bl != -1)
             {
                 bLink[sMap.bfaces[j]] = bl;
             }
         }
 
         // Determine whether to use reverse points.
         LibUtilities::PointsType t =
             revPoints[elType][faceNum] ? LibUtilities::eBoundaryLayerPoints
                                        : LibUtilities::eBoundaryLayerPointsRev;
 
         // Determine value of r based on geometry.
         if (ratioIsString)
         {
             NekDouble x, y, z;
             NekDouble x1, y1, z1;
             int nverts = geom->GetNumVerts();
 
             x = y = z = 0.0;
 
             for (int i = 0; i < nverts; ++i)
             {
                 geom->GetVertex(i)->GetCoords(x1, y1, z1);
                 x += x1;
                 y += y1;
                 z += z1;
             }
             x /= (NekDouble)nverts;
             y /= (NekDouble)nverts;
             z /= (NekDouble)nverts;
             r = rEval.Evaluate(rExprId, x, y, z, 0.0);
         }
 
         LocalRegions::ExpansionSharedPtr q;
 
         if (elType == LibUtilities::ePrism)
         {
             // Create basis.
             LibUtilities::BasisKey B0(
                 LibUtilities::eModified_A, nq, LibUtilities::PointsKey(nq, pt));
             LibUtilities::BasisKey B1(LibUtilities::eModified_A,
                                       2,
                                       LibUtilities::PointsKey(nl + 1, t, r));
             LibUtilities::BasisKey B2(
                 LibUtilities::eModified_B, nq, LibUtilities::PointsKey(nq, pt));
 
             // Create local region.
             SpatialDomains::PrismGeomSharedPtr g =
                 boost::dynamic_pointer_cast<SpatialDomains::PrismGeom>(geom);
             q = MemoryManager<LocalRegions::PrismExp>::AllocateSharedPtr(
                 B0, B1, B2, g);
         }
         else if (elType == LibUtilities::eHexahedron)
         {
             // Create basis.
             LibUtilities::BasisKey B0(
                 LibUtilities::eModified_A, nq, LibUtilities::PointsKey(nq, pt));
             LibUtilities::BasisKey B1(LibUtilities::eModified_A,
                                       2,
                                       LibUtilities::PointsKey(nl + 1, t, r));
 
             // Create local region.
             SpatialDomains::HexGeomSharedPtr g =
                 boost::dynamic_pointer_cast<SpatialDomains::HexGeom>(geom);
             q = MemoryManager<LocalRegions::HexExp>::AllocateSharedPtr(
                 B0, B0, B1, g);
         }
 
         // Grab co-ordinates.
         Array<OneD, NekDouble> x(nq * nq * (nl + 1));
         Array<OneD, NekDouble> y(nq * nq * (nl + 1));
         Array<OneD, NekDouble> z(nq * nq * (nl + 1));
         q->GetCoords(x, y, z);
 
         int nSplitEdge = sEdge.size;
         vector<vector<NodeSharedPtr> > edgeNodes(nSplitEdge);
 
         // Loop over edges to be split.
         for (int j = 0; j < nSplitEdge; ++j)
         {
             int locEdge = sEdge.edge[j];
             int edgeId  = el[i]->GetEdge(locEdge)->m_id;
 
             // Determine whether we have already generated vertices
             // along this edge.
             eIt = edgeMap.find(edgeId);
 
             if (eIt == edgeMap.end())
             {
                 // If not then resize storage to hold new points.
                 edgeNodes[j].resize(nl + 1);
 
                 // Re-use existing vertices at endpoints of edge to
                 // avoid duplicating the existing vertices.
                 edgeNodes[j][0]  = el[i]->GetVertex(sEdge.edgeVert[j][0]);
                 edgeNodes[j][nl] = el[i]->GetVertex(sEdge.edgeVert[j][1]);
 
                 // Variable geometric ratio
                 if (ratioIsString)
                 {
                     NekDouble x0, y0, z0;
                     NekDouble x1, y1, z1;
                     NekDouble xm, ym, zm;
 
                     // -> Find edge end and mid points
                     x0 = x[sEdge.offset[j]];
                     y0 = y[sEdge.offset[j]];
                     z0 = z[sEdge.offset[j]];
 
                     x1 = x[sEdge.offset[j] + nl * nq];
                     y1 = y[sEdge.offset[j] + nl * nq];
                     z1 = z[sEdge.offset[j] + nl * nq];
 
                     xm = 0.5 * (x0 + x1);
                     ym = 0.5 * (y0 + y1);
                     zm = 0.5 * (z0 + z1);
 
                     // evaluate r factor based on mid point value
                     NekDouble rnew;
                     rnew = rEval.Evaluate(rExprId, xm, ym, zm, 0.0);
 
                     // Get basis with new r;
                     LibUtilities::PointsKey Pkey(nl + 1, t, rnew);
                     LibUtilities::PointsSharedPtr newP =
                         LibUtilities::PointsManager()[Pkey];
 
                     const Array<OneD, const NekDouble> z = newP->GetZ();
 
                     // Create new interior nodes based on this new blend
                     for (int k = 1; k < nl; ++k)
                     {
                         xm = 0.5 * (1 + z[k]) * (x1 - x0) + x0;
                         ym = 0.5 * (1 + z[k]) * (y1 - y0) + y0;
                         zm = 0.5 * (1 + z[k]) * (z1 - z0) + z0;
                         edgeNodes[j][k] =
                             NodeSharedPtr(new Node(nodeId++, xm, ym, zm));
                     }
                 }
                 else
                 {
                     // Create new interior nodes.
                     for (int k = 1; k < nl; ++k)
                     {
                         int pos         = sEdge.offset[j] + k * sEdge.inc[j];
                         edgeNodes[j][k] = NodeSharedPtr(
                             new Node(nodeId++, x[pos], y[pos], z[pos]));
                     }
                 }
 
                 // Store these edges in edgeMap.
                 edgeMap[edgeId] = edgeNodes[j];
             }
             else
             {
                 edgeNodes[j] = eIt->second;
             }
         }
 
         // Create element layers.
         for (int j = 0; j < nl; ++j)
         {
             // Offset of this layer within the collapsed coordinate
             // system.
             int offset = j * sMap.layerOff;
 
             // Get corner vertices.
             vector<NodeSharedPtr> nodeList(sMap.size);
             for (int k = 0; k < sMap.size; ++k)
             {
                 nodeList[k] = edgeNodes[sMap.conn[k][0]][j + sMap.conn[k][1]];
             }
 
             // Create the element.
             ElmtConfig conf(elType, 1, true, true, false);
             ElementSharedPtr elmt = GetElementFactory().CreateInstance(
                 elType, conf, nodeList, el[i]->GetTagList());
 
             // Add high order nodes to split prismatic edges.
             for (int l = 0; l < sMap.size; ++l)
             {
                 EdgeSharedPtr HOedge = elmt->GetEdge(sMap.edge[l]);
                 for (int k = 1; k < nq - 1; ++k)
                 {
                     int pos = offset + sMap.offset[l] + k * sMap.inc[l];
                     HOedge->m_edgeNodes.push_back(NodeSharedPtr(
                         new Node(nodeId++, x[pos], y[pos], z[pos])));
                 }
                 HOedge->m_curveType = pt;
             }
 
             // Change the surface elements to match the layers of
             // elements on the boundary of the domain.
             map<int, int>::iterator it;
             for (it = bLink.begin(); it != bLink.end(); ++it)
             {
                 int fid = it->first;
                 int bl  = it->second;
 
                 vector<NodeSharedPtr> qNodeList(4);
                 for (int k = 0; k < 4; ++k)
                 {
                     qNodeList[k] = nodeList[faceNodeMap[elType][fid][k]];
                 }
                 vector<int> tagBE;
                 tagBE =
                     m_mesh->m_element[m_mesh->m_expDim - 1][bl]->GetTagList();
                 ElmtConfig bconf(
                     LibUtilities::eQuadrilateral, 1, true, true, false);
                 ElementSharedPtr boundaryElmt =
                     GetElementFactory().CreateInstance(
                         LibUtilities::eQuadrilateral, bconf, qNodeList, tagBE);
 
                 // Overwrite first layer boundary element with new
                 // boundary element, otherwise push this back to end of
                 // the boundary list
                 if (j == 0)
                 {
                     m_mesh->m_element[m_mesh->m_expDim - 1][bl] = boundaryElmt;
                 }
                 else
                 {
                     m_mesh->m_element[m_mesh->m_expDim - 1].push_back(
                         boundaryElmt);
                 }
             }
 
             m_mesh->m_element[m_mesh->m_expDim].push_back(elmt);
         }
     }
 
     // Re-process mesh to eliminate duplicate vertices and edges.
     ProcessVertices();
     ProcessEdges();
     ProcessFaces();
     ProcessElements();
     ProcessComposites();
 }

Member Data Documentation

ModuleKey Nektar::Utilities::ProcessBL::className

static

Initial value:

= GetModuleFactory().RegisterCreatorFunction(
    ModuleKey(eProcessModule, "bl"),
    ProcessBL::create,
    "Refines a prismatic boundary layer.")

Definition at line 60 of file ProcessBL.h.

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation