├── README.md ├── build ├── demo.cpp ├── demo.msh ├── elements.txt └── nodes.txt └── demo ├── README ├── demo.cpp ├── oneDExample.cpp ├── threeDDemo.cpp └── twoDExample.cpp /README.md: -------------------------------------------------------------------------------- 1 | # LearnGmsh 2 | Some demo programs of learning Gmsh. 3 | 4 | 5 | 6 | demo : storage all example programs 7 | build : Compile and run directory 8 | -------------------------------------------------------------------------------- /build/demo.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | 9 | void writeNodes(vector& nodes, string s) 10 | { 11 | string filename = s + ".txt"; 12 | ofstream outfileb(filename.c_str(), ios::out); 13 | for(int i = 0; i < nodes.size(); i++) 14 | { 15 | outfileb<<(nodes[i])< >& elements, string s) 22 | { 23 | string filename = s + ".txt"; 24 | ofstream outfileb(filename.c_str(), ios::out); 25 | for(int i = 0; i < elements[1].size(); i++) 26 | { 27 | outfileb<<(elements[1][i])< nodes,y; 130 | vector nodeTags; 131 | gmsh::model::mesh::getNodes(nodeTags, nodes, y, -2, -1, false, true); 132 | cout<<"The number of nodes: "< elementTypes; 144 | vector > elementTags, nodeTags2; 145 | gmsh::model::mesh::getElements(elementTypes, elementTags, nodeTags2, -2, -1); 146 | cout<<"The number of elements: "< 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | 9 | void writeNodes(vector& nodes, string s) 10 | { 11 | string filename = s + ".txt"; 12 | ofstream outfileb(filename.c_str(), ios::out); 13 | for(int i = 0; i < nodes.size(); i++) 14 | { 15 | outfileb<<(nodes[i])< >& elements, string s) 22 | { 23 | string filename = s + ".txt"; 24 | ofstream outfileb(filename.c_str(), ios::out); 25 | for(int i = 0; i < elements[1].size(); i++) 26 | { 27 | outfileb<<(elements[1][i])< nodes,y; 130 | vector nodeTags; 131 | gmsh::model::mesh::getNodes(nodeTags, nodes, y, -2, -1, false, true); 132 | cout<<"The number of nodes: "< elementTypes; 144 | vector > elementTags, nodeTags2; 145 | gmsh::model::mesh::getElements(elementTypes, elementTags, nodeTags2, -2, -1); 146 | cout<<"The number of elements: "< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | #include 8 | #include 9 | 10 | using namespace std; 11 | 12 | class Point 13 | { 14 | public: 15 | Point(const double x = 0, const double y = 0, const double z = 0):_x(x), _y(y), _z(z) { } 16 | ~Point() { } 17 | const double getX() const {return _x;} 18 | const double getY() const {return _y;} 19 | const double getZ() const {return _z;} 20 | void setX(const double x) {_x = x;} 21 | void setY(const double y) {_y = y;} 22 | void setZ(const double z) {_z = z;} 23 | bool operator < (const Point& p) const; 24 | 25 | protected: 26 | double _x, _y, _z; 27 | }; 28 | 29 | bool Point::operator < (const Point& p) const 30 | { 31 | double px = p.getX(); 32 | double py = p.getY(); 33 | if(px == _x) { 34 | return py < _y; 35 | } else { 36 | return px < _x; 37 | } 38 | } 39 | 40 | 41 | class Polygon 42 | { 43 | public: 44 | Polygon() : _vertex(), _name() {} 45 | Polygon(const vector& vertex, const string& name = "poly") :_vertex(vertex), _name(name) {} 46 | ~Polygon() {} 47 | const vector& getVertex() const {return _vertex;} 48 | void clear() {_vertex.clear();} 49 | void append(const Point& p) {_vertex.push_back(p);} 50 | const string& getName() const {return _name;} 51 | void setPoints(const vector& vertex) {_vertex = vertex;} 52 | void setName(const string& name) {_name = name;} 53 | 54 | private: 55 | vector _vertex; 56 | string _name; 57 | }; 58 | 59 | class Topology 60 | { 61 | public: 62 | Topology(const int firstId = -3, const int secondId = -3) : _firstId(firstId), _secondId(secondId) {} 63 | ~Topology() {} 64 | const int getFirstId() const {return _firstId;} 65 | const int getSecondId() const {return _secondId;} 66 | void setFirstId(const int firstId) {_firstId = firstId;} 67 | void setSecondId(const int secondId) {_secondId= secondId;} 68 | bool operator < (const Topology& topo) const; 69 | 70 | private: 71 | int _firstId, _secondId; 72 | }; 73 | 74 | bool Topology::operator < (const Topology& topo) const 75 | { 76 | int tof = topo.getFirstId(); 77 | int tos = topo.getSecondId(); 78 | if(tof == _firstId) { 79 | return tos < _secondId; 80 | } else { 81 | return tof < _firstId; 82 | } 83 | } 84 | 85 | class Segment 86 | { 87 | public: 88 | Segment() : _startPt(), _endPt() {} 89 | Segment(const Point& startPt, const Point& endPt) : _startPt(startPt), _endPt(endPt) {} 90 | ~Segment() {} 91 | const Point& getStartPt() const {return _startPt;} 92 | const Point& getEndPt() const {return _endPt;} 93 | void setStartPt(const Point& startPt) {_startPt = startPt;} 94 | void setEndPt(const Point& endPt) {_endPt = endPt;} 95 | 96 | protected: 97 | Point _startPt, _endPt; 98 | }; 99 | 100 | class Element : public Segment 101 | { 102 | public: 103 | Element() : Segment(), _topo() {} 104 | Element(const Point& startPt, const Point& endPt, const Topology& topo) : Segment(startPt, endPt), _topo(topo) {} 105 | ~Element() {} 106 | 107 | const Topology& getTopology() const {return _topo;} 108 | void setTopology(const Topology& topo) {_topo = topo;} 109 | void setTopology(const int firstId, const int secondId) {_topo = Topology(firstId, secondId);} 110 | 111 | private: 112 | Topology _topo; 113 | }; 114 | 115 | void generatePolygons(vector& region) 116 | { 117 | Polygon poly; 118 | double left, right, bot, top; 119 | double x, y, z = 0; 120 | Point p; 121 | 122 | poly.clear(); 123 | p = Point(0, 0, z); 124 | poly.append(p); 125 | p = Point(8, 0, z); 126 | poly.append(p); 127 | p = Point(8, 1, z); 128 | poly.append(p); 129 | p = Point(6, 1, z); 130 | poly.append(p); 131 | p = Point(5, 1, z); 132 | poly.append(p); 133 | p = Point(3, 1, z); 134 | poly.append(p); 135 | p = Point(2, 1, z); 136 | poly.append(p); 137 | p = Point(0, 1, z); 138 | poly.append(p); 139 | poly.setName("poly_1"); 140 | region.push_back(poly); 141 | 142 | poly.clear(); 143 | p = Point(0, 1, z); 144 | poly.append(p); 145 | p = Point(2, 1, z); 146 | poly.append(p); 147 | p = Point(2, 2, z); 148 | poly.append(p); 149 | p = Point(0, 2, z); 150 | poly.append(p); 151 | poly.setName("poly_2"); 152 | region.push_back(poly); 153 | 154 | poly.clear(); 155 | p = Point(3, 1, z); 156 | poly.append(p); 157 | p = Point(5, 1, z); 158 | poly.append(p); 159 | p = Point(5, 2, z); 160 | poly.append(p); 161 | p = Point(3, 2, z); 162 | poly.append(p); 163 | poly.setName("poly_3"); 164 | region.push_back(poly); 165 | 166 | poly.clear(); 167 | p = Point(6, 1, z); 168 | poly.append(p); 169 | p = Point(8, 1, z); 170 | poly.append(p); 171 | p = Point(8, 2, z); 172 | poly.append(p); 173 | p = Point(6, 2, z); 174 | poly.append(p); 175 | poly.setName("poly_4"); 176 | region.push_back(poly); 177 | 178 | poly.clear(); 179 | p = Point(0, 2, z); 180 | poly.append(p); 181 | p = Point(2, 2, z); 182 | poly.append(p); 183 | p = Point(3, 2, z); 184 | poly.append(p); 185 | p = Point(5, 2, z); 186 | poly.append(p); 187 | p = Point(6, 2, z); 188 | poly.append(p); 189 | p = Point(8, 2, z); 190 | poly.append(p); 191 | p = Point(8, 3, z); 192 | poly.append(p); 193 | p = Point(0, 3, z); 194 | poly.append(p); 195 | poly.setName("poly_5"); 196 | region.push_back(poly); 197 | } 198 | 199 | int main(int argc, char **argv) 200 | { 201 | clock_t start, finish; 202 | start = clock(); 203 | 204 | gmsh::initialize(); 205 | gmsh::option::setNumber("General.Terminal", 1); 206 | gmsh::model::add("demo"); 207 | 208 | double lc = 0.8; 209 | vector region; 210 | generatePolygons(region); 211 | 212 | int dim = 1; 213 | int tag = 1; 214 | double x, y, z; 215 | vector loop, curveloop, planeSurface; 216 | 217 | int ct_point = 1; 218 | int ct_line = 1; 219 | 220 | // record the points where the previous polygon was inserted 221 | map recPoints; 222 | // record the line where the previous polygon wsa inserted 223 | map recLines; 224 | vector > domElelIds(region.size()); 225 | for(int i = 0; i < region.size(); i++) 226 | { 227 | loop.clear(); 228 | Polygon poly = region[i]; 229 | const vector& vertex = poly.getVertex(); 230 | for(int j = 0; j < vertex.size(); j++) 231 | { 232 | Point p = vertex[j]; 233 | auto iter = recPoints.find(p); 234 | if(iter == recPoints.end()) 235 | { 236 | x = p.getX(); 237 | y = p.getY(); 238 | z = p.getZ(); 239 | gmsh::model::geo::addPoint(x, y, z, lc, ct_point); 240 | recPoints[p] = ct_point; 241 | loop.push_back(ct_point); 242 | ct_point++; 243 | } else { 244 | loop.push_back(iter->second); 245 | } 246 | } 247 | curveloop.clear(); 248 | for(int j = 0; j < loop.size(); j++) 249 | { 250 | int l1 = loop[j]; 251 | int l2 = j == loop.size()-1 ? loop[0] : loop[j+1]; 252 | Topology topo(l1, l2); 253 | Topology topo2(l2, l1); 254 | auto iterl = recLines.find(topo); 255 | auto iterl2 = recLines.find(topo2); 256 | bool flag = (iterl == recLines.end()) && (iterl2 == recLines.end()); 257 | if(flag) 258 | { 259 | gmsh::model::geo::addLine(l1, l2, ct_line); 260 | recLines[topo] = ct_line; 261 | recLines[topo2] = -ct_line; 262 | curveloop.push_back(ct_line); 263 | ct_line++; 264 | } else { 265 | if(iterl != recLines.end()) 266 | curveloop.push_back(iterl->second); 267 | else 268 | curveloop.push_back(iterl2->second); 269 | } 270 | } 271 | planeSurface.push_back(gmsh::model::geo::addCurveLoop(curveloop)); 272 | tag = gmsh::model::addPhysicalGroup(dim, curveloop); 273 | string name = "Polygon_" + to_string(i); 274 | gmsh::model::setPhysicalName(dim, tag, name); 275 | domElelIds[i] = curveloop; 276 | } 277 | 278 | gmsh::model::geo::addPlaneSurface(planeSurface); 279 | 280 | dim = 1; 281 | gmsh::model::addPhysicalGroup(dim, planeSurface); 282 | 283 | gmsh::model::geo::synchronize(); 284 | 285 | gmsh::model::mesh::generate(1); 286 | 287 | #if 1 288 | clock_t info_s, info_e; 289 | info_s = clock(); 290 | // get Mesh information 291 | 292 | // get Nodes 293 | dim = -1; 294 | tag = -1; 295 | bool includeBoundary = false; 296 | vector coord, parametricCoord; 297 | vector nodeTags; 298 | gmsh::model::mesh::getNodes(nodeTags, coord, parametricCoord, dim, tag, includeBoundary, true); 299 | cout<<"The number of nodes: "< nodes; 301 | nodes.reserve(1000); 302 | Point p; 303 | for(int i = 0; i < coord.size(); i+=3) 304 | { 305 | x = coord[i]; 306 | y = coord[i+1]; 307 | z = coord[i+2]; 308 | p = Point(x, y, z); 309 | nodes.push_back(p); 310 | } 311 | 312 | // get Elemetnts 313 | dim = 1; 314 | tag = -1; 315 | vector elementTypes; 316 | vector > elemetTags, nodeTagss; 317 | gmsh::model::mesh::getElements(elementTypes, elemetTags, nodeTagss, dim, tag); 318 | cout<<"The number of elemnets: "< bouNodesIds; 336 | // boundaryTag = tag = gmsh::model::addPhysicalGroup(dim, curveloop) 337 | // then we can get one polygon points id on edges 338 | int boundaryTag = 1; 339 | gmsh::model::mesh::getNodesForPhysicalGroup(dim, boundaryTag, bouNodesIds, coord); 340 | vector boundaryNodesIds(bouNodesIds.size()); 341 | // just because index from star 0 342 | for(int i = 0; i < bouNodesIds.size(); i++) 343 | { 344 | boundaryNodesIds[i] = bouNodesIds[i]-1; 345 | //cout< bcurveLoop = domElelIds[0]; 352 | vector boundaryElementsIds; 353 | dim = 1; 354 | int dim2 = 1; 355 | bool strict = true; 356 | double xx, yy, zz; 357 | vector elemetTag; 358 | for(int i = 0; i < bcurveLoop.size(); i++) 359 | { 360 | tag = abs(bcurveLoop[i]); 361 | gmsh::model::mesh::getElements(elementTypes, elemetTags, nodeTagss, dim, tag); 362 | for(int k = 0; k < nodeTagss[0].size(); k+=2) 363 | { 364 | id1 = nodeTagss[0][k]-1; 365 | id2 = nodeTagss[0][k+1]-1; 366 | xx = (nodes[id1].getX() + nodes[id2].getX())/2.0; 367 | yy = (nodes[id1].getY() + nodes[id2].getY())/2.0; 368 | zz = (nodes[id1].getZ() + nodes[id2].getZ())/2.0; 369 | gmsh::model::mesh::getElementsByCoordinates(xx, yy, zz, elemetTag, dim2, strict); 370 | for(int kk= 0; kk < elemetTag.size(); kk++) 371 | { 372 | boundaryElementsIds.push_back(elemetTag[kk]-1); 373 | } 374 | } 375 | if(bcurveLoop[i] < 0) 376 | { 377 | reverse(boundaryElementsIds.begin(), boundaryElementsIds.end()); 378 | } 379 | } 380 | info_e = clock(); 381 | #endif 382 | gmsh::write("demo.msh"); 383 | gmsh::finalize(); 384 | finish = clock(); 385 | cout<<"The run time of get information: "<<(double)(info_e - info_s)/CLOCKS_PER_SEC<<"s"< 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | 9 | void writeNodes(vector& nodes, string s) 10 | { 11 | string filename = s + ".txt"; 12 | ofstream outfileb(filename.c_str(), ios::out); 13 | for(int i = 0; i < nodes.size(); i++) 14 | { 15 | outfileb<<(nodes[i])< >& elements, string s) 22 | { 23 | string filename = s + ".txt"; 24 | ofstream outfileb(filename.c_str(), ios::out); 25 | for(int i = 0; i < elements[1].size(); i++) 26 | { 27 | outfileb<<(elements[1][i])< nodes,y; 151 | vector nodeTags; 152 | gmsh::model::mesh::getNodes(nodeTags, nodes, y, -2, -1, false, true); 153 | cout<<"The number of nodes: "< elementTypes; 165 | vector > elementTags, nodeTags2; 166 | gmsh::model::mesh::getElements(elementTypes, elementTags, nodeTags2, -2, -1); 167 | cout<<"The number of elements: "< 2 | #include 3 | #include 4 | #include 5 | #include 6 | #include 7 | using namespace std; 8 | 9 | 10 | class Point 11 | { 12 | public: 13 | Point(const double x = 0, const double y = 0, const double z = 0):_x(x), _y(y), _z(z) {} 14 | ~Point() {} 15 | const double getX() const {return _x;} 16 | const double getY() const {return _y;} 17 | const double getZ() const {return _z;} 18 | void setX(const double x) {_x = x;} 19 | void setY(const double y) {_y = y;} 20 | void setZ(const double z) {_z = z;} 21 | 22 | private: 23 | double _x, _y, _z; 24 | }; 25 | 26 | 27 | 28 | class Triangle 29 | { 30 | /** 31 | * Triangle vertex index 32 | * _id[0] ~ _id[2] : three vertices index of triangle 33 | * _id[3] is the midpoint between _id[0] and _id[1] 34 | * _id[4] is the midpoint between _id[1] and _id[2] 35 | * _id[5] is the midpoint between _id[2] and _id[0] 36 | */ 37 | public: 38 | Triangle() {} 39 | ~Triangle() {} 40 | const vector& getIds() const {return _ids;} 41 | void clear() {_ids.clear();} 42 | void append(unsigned int id) {_ids.push_back(id);} 43 | void resize(const unsigned int size) {_ids.resize(size);} 44 | 45 | private: 46 | vector _ids; 47 | }; 48 | 49 | 50 | 51 | void generateBoudaryAndHoles(vector& boundary, vector >& holes) 52 | { 53 | double left, right, bot, top; 54 | double x, y, z; 55 | left = 0; 56 | right = 5; 57 | bot = 0; 58 | top = 4; 59 | z = 0; 60 | Point p; 61 | p = Point(left, bot, z); 62 | boundary.push_back(p); 63 | p = Point(right, bot, z); 64 | boundary.push_back(p); 65 | p = Point(right, top, z); 66 | boundary.push_back(p); 67 | p = Point(left, top, z); 68 | boundary.push_back(p); 69 | p = Point(left, (bot+top)/2.0, z); 70 | boundary.push_back(p); 71 | 72 | 73 | vector hole; 74 | left = 1; 75 | right = 2; 76 | bot = 1; 77 | top = 2; 78 | p = Point(left, bot, z); 79 | hole.push_back(p); 80 | p = Point(right, bot, z); 81 | hole.push_back(p); 82 | p = Point(right, top, z); 83 | hole.push_back(p); 84 | p = Point(left, top, z); 85 | hole.push_back(p); 86 | p = Point(left, (bot+top)/2.0, z); 87 | hole.push_back(p); 88 | holes.push_back(hole); 89 | 90 | 91 | hole.clear(); 92 | left = 3; 93 | right = 4; 94 | bot = 1; 95 | top = 2; 96 | p = Point(left, bot, z); 97 | hole.push_back(p); 98 | p = Point(right, bot, z); 99 | hole.push_back(p); 100 | p = Point(right, top, z); 101 | hole.push_back(p); 102 | p = Point(left, top, z); 103 | hole.push_back(p); 104 | holes.push_back(hole); 105 | } 106 | 107 | 108 | int main(int argc, char **argv) 109 | { 110 | gmsh::initialize(); 111 | gmsh::option::setNumber("General.Terminal", 1); 112 | 113 | gmsh::model::add("demo"); 114 | 115 | double boundartLc = 1, holeLc = 0.4; 116 | vector boundary; 117 | vector > holes; 118 | generateBoudaryAndHoles(boundary, holes); 119 | 120 | int dim = 1; 121 | int tag = 1; 122 | double x, y, z; 123 | vector loop, curveLoop, planeSurface; 124 | 125 | int boundaryTag; 126 | for(int i = 0; i < boundary.size(); i++) 127 | { 128 | x = boundary[i].getX(); 129 | y = boundary[i].getY(); 130 | z = boundary[i].getZ(); 131 | loop.push_back(gmsh::model::geo::addPoint(x, y, z, boundartLc)); 132 | } 133 | 134 | for(int i = 0; i < loop.size(); i++) 135 | { 136 | curveLoop.push_back(gmsh::model::geo::addLine(loop[i], i == loop.size()-1 ? loop[0] : loop[i+1])); 137 | } 138 | planeSurface.push_back(gmsh::model::geo::addCurveLoop(curveLoop)); 139 | boundaryTag = gmsh::model::addPhysicalGroup(dim, curveLoop); 140 | gmsh::model::setPhysicalName(dim, boundaryTag, "Boundary"); 141 | 142 | vector bcurveLoop = curveLoop; 143 | 144 | vector > recCurveLoop; 145 | vector holesTags; 146 | for(int i = 0; i < holes.size(); i++) 147 | { 148 | loop.clear(); 149 | curveLoop.clear(); 150 | for(int j = 0; j < holes[i].size(); j++) 151 | { 152 | x = holes[i][j].getX(); 153 | y = holes[i][j].getY(); 154 | z = holes[i][j].getZ(); 155 | loop.push_back(gmsh::model::geo::addPoint(x, y, z, holeLc)); 156 | } 157 | 158 | for(int j = 0; j < loop.size(); j++) 159 | { 160 | curveLoop.push_back(gmsh::model::geo::addLine(loop[j], j == loop.size()-1 ? loop[0] : loop[j+1])); 161 | } 162 | planeSurface.push_back(-gmsh::model::geo::addCurveLoop(curveLoop)); 163 | 164 | tag = gmsh::model::addPhysicalGroup(dim, curveLoop); 165 | holesTags.push_back(tag); 166 | string name = "hole" + to_string(i); 167 | gmsh::model::setPhysicalName(dim, tag, name); 168 | recCurveLoop.push_back(curveLoop); 169 | } 170 | 171 | gmsh::model::geo::addPlaneSurface(planeSurface); 172 | 173 | dim = 2; 174 | gmsh::model::addPhysicalGroup(dim, planeSurface); 175 | 176 | gmsh::model::geo::synchronize(); 177 | 178 | gmsh::model::mesh::generate(2); 179 | 180 | 181 | // get mesh information 182 | // Nodes 183 | dim = -1; 184 | tag = -1; 185 | bool includeBoundary = false; 186 | vector coord, parametricCoord; 187 | vector nodeTags; 188 | gmsh::model::mesh::getNodes(nodeTags, coord, parametricCoord, dim, tag, includeBoundary, true); 189 | cout<<"The number of nodes: "< nodes; 191 | nodes.reserve(1000); 192 | Point p; 193 | for(int i = 0; i < coord.size(); i+=3) 194 | { 195 | x = coord[i]; 196 | y = coord[i+1]; 197 | z = coord[i+2]; 198 | p = Point(x, y, z); 199 | nodes.push_back(p); 200 | } 201 | 202 | 203 | 204 | //Elements 205 | dim = -1; 206 | tag = -1; 207 | vector elementTypes; 208 | vector > elementTags, nodeTagss; 209 | gmsh::model::mesh::getElements(elementTypes, elementTags, nodeTagss, dim, tag); 210 | cout<<"The number of elements: "< boundaryNodesId = elementTags[0]; 213 | vector triangles; 214 | triangles.reserve(1000); 215 | unsigned int id1, id2, id3; 216 | for(int i = 0; i < nodeTagss[1].size(); i += 3) 217 | { 218 | Triangle tri; 219 | id1 = nodeTagss[1][i]-1; 220 | id2 = nodeTagss[1][i+1]-1; 221 | id3 = nodeTagss[1][i+2]-1; 222 | tri.append(id1); 223 | tri.append(id2); 224 | tri.append(id3); 225 | triangles.push_back(tri); 226 | } 227 | 228 | 229 | 230 | // get boundary nodes id and it's coordinate information 231 | // coord is coordinate information (x1, y1, z1, .....) 232 | dim = 1; 233 | vector bouNodesIds; 234 | gmsh::model::mesh::getNodesForPhysicalGroup(dim, boundaryTag, bouNodesIds, coord); 235 | vector boundaryNodesIds(bouNodesIds.size()); 236 | // just because index from start 0 237 | for(int i = 0; i < bouNodesIds.size(); i++) 238 | { 239 | boundaryNodesIds[i] = bouNodesIds[i]-1; 240 | } 241 | 242 | 243 | // get holes nodes id and it's coordinate information 244 | vector > hosNodesIds(holesTags.size()); 245 | vector > holesNodesIds(holesTags.size()); 246 | for(int i = 0; i < holesTags.size(); i++) 247 | { 248 | gmsh::model::mesh::getNodesForPhysicalGroup(dim, holesTags[i], hosNodesIds[i], coord); 249 | } 250 | for(int i = 0; i < hosNodesIds.size(); i++) 251 | { 252 | holesNodesIds[i].resize(hosNodesIds[i].size()); 253 | for(int j = 0; j < hosNodesIds[i].size(); j++) 254 | { 255 | holesNodesIds[i][j] = hosNodesIds[i][j]-1; 256 | } 257 | } 258 | 259 | #if 0 260 | for(int i = 0; i < holesNodesIds.size(); i++) 261 | { 262 | for(int j = 0; j < holesNodesIds[i].size(); j++) 263 | { 264 | cout< > holesElementsIds(recCurveLoop.size()); 274 | dim = 1; 275 | int dim2 = 2; 276 | vector elementTag; 277 | bool strict = true; 278 | double xx, yy, zz; 279 | vector holeElementsIds; 280 | for(int i = 0; i < recCurveLoop.size(); i++) 281 | { 282 | holeElementsIds.clear(); 283 | for(int j = 0; j < recCurveLoop[i].size(); j++) 284 | { 285 | //elementTypes.clear(); 286 | //elementTags.clear(); 287 | //nodeTagss.clear(); 288 | tag = recCurveLoop[i][j]; 289 | gmsh::model::mesh::getElements(elementTypes, elementTags, nodeTagss, dim, tag); 290 | for(int k = 0; k < nodeTagss[0].size(); k += 2) 291 | { 292 | id1 = nodeTagss[0][k]-1; 293 | id2 = nodeTagss[0][k+1]-1; 294 | xx = (nodes[id1].getX() + nodes[id2].getX())/2.0; 295 | yy = (nodes[id1].getY() + nodes[id2].getY())/2.0; 296 | zz = (nodes[id1].getZ() + nodes[id2].getZ())/2.0; 297 | gmsh::model::mesh::getElementsByCoordinates(xx, yy, zz, elementTag, dim2, strict); 298 | for(int kk = 0; kk < elementTag.size(); kk++) 299 | { 300 | holeElementsIds.push_back(elementTag[kk]-1); 301 | } 302 | } 303 | } 304 | holesElementsIds.push_back(holeElementsIds); 305 | } 306 | #if 0 307 | for(int i = 0; i < holesElementsIds.size(); i++) 308 | { 309 | for(int j = 0; j < holesElementsIds[i].size(); j++) 310 | { 311 | cout< boundaryElementsIds; 319 | dim = 1; 320 | dim2 = 2; 321 | strict = true; 322 | for(int i = 0; i < bcurveLoop.size(); i++) 323 | { 324 | tag = bcurveLoop [i]; 325 | gmsh::model::mesh::getElements(elementTypes, elementTags, nodeTagss, dim, tag); 326 | for(int k = 0; k < nodeTagss[0].size(); k += 2) 327 | { 328 | id1 = nodeTagss[0][k]-1; 329 | id2 = nodeTagss[0][k+1]-1; 330 | xx = (nodes[id1].getX() + nodes[id2].getX())/2.0; 331 | yy = (nodes[id1].getY() + nodes[id2].getY())/2.0; 332 | zz = (nodes[id1].getZ() + nodes[id2].getZ())/2.0; 333 | gmsh::model::mesh::getElementsByCoordinates(xx, yy, zz, elementTag, dim2, strict); 334 | for(int kk = 0; kk < elementTag.size(); kk++) 335 | { 336 | boundaryElementsIds.push_back(elementTag[kk]-1); 337 | } 338 | } 339 | } 340 | 341 | gmsh::write("demo.msh"); 342 | 343 | gmsh::finalize(); 344 | return 0; 345 | } 346 | --------------------------------------------------------------------------------