TTK
Loading...
Searching...
No Matches
Triangulation.h
Go to the documentation of this file.
1
34
35#pragma once
36
37// base code includes
43
44#include <array>
45
46namespace ttk {
47
48 class Triangulation final : public AbstractTriangulation {
49
50 public:
53 Triangulation(Triangulation &&) noexcept;
56 ~Triangulation() override;
57
58 enum class Type {
65 };
66
70 enum class STRATEGY {
74 DEFAULT = 0,
79 };
80
83 inline int clear() {
84
87 }
88
89 return 0;
90 }
91
94 inline size_t footprint() const {
95
98 }
99
100 return 0;
101 }
102
124 inline int getCellEdge(const SimplexId &cellId,
125 const int &localEdgeId,
126 SimplexId &edgeId) const override {
127
128 // initialize output variable before early return
129 edgeId = -1;
130
131#ifndef TTK_ENABLE_KAMIKAZE
132 if(isEmptyCheck())
133 return -1;
134#endif
135
136 return abstractTriangulation_->getCellEdge(cellId, localEdgeId, edgeId);
137 }
138
155 inline SimplexId getCellEdgeNumber(const SimplexId &cellId) const override {
156#ifndef TTK_ENABLE_KAMIKAZE
157 if(isEmptyCheck())
158 return -1;
159#endif
161 }
162
191 inline const std::vector<std::vector<SimplexId>> *getCellEdges() override {
192#ifndef TTK_ENABLE_KAMIKAZE
193 if(isEmptyCheck())
194 return nullptr;
195#endif
197 }
198
199 inline int
200 getCellIncenter(SimplexId cellId, int dim, float incenter[3]) const {
201#ifndef TTK_ENABLE_KAMIKAZE
202 if(isEmptyCheck())
203 return -1;
204#endif
205 return abstractTriangulation_->getCellIncenter(cellId, dim, incenter);
206 }
207
227 inline int getCellNeighbor(const SimplexId &cellId,
228 const int &localNeighborId,
229 SimplexId &neighborId) const override {
230
231 // initialize output variable before early return
232 neighborId = -1;
233#ifndef TTK_ENABLE_KAMIKAZE
234 if(isEmptyCheck())
235 return -1;
236#endif
238 cellId, localNeighborId, neighborId);
239 }
240
255 inline SimplexId
256 getCellNeighborNumber(const SimplexId &cellId) const override {
257
258#ifndef TTK_ENABLE_KAMIKAZE
259 if(isEmptyCheck())
260 return -1;
261#endif
263 }
264
290 inline const std::vector<std::vector<SimplexId>> *
291 getCellNeighbors() override {
292#ifndef TTK_ENABLE_KAMIKAZE
293 if(isEmptyCheck())
294 return nullptr;
295#endif
297 }
298
321 inline int getCellTriangle(const SimplexId &cellId,
322 const int &localTriangleId,
323 SimplexId &triangleId) const override {
324
325#ifndef TTK_ENABLE_KAMIKAZE
326 // initialize output variable before early return
327 triangleId = -1;
328
329 if(isEmptyCheck())
330 return -1;
331#endif
333 cellId, localTriangleId, triangleId);
334 }
335
353 inline SimplexId
354 getCellTriangleNumber(const SimplexId &cellId) const override {
355#ifndef TTK_ENABLE_KAMIKAZE
356 if(isEmptyCheck())
357 return -1;
358#endif
360 }
361
393 inline const std::vector<std::vector<SimplexId>> *
394 getCellTriangles() override {
395#ifndef TTK_ENABLE_KAMIKAZE
396 if(isEmptyCheck())
397 return nullptr;
398#endif
400 }
401
413 inline int getCellVertex(const SimplexId &cellId,
414 const int &localVertexId,
415 SimplexId &vertexId) const override {
416
417#ifndef TTK_ENABLE_KAMIKAZE
418 // initialize output variable before early return
419 vertexId = -1;
420
421 if(isEmptyCheck())
422 return -1;
423#endif
424
426 cellId, localVertexId, vertexId);
427 }
428
435 inline SimplexId
436 getCellVertexNumber(const SimplexId &cellId) const override {
437
438#ifndef TTK_ENABLE_KAMIKAZE
439 if(isEmptyCheck())
440 return -1;
441#endif
443 }
444
448 inline int getDimensionality() const override {
449#ifndef TTK_ENABLE_KAMIKAZE
450 if(isEmptyCheck())
451 return -1;
452#endif
454 }
455
480 inline const std::vector<std::array<SimplexId, 2>> *getEdges() override {
481#ifndef TTK_ENABLE_KAMIKAZE
482 if(isEmptyCheck())
483 return nullptr;
484#endif
486 }
487
499 inline int getEdgeIncenter(SimplexId edgeId, float incenter[3]) const {
500#ifndef TTK_ENABLE_KAMIKAZE
501 if(isEmptyCheck())
502 return -1;
503#endif
504 return abstractTriangulation_->getEdgeIncenter(edgeId, incenter);
505 }
506
518 inline int getTriangleIncenter(SimplexId triangleId,
519 float incenter[3]) const {
520#ifndef TTK_ENABLE_KAMIKAZE
521 if(isEmptyCheck())
522 return -1;
523#endif
524 return abstractTriangulation_->getTriangleIncenter(triangleId, incenter);
525 }
526
546 inline int getEdgeLink(const SimplexId &edgeId,
547 const int &localLinkId,
548 SimplexId &linkId) const override {
549#ifndef TTK_ENABLE_KAMIKAZE
550 // initialize output variable before early return
551 linkId = -1;
552
553 if(isEmptyCheck())
554 return -1;
555#endif
556 return abstractTriangulation_->getEdgeLink(edgeId, localLinkId, linkId);
557 }
558
573 inline SimplexId getEdgeLinkNumber(const SimplexId &edgeId) const override {
574#ifndef TTK_ENABLE_KAMIKAZE
575 if(isEmptyCheck())
576 return -1;
577#endif
579 }
580
604 inline const std::vector<std::vector<SimplexId>> *getEdgeLinks() override {
605#ifndef TTK_ENABLE_KAMIKAZE
606 if(isEmptyCheck())
607 return nullptr;
608#endif
610 }
611
634 inline int getEdgeStar(const SimplexId &edgeId,
635 const int &localStarId,
636 SimplexId &starId) const override {
637#ifndef TTK_ENABLE_KAMIKAZE
638 // initialize output variable before early return
639 starId = -1;
640
641 if(isEmptyCheck())
642 return -1;
643#endif
644 return abstractTriangulation_->getEdgeStar(edgeId, localStarId, starId);
645 }
646
664 inline SimplexId getEdgeStarNumber(const SimplexId &edgeId) const override {
665#ifndef TTK_ENABLE_KAMIKAZE
666 if(isEmptyCheck())
667 return -1;
668#endif
670 }
671
700 inline const std::vector<std::vector<SimplexId>> *getEdgeStars() override {
701#ifndef TTK_ENABLE_KAMIKAZE
702 if(isEmptyCheck())
703 return nullptr;
704#endif
706 }
707
727 inline int getEdgeTriangle(const SimplexId &edgeId,
728 const int &localTriangleId,
729 SimplexId &triangleId) const override {
730
731#ifndef TTK_ENABLE_KAMIKAZE
732 // initialize output variable before early return
733 triangleId = -1;
734
735 if(isEmptyCheck())
736 return -1;
737#endif
739 edgeId, localTriangleId, triangleId);
740 }
741
756 inline SimplexId
757 getEdgeTriangleNumber(const SimplexId &edgeId) const override {
758#ifndef TTK_ENABLE_KAMIKAZE
759 if(isEmptyCheck())
760 return -1;
761#endif
763 }
764
790 inline const std::vector<std::vector<SimplexId>> *
791 getEdgeTriangles() override {
792#ifndef TTK_ENABLE_KAMIKAZE
793 if(isEmptyCheck())
794 return nullptr;
795#endif
797 }
798
816 inline int getEdgeVertex(const SimplexId &edgeId,
817 const int &localVertexId,
818 SimplexId &vertexId) const override {
819#ifndef TTK_ENABLE_KAMIKAZE
820 // initialize output variable before early return
821 vertexId = -1;
822
823 if(isEmptyCheck())
824 return -1;
825#endif
827 edgeId, localVertexId, vertexId);
828 }
829
834 }
835
841 inline SimplexId getNumberOfCells() const override {
842
843#ifndef TTK_ENABLE_KAMIKAZE
844 if(isEmptyCheck())
845 return -1;
846#endif
847
849 }
850
864 inline SimplexId getNumberOfEdges() const override {
865#ifndef TTK_ENABLE_KAMIKAZE
866 if(isEmptyCheck())
867 return -1;
868#endif
870 }
871
885 inline SimplexId getNumberOfTriangles() const override {
886#ifndef TTK_ENABLE_KAMIKAZE
887
888 if(isEmptyCheck())
889 return -1;
890#endif
892 }
893
896 inline SimplexId getNumberOfVertices() const override {
897
898#ifndef TTK_ENABLE_KAMIKAZE
899 if(isEmptyCheck())
900 return -1;
901#endif
903 }
904
911 int getTetraIncenter(SimplexId tetraId, float incenter[3]) const {
912#ifndef TTK_ENABLE_KAMIKAZE
913 if(isEmptyCheck())
914 return -1;
915#endif
916 return abstractTriangulation_->getTetraIncenter(tetraId, incenter);
917 }
918
943 inline const std::vector<std::array<SimplexId, 3>> *
944 getTriangles() override {
945#ifndef TTK_ENABLE_KAMIKAZE
946 if(isEmptyCheck())
947 return nullptr;
948#endif
950 }
951
970 inline int getTriangleEdge(const SimplexId &triangleId,
971 const int &localEdgeId,
972 SimplexId &edgeId) const override {
973#ifndef TTK_ENABLE_KAMIKAZE
974 // initialize output variable before early return
975 edgeId = -1;
976
977 if(isEmptyCheck())
978 return -1;
979#endif
981 triangleId, localEdgeId, edgeId);
982 }
983
998 inline SimplexId
999 getTriangleEdgeNumber(const SimplexId &triangleId) const override {
1000#ifndef TTK_ENABLE_KAMIKAZE
1001 if(isEmptyCheck())
1002 return -1;
1003#endif
1005 }
1006
1032 inline const std::vector<std::vector<SimplexId>> *
1033 getTriangleEdges() override {
1034#ifndef TTK_ENABLE_KAMIKAZE
1035 if(isEmptyCheck())
1036 return nullptr;
1037#endif
1039 }
1040
1060 inline int getTriangleLink(const SimplexId &triangleId,
1061 const int &localLinkId,
1062 SimplexId &linkId) const override {
1063#ifndef TTK_ENABLE_KAMIKAZE
1064 // initialize output variable before early return
1065 linkId = -1;
1066
1067 if(isEmptyCheck())
1068 return -1;
1069#endif
1071 triangleId, localLinkId, linkId);
1072 }
1073
1089 inline SimplexId
1090 getTriangleLinkNumber(const SimplexId &triangleId) const override {
1091#ifndef TTK_ENABLE_KAMIKAZE
1092 if(isEmptyCheck())
1093 return -1;
1094#endif
1096 }
1097
1122 inline const std::vector<std::vector<SimplexId>> *
1123 getTriangleLinks() override {
1124#ifndef TTK_ENABLE_KAMIKAZE
1125 if(isEmptyCheck())
1126 return nullptr;
1127#endif
1129 }
1130
1151 inline int getTriangleStar(const SimplexId &triangleId,
1152 const int &localStarId,
1153 SimplexId &starId) const override {
1154#ifndef TTK_ENABLE_KAMIKAZE
1155 // initialize output variable before early return
1156 starId = -1;
1157
1158 if(isEmptyCheck())
1159 return -1;
1160#endif
1162 triangleId, localStarId, starId);
1163 }
1164
1179 inline SimplexId
1180 getTriangleStarNumber(const SimplexId &triangleId) const override {
1181#ifndef TTK_ENABLE_KAMIKAZE
1182 if(isEmptyCheck())
1183 return -1;
1184#endif
1186 }
1187
1213 inline const std::vector<std::vector<SimplexId>> *
1214 getTriangleStars() override {
1215#ifndef TTK_ENABLE_KAMIKAZE
1216 if(isEmptyCheck())
1217 return nullptr;
1218#endif
1220 }
1221
1239 inline int getTriangleVertex(const SimplexId &triangleId,
1240 const int &localVertexId,
1241 SimplexId &vertexId) const override {
1242
1243#ifndef TTK_ENABLE_KAMIKAZE
1244 // initialize output variable before early return
1245 vertexId = -1;
1246
1247 if(isEmptyCheck())
1248 return -1;
1249#endif
1251 triangleId, localVertexId, vertexId);
1252 }
1253
1270 else
1272 }
1273
1294 inline int getVertexEdge(const SimplexId &vertexId,
1295 const int &localEdgeId,
1296 SimplexId &edgeId) const override {
1297
1298#ifndef TTK_ENABLE_KAMIKAZE
1299 // initialize output variable before early return
1300 edgeId = -1;
1301
1302 if(isEmptyCheck())
1303 return -1;
1304#endif
1306 vertexId, localEdgeId, edgeId);
1307 }
1308
1323 inline SimplexId
1324 getVertexEdgeNumber(const SimplexId &vertexId) const override {
1325#ifndef TTK_ENABLE_KAMIKAZE
1326 if(isEmptyCheck())
1327 return -1;
1328#endif
1330 }
1331
1358 inline const std::vector<std::vector<SimplexId>> *
1359 getVertexEdges() override {
1360#ifndef TTK_ENABLE_KAMIKAZE
1361 if(isEmptyCheck())
1362 return nullptr;
1363#endif
1364 if(getDimensionality() == 1)
1366
1368 }
1369
1370#ifdef TTK_ENABLE_MPI
1371
1383 inline SimplexId getVertexGlobalId(const SimplexId lvid) const override {
1384#ifndef TTK_ENABLE_KAMIKAZE
1385 if(isEmptyCheck())
1386 return -1;
1387#endif
1388 return abstractTriangulation_->getVertexGlobalId(lvid);
1389 }
1390
1402 inline std::unordered_map<SimplexId, SimplexId> &getVertexGlobalIdMap() {
1403 return this->explicitTriangulation_.getVertexGlobalIdMap();
1404 }
1405
1408 inline void setHasPreconditionedDistributedVertices(bool flag) override {
1409 abstractTriangulation_->setHasPreconditionedDistributedVertices(flag);
1410 }
1411
1412 inline bool hasPreconditionedDistributedCells() const override {
1413 return abstractTriangulation_->hasPreconditionedDistributedCells();
1414 }
1415 inline bool hasPreconditionedDistributedVertices() const override {
1416 return abstractTriangulation_->hasPreconditionedDistributedVertices();
1417 }
1418
1419 inline const std::vector<int> &getNeighborRanks() const override {
1420 return abstractTriangulation_->getNeighborRanks();
1421 }
1422 inline std::vector<int> &getNeighborRanks() override {
1423 return abstractTriangulation_->getNeighborRanks();
1424 }
1425
1426 inline const std::vector<std::array<ttk::SimplexId, 6>> &
1427 getNeighborVertexBBoxes() const override {
1428 return abstractTriangulation_->getNeighborVertexBBoxes();
1429 }
1430
1431 inline const std::vector<std::vector<SimplexId>> &
1432 getGhostCellsPerOwner() const override {
1433 return abstractTriangulation_->getGhostCellsPerOwner();
1434 }
1435
1436 inline const std::vector<std::vector<SimplexId>> &
1437 getRemoteGhostCells() const override {
1438 return abstractTriangulation_->getRemoteGhostCells();
1439 }
1440
1441 inline int getVertexRank(const SimplexId lvid) const override {
1442 return this->abstractTriangulation_->getVertexRank(lvid);
1443 }
1444
1456 inline SimplexId getVertexLocalId(const SimplexId geid) const override {
1457#ifndef TTK_ENABLE_KAMIKAZE
1458 if(isEmptyCheck())
1459 return -1;
1460#endif
1461 return abstractTriangulation_->getVertexLocalId(geid);
1462 }
1463
1474 inline void createMetaGrid(const double *const bounds) {
1475 this->implicitPreconditionsTriangulation_.createMetaGrid(bounds);
1476 this->periodicImplicitTriangulation_.createMetaGrid(bounds);
1477 this->implicitTriangulation_.createMetaGrid(bounds);
1478 this->periodicPreconditionsTriangulation_.createMetaGrid(bounds);
1479 // also pass bounding box to ExplicitTriangulation...
1480 this->explicitTriangulation_.setBoundingBox(bounds);
1481 }
1482
1483 inline void setIsBoundaryPeriodic(std::array<unsigned char, 6> boundary) {
1484 this->periodicImplicitTriangulation_.setIsBoundaryPeriodic(boundary);
1485 this->periodicPreconditionsTriangulation_.setIsBoundaryPeriodic(boundary);
1486 }
1487
1496 inline int getDistributedGlobalCellId(const ttk::SimplexId &localCellId,
1497 const int &cellDim,
1498 ttk::SimplexId &globalCellId) const {
1499#ifndef TTK_ENABLE_KAMIKAZE
1500 if(isEmptyCheck())
1501 return -1;
1502#endif
1503 return this->abstractTriangulation_->getDistributedGlobalCellId(
1504 localCellId, cellDim, globalCellId);
1505 }
1506
1507#endif // TTK_ENABLE_MPI
1508
1528 inline int getVertexLink(const SimplexId &vertexId,
1529 const int &localLinkId,
1530 SimplexId &linkId) const override {
1531
1532#ifndef TTK_ENABLE_KAMIKAZE
1533 // initialize output variable before early return
1534 linkId = -1;
1535
1536 if(isEmptyCheck())
1537 return -1;
1538#endif
1540 vertexId, localLinkId, linkId);
1541 }
1542
1557 inline SimplexId
1558 getVertexLinkNumber(const SimplexId &vertexId) const override {
1559
1560#ifndef TTK_ENABLE_KAMIKAZE
1561 if(isEmptyCheck())
1562 return -1;
1563#endif
1565 }
1566
1591 inline const std::vector<std::vector<SimplexId>> *
1592 getVertexLinks() override {
1593
1594#ifndef TTK_ENABLE_KAMIKAZE
1595 if(isEmptyCheck())
1596 return nullptr;
1597#endif
1599 }
1600
1617 inline int getVertexNeighbor(const SimplexId &vertexId,
1618 const int &localNeighborId,
1619 SimplexId &neighborId) const override {
1620
1621#ifndef TTK_ENABLE_KAMIKAZE
1622 // initialize output variable before early return
1623 neighborId = -1;
1624
1625 if(isEmptyCheck())
1626 return -1;
1627#endif
1629 vertexId, localNeighborId, neighborId);
1630 }
1631
1643 inline SimplexId
1644 getVertexNeighborNumber(const SimplexId &vertexId) const override {
1645
1646#ifndef TTK_ENABLE_KAMIKAZE
1647 if(isEmptyCheck())
1648 return -1;
1649#endif
1651 }
1652
1676 inline const std::vector<std::vector<SimplexId>> *
1678#ifndef TTK_ENABLE_KAMIKAZE
1679 if(isEmptyCheck())
1680 return nullptr;
1681#endif
1683 }
1684
1691 inline int getVertexPoint(const SimplexId &vertexId,
1692 float &x,
1693 float &y,
1694 float &z) const override {
1695
1696#ifndef TTK_ENABLE_KAMIKAZE
1697 // initialize output variables before early return
1698 x = NAN;
1699 y = NAN;
1700 z = NAN;
1701
1702 if(isEmptyCheck())
1703 return -1;
1704#endif
1705 return abstractTriangulation_->getVertexPoint(vertexId, x, y, z);
1706 }
1707
1728 inline int getVertexStar(const SimplexId &vertexId,
1729 const int &localStarId,
1730 SimplexId &starId) const override {
1731
1732#ifndef TTK_ENABLE_KAMIKAZE
1733 // initialize output variable before early return
1734 starId = -1;
1735
1736 if(isEmptyCheck())
1737 return -1;
1738#endif
1740 vertexId, localStarId, starId);
1741 }
1742
1757 inline SimplexId
1758 getVertexStarNumber(const SimplexId &vertexId) const override {
1759#ifndef TTK_ENABLE_KAMIKAZE
1760 if(isEmptyCheck())
1761 return -1;
1762#endif
1764 }
1765
1791 inline const std::vector<std::vector<SimplexId>> *
1792 getVertexStars() override {
1793#ifndef TTK_ENABLE_KAMIKAZE
1794 if(isEmptyCheck())
1795 return nullptr;
1796#endif
1798 }
1799
1820 inline int getVertexTriangle(const SimplexId &vertexId,
1821 const int &localTriangleId,
1822 SimplexId &triangleId) const override {
1823
1824#ifndef TTK_ENABLE_KAMIKAZE
1825 // initialize output variable before early return
1826 triangleId = -1;
1827
1828 if(isEmptyCheck())
1829 return -1;
1830#endif
1832 vertexId, localTriangleId, triangleId);
1833 }
1834
1849 inline SimplexId
1850 getVertexTriangleNumber(const SimplexId &vertexId) const override {
1851
1852#ifndef TTK_ENABLE_KAMIKAZE
1853 if(isEmptyCheck())
1854 return -1;
1855#endif
1857 }
1858
1884 inline const std::vector<std::vector<SimplexId>> *
1886
1887#ifndef TTK_ENABLE_KAMIKAZE
1888 if(isEmptyCheck())
1889 return nullptr;
1890#endif
1892 }
1893
1913 inline bool isEdgeOnBoundary(const SimplexId &edgeId) const override {
1914#ifndef TTK_ENABLE_KAMIKAZE
1915 if(isEmptyCheck())
1916 return false;
1917#endif
1919 }
1920
1923 inline bool isEmpty() const override {
1924 return !abstractTriangulation_;
1925 }
1926
1930 inline bool isManifold() const override {
1931#ifndef TTK_ENABLE_KAMIKAZE
1932 if(this->isEmptyCheck()) {
1933 return true;
1934 }
1935#endif // TTK_ENABLE_KAMIKAZE
1936 return this->abstractTriangulation_->isManifold();
1937 }
1938
1959 inline int preconditionManifold() override {
1960#ifndef TTK_ENABLE_KAMIKAZE
1961 if(this->isEmptyCheck())
1962 return false;
1963#endif // TTK_ENABLE_KAMIKAZE
1965 }
1966
1987 inline bool
1988 isTriangleOnBoundary(const SimplexId &triangleId) const override {
1989#ifndef TTK_ENABLE_KAMIKAZE
1990 if(isEmptyCheck())
1991 return false;
1992#endif
1993 return abstractTriangulation_->isTriangleOnBoundary(triangleId);
1994 }
1995
2013 inline bool isVertexOnBoundary(const SimplexId &vertexId) const override {
2014#ifndef TTK_ENABLE_KAMIKAZE
2015 if(isEmptyCheck())
2016 return false;
2017#endif
2019 }
2020
2034 inline int preconditionBoundaryEdges() override {
2035#ifndef TTK_ENABLE_KAMIKAZE
2036 if(isEmptyCheck())
2037 return -1;
2038#endif
2040 }
2041
2055 inline int preconditionBoundaryTriangles() override {
2056#ifndef TTK_ENABLE_KAMIKAZE
2057 if(isEmptyCheck())
2058 return -1;
2059#endif
2060
2062 }
2063
2077 inline int preconditionBoundaryVertices() override {
2078#ifndef TTK_ENABLE_KAMIKAZE
2079 if(isEmptyCheck())
2080 return -1;
2081#endif
2083 }
2084
2100 inline int preconditionCellEdges() override {
2101#ifndef TTK_ENABLE_KAMIKAZE
2102 if(isEmptyCheck())
2103 return -1;
2104#endif
2105
2107 }
2108
2126 inline int preconditionCellNeighbors() override {
2127
2128#ifndef TTK_ENABLE_KAMIKAZE
2129 if(isEmptyCheck())
2130 return -1;
2131#endif
2133 }
2134
2152 inline int preconditionCellTriangles() override {
2153
2154#ifndef TTK_ENABLE_KAMIKAZE
2155 if(isEmptyCheck())
2156 return -1;
2157#endif
2159 }
2160
2178 inline int preconditionEdges() override {
2179
2180#ifndef TTK_ENABLE_KAMIKAZE
2181 if(isEmptyCheck())
2182 return -1;
2183#endif
2184
2186 }
2187
2205 inline int preconditionEdgeLinks() override {
2206
2207#ifndef TTK_ENABLE_KAMIKAZE
2208 if(isEmptyCheck())
2209 return -1;
2210#endif
2212 }
2213
2231 inline int preconditionEdgeStars() override {
2232
2233#ifndef TTK_ENABLE_KAMIKAZE
2234 if(isEmptyCheck())
2235 return -1;
2236#endif
2238 }
2239
2257 inline int preconditionEdgeTriangles() override {
2258
2259#ifndef TTK_ENABLE_KAMIKAZE
2260 if(isEmptyCheck())
2261 return -1;
2262#endif
2263
2265 }
2266
2284 inline int preconditionTriangles() override {
2285
2286#ifndef TTK_ENABLE_KAMIKAZE
2287 if(isEmptyCheck())
2288 return -1;
2289#endif
2291 }
2292
2310 inline int preconditionTriangleEdges() override {
2311
2312#ifndef TTK_ENABLE_KAMIKAZE
2313 if(isEmptyCheck())
2314 return -1;
2315#endif
2317 }
2318
2336 inline int preconditionTriangleLinks() override {
2337
2338#ifndef TTK_ENABLE_KAMIKAZE
2339 if(isEmptyCheck())
2340 return -1;
2341#endif
2343 }
2344
2362 inline int preconditionTriangleStars() override {
2363
2364#ifndef TTK_ENABLE_KAMIKAZE
2365 if(isEmptyCheck())
2366 return -1;
2367#endif
2368
2370 }
2371
2389 inline int preconditionVertexEdges() override {
2390
2391#ifndef TTK_ENABLE_KAMIKAZE
2392 if(isEmptyCheck())
2393 return -1;
2394#endif
2395
2397 }
2398
2409 inline int getCellVTKID(const int &ttkId, int &vtkId) const override {
2410
2411#ifndef TTK_ENABLE_KAMIKAZE
2412 if(isEmptyCheck())
2413 return -1;
2414#endif
2415
2416 return abstractTriangulation_->getCellVTKID(ttkId, vtkId);
2417 }
2418
2419#ifdef TTK_ENABLE_MPI
2437 inline int preconditionDistributedVertices() override {
2438
2439#ifndef TTK_ENABLE_KAMIKAZE
2440 if(isEmptyCheck())
2441 return -1;
2442#endif
2443 return abstractTriangulation_->preconditionDistributedVertices();
2444 }
2445
2446 inline int preconditionEdgeRankArray() override {
2447
2448#ifndef TTK_ENABLE_KAMIKAZE
2449 if(isEmptyCheck())
2450 return -1;
2451#endif
2452 return abstractTriangulation_->preconditionEdgeRankArray();
2453 }
2454
2455 inline int preconditionTriangleRankArray() override {
2456
2457#ifndef TTK_ENABLE_KAMIKAZE
2458 if(isEmptyCheck())
2459 return -1;
2460#endif
2461 return abstractTriangulation_->preconditionTriangleRankArray();
2462 }
2463
2464 inline int setVertexRankArray(const int *rankArray) override {
2465 return abstractTriangulation_->setVertexRankArray(rankArray);
2466 }
2467
2468 inline int setCellRankArray(const int *rankArray) override {
2469 return abstractTriangulation_->setCellRankArray(rankArray);
2470 }
2471
2482
2483 inline int preconditionGlobalBoundary() override {
2484#ifndef TTK_ENABLE_KAMIKAZE
2485 if(isEmptyCheck())
2486 return -1;
2487#endif
2488 return abstractTriangulation_->preconditionGlobalBoundary();
2489 }
2501 inline int preconditionDistributedCells() override {
2502
2503#ifndef TTK_ENABLE_KAMIKAZE
2504 if(isEmptyCheck())
2505 return -1;
2506#endif
2507 return abstractTriangulation_->preconditionDistributedCells();
2508 }
2509
2525 inline int preconditionExchangeGhostCells() override {
2526
2527#ifndef TTK_ENABLE_KAMIKAZE
2528 if(isEmptyCheck())
2529 return -1;
2530#endif
2531 return abstractTriangulation_->preconditionExchangeGhostCells();
2532 }
2533
2549 inline int preconditionExchangeGhostVertices() override {
2550
2551#ifndef TTK_ENABLE_KAMIKAZE
2552 if(isEmptyCheck())
2553 return -1;
2554#endif
2555 return abstractTriangulation_->preconditionExchangeGhostVertices();
2556 }
2557#endif // TTK_ENABLE_MPI
2558
2576 inline int preconditionVertexLinks() override {
2577
2578#ifndef TTK_ENABLE_KAMIKAZE
2579 if(isEmptyCheck())
2580 return -1;
2581#endif
2582
2584 }
2585
2603 inline int preconditionVertexNeighbors() override {
2604
2605#ifndef TTK_ENABLE_KAMIKAZE
2606 if(isEmptyCheck())
2607 return -1;
2608#endif
2610 }
2611
2629 inline int preconditionVertexStars() override {
2630
2631#ifndef TTK_ENABLE_KAMIKAZE
2632 if(isEmptyCheck())
2633 return -1;
2634#endif
2635
2637 }
2638
2656 inline int preconditionVertexTriangles() override {
2657
2658#ifndef TTK_ENABLE_KAMIKAZE
2659 if(isEmptyCheck())
2660 return -1;
2661#endif
2663 }
2664
2666 inline int setDebugLevel(const int &debugLevel) override {
2673 debugLevel_ = debugLevel;
2674 return 0;
2675 }
2676
2677 // Set the cache size
2678 inline int setCacheSize(const float &ratio) {
2681 }
2682 return 0;
2683 }
2684
2685#ifdef TTK_CELL_ARRAY_NEW
2705 inline int setInputCells(const SimplexId &cellNumber,
2706 const LongSimplexId *connectivity,
2707 const LongSimplexId *offset) {
2711 cellNumber, connectivity, offset);
2712 }
2713
2714 inline int setStellarInputCells(const SimplexId &cellNumber,
2715 const LongSimplexId *connectivity,
2716 const LongSimplexId *offset) {
2720 cellNumber, connectivity, offset);
2721 }
2722#else
2743 inline int setInputCells(const SimplexId &cellNumber,
2744 const LongSimplexId *cellArray) {
2747 return explicitTriangulation_.setInputCells(cellNumber, cellArray);
2748 }
2749
2750 inline int setStellarInputCells(const SimplexId &cellNumber,
2751 const LongSimplexId *cellArray) {
2752
2755
2756 return compactTriangulation_.setInputCells(cellNumber, cellArray);
2757 }
2758#endif
2779 inline int setInputGrid(const float &xOrigin,
2780 const float &yOrigin,
2781 const float &zOrigin,
2782 const float &xSpacing,
2783 const float &ySpacing,
2784 const float &zSpacing,
2785 const SimplexId &xDim,
2786 const SimplexId &yDim,
2787 const SimplexId &zDim) {
2788 gridDimensions_[0] = xDim;
2789 gridDimensions_[1] = yDim;
2790 gridDimensions_[2] = zDim;
2791
2792 int ret{};
2793
2795 xOrigin, yOrigin, zOrigin, xSpacing, ySpacing, zSpacing, xDim, yDim,
2796 zDim);
2798 xOrigin, yOrigin, zOrigin, xSpacing, ySpacing, zSpacing, xDim, yDim,
2799 zDim);
2800 ret |= implicitTriangulation_.setInputGrid(xOrigin, yOrigin, zOrigin,
2801 xSpacing, ySpacing, zSpacing,
2802 xDim, yDim, zDim);
2804 xOrigin, yOrigin, zOrigin, xSpacing, ySpacing, zSpacing, xDim, yDim,
2805 zDim);
2806 const auto useImplicitPreconditions = this->processImplicitStrategy();
2807
2808 this->switchGrid(this->hasPeriodicBoundaries_, useImplicitPreconditions);
2809 return ret;
2810 }
2811
2816 inline void
2817 setPeriodicBoundaryConditions(const bool &usePeriodicBoundaries) {
2818
2823 if(usePeriodicBoundaries == hasPeriodicBoundaries_) {
2824 return;
2825 }
2826 const auto hasPreconditions{this->hasImplicitPreconditions()};
2827
2828 this->switchGrid(usePeriodicBoundaries, hasPreconditions);
2829
2830 // reset hasPreconditioned boolean
2832 // but don't forget to set hasPeriodicBoundaries_
2833 hasPeriodicBoundaries_ = usePeriodicBoundaries;
2834 }
2835 }
2836
2841 inline void setImplicitPreconditions(const STRATEGY strategy) {
2846
2847 const auto useImplicitPreconditions
2848 = this->processImplicitStrategy(strategy);
2849
2850 if(useImplicitPreconditions == this->hasImplicitPreconditions()) {
2851 return;
2852 }
2853 const auto isPeriodic{this->hasPeriodicBoundaries_};
2854
2855 this->switchGrid(isPeriodic, useImplicitPreconditions);
2856
2857 // reset hasPreconditioned boolean
2859 // but don't forget to set hasImplicitPreconditions_
2860 hasPeriodicBoundaries_ = isPeriodic;
2861 }
2862 }
2863
2882 inline int setInputPoints(const SimplexId &pointNumber,
2883 const void *pointSet,
2884 const bool &doublePrecision = false) {
2885
2889 pointNumber, pointSet, doublePrecision);
2890 }
2891
2892 inline int setStellarInputPoints(const SimplexId &pointNumber,
2893 const void *pointSet,
2894 const int *indexArray,
2895 const bool &doublePrecision = false) {
2896
2900 pointNumber, pointSet, indexArray, doublePrecision);
2901 }
2902
2904 inline int setThreadNumber(const ThreadId threadNumber) override {
2911 threadNumber_ = threadNumber;
2912 return 0;
2913 }
2914
2917 inline int setWrapper(const Wrapper *wrapper) override {
2924 return 0;
2925 }
2926
2928 inline bool hasImplicitPreconditions() const {
2931 }
2932
2933#ifdef TTK_ENABLE_MPI
2934
2935 // GlobalPointIds, GlobalCellIds (only for ExplicitTriangulation)
2936
2937 inline void setVertsGlobalIds(const LongSimplexId *data) {
2938 this->explicitTriangulation_.setVertsGlobalIds(data);
2939 }
2940 inline void setCellsGlobalIds(const LongSimplexId *const data) {
2941 this->explicitTriangulation_.setCellsGlobalIds(data);
2942 }
2943
2944 // "vtkGhostType" on vertices & cells
2945
2946 inline void setVertexGhostArray(const unsigned char *data) {
2947 this->abstractTriangulation_->setVertexGhostArray(data);
2948 }
2949 inline void setCellGhostArray(const unsigned char *data) {
2950 this->abstractTriangulation_->setCellGhostArray(data);
2951 }
2952
2953 inline bool getIsMPIValid() const {
2954 return isMPIValid_;
2955 }
2956
2957 inline void setIsMPIValid(bool flag) {
2958 isMPIValid_ = flag;
2959 }
2960#endif // TTK_ENABLE_MPI
2961
2962 protected:
2963#ifdef TTK_ENABLE_MPI
2964 bool isMPIValid_{true};
2965#endif
2966 inline bool isEmptyCheck() const {
2968 printErr("Trying to access an empty data-structure!");
2969 return true;
2970 }
2971 return false;
2972 }
2973
2980 bool processImplicitStrategy(const STRATEGY strategy
2981 = STRATEGY::DEFAULT) const;
2982
2989 void switchGrid(const bool usePeriodic, const bool usePreconditions);
2990
2998 };
2999} // namespace ttk
AbstractTriangulation is an interface class that defines an interface for efficient traversal methods...
virtual const std::vector< std::vector< SimplexId > > * getVertexNeighbors()
virtual int getVertexPoint(const SimplexId &vertexId, float &x, float &y, float &z) const
virtual int getEdgeLink(const SimplexId &edgeId, const int &localLinkId, SimplexId &linkId) const
virtual SimplexId getVertexTriangleNumber(const SimplexId &vertexId) const
virtual const std::vector< std::vector< SimplexId > > * getCellNeighbors()
virtual int getVertexTriangle(const SimplexId &vertexId, const int &localTriangleId, SimplexId &triangleId) const
virtual int getVertexEdge(const SimplexId &vertexId, const int &localEdgeId, SimplexId &edgeId) const
int getCellIncenter(const SimplexId cellid, const int dim, float incenter[3]) const
virtual SimplexId getEdgeTriangleNumber(const SimplexId &edgeId) const
virtual bool isTriangleOnBoundary(const SimplexId &triangleId) const
virtual const std::vector< std::vector< SimplexId > > * getVertexStars()
virtual const std::vector< std::vector< SimplexId > > * getEdgeStars()
virtual const std::vector< std::vector< SimplexId > > * getVertexLinks()
virtual const std::vector< std::vector< SimplexId > > * getVertexTriangles()
virtual int getTriangleStar(const SimplexId &triangleId, const int &localStarId, SimplexId &starId) const
virtual SimplexId getVertexNeighborNumber(const SimplexId &vertexId) const
virtual int getEdgeTriangle(const SimplexId &edgeId, const int &localTriangleId, SimplexId &triangleId) const
virtual int getEdgeVertex(const SimplexId &edgeId, const int &localVertexId, SimplexId &vertexId) const
virtual const std::vector< std::array< SimplexId, 2 > > * getEdges()
virtual int getTriangleEdge(const SimplexId &triangleId, const int &localEdgeId, SimplexId &edgeId) const
virtual SimplexId getTriangleLinkNumber(const SimplexId &triangleId) const
virtual bool isVertexOnBoundary(const SimplexId &vertexId) const
virtual const std::vector< std::vector< SimplexId > > * getTriangleLinks()
virtual SimplexId getCellEdgeNumber(const SimplexId &cellId) const
virtual bool isEdgeOnBoundary(const SimplexId &edgeId) const
virtual const std::vector< std::vector< SimplexId > > * getEdgeTriangles()
virtual const std::vector< std::array< SimplexId, 3 > > * getTriangles()
virtual int getTriangleLink(const SimplexId &triangleId, const int &localLinkId, SimplexId &linkId) const
virtual const std::vector< std::vector< SimplexId > > * getEdgeLinks()
virtual SimplexId getNumberOfCells() const
virtual SimplexId getCellTriangleNumber(const SimplexId &cellId) const
virtual SimplexId getNumberOfVertices() const
virtual SimplexId getCellNeighborNumber(const SimplexId &cellId) const
virtual int getDimensionality() const
virtual int getCellEdge(const SimplexId &cellId, const int &localEdgeId, SimplexId &edgeId) const
virtual int getEdgeStar(const SimplexId &edgeId, const int &localStarId, SimplexId &starId) const
virtual int getVertexNeighbor(const SimplexId &vertexId, const int &localNeighborId, SimplexId &neighborId) const
virtual SimplexId getEdgeLinkNumber(const SimplexId &edgeId) const
virtual const std::vector< std::vector< SimplexId > > * getVertexEdges()
virtual int getVertexStar(const SimplexId &vertexId, const int &localStarId, SimplexId &starId) const
virtual SimplexId getTriangleStarNumber(const SimplexId &triangleId) const
virtual int getCellVertex(const SimplexId &cellId, const int &localVertexId, SimplexId &vertexId) const
virtual SimplexId getCellVertexNumber(const SimplexId &cellId) const
int getTriangleIncenter(const SimplexId triangleId, float incenter[3]) const
virtual const std::vector< std::vector< SimplexId > > * getTriangleStars()
std::array< SimplexId, 3 > gridDimensions_
virtual SimplexId getNumberOfTriangles() const
virtual int getTriangleVertex(const SimplexId &triangleId, const int &localVertexId, SimplexId &vertexId) const
virtual SimplexId getVertexStarNumber(const SimplexId &vertexId) const
virtual int getCellVTKID(const int &ttkId, int &vtkId) const
int getEdgeIncenter(const SimplexId edgeId, float incenter[3]) const
virtual int getCellTriangle(const SimplexId &cellId, const int &localTriangleId, SimplexId &triangleId) const
virtual const std::vector< std::vector< SimplexId > > * getTriangleEdges()
virtual SimplexId getVertexLinkNumber(const SimplexId &vertexId) const
virtual SimplexId getVertexEdgeNumber(const SimplexId &vertexId) const
virtual SimplexId getNumberOfEdges() const
size_t footprint(size_t size=0) const
virtual const std::vector< std::vector< SimplexId > > * getCellTriangles()
int getTetraIncenter(const SimplexId tetraId, float incenter[3]) const
virtual SimplexId getTriangleEdgeNumber(const SimplexId &triangleId) const
virtual int getCellNeighbor(const SimplexId &cellId, const int &localNeighborId, SimplexId &neighborId) const
virtual int getVertexLink(const SimplexId &vertexId, const int &localLinkId, SimplexId &linkId) const
virtual SimplexId getEdgeStarNumber(const SimplexId &edgeId) const
virtual const std::vector< std::vector< SimplexId > > * getCellEdges()
int threadNumber_
Definition: BaseClass.h:95
virtual int setThreadNumber(const int threadNumber)
Definition: BaseClass.h:80
CompactTriangulation is a class implemented based on the TopoCluster data structure,...
int setInputCells(const SimplexId &cellNumber, const LongSimplexId *cellArray)
void initCache(const float ratio=0.2)
int setInputPoints(const SimplexId &pointNumber, const void *pointSet, const int *indexArray, const bool &doublePrecision=false)
int debugLevel_
Definition: Debug.h:379
int setWrapper(const Wrapper *wrapper) override
Definition: Debug.cpp:155
virtual int setDebugLevel(const int &debugLevel)
Definition: Debug.cpp:147
int printErr(const std::string &msg, const debug::LineMode &lineMode=debug::LineMode::NEW, std::ostream &stream=std::cerr) const
Definition: Debug.h:149
ExplicitTriangulation is a class that provides time efficient traversal methods on triangulations of ...
int setInputCells(const SimplexId &cellNumber, const LongSimplexId *cellArray)
int setInputPoints(const SimplexId &pointNumber, const void *pointSet, const bool &doublePrecision=false)
Implicit Triangulation class without preconditioning.
int setInputGrid(const float &xOrigin, const float &yOrigin, const float &zOrigin, const float &xSpacing, const float &ySpacing, const float &zSpacing, const SimplexId &xDim, const SimplexId &yDim, const SimplexId &zDim) override
Implicit Triangulation class with preconditioning.
int setInputGrid(const float &xOrigin, const float &yOrigin, const float &zOrigin, const float &xSpacing, const float &ySpacing, const float &zSpacing, const SimplexId &xDim, const SimplexId &yDim, const SimplexId &zDim) override
Periodic implicit Triangulation class without preconditioning.
Periodic implicit Triangulation class with preconditioning.
Triangulation is a class that provides time and memory efficient traversal methods on triangulations ...
Definition: Triangulation.h:48
const std::vector< std::vector< SimplexId > > * getCellEdges() override
int preconditionVertexNeighbors() override
ImplicitNoPreconditions implicitTriangulation_
int setDebugLevel(const int &debugLevel) override
Tune the debug level (default: 0)
int preconditionEdges() override
const std::vector< std::array< SimplexId, 2 > > * getEdges() override
SimplexId getVertexEdgeNumber(const SimplexId &vertexId) const override
const std::vector< std::vector< SimplexId > > * getEdgeStars() override
int getTriangleEdge(const SimplexId &triangleId, const int &localEdgeId, SimplexId &edgeId) const override
int setStellarInputPoints(const SimplexId &pointNumber, const void *pointSet, const int *indexArray, const bool &doublePrecision=false)
AbstractTriangulation * getData()
int getTriangleVertex(const SimplexId &triangleId, const int &localVertexId, SimplexId &vertexId) const override
int getEdgeLink(const SimplexId &edgeId, const int &localLinkId, SimplexId &linkId) const override
SimplexId getVertexStarNumber(const SimplexId &vertexId) const override
int preconditionEdgeStars() override
int preconditionCellNeighbors() override
CompactTriangulation compactTriangulation_
SimplexId getCellNeighborNumber(const SimplexId &cellId) const override
bool isVertexOnBoundary(const SimplexId &vertexId) const override
int setWrapper(const Wrapper *wrapper) override
const std::vector< std::vector< SimplexId > > * getEdgeLinks() override
bool hasImplicitPreconditions() const
Returns true if the grid uses preconditions.
SimplexId getCellEdgeNumber(const SimplexId &cellId) const override
ExplicitTriangulation explicitTriangulation_
int getEdgeTriangle(const SimplexId &edgeId, const int &localTriangleId, SimplexId &triangleId) const override
PeriodicNoPreconditions periodicImplicitTriangulation_
SimplexId getNumberOfEdges() const override
Triangulation::Type getType() const
int preconditionTriangles() override
const std::vector< std::vector< SimplexId > > * getVertexLinks() override
const std::vector< std::vector< SimplexId > > * getVertexEdges() override
const std::vector< std::vector< SimplexId > > * getCellTriangles() override
int preconditionTriangleLinks() override
SimplexId getTriangleLinkNumber(const SimplexId &triangleId) const override
int preconditionVertexEdges() override
int getVertexTriangle(const SimplexId &vertexId, const int &localTriangleId, SimplexId &triangleId) const override
int getCellVertex(const SimplexId &cellId, const int &localVertexId, SimplexId &vertexId) const override
const std::vector< std::vector< SimplexId > > * getVertexTriangles() override
SimplexId getCellVertexNumber(const SimplexId &cellId) const override
SimplexId getEdgeStarNumber(const SimplexId &edgeId) const override
SimplexId getNumberOfCells() const override
bool isManifold() const override
int getTriangleLink(const SimplexId &triangleId, const int &localLinkId, SimplexId &linkId) const override
int preconditionVertexLinks() override
~Triangulation() override
int setInputPoints(const SimplexId &pointNumber, const void *pointSet, const bool &doublePrecision=false)
void switchGrid(const bool usePeriodic, const bool usePreconditions)
Switch regular grid triangulation type.
const std::vector< std::vector< SimplexId > > * getTriangleEdges() override
AbstractTriangulation * abstractTriangulation_
int getVertexEdge(const SimplexId &vertexId, const int &localEdgeId, SimplexId &edgeId) const override
int setInputCells(const SimplexId &cellNumber, const LongSimplexId *cellArray)
bool isEdgeOnBoundary(const SimplexId &edgeId) const override
SimplexId getTriangleEdgeNumber(const SimplexId &triangleId) const override
int getEdgeIncenter(SimplexId edgeId, float incenter[3]) const
SimplexId getEdgeLinkNumber(const SimplexId &edgeId) const override
int getVertexPoint(const SimplexId &vertexId, float &x, float &y, float &z) const override
bool processImplicitStrategy(const STRATEGY strategy=STRATEGY::DEFAULT) const
Should we precondition the implicit/periodic triangulations?
int preconditionCellTriangles() override
int setStellarInputCells(const SimplexId &cellNumber, const LongSimplexId *cellArray)
bool isEmpty() const override
PeriodicWithPreconditions periodicPreconditionsTriangulation_
int preconditionBoundaryEdges() override
int getCellEdge(const SimplexId &cellId, const int &localEdgeId, SimplexId &edgeId) const override
int getCellIncenter(SimplexId cellId, int dim, float incenter[3]) const
const std::vector< std::vector< SimplexId > > * getVertexStars() override
int getEdgeVertex(const SimplexId &edgeId, const int &localVertexId, SimplexId &vertexId) const override
const std::vector< std::vector< SimplexId > > * getTriangleStars() override
int preconditionManifold() override
int getVertexStar(const SimplexId &vertexId, const int &localStarId, SimplexId &starId) const override
SimplexId getCellTriangleNumber(const SimplexId &cellId) const override
int getVertexNeighbor(const SimplexId &vertexId, const int &localNeighborId, SimplexId &neighborId) const override
int preconditionTriangleStars() override
SimplexId getVertexLinkNumber(const SimplexId &vertexId) const override
const std::vector< std::vector< SimplexId > > * getEdgeTriangles() override
size_t footprint() const
Definition: Triangulation.h:94
SimplexId getTriangleStarNumber(const SimplexId &triangleId) const override
ImplicitWithPreconditions implicitPreconditionsTriangulation_
int getTetraIncenter(SimplexId tetraId, float incenter[3]) const
int preconditionCellEdges() override
int getTriangleStar(const SimplexId &triangleId, const int &localStarId, SimplexId &starId) const override
int getDimensionality() const override
int preconditionVertexStars() override
SimplexId getVertexTriangleNumber(const SimplexId &vertexId) const override
SimplexId getEdgeTriangleNumber(const SimplexId &edgeId) const override
bool isEmptyCheck() const
int preconditionEdgeTriangles() override
int preconditionBoundaryTriangles() override
void setPeriodicBoundaryConditions(const bool &usePeriodicBoundaries)
int setInputGrid(const float &xOrigin, const float &yOrigin, const float &zOrigin, const float &xSpacing, const float &ySpacing, const float &zSpacing, const SimplexId &xDim, const SimplexId &yDim, const SimplexId &zDim)
int getCellTriangle(const SimplexId &cellId, const int &localTriangleId, SimplexId &triangleId) const override
int getEdgeStar(const SimplexId &edgeId, const int &localStarId, SimplexId &starId) const override
int getTriangleIncenter(SimplexId triangleId, float incenter[3]) const
int preconditionEdgeLinks() override
const std::vector< std::array< SimplexId, 3 > > * getTriangles() override
const std::vector< std::vector< SimplexId > > * getVertexNeighbors() override
int setThreadNumber(const ThreadId threadNumber) override
Tune the number of active threads (default: number of logical cores)
const std::vector< std::vector< SimplexId > > * getCellNeighbors() override
int getCellNeighbor(const SimplexId &cellId, const int &localNeighborId, SimplexId &neighborId) const override
int preconditionVertexTriangles() override
const std::vector< std::vector< SimplexId > > * getTriangleLinks() override
Triangulation & operator=(const Triangulation &)
SimplexId getNumberOfVertices() const override
int setCacheSize(const float &ratio)
int preconditionBoundaryVertices() override
SimplexId getNumberOfTriangles() const override
SimplexId getVertexNeighborNumber(const SimplexId &vertexId) const override
int preconditionTriangleEdges() override
int getCellVTKID(const int &ttkId, int &vtkId) const override
bool isTriangleOnBoundary(const SimplexId &triangleId) const override
void setImplicitPreconditions(const STRATEGY strategy)
Set the input grid preconditioning strategy.
int getVertexLink(const SimplexId &vertexId, const int &localLinkId, SimplexId &linkId) const override
Wrapper class to wrap ttk code.
Definition: Wrapper.h:14
The Topology ToolKit.
long long int LongSimplexId
Identifier type for simplices of any dimension.
Definition: DataTypes.h:15
int ThreadId
Identifier type for threads (i.e. with OpenMP).
Definition: DataTypes.h:26
int SimplexId
Identifier type for simplices of any dimension.
Definition: DataTypes.h:22