OGS
NodeReordering.cpp File Reference

Detailed Description

2013/13/06 KR Initial implementation

Copyright
Copyright (c) 2012-2025, OpenGeoSys Community (http://www.opengeosys.org) Distributed under a Modified BSD License. See accompanying file LICENSE.txt or http://www.opengeosys.org/project/license

Definition in file NodeReordering.cpp.

#include <tclap/CmdLine.h>
#include <Eigen/Dense>
#include <algorithm>
#include <array>
#include <concepts>
#include <functional>
#include <vector>
#include "BaseLib/Algorithm.h"
#include "BaseLib/Logging.h"
#include "BaseLib/MPI.h"
#include "BaseLib/TCLAPArguments.h"
#include "InfoLib/GitInfo.h"
#include "MeshLib/ElementCoordinatesMappingLocal.h"
#include "MeshLib/Elements/Element.h"
#include "MeshLib/IO/readMeshFromFile.h"
#include "MeshLib/IO/writeMeshToFile.h"
#include "MeshLib/Mesh.h"
#include "MeshLib/MeshEnums.h"
#include "MeshLib/Node.h"
#include "MeshLib/Utils/GetSpaceDimension.h"
#include "NumLib/Fem/ShapeFunction/ShapeHex20.h"
#include "NumLib/Fem/ShapeFunction/ShapeHex8.h"
#include "NumLib/Fem/ShapeFunction/ShapeLine2.h"
#include "NumLib/Fem/ShapeFunction/ShapeLine3.h"
#include "NumLib/Fem/ShapeFunction/ShapePoint1.h"
#include "NumLib/Fem/ShapeFunction/ShapePrism15.h"
#include "NumLib/Fem/ShapeFunction/ShapePrism6.h"
#include "NumLib/Fem/ShapeFunction/ShapePyra13.h"
#include "NumLib/Fem/ShapeFunction/ShapePyra5.h"
#include "NumLib/Fem/ShapeFunction/ShapeQuad4.h"
#include "NumLib/Fem/ShapeFunction/ShapeQuad8.h"
#include "NumLib/Fem/ShapeFunction/ShapeQuad9.h"
#include "NumLib/Fem/ShapeFunction/ShapeTet10.h"
#include "NumLib/Fem/ShapeFunction/ShapeTet4.h"
#include "NumLib/Fem/ShapeFunction/ShapeTri3.h"
#include "NumLib/Fem/ShapeFunction/ShapeTri6.h"
Include dependency graph for NodeReordering.cpp:

Go to the source code of this file.

Classes

struct  ElementReorderConfigBase

Functions

template<typename GradShapeFunction, int Dim>
bool checkJacobianDeterminant (MeshLib::Element const &e, int const mesh_space_dimension, std::array< double, Dim > const &xi, bool const check_reordered=false)
template<ShapeFunction ShapeFunc, int Dim>
ElementReorderConfigBase makeElementConfig (std::array< double, Dim > xi, std::function< void(MeshLib::Element &, const std::vector< MeshLib::Node * > &)> reorder)
void reverseNodeOrder (std::vector< MeshLib::Element * > &elements, int const mesh_space_dimension, bool const forced)
 Reverses order of nodes. In particular, this fixes issues between (Gmsh or OGS5) and OGS6 meshes.
void fixVtkInconsistencies (std::vector< MeshLib::Element * > &elements)
void reorderNonlinearNodes (MeshLib::Mesh &mesh)
 Orders the base nodes of each elements before its non-linear nodes.
int main (int argc, char *argv[])

Variables

static const std::array< ElementReorderConfigBase, static_cast< int >(MeshLib::CellType::enum_length)> element_configs_array

Function Documentation

◆ checkJacobianDeterminant()

template<typename GradShapeFunction, int Dim>
bool checkJacobianDeterminant ( MeshLib::Element const & e,
int const mesh_space_dimension,
std::array< double, Dim > const & xi,
bool const check_reordered = false )

Definition at line 52 of file NodeReordering.cpp.

56{
57 Eigen::Matrix<double, GradShapeFunction::DIM, GradShapeFunction::NPOINTS,
58 Eigen::RowMajor>
59 dNdxi;
60 Eigen::Map<Eigen::VectorXd> dN_vec(dNdxi.data(), dNdxi.size());
61 GradShapeFunction::computeGradShapeFunction(xi.data(), dN_vec);
62 MeshLib::ElementCoordinatesMappingLocal ele_local_coord(
63 e, mesh_space_dimension);
64
65 Eigen::MatrixXd J = Eigen::MatrixXd::Zero(Dim, Dim);
66 assert(e.getNumberOfNodes() == GradShapeFunction::NPOINTS);
67 for (unsigned k = 0; k < GradShapeFunction::NPOINTS; k++)
68 {
69 const MathLib::Point3d& mapped_pt =
70 ele_local_coord.getMappedCoordinates(k);
71 J += dNdxi.col(k) * mapped_pt.asEigenVector3d().head(Dim).transpose();
72 }
73
74 if (!check_reordered)
75 {
76 return !(J.determinant() < 0);
77 }
78
79 if (J.determinant() < 0)
80 {
81 OGS_FATAL(
82 "Element {:d} has negative Jacobian determinant {:g}. "
83 "NodeReordering fails.",
84 e.getID(), J.determinant());
85 }
86
87 return true;
88}
OGS_FATAL
#define OGS_FATAL(...)
Definition Error.h:26
MathLib::Point3d::asEigenVector3d
Eigen::Vector3d const & asEigenVector3d() const
Definition Point3d.h:64

References MathLib::Point3d::asEigenVector3d(), MeshLib::Element::getID(), MeshLib::ElementCoordinatesMappingLocal::getMappedCoordinates(), MeshLib::Element::getNumberOfNodes(), and OGS_FATAL.

Referenced by makeElementConfig().

◆ fixVtkInconsistencies()

void fixVtkInconsistencies ( std::vector< MeshLib::Element * > & elements)

Fixes inconsistencies between VTK's and OGS' node order for prism elements. In particular, this fixes issues between OGS6 meshes with and without InSitu-Lib

Definition at line 369 of file NodeReordering.cpp.

370{
371 for (auto* const element : elements)
372 {
373 const unsigned nElemNodes(element->getNumberOfBaseNodes());
374 std::vector<MeshLib::Node*> nodes(element->getNodes(),
375 element->getNodes() + nElemNodes);
376
377 for (std::size_t j = 0; j < nElemNodes; ++j)
378 {
379 if (element->getGeomType() == MeshLib::MeshElemType::PRISM)
380 {
381 for (std::size_t k = 0; k < 3; ++k)
382 {
383 element->setNode(k, nodes[k + 3]);
384 element->setNode(k + 3, nodes[k]);
385 }
386 break;
387 }
388 }
389 }
390}

References MeshLib::PRISM.

Referenced by main().

◆ main()

int main ( int argc,
char * argv[] )

Definition at line 427 of file NodeReordering.cpp.

428{
429 enum class ExpectedCellType
430 {
431 INVALID = 0,
432 POINT1 = 1,
433 LINE2 = 2,
434 LINE3 = 3,
435 TRI3 = 4,
436 TRI6 = 5,
437 QUAD4 = 6,
438 QUAD8 = 7,
439 QUAD9 = 8,
440 TET4 = 9,
441 TET10 = 10,
442 HEX8 = 11,
443 HEX20 = 12,
444 HEX27 = 13,
445 PRISM6 = 14,
446 PRISM15 = 15,
447 PRISM18 = 16,
448 PYRAMID5 = 17,
449 PYRAMID13 = 18,
450 enum_length
451 };
452
453 constexpr bool are_expected_cell_types =
454 static_cast<int>(ExpectedCellType::enum_length) ==
455 static_cast<int>(MeshLib::CellType::enum_length) &&
456 static_cast<int>(ExpectedCellType::INVALID) ==
457 static_cast<int>(MeshLib::CellType::INVALID) &&
458 static_cast<int>(ExpectedCellType::POINT1) ==
459 static_cast<int>(MeshLib::CellType::POINT1) &&
460 static_cast<int>(ExpectedCellType::LINE2) ==
461 static_cast<int>(MeshLib::CellType::LINE2) &&
462 static_cast<int>(ExpectedCellType::LINE3) ==
463 static_cast<int>(MeshLib::CellType::LINE3) &&
464 static_cast<int>(ExpectedCellType::TRI3) ==
465 static_cast<int>(MeshLib::CellType::TRI3) &&
466 static_cast<int>(ExpectedCellType::TRI6) ==
467 static_cast<int>(MeshLib::CellType::TRI6) &&
468 static_cast<int>(ExpectedCellType::QUAD4) ==
469 static_cast<int>(MeshLib::CellType::QUAD4) &&
470 static_cast<int>(ExpectedCellType::QUAD8) ==
471 static_cast<int>(MeshLib::CellType::QUAD8) &&
472 static_cast<int>(ExpectedCellType::QUAD9) ==
473 static_cast<int>(MeshLib::CellType::QUAD9) &&
474 static_cast<int>(ExpectedCellType::TET4) ==
475 static_cast<int>(MeshLib::CellType::TET4) &&
476 static_cast<int>(ExpectedCellType::TET10) ==
477 static_cast<int>(MeshLib::CellType::TET10) &&
478 static_cast<int>(ExpectedCellType::HEX8) ==
479 static_cast<int>(MeshLib::CellType::HEX8) &&
480 static_cast<int>(ExpectedCellType::HEX20) ==
481 static_cast<int>(MeshLib::CellType::HEX20) &&
482 static_cast<int>(ExpectedCellType::HEX27) ==
483 static_cast<int>(MeshLib::CellType::HEX27) &&
484 static_cast<int>(ExpectedCellType::PRISM6) ==
485 static_cast<int>(MeshLib::CellType::PRISM6) &&
486 static_cast<int>(ExpectedCellType::PRISM15) ==
487 static_cast<int>(MeshLib::CellType::PRISM15) &&
488 static_cast<int>(ExpectedCellType::PRISM18) ==
489 static_cast<int>(MeshLib::CellType::PRISM18) &&
490 static_cast<int>(ExpectedCellType::PYRAMID5) ==
491 static_cast<int>(MeshLib::CellType::PYRAMID5) &&
492 static_cast<int>(ExpectedCellType::PYRAMID13) ==
493 static_cast<int>(MeshLib::CellType::PYRAMID13);
494 // This error should never occur unless someone has changed the
495 // MeshLib::CellType enum class. These assertions ensure that the
496 // array 'element_configs_array' is up to date.
497 if (!are_expected_cell_types)
498 {
499 OGS_FATAL(
500 "The enum class MeshLib::CellType has changed. Please adapt the "
501 "array 'element_configs_array' in NodeReordering.cpp accordingly.");
502 }
503
504 TCLAP::CmdLine cmd(
505 "Reorders mesh nodes in elements to make old or incorrectly ordered "
506 "meshes compatible with OGS6.\n"
507 "Three options are available:\n"
508 "Method 0: Reversing order of nodes and checking again for all "
509 "elements.\n"
510 "Method 1: Reversing order of nodes unless it's perceived correct by "
511 "OGS6 standards. This is the default selection.\n"
512 "Method 2: Fixing node ordering issues between VTK and OGS6 (only "
513 "applies to prism-elements)\n"
514 "Method 3: Re-ordering of mesh node vector such that all base nodes "
515 "are sorted before all nonlinear nodes.\n\n"
516 "OpenGeoSys-6 software, version " +
517 GitInfoLib::GitInfo::ogs_version +
518 ".\n"
519 "Copyright (c) 2012-2025, OpenGeoSys Community "
520 "(http://www.opengeosys.org)",
521 ' ', GitInfoLib::GitInfo::ogs_version);
522
523 std::vector<int> method_ids{0, 1, 2, 3};
524 TCLAP::ValuesConstraint<int> allowed_values(method_ids);
525 TCLAP::ValueArg<int> method_arg("m", "method",
526 "reordering method selection", false, 1,
527 &allowed_values);
528 cmd.add(method_arg);
529 TCLAP::ValueArg<std::string> output_mesh_arg(
530 "o", "output_mesh", "Output (.vtu). The name of the output mesh file",
531 true, "", "OUTPUT_FILE");
532 cmd.add(output_mesh_arg);
533 TCLAP::ValueArg<std::string> input_mesh_arg(
534 "i", "input_mesh",
535 "Input (.vtu | .vtk | .msh). The name of the input mesh file", true, "",
536 "INPUT_FILE");
537 cmd.add(input_mesh_arg);
538 auto log_level_arg = BaseLib::makeLogLevelArg();
539 cmd.add(log_level_arg);
540 cmd.parse(argc, argv);
541
542 BaseLib::MPI::Setup mpi_setup(argc, argv);
543 BaseLib::initOGSLogger(log_level_arg.getValue());
544
545 std::unique_ptr<MeshLib::Mesh> mesh(
546 MeshLib::IO::readMeshFromFile(input_mesh_arg.getValue()));
547
548 if (!mesh)
549 {
550 return EXIT_FAILURE;
551 }
552
553 INFO("Reordering nodes... ");
554 if (!method_arg.isSet() || method_arg.getValue() < 2)
555 {
556 bool const forced = (method_arg.getValue() == 0);
557
558 if (forced)
559 {
560 INFO("Method 0: Reversing order of nodes will be checked again.");
561 }
562 INFO(
563 "Method: Reversing order of nodes unless it is considered correct "
564 "by the OGS6 standard, i.e. such that det(J) > 0, where J is the "
565 "Jacobian of the global-to-local coordinate transformation.");
566 int const mesh_space_dimension =
567 MeshLib::getSpaceDimension(mesh->getNodes());
568 reverseNodeOrder(
569 const_cast<std::vector<MeshLib::Element*>&>(mesh->getElements()),
570 mesh_space_dimension, forced);
571 }
572 else if (method_arg.getValue() == 2)
573 {
574 fixVtkInconsistencies(
575 const_cast<std::vector<MeshLib::Element*>&>(mesh->getElements()));
576 }
577 else if (method_arg.getValue() == 3)
578 {
579 reorderNonlinearNodes(*mesh);
580 }
581
582 MeshLib::IO::writeMeshToFile(*mesh, output_mesh_arg.getValue());
583
584 INFO("VTU file written.");
585
586 return EXIT_SUCCESS;
587}
INFO
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:36
reverseNodeOrder
void reverseNodeOrder(std::vector< MeshLib::Element * > &elements, int const mesh_space_dimension, bool const forced)
Reverses order of nodes. In particular, this fixes issues between (Gmsh or OGS5) and OGS6 meshes.
Definition NodeReordering.cpp:292
fixVtkInconsistencies
void fixVtkInconsistencies(std::vector< MeshLib::Element * > &elements)
Definition NodeReordering.cpp:369
reorderNonlinearNodes
void reorderNonlinearNodes(MeshLib::Mesh &mesh)
Orders the base nodes of each elements before its non-linear nodes.
Definition NodeReordering.cpp:393
BaseLib::makeLogLevelArg
TCLAP::ValueArg< std::string > makeLogLevelArg()
Definition TCLAPArguments.cpp:17
BaseLib::initOGSLogger
void initOGSLogger(std::string const &log_level)
Definition Logging.cpp:64
GitInfoLib::GitInfo::ogs_version
GITINFOLIB_EXPORT const std::string ogs_version
MeshLib::IO::readMeshFromFile
MeshLib::Mesh * readMeshFromFile(const std::string &file_name, bool const compute_element_neighbors)
Definition readMeshFromFile.cpp:68
MeshLib::IO::writeMeshToFile
int writeMeshToFile(const MeshLib::Mesh &mesh, std::filesystem::path const &file_path, std::set< std::string > variable_output_names)
Definition writeMeshToFile.cpp:24
MeshLib::getSpaceDimension
int getSpaceDimension(std::vector< Node * > const &nodes)
Computes dimension of the embedding space containing the set of given points.
Definition GetSpaceDimension.cpp:23

References MeshLib::enum_length, enum_length, fixVtkInconsistencies(), MeshLib::getSpaceDimension(), MeshLib::HEX20, MeshLib::HEX27, MeshLib::HEX8, INFO(), BaseLib::initOGSLogger(), MeshLib::INVALID, INVALID, MeshLib::LINE2, MeshLib::LINE3, BaseLib::makeLogLevelArg(), OGS_FATAL, GitInfoLib::GitInfo::ogs_version, MeshLib::POINT1, MeshLib::PRISM15, MeshLib::PRISM18, MeshLib::PRISM6, MeshLib::PYRAMID13, MeshLib::PYRAMID5, MeshLib::QUAD4, MeshLib::QUAD8, MeshLib::QUAD9, MeshLib::IO::readMeshFromFile(), reorderNonlinearNodes(), reverseNodeOrder(), MeshLib::TET10, MeshLib::TET4, MeshLib::TRI3, MeshLib::TRI6, and MeshLib::IO::writeMeshToFile().

◆ makeElementConfig()

template<ShapeFunction ShapeFunc, int Dim>
ElementReorderConfigBase makeElementConfig ( std::array< double, Dim > xi,
std::function< void(MeshLib::Element &, const std::vector< MeshLib::Node * > &)> reorder )

Definition at line 105 of file NodeReordering.cpp.

109{
110 return ElementReorderConfigBase{
111 [xi](MeshLib::Element& e, int mesh_space_dimension,
112 bool check_reordered)
113 {
114 return checkJacobianDeterminant<ShapeFunc, Dim>(
115 e, mesh_space_dimension, xi, check_reordered);
116 },
117 reorder};
118}
checkJacobianDeterminant
bool checkJacobianDeterminant(MeshLib::Element const &e, int const mesh_space_dimension, std::array< double, Dim > const &xi, bool const check_reordered=false)
Definition NodeReordering.cpp:52

References checkJacobianDeterminant().

◆ reorderNonlinearNodes()

void reorderNonlinearNodes ( MeshLib::Mesh & mesh)

Orders the base nodes of each elements before its non-linear nodes.

Definition at line 393 of file NodeReordering.cpp.

394{
395 std::vector<MeshLib::Node*> base_nodes;
396 std::vector<MeshLib::Node*> nonlinear_nodes;
397 for (MeshLib::Element const* e : mesh.getElements())
398 {
399 for (unsigned i = 0; i < e->getNumberOfBaseNodes(); i++)
400 {
401 base_nodes.push_back(const_cast<MeshLib::Node*>(e->getNode(i)));
402 }
403 for (unsigned i = e->getNumberOfBaseNodes(); i < e->getNumberOfNodes();
404 i++)
405 {
406 nonlinear_nodes.push_back(
407 const_cast<MeshLib::Node*>(e->getNode(i)));
408 }
409 }
410
411 BaseLib::makeVectorUnique(base_nodes,
412 MeshLib::idsComparator<MeshLib::Node*>);
413 BaseLib::makeVectorUnique(nonlinear_nodes,
414 MeshLib::idsComparator<MeshLib::Node*>);
415
416 std::vector<MeshLib::Node*>& allnodes =
417 const_cast<std::vector<MeshLib::Node*>&>(mesh.getNodes());
418 allnodes.clear();
419
420 allnodes.insert(allnodes.end(), base_nodes.begin(), base_nodes.end());
421 allnodes.insert(allnodes.end(), nonlinear_nodes.begin(),
422 nonlinear_nodes.end());
423
424 mesh.resetNodeIDs();
425}
MeshLib::Mesh::getNodes
std::vector< Node * > const & getNodes() const
Get the nodes-vector for the mesh.
Definition Mesh.h:108
MeshLib::Mesh::getElements
std::vector< Element * > const & getElements() const
Get the element-vector for the mesh.
Definition Mesh.h:111
MeshLib::Mesh::resetNodeIDs
void resetNodeIDs()
Resets the IDs of all mesh-nodes to their position in the node vector.
Definition Mesh.cpp:160
BaseLib::makeVectorUnique
void makeVectorUnique(std::vector< T > &v)
Definition Algorithm.h:180
MeshLib::idsComparator
bool idsComparator(T const a, T const b)
Definition Mesh.h:208

References MeshLib::Mesh::getElements(), MeshLib::Mesh::getNodes(), MeshLib::idsComparator(), BaseLib::makeVectorUnique(), and MeshLib::Mesh::resetNodeIDs().

Referenced by main().

◆ reverseNodeOrder()

void reverseNodeOrder ( std::vector< MeshLib::Element * > & elements,
int const mesh_space_dimension,
bool const forced )

Reverses order of nodes. In particular, this fixes issues between (Gmsh or OGS5) and OGS6 meshes.

Parameters
elementsMesh elements whose nodes should be reordered
forcedIf true, nodes are reordered for all elements, if false it is first checked if the node order is correct according to OGS6 element definitions.

Definition at line 292 of file NodeReordering.cpp.

294{
295 std::size_t n_corrected_elements = 0;
296
297 for (auto* element : elements)
298 {
299 auto const cell_type = element->getCellType();
300
301 if (cell_type == MeshLib::CellType::INVALID)
302 {
303 OGS_FATAL("Element type `{:s}' does not exist.",
304 MeshLib::CellType2String(cell_type));
305 }
306 // This check is already done in MeshLib::readMeshFromFile(). Therefore,
307 // this is just a safeguard.
308 if (cell_type == MeshLib::CellType::HEX27 ||
309 cell_type == MeshLib::CellType::PRISM18)
310 {
311 OGS_FATAL("Element type `{:s}' is not supported in OGS.",
312 MeshLib::CellType2String(cell_type));
313 }
314
315 if (cell_type == MeshLib::CellType::POINT1)
316 {
317 continue;
318 }
319
320 const auto& element_config =
321 element_configs_array[static_cast<int>(cell_type)];
322
323 if (element_config.is_node_ordering_correct(
324 *element, mesh_space_dimension, false /*check_reordered*/))
325 {
326 continue;
327 }
328
329 // Save nodes before reordering
330 const unsigned nElemNodes = element->getNumberOfNodes();
331 std::vector<MeshLib::Node*> nodes(element->getNodes(),
332 element->getNodes() + nElemNodes);
333
334 double const element_volume_origin = element->computeVolume();
335
336 element_config.reorder_element_nodes(*element, nodes);
337
338 // Ensure that the element volume did not change.
339 double const element_volume = element->computeVolume();
340 // We use a fixed tolerance here because for very small elements the
341 // machine epsilon might be too small.
342 if (std::fabs(element_volume - element_volume_origin) > 1e-14)
343 {
344 OGS_FATAL(
345 "Reordering of element {:d} nodes failed as its volume changed "
346 "from {:.12e} to {:.12e}.",
347 element->getID(), element_volume_origin, element_volume);
348 }
349 // Element::computeVolume() uses the element vertecies to compute
350 // the element volume, so the change of edge nodes are not
351 // considered. Therefore, we need to additionally check the Jacobian
352 // determinant here if forced is true.
353 if (forced)
354 {
355 element_config.is_node_ordering_correct(
356 *element, mesh_space_dimension, true /*check_reordered*/);
357 }
358
359 ++n_corrected_elements;
360 }
361
362 INFO("Corrected {:d} elements.", n_corrected_elements);
363}
element_configs_array
static const std::array< ElementReorderConfigBase, static_cast< int >(MeshLib::CellType::enum_length)> element_configs_array
Definition NodeReordering.cpp:122
MeshLib::CellType2String
std::string CellType2String(const CellType t)
Given a MeshElemType this returns the appropriate string.
Definition MeshEnums.cpp:157

References MeshLib::CellType2String(), element_configs_array, MeshLib::HEX27, INFO(), MeshLib::INVALID, OGS_FATAL, MeshLib::POINT1, and MeshLib::PRISM18.

Referenced by main().

Variable Documentation

◆ element_configs_array

const std::array<ElementReorderConfigBase, static_cast<int>(MeshLib::CellType::enum_length)> element_configs_array
static

Definition at line 122 of file NodeReordering.cpp.

123{
124 auto swap_nodes_i_j = [](MeshLib::Element& element,
125 const std::vector<MeshLib::Node*>& nodes,
126 unsigned const i, unsigned const j)
127 {
128 element.setNode(i, nodes[j]);
129 element.setNode(j, nodes[i]);
130 };
131
132 auto order_nodes_quadratic_quad =
133 [swap_nodes_i_j](MeshLib::Element& element,
134 const std::vector<MeshLib::Node*>& nodes)
135 {
136 swap_nodes_i_j(element, nodes, 1, 3);
137 swap_nodes_i_j(element, nodes, 5, 6);
138 swap_nodes_i_j(element, nodes, 4, 7);
139 };
140
141 std::array<ElementReorderConfigBase,
142 static_cast<int>(MeshLib::CellType::enum_length)>
143 arr{};
144
145 arr[static_cast<int>(MeshLib::CellType::LINE2)] =
146 makeElementConfig<NumLib::ShapeLine2, 1>(
147 {0.5},
148 [&swap_nodes_i_j](MeshLib::Element& element,
149 const std::vector<MeshLib::Node*>& nodes)
150 { swap_nodes_i_j(element, nodes, 0, 1); });
151
152 arr[static_cast<int>(MeshLib::CellType::LINE3)] =
153 makeElementConfig<NumLib::ShapeLine3, 1>(
154 {0.5},
155 [&swap_nodes_i_j](MeshLib::Element& element,
156 const std::vector<MeshLib::Node*>& nodes)
157 { swap_nodes_i_j(element, nodes, 0, 1); });
158
159 arr[static_cast<int>(MeshLib::CellType::TRI3)] =
160 makeElementConfig<NumLib::ShapeTri3, 2>(
161 {1.0 / 3.0, 1.0 / 3.0},
162 [&swap_nodes_i_j](MeshLib::Element& element,
163 const std::vector<MeshLib::Node*>& nodes)
164 { swap_nodes_i_j(element, nodes, 1, 2); });
165
166 arr[static_cast<int>(MeshLib::CellType::TRI6)] =
167 makeElementConfig<NumLib::ShapeTri6, 2>(
168 {1.0 / 3.0, 1.0 / 3.0},
169 [&swap_nodes_i_j](MeshLib::Element& element,
170 const std::vector<MeshLib::Node*>& nodes)
171 {
172 swap_nodes_i_j(element, nodes, 1, 2);
173 swap_nodes_i_j(element, nodes, 3, 5);
174 });
175
176 arr[static_cast<int>(MeshLib::CellType::QUAD4)] =
177 makeElementConfig<NumLib::ShapeQuad4, 2>(
178 {0.0, 0.0},
179 [&swap_nodes_i_j](MeshLib::Element& element,
180 const std::vector<MeshLib::Node*>& nodes)
181 { swap_nodes_i_j(element, nodes, 0, 2); });
182
183 arr[static_cast<int>(MeshLib::CellType::QUAD8)] =
184 makeElementConfig<NumLib::ShapeQuad8, 2>(
185 {0.0, 0.0},
186 [&order_nodes_quadratic_quad](
187 MeshLib::Element& element,
188 const std::vector<MeshLib::Node*>& nodes)
189 { order_nodes_quadratic_quad(element, nodes); });
190 arr[static_cast<int>(MeshLib::CellType::QUAD9)] =
191 makeElementConfig<NumLib::ShapeQuad9, 2>(
192 {0.0, 0.0},
193 [&order_nodes_quadratic_quad](
194 MeshLib::Element& element,
195 const std::vector<MeshLib::Node*>& nodes)
196 { order_nodes_quadratic_quad(element, nodes); });
197 arr[static_cast<int>(MeshLib::CellType::TET4)] =
198 makeElementConfig<NumLib::ShapeTet4, 3>(
199 {0.25, 0.25, 0.25},
200 [&swap_nodes_i_j](MeshLib::Element& element,
201 const std::vector<MeshLib::Node*>& nodes)
202 { swap_nodes_i_j(element, nodes, 1, 2); });
203
204 arr[static_cast<int>(MeshLib::CellType::TET10)] =
205 makeElementConfig<NumLib::ShapeTet10, 3>(
206 {0.25, 0.25, 0.25},
207 [&swap_nodes_i_j](MeshLib::Element& element,
208 const std::vector<MeshLib::Node*>& nodes)
209 {
210 swap_nodes_i_j(element, nodes, 1, 2);
211 swap_nodes_i_j(element, nodes, 4, 6);
212 swap_nodes_i_j(element, nodes, 8, 9);
213 });
214 arr[static_cast<int>(MeshLib::CellType::PRISM6)] =
215 makeElementConfig<NumLib::ShapePrism6, 3>(
216 {1.0 / 3.0, 1.0 / 3.0, 0.5},
217 [&swap_nodes_i_j](MeshLib::Element& element,
218 const std::vector<MeshLib::Node*>& nodes)
219 {
220 swap_nodes_i_j(element, nodes, 1, 2);
221 swap_nodes_i_j(element, nodes, 4, 5);
222 });
223
224 arr[static_cast<int>(MeshLib::CellType::PRISM15)] =
225 makeElementConfig<NumLib::ShapePrism15, 3>(
226 {1.0 / 3.0, 1.0 / 3., 0.5},
227 [&swap_nodes_i_j](MeshLib::Element& element,
228 const std::vector<MeshLib::Node*>& nodes)
229 {
230 swap_nodes_i_j(element, nodes, 0, 3);
231 swap_nodes_i_j(element, nodes, 1, 4);
232 swap_nodes_i_j(element, nodes, 2, 5);
233 swap_nodes_i_j(element, nodes, 6, 9);
234 swap_nodes_i_j(element, nodes, 7, 10);
235 swap_nodes_i_j(element, nodes, 8, 11);
236 });
237
238 arr[static_cast<int>(MeshLib::CellType::PYRAMID5)] =
239 makeElementConfig<NumLib::ShapePyra5, 3>(
240 {0.25, 0.25, 0.5},
241 [&swap_nodes_i_j](MeshLib::Element& element,
242 const std::vector<MeshLib::Node*>& nodes)
243 { swap_nodes_i_j(element, nodes, 0, 2); });
244
245 arr[static_cast<int>(MeshLib::CellType::PYRAMID13)] =
246 makeElementConfig<NumLib::ShapePyra13, 3>(
247 {0.25, 0.25, 0.5},
248 [&swap_nodes_i_j](MeshLib::Element& element,
249 const std::vector<MeshLib::Node*>& nodes)
250 {
251 swap_nodes_i_j(element, nodes, 0, 2);
252 swap_nodes_i_j(element, nodes, 9, 11);
253 swap_nodes_i_j(element, nodes, 5, 6);
254 swap_nodes_i_j(element, nodes, 7, 8);
255 });
256 arr[static_cast<int>(MeshLib::CellType::HEX8)] =
257 makeElementConfig<NumLib::ShapeHex8, 3>(
258 {0.5, 0.5, 0.5},
259 [&swap_nodes_i_j](MeshLib::Element& element,
260 const std::vector<MeshLib::Node*>& nodes)
261 {
262 swap_nodes_i_j(element, nodes, 0, 2);
263 swap_nodes_i_j(element, nodes, 4, 6);
264 });
265
266 arr[static_cast<int>(MeshLib::CellType::HEX20)] =
267 makeElementConfig<NumLib::ShapeHex20, 3>(
268 {0.5, 0.5, 0.5},
269 [&swap_nodes_i_j](MeshLib::Element& element,
270 const std::vector<MeshLib::Node*>& nodes)
271 {
272 swap_nodes_i_j(element, nodes, 0, 2);
273 swap_nodes_i_j(element, nodes, 4, 6);
274 swap_nodes_i_j(element, nodes, 16, 18);
275 swap_nodes_i_j(element, nodes, 8, 9);
276 swap_nodes_i_j(element, nodes, 10, 11);
277 swap_nodes_i_j(element, nodes, 12, 13);
278 swap_nodes_i_j(element, nodes, 14, 15);
279 });
280 return arr;
281}();
makeElementConfig
ElementReorderConfigBase makeElementConfig(std::array< double, Dim > xi, std::function< void(MeshLib::Element &, const std::vector< MeshLib::Node * > &)> reorder)
Definition NodeReordering.cpp:105
MeshLib::Element::setNode
virtual void setNode(unsigned idx, Node *node)=0

Referenced by reverseNodeOrder().