Debian Codegraph @

packages/rol/example/PDE-OPT/topo-opt/elasticity/src/mesh_topo-opt.hpp

raw
1 // @HEADER
2 // *****************************************************************************
3 // Rapid Optimization Library (ROL) Package
4 //
5 // Copyright 2014 NTESS and the ROL contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9
10 #ifndef MESHMANAGER_ELASTICITY_HPP
11 #define MESHMANAGER_ELASTICITY_HPP
12
13 #include "../../../TOOLS/meshmanager.hpp"
14
15 template <class Real>
16 class MeshManager_TopoOpt : public MeshManager_Rectangle<Real> {
17
18 private:
19
20 int nx_;
21 int ny_;
22 Real height_;
23 Real width_;
24 std::string name_;
25 ROL::Ptr<std::vector<std::vector<std::vector<int> > > > meshSideSets_;
26
27 public:
28
29 MeshManager_TopoOpt(Teuchos::ParameterList &parlist) : MeshManager_Rectangle<Real>(parlist)
30 {
31 nx_ = parlist.sublist("Geometry").get("NX", 3);
32 ny_ = parlist.sublist("Geometry").get("NY", 3);
33 height_ = parlist.sublist("Geometry").get("Height", 1.0);
34 width_ = parlist.sublist("Geometry").get("Width", 2.0);
35 name_ = parlist.sublist("Problem").get("Example","Default");
36 computeSideSets();
37 }
38
39 void computeSideSets() {
40 if (name_ == "2D Cantilever with 3 Loads") {
41 cantilever_computeSideSets();
42 }
43 else if (name_ == "2D Carrier Plate") {
44 carrierplate_computeSideSets();
45 }
46 else if (name_ == "2D Wheel") {
47 wheel_computeSideSets();
48 }
49 else {
50 default_computeSideSets();
51 }
52 }
53
54 private:
55
56 void cantilever_computeSideSets() {
57 int numSideSets = 9;
58 meshSideSets_ = ROL::makePtr<std::vector<std::vector<std::vector<int>>>>(numSideSets);
59
60 Real pf(1.0/6.0);
61 int np = static_cast<int>(pf * static_cast<Real>(nx_));
62 int nf = nx_-5*np;
63
64 // Bottom
65 (*meshSideSets_)[0].resize(4);
66 (*meshSideSets_)[0][0].resize(nf);
67 (*meshSideSets_)[0][1].resize(0);
68 (*meshSideSets_)[0][2].resize(0);
69 (*meshSideSets_)[0][3].resize(0);
70 (*meshSideSets_)[1].resize(4);
71 (*meshSideSets_)[1][0].resize(np);
72 (*meshSideSets_)[1][1].resize(0);
73 (*meshSideSets_)[1][2].resize(0);
74 (*meshSideSets_)[1][3].resize(0);
75 (*meshSideSets_)[2].resize(4);
76 (*meshSideSets_)[2][0].resize(np);
77 (*meshSideSets_)[2][1].resize(0);
78 (*meshSideSets_)[2][2].resize(0);
79 (*meshSideSets_)[2][3].resize(0);
80 (*meshSideSets_)[3].resize(4);
81 (*meshSideSets_)[3][0].resize(np);
82 (*meshSideSets_)[3][1].resize(0);
83 (*meshSideSets_)[3][2].resize(0);
84 (*meshSideSets_)[3][3].resize(0);
85 (*meshSideSets_)[4].resize(4);
86 (*meshSideSets_)[4][0].resize(np);
87 (*meshSideSets_)[4][1].resize(0);
88 (*meshSideSets_)[4][2].resize(0);
89 (*meshSideSets_)[4][3].resize(0);
90 (*meshSideSets_)[5].resize(4);
91 (*meshSideSets_)[5][0].resize(np);
92 (*meshSideSets_)[5][1].resize(0);
93 (*meshSideSets_)[5][2].resize(0);
94 (*meshSideSets_)[5][3].resize(0);
95 // Right
96 (*meshSideSets_)[6].resize(4);
97 (*meshSideSets_)[6][0].resize(0);
98 (*meshSideSets_)[6][1].resize(ny_);
99 (*meshSideSets_)[6][2].resize(0);
100 (*meshSideSets_)[6][3].resize(0);
101 // Top
102 (*meshSideSets_)[7].resize(4);
103 (*meshSideSets_)[7][0].resize(0);
104 (*meshSideSets_)[7][1].resize(0);
105 (*meshSideSets_)[7][2].resize(nx_);
106 (*meshSideSets_)[7][3].resize(0);
107 // Left
108 (*meshSideSets_)[8].resize(4);
109 (*meshSideSets_)[8][0].resize(0);
110 (*meshSideSets_)[8][1].resize(0);
111 (*meshSideSets_)[8][2].resize(0);
112 (*meshSideSets_)[8][3].resize(ny_);
113
114 for (int i=0; i<nf; ++i) {
115 (*meshSideSets_)[0][0][i] = i;
116 }
117 for (int i=0; i<np; ++i) {
118 (*meshSideSets_)[1][0][i] = i + nf;
119 }
120 for (int i=0; i<np; ++i) {
121 (*meshSideSets_)[2][0][i] = i + (nf+np);
122 }
123 for (int i=0; i<np; ++i) {
124 (*meshSideSets_)[3][0][i] = i + (nf+2*np);
125 }
126 for (int i=0; i<np; ++i) {
127 (*meshSideSets_)[4][0][i] = i + (nf+3*np);
128 }
129 for (int i=0; i<np; ++i) {
130 (*meshSideSets_)[5][0][i] = i + (nf+4*np);
131 }
132 for (int i=0; i<ny_; ++i) {
133 (*meshSideSets_)[6][1][i] = (i+1)*nx_-1;
134 }
135 for (int i=0; i<nx_; ++i) {
136 (*meshSideSets_)[7][2][i] = i + nx_*(ny_-1);
137 }
138 for (int i=0; i<ny_; ++i) {
139 (*meshSideSets_)[8][3][i] = i*nx_;
140 }
141 } // cantilever_computeSideSets
142
143 void carrierplate_computeSideSets() {
144 int numSideSets = 6;
145 meshSideSets_ = ROL::makePtr<std::vector<std::vector<std::vector<int>>>>(numSideSets);
146
147 Real pf(0.25);
148 int np = static_cast<int>(pf * static_cast<Real>(nx_));
149 int nc = nx_-2*np;
150
151 // Bottom
152 (*meshSideSets_)[0].resize(4);
153 (*meshSideSets_)[0][0].resize(nx_);
154 (*meshSideSets_)[0][1].resize(0);
155 (*meshSideSets_)[0][2].resize(0);
156 (*meshSideSets_)[0][3].resize(0);
157 // Right
158 (*meshSideSets_)[1].resize(4);
159 (*meshSideSets_)[1][0].resize(0);
160 (*meshSideSets_)[1][1].resize(ny_);
161 (*meshSideSets_)[1][2].resize(0);
162 (*meshSideSets_)[1][3].resize(0);
163 // Top
164 (*meshSideSets_)[2].resize(4);
165 (*meshSideSets_)[2][0].resize(0);
166 (*meshSideSets_)[2][1].resize(0);
167 (*meshSideSets_)[2][2].resize(np);
168 (*meshSideSets_)[2][3].resize(0);
169 (*meshSideSets_)[3].resize(4);
170 (*meshSideSets_)[3][0].resize(0);
171 (*meshSideSets_)[3][1].resize(0);
172 (*meshSideSets_)[3][2].resize(nc);
173 (*meshSideSets_)[3][3].resize(0);
174 (*meshSideSets_)[4].resize(4);
175 (*meshSideSets_)[4][0].resize(0);
176 (*meshSideSets_)[4][1].resize(0);
177 (*meshSideSets_)[4][2].resize(np);
178 (*meshSideSets_)[4][3].resize(0);
179 // Left
180 (*meshSideSets_)[5].resize(4);
181 (*meshSideSets_)[5][0].resize(0);
182 (*meshSideSets_)[5][1].resize(0);
183 (*meshSideSets_)[5][2].resize(0);
184 (*meshSideSets_)[5][3].resize(ny_);
185
186 for (int i=0; i<nx_; ++i) {
187 (*meshSideSets_)[0][0][i] = i;
188 }
189 for (int i=0; i<ny_; ++i) {
190 (*meshSideSets_)[1][1][i] = (i+1)*nx_-1;
191 }
192 for (int i=0; i<np; ++i) {
193 (*meshSideSets_)[2][2][i] = i + nx_*(ny_-1);
194 }
195 for (int i=0; i<nc; ++i) {
196 (*meshSideSets_)[3][2][i] = i + nx_*(ny_-1) + np;
197 }
198 for (int i=0; i<np; ++i) {
199 (*meshSideSets_)[4][2][i] = i + nx_*(ny_-1) + (np+nc);
200 }
201 for (int i=0; i<ny_; ++i) {
202 (*meshSideSets_)[5][3][i] = i*nx_;
203 }
204 } // carrierplate_computeSideSets
205
206 void wheel_computeSideSets() {
207 int numSideSets = 8;
208 meshSideSets_ = ROL::makePtr<std::vector<std::vector<std::vector<int>>>>(numSideSets);
209
210 Real pf(0.125);
211 Real patchFrac = (pf < width_) ? pf/width_ : pf;
212 int np = static_cast<int>(patchFrac * static_cast<Real>(nx_));
213 int nz = static_cast<int>(0.5*static_cast<Real>(nx_-4*np));
214 int nc = nx_-2*(np+nz);
215
216 // Bottom
217 (*meshSideSets_)[0].resize(4);
218 (*meshSideSets_)[0][0].resize(np);
219 (*meshSideSets_)[0][1].resize(0);
220 (*meshSideSets_)[0][2].resize(0);
221 (*meshSideSets_)[0][3].resize(0);
222 (*meshSideSets_)[1].resize(4);
223 (*meshSideSets_)[1][0].resize(nz);
224 (*meshSideSets_)[1][1].resize(0);
225 (*meshSideSets_)[1][2].resize(0);
226 (*meshSideSets_)[1][3].resize(0);
227 (*meshSideSets_)[2].resize(4);
228 (*meshSideSets_)[2][0].resize(nc);
229 (*meshSideSets_)[2][1].resize(0);
230 (*meshSideSets_)[2][2].resize(0);
231 (*meshSideSets_)[2][3].resize(0);
232 (*meshSideSets_)[3].resize(4);
233 (*meshSideSets_)[3][0].resize(nz);
234 (*meshSideSets_)[3][1].resize(0);
235 (*meshSideSets_)[3][2].resize(0);
236 (*meshSideSets_)[3][3].resize(0);
237 (*meshSideSets_)[4].resize(4);
238 (*meshSideSets_)[4][0].resize(np);
239 (*meshSideSets_)[4][1].resize(0);
240 (*meshSideSets_)[4][2].resize(0);
241 (*meshSideSets_)[4][3].resize(0);
242 // Right
243 (*meshSideSets_)[5].resize(4);
244 (*meshSideSets_)[5][0].resize(0);
245 (*meshSideSets_)[5][1].resize(ny_);
246 (*meshSideSets_)[5][2].resize(0);
247 (*meshSideSets_)[5][3].resize(0);
248 // Top
249 (*meshSideSets_)[6].resize(4);
250 (*meshSideSets_)[6][0].resize(0);
251 (*meshSideSets_)[6][1].resize(0);
252 (*meshSideSets_)[6][2].resize(nx_);
253 (*meshSideSets_)[6][3].resize(0);
254 // Left
255 (*meshSideSets_)[7].resize(4);
256 (*meshSideSets_)[7][0].resize(0);
257 (*meshSideSets_)[7][1].resize(0);
258 (*meshSideSets_)[7][2].resize(0);
259 (*meshSideSets_)[7][3].resize(ny_);
260
261 for (int i=0; i<np; ++i) {
262 (*meshSideSets_)[0][0][i] = i;
263 }
264 for (int i=0; i<nz; ++i) {
265 (*meshSideSets_)[1][0][i] = i + np;
266 }
267 for (int i=0; i<nc; ++i) {
268 (*meshSideSets_)[2][0][i] = i + (np+nz);
269 }
270 for (int i=0; i<nz; ++i) {
271 (*meshSideSets_)[3][0][i] = i + (np+nz+nc);
272 }
273 for (int i=0; i<np; ++i) {
274 (*meshSideSets_)[4][0][i] = i + (np+nz+nc+nz);
275 }
276 for (int i=0; i<ny_; ++i) {
277 (*meshSideSets_)[5][1][i] = (i+1)*nx_-1;
278 }
279 for (int i=0; i<nx_; ++i) {
280 (*meshSideSets_)[6][2][i] = i + nx_*(ny_-1);
281 }
282 for (int i=0; i<ny_; ++i) {
283 (*meshSideSets_)[7][3][i] = i*nx_;
284 }
285 } // wheel_computeSideSets
286
287 void default_computeSideSets() {
288
289 int numSideSets = 4;
290 meshSideSets_ = ROL::makePtr<std::vector<std::vector<std::vector<int> > >>(numSideSets);
291
292 //
293 (*meshSideSets_)[0].resize(4);
294 (*meshSideSets_)[0][0].resize(nx_);
295 (*meshSideSets_)[0][1].resize(0);
296 (*meshSideSets_)[0][2].resize(0);
297 (*meshSideSets_)[0][3].resize(0);
298 //
299 (*meshSideSets_)[1].resize(4);
300 (*meshSideSets_)[1][0].resize(0);
301 (*meshSideSets_)[1][1].resize(ny_);
302 (*meshSideSets_)[1][2].resize(0);
303 (*meshSideSets_)[1][3].resize(0);
304 //
305 (*meshSideSets_)[2].resize(4);
306 (*meshSideSets_)[2][0].resize(0);
307 (*meshSideSets_)[2][1].resize(0);
308 (*meshSideSets_)[2][2].resize(nx_);
309 (*meshSideSets_)[2][3].resize(0);
310 //
311 (*meshSideSets_)[3].resize(4);
312 (*meshSideSets_)[3][0].resize(0);
313 (*meshSideSets_)[3][1].resize(0);
314 (*meshSideSets_)[3][2].resize(0);
315 (*meshSideSets_)[3][3].resize(ny_);
316
317 for (int i=0; i<nx_; ++i) {
318 (*meshSideSets_)[0][0][i] = i;
319 }
320 for (int i=0; i<ny_; ++i) {
321 (*meshSideSets_)[1][1][i] = (i+1)*nx_-1;
322 }
323 for (int i=0; i<nx_; ++i) {
324 (*meshSideSets_)[2][2][i] = i + nx_*(ny_-1);
325 }
326 for (int i=0; i<ny_; ++i) {
327 (*meshSideSets_)[3][3][i] = i*nx_;
328 }
329 } // default_computeSideSets
330
331 ROL::Ptr<std::vector<std::vector<std::vector<int>>>> getSideSets(
332 const bool verbose = false,
333 std::ostream & outStream = std::cout) const {
334 if ( verbose ) {
335 outStream << "Mesh_TopoOpt: getSideSets called" << std::endl;
336 outStream << "Mesh_TopoOpt: numSideSets = " << meshSideSets_->size() << std::endl;
337 }
338 return meshSideSets_;
339 }
340
341 }; // MeshManager_TopoOpt
342
343 #endif