9#ifndef GOOSEFEM_MESHHEX8_H
10#define GOOSEFEM_MESHHEX8_H
49 m_nnode = (m_nelx + 1) * (m_nely + 1) * (m_nelz + 1);
50 m_nelem = m_nelx * m_nely * m_nelz;
57 size_t nelx_impl()
const
62 size_t nely_impl()
const
67 size_t nelz_impl()
const
77 array_type::tensor<double, 2> coor_impl()
const
79 array_type::tensor<double, 2> ret = xt::empty<double>({m_nnode, m_ndim});
81 array_type::tensor<double, 1> x =
82 xt::linspace<double>(0.0, m_h *
static_cast<double>(m_nelx), m_nelx + 1);
83 array_type::tensor<double, 1> y =
84 xt::linspace<double>(0.0, m_h *
static_cast<double>(m_nely), m_nely + 1);
85 array_type::tensor<double, 1> z =
86 xt::linspace<double>(0.0, m_h *
static_cast<double>(m_nelz), m_nelz + 1);
90 for (
size_t iz = 0; iz < m_nelz + 1; ++iz) {
91 for (
size_t iy = 0; iy < m_nely + 1; ++iy) {
92 for (
size_t ix = 0; ix < m_nelx + 1; ++ix) {
93 ret(inode, 0) = x(ix);
94 ret(inode, 1) = y(iy);
95 ret(inode, 2) = z(iz);
104 array_type::tensor<size_t, 2> conn_impl()
const
106 array_type::tensor<size_t, 2> ret = xt::empty<size_t>({m_nelem, m_nne});
110 for (
size_t iz = 0; iz < m_nelz; ++iz) {
111 for (
size_t iy = 0; iy < m_nely; ++iy) {
112 for (
size_t ix = 0; ix < m_nelx; ++ix) {
113 ret(ielem, 0) = iy * (m_nelx + 1) + ix + iz * (m_nely + 1) * (m_nelx + 1);
114 ret(ielem, 1) = iy * (m_nelx + 1) + (ix + 1) + iz * (m_nely + 1) * (m_nelx + 1);
115 ret(ielem, 3) = (iy + 1) * (m_nelx + 1) + ix + iz * (m_nely + 1) * (m_nelx + 1);
117 (iy + 1) * (m_nelx + 1) + (ix + 1) + iz * (m_nely + 1) * (m_nelx + 1);
118 ret(ielem, 4) = iy * (m_nelx + 1) + ix + (iz + 1) * (m_nely + 1) * (m_nelx + 1);
120 (iy) * (m_nelx + 1) + (ix + 1) + (iz + 1) * (m_nely + 1) * (m_nelx + 1);
122 (iy + 1) * (m_nelx + 1) + ix + (iz + 1) * (m_nely + 1) * (m_nelx + 1);
124 (iy + 1) * (m_nelx + 1) + (ix + 1) + (iz + 1) * (m_nely + 1) * (m_nelx + 1);
133 array_type::tensor<size_t, 1> nodesFront_impl()
const
135 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nelx + 1) * (m_nely + 1)});
137 for (
size_t iy = 0; iy < m_nely + 1; ++iy) {
138 for (
size_t ix = 0; ix < m_nelx + 1; ++ix) {
139 ret(iy * (m_nelx + 1) + ix) = iy * (m_nelx + 1) + ix;
146 array_type::tensor<size_t, 1> nodesBack_impl()
const
148 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nelx + 1) * (m_nely + 1)});
150 for (
size_t iy = 0; iy < m_nely + 1; ++iy) {
151 for (
size_t ix = 0; ix < m_nelx + 1; ++ix) {
152 ret(iy * (m_nelx + 1) + ix) =
153 iy * (m_nelx + 1) + ix + m_nelz * (m_nely + 1) * (m_nelx + 1);
160 array_type::tensor<size_t, 1> nodesLeft_impl()
const
162 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nely + 1) * (m_nelz + 1)});
164 for (
size_t iz = 0; iz < m_nelz + 1; ++iz) {
165 for (
size_t iy = 0; iy < m_nely + 1; ++iy) {
166 ret(iz * (m_nely + 1) + iy) = iy * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1);
173 array_type::tensor<size_t, 1> nodesRight_impl()
const
175 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nely + 1) * (m_nelz + 1)});
177 for (
size_t iz = 0; iz < m_nelz + 1; ++iz) {
178 for (
size_t iy = 0; iy < m_nely + 1; ++iy) {
179 ret(iz * (m_nely + 1) + iy) =
180 iy * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1) + m_nelx;
187 array_type::tensor<size_t, 1> nodesBottom_impl()
const
189 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nelx + 1) * (m_nelz + 1)});
191 for (
size_t iz = 0; iz < m_nelz + 1; ++iz) {
192 for (
size_t ix = 0; ix < m_nelx + 1; ++ix) {
193 ret(iz * (m_nelx + 1) + ix) = ix + iz * (m_nelx + 1) * (m_nely + 1);
200 array_type::tensor<size_t, 1> nodesTop_impl()
const
202 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nelx + 1) * (m_nelz + 1)});
204 for (
size_t iz = 0; iz < m_nelz + 1; ++iz) {
205 for (
size_t ix = 0; ix < m_nelx + 1; ++ix) {
206 ret(iz * (m_nelx + 1) + ix) =
207 ix + m_nely * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1);
214 array_type::tensor<size_t, 1> nodesFrontFace_impl()
const
216 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nelx - 1) * (m_nely - 1)});
218 for (
size_t iy = 1; iy < m_nely; ++iy) {
219 for (
size_t ix = 1; ix < m_nelx; ++ix) {
220 ret((iy - 1) * (m_nelx - 1) + (ix - 1)) = iy * (m_nelx + 1) + ix;
227 array_type::tensor<size_t, 1> nodesBackFace_impl()
const
229 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nelx - 1) * (m_nely - 1)});
231 for (
size_t iy = 1; iy < m_nely; ++iy) {
232 for (
size_t ix = 1; ix < m_nelx; ++ix) {
233 ret((iy - 1) * (m_nelx - 1) + (ix - 1)) =
234 iy * (m_nelx + 1) + ix + m_nelz * (m_nely + 1) * (m_nelx + 1);
241 array_type::tensor<size_t, 1> nodesLeftFace_impl()
const
243 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nely - 1) * (m_nelz - 1)});
245 for (
size_t iz = 1; iz < m_nelz; ++iz) {
246 for (
size_t iy = 1; iy < m_nely; ++iy) {
247 ret((iz - 1) * (m_nely - 1) + (iy - 1)) =
248 iy * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1);
255 array_type::tensor<size_t, 1> nodesRightFace_impl()
const
257 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nely - 1) * (m_nelz - 1)});
259 for (
size_t iz = 1; iz < m_nelz; ++iz) {
260 for (
size_t iy = 1; iy < m_nely; ++iy) {
261 ret((iz - 1) * (m_nely - 1) + (iy - 1)) =
262 iy * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1) + m_nelx;
269 array_type::tensor<size_t, 1> nodesBottomFace_impl()
const
271 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nelx - 1) * (m_nelz - 1)});
273 for (
size_t iz = 1; iz < m_nelz; ++iz) {
274 for (
size_t ix = 1; ix < m_nelx; ++ix) {
275 ret((iz - 1) * (m_nelx - 1) + (ix - 1)) = ix + iz * (m_nelx + 1) * (m_nely + 1);
282 array_type::tensor<size_t, 1> nodesTopFace_impl()
const
284 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({(m_nelx - 1) * (m_nelz - 1)});
286 for (
size_t iz = 1; iz < m_nelz; ++iz) {
287 for (
size_t ix = 1; ix < m_nelx; ++ix) {
288 ret((iz - 1) * (m_nelx - 1) + (ix - 1)) =
289 ix + m_nely * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1);
296 array_type::tensor<size_t, 1> nodesFrontBottomEdge_impl()
const
298 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelx + 1});
300 for (
size_t ix = 0; ix < m_nelx + 1; ++ix) {
307 array_type::tensor<size_t, 1> nodesFrontTopEdge_impl()
const
309 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelx + 1});
311 for (
size_t ix = 0; ix < m_nelx + 1; ++ix) {
312 ret(ix) = ix + m_nely * (m_nelx + 1);
318 array_type::tensor<size_t, 1> nodesFrontLeftEdge_impl()
const
320 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nely + 1});
322 for (
size_t iy = 0; iy < m_nely + 1; ++iy) {
323 ret(iy) = iy * (m_nelx + 1);
329 array_type::tensor<size_t, 1> nodesFrontRightEdge_impl()
const
331 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nely + 1});
333 for (
size_t iy = 0; iy < m_nely + 1; ++iy) {
334 ret(iy) = iy * (m_nelx + 1) + m_nelx;
340 array_type::tensor<size_t, 1> nodesBackBottomEdge_impl()
const
342 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelx + 1});
344 for (
size_t ix = 0; ix < m_nelx + 1; ++ix) {
345 ret(ix) = ix + m_nelz * (m_nely + 1) * (m_nelx + 1);
351 array_type::tensor<size_t, 1> nodesBackTopEdge_impl()
const
353 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelx + 1});
355 for (
size_t ix = 0; ix < m_nelx + 1; ++ix) {
356 ret(ix) = m_nely * (m_nelx + 1) + ix + m_nelz * (m_nely + 1) * (m_nelx + 1);
362 array_type::tensor<size_t, 1> nodesBackLeftEdge_impl()
const
364 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nely + 1});
366 for (
size_t iy = 0; iy < m_nely + 1; ++iy) {
367 ret(iy) = iy * (m_nelx + 1) + m_nelz * (m_nelx + 1) * (m_nely + 1);
373 array_type::tensor<size_t, 1> nodesBackRightEdge_impl()
const
375 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nely + 1});
377 for (
size_t iy = 0; iy < m_nely + 1; ++iy) {
378 ret(iy) = iy * (m_nelx + 1) + m_nelz * (m_nelx + 1) * (m_nely + 1) + m_nelx;
384 array_type::tensor<size_t, 1> nodesBottomLeftEdge_impl()
const
386 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelz + 1});
388 for (
size_t iz = 0; iz < m_nelz + 1; ++iz) {
389 ret(iz) = iz * (m_nelx + 1) * (m_nely + 1);
395 array_type::tensor<size_t, 1> nodesBottomRightEdge_impl()
const
397 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelz + 1});
399 for (
size_t iz = 0; iz < m_nelz + 1; ++iz) {
400 ret(iz) = iz * (m_nelx + 1) * (m_nely + 1) + m_nelx;
406 array_type::tensor<size_t, 1> nodesTopLeftEdge_impl()
const
408 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelz + 1});
410 for (
size_t iz = 0; iz < m_nelz + 1; ++iz) {
411 ret(iz) = m_nely * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1);
417 array_type::tensor<size_t, 1> nodesTopRightEdge_impl()
const
419 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelz + 1});
421 for (
size_t iz = 0; iz < m_nelz + 1; ++iz) {
422 ret(iz) = m_nely * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1) + m_nelx;
428 array_type::tensor<size_t, 1> nodesFrontBottomOpenEdge_impl()
const
430 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelx - 1});
432 for (
size_t ix = 1; ix < m_nelx; ++ix) {
439 array_type::tensor<size_t, 1> nodesFrontTopOpenEdge_impl()
const
441 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelx - 1});
443 for (
size_t ix = 1; ix < m_nelx; ++ix) {
444 ret(ix - 1) = ix + m_nely * (m_nelx + 1);
450 array_type::tensor<size_t, 1> nodesFrontLeftOpenEdge_impl()
const
452 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nely - 1});
454 for (
size_t iy = 1; iy < m_nely; ++iy) {
455 ret(iy - 1) = iy * (m_nelx + 1);
461 array_type::tensor<size_t, 1> nodesFrontRightOpenEdge_impl()
const
463 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nely - 1});
465 for (
size_t iy = 1; iy < m_nely; ++iy) {
466 ret(iy - 1) = iy * (m_nelx + 1) + m_nelx;
472 array_type::tensor<size_t, 1> nodesBackBottomOpenEdge_impl()
const
474 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelx - 1});
476 for (
size_t ix = 1; ix < m_nelx; ++ix) {
477 ret(ix - 1) = ix + m_nelz * (m_nely + 1) * (m_nelx + 1);
483 array_type::tensor<size_t, 1> nodesBackTopOpenEdge_impl()
const
485 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelx - 1});
487 for (
size_t ix = 1; ix < m_nelx; ++ix) {
488 ret(ix - 1) = m_nely * (m_nelx + 1) + ix + m_nelz * (m_nely + 1) * (m_nelx + 1);
494 array_type::tensor<size_t, 1> nodesBackLeftOpenEdge_impl()
const
496 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nely - 1});
498 for (
size_t iy = 1; iy < m_nely; ++iy) {
499 ret(iy - 1) = iy * (m_nelx + 1) + m_nelz * (m_nelx + 1) * (m_nely + 1);
505 array_type::tensor<size_t, 1> nodesBackRightOpenEdge_impl()
const
507 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nely - 1});
509 for (
size_t iy = 1; iy < m_nely; ++iy) {
510 ret(iy - 1) = iy * (m_nelx + 1) + m_nelz * (m_nelx + 1) * (m_nely + 1) + m_nelx;
516 array_type::tensor<size_t, 1> nodesBottomLeftOpenEdge_impl()
const
518 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelz - 1});
520 for (
size_t iz = 1; iz < m_nelz; ++iz) {
521 ret(iz - 1) = iz * (m_nelx + 1) * (m_nely + 1);
527 array_type::tensor<size_t, 1> nodesBottomRightOpenEdge_impl()
const
529 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelz - 1});
531 for (
size_t iz = 1; iz < m_nelz; ++iz) {
532 ret(iz - 1) = iz * (m_nelx + 1) * (m_nely + 1) + m_nelx;
538 array_type::tensor<size_t, 1> nodesTopLeftOpenEdge_impl()
const
540 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelz - 1});
542 for (
size_t iz = 1; iz < m_nelz; ++iz) {
543 ret(iz - 1) = m_nely * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1);
549 array_type::tensor<size_t, 1> nodesTopRightOpenEdge_impl()
const
551 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nelz - 1});
553 for (
size_t iz = 1; iz < m_nelz; ++iz) {
554 ret(iz - 1) = m_nely * (m_nelx + 1) + iz * (m_nelx + 1) * (m_nely + 1) + m_nelx;
560 size_t nodesFrontBottomLeftCorner_impl()
const
565 size_t nodesFrontBottomRightCorner_impl()
const
570 size_t nodesFrontTopLeftCorner_impl()
const
572 return m_nely * (m_nelx + 1);
575 size_t nodesFrontTopRightCorner_impl()
const
577 return m_nely * (m_nelx + 1) + m_nelx;
580 size_t nodesBackBottomLeftCorner_impl()
const
582 return m_nelz * (m_nely + 1) * (m_nelx + 1);
585 size_t nodesBackBottomRightCorner_impl()
const
587 return m_nelx + m_nelz * (m_nely + 1) * (m_nelx + 1);
590 size_t nodesBackTopLeftCorner_impl()
const
592 return m_nely * (m_nelx + 1) + m_nelz * (m_nely + 1) * (m_nelx + 1);
595 size_t nodesBackTopRightCorner_impl()
const
597 return m_nely * (m_nelx + 1) + m_nelx + m_nelz * (m_nely + 1) * (m_nelx + 1);
639 m_Lx = m_h *
static_cast<double>(
nelx);
640 m_Lz = m_h *
static_cast<double>(
nelz);
656 nmin = (
nely + 1) / 2;
660 if (nfine % 2 == 0) {
661 nfine = nfine / 2 + 1;
664 nfine = (nfine + 1) / 2;
679 for (
size_t iy = nfine;;) {
685 if (iy >=
nely || ntot >= nmin) {
691 if (3 * nhy(iy) <= ntot &&
nelx % (3 * nhx(iy)) == 0 && ntot + nhy(iy) < nmin) {
695 auto vnhy = xt::view(nhy, xt::range(iy + 1, _));
696 auto vnhx = xt::view(nhx, xt::range(iy, _));
701 if (iy + 1 <
nely && ntot + 2 * nhy(iy) < nmin) {
702 if (
nelz % (3 * nhz(iy + 1)) == 0) {
709 nhy(iy) = nhy(iy - 1);
710 auto vnhz = xt::view(nhz, xt::range(iy, _));
717 else if (3 * nhy(iy) <= ntot &&
nelz % (3 * nhz(iy)) == 0 && ntot + nhy(iy) < nmin) {
721 auto vnhy = xt::view(nhy, xt::range(iy + 1, _));
722 auto vnhz = xt::view(nhz, xt::range(iy, _));
732 if (iy >=
nely || ntot >= nmin) {
741 m_nhx = xt::empty<size_t>({
nely * 2 - 1});
742 m_nhy = xt::empty<size_t>({
nely * 2 - 1});
743 m_nhz = xt::empty<size_t>({
nely * 2 - 1});
744 m_refine = xt::empty<int>({
nely * 2 - 1});
745 m_layer_nelx = xt::empty<size_t>({
nely * 2 - 1});
746 m_layer_nelz = xt::empty<size_t>({
nely * 2 - 1});
747 m_nnd = xt::empty<size_t>({
nely * 2});
748 m_startElem = xt::empty<size_t>({
nely * 2 - 1});
749 m_startNode = xt::empty<size_t>({
nely * 2});
753 for (
size_t iy = 0; iy <
nely; ++iy) {
754 m_nhx(iy) = nhx(
nely - iy - 1);
755 m_nhy(iy) = nhy(
nely - iy - 1);
756 m_nhz(iy) = nhz(
nely - iy - 1);
757 m_refine(iy) = refine(
nely - iy - 1);
760 for (
size_t iy = 0; iy <
nely - 1; ++iy) {
761 m_nhx(iy +
nely) = nhx(iy + 1);
762 m_nhy(iy +
nely) = nhy(iy + 1);
763 m_nhz(iy +
nely) = nhz(iy + 1);
764 m_refine(iy +
nely) = refine(iy + 1);
771 for (
size_t iy = 0; iy <
nely; ++iy) {
772 m_layer_nelx(iy) =
nelx / m_nhx(iy);
773 m_layer_nelz(iy) =
nelz / m_nhz(iy);
778 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy)
779 m_nnd(iy) = (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy) + 1);
781 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy)
782 m_nnd(iy + 1) = (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy) + 1);
792 for (
size_t i = 0; i < (
nely - 1) / 2; ++i) {
794 m_startElem(i) = m_nelem;
796 if (m_refine(i) == 0) {
797 m_nnode += (3 * m_layer_nelx(i) + 1) * (m_layer_nelz(i) + 1);
799 else if (m_refine(i) == 2) {
800 m_nnode += (m_layer_nelx(i) + 1) * (3 * m_layer_nelz(i) + 1);
803 m_nnode += (m_layer_nelx(i) + 1) * (m_layer_nelz(i) + 1);
806 if (m_refine(i) == 0) {
807 m_nelem += (4 * m_layer_nelx(i)) * (m_layer_nelz(i));
809 else if (m_refine(i) == 2) {
810 m_nelem += (m_layer_nelx(i)) * (4 * m_layer_nelz(i));
813 m_nelem += (m_layer_nelx(i)) * (m_layer_nelz(i));
816 m_startNode(i + 1) = m_nnode;
820 for (
size_t i = (
nely - 1) / 2; i <
nely; ++i) {
822 m_startElem(i) = m_nelem;
824 if (m_refine(i) == 0) {
825 m_nnode += (5 * m_layer_nelx(i) + 1) * (m_layer_nelz(i) + 1);
827 else if (m_refine(i) == 2) {
828 m_nnode += (m_layer_nelx(i) + 1) * (5 * m_layer_nelz(i) + 1);
831 m_nnode += (m_layer_nelx(i) + 1) * (m_layer_nelz(i) + 1);
834 if (m_refine(i) == 0) {
835 m_nelem += (4 * m_layer_nelx(i)) * (m_layer_nelz(i));
837 else if (m_refine(i) == 2) {
838 m_nelem += (m_layer_nelx(i)) * (4 * m_layer_nelz(i));
841 m_nelem += (m_layer_nelx(i)) * (m_layer_nelz(i));
844 m_startNode(i + 1) = m_nnode;
847 m_nnode += (m_layer_nelx(
nely - 1) + 1) * (m_layer_nelz(
nely - 1) + 1);
856 size_t nely =
static_cast<size_t>(m_nhy.size());
857 size_t y = (
nely - 1) / 2;
861 for (
size_t x = 0; x < m_layer_nelx(y); ++x) {
862 for (
size_t z = 0; z < m_layer_nelz(y); ++z) {
863 ret(x + z * m_layer_nelx(y)) = m_startElem(y) + x + z * m_layer_nelx(y);
874 size_t nelx_impl()
const
876 return xt::amax(m_layer_nelx)();
879 size_t nely_impl()
const
881 return xt::sum(m_nhy)();
884 size_t nelz_impl()
const
886 return xt::amax(m_layer_nelz)();
893 array_type::tensor<double, 2> coor_impl()
const
896 array_type::tensor<double, 2> ret = xt::empty<double>({m_nnode, m_ndim});
900 size_t nely =
static_cast<size_t>(m_nhy.size());
904 array_type::tensor<double, 1> y = xt::empty<double>({
nely + 1});
908 for (
size_t iy = 1; iy <
nely + 1; ++iy) {
909 y(iy) = y(iy - 1) + m_nhy(iy - 1) * m_h;
915 for (
size_t iy = 0;; ++iy) {
917 array_type::tensor<double, 1> x = xt::linspace<double>(0.0, m_Lx, m_layer_nelx(iy) + 1);
918 array_type::tensor<double, 1> z = xt::linspace<double>(0.0, m_Lz, m_layer_nelz(iy) + 1);
921 for (
size_t iz = 0; iz < m_layer_nelz(iy) + 1; ++iz) {
922 for (
size_t ix = 0; ix < m_layer_nelx(iy) + 1; ++ix) {
923 ret(inode, 0) = x(ix);
924 ret(inode, 1) = y(iy);
925 ret(inode, 2) = z(iz);
931 if (iy == (
nely - 1) / 2) {
936 if (m_refine(iy) == 0) {
938 double dx = m_h *
static_cast<double>(m_nhx(iy) / 3);
939 double dy = m_h *
static_cast<double>(m_nhy(iy) / 2);
941 for (
size_t iz = 0; iz < m_layer_nelz(iy) + 1; ++iz) {
942 for (
size_t ix = 0; ix < m_layer_nelx(iy); ++ix) {
943 for (
size_t j = 0; j < 2; ++j) {
944 ret(inode, 0) = x(ix) + dx *
static_cast<double>(j + 1);
945 ret(inode, 1) = y(iy) + dy;
946 ret(inode, 2) = z(iz);
954 else if (m_refine(iy) == 2) {
956 double dz = m_h *
static_cast<double>(m_nhz(iy) / 3);
957 double dy = m_h *
static_cast<double>(m_nhy(iy) / 2);
959 for (
size_t iz = 0; iz < m_layer_nelz(iy); ++iz) {
960 for (
size_t j = 0; j < 2; ++j) {
961 for (
size_t ix = 0; ix < m_layer_nelx(iy) + 1; ++ix) {
962 ret(inode, 0) = x(ix);
963 ret(inode, 1) = y(iy) + dy;
964 ret(inode, 2) = z(iz) + dz *
static_cast<double>(j + 1);
974 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
976 array_type::tensor<double, 1> x = xt::linspace<double>(0.0, m_Lx, m_layer_nelx(iy) + 1);
977 array_type::tensor<double, 1> z = xt::linspace<double>(0.0, m_Lz, m_layer_nelz(iy) + 1);
980 if (m_refine(iy) == 0) {
982 double dx = m_h *
static_cast<double>(m_nhx(iy) / 3);
983 double dy = m_h *
static_cast<double>(m_nhy(iy) / 2);
985 for (
size_t iz = 0; iz < m_layer_nelz(iy) + 1; ++iz) {
986 for (
size_t ix = 0; ix < m_layer_nelx(iy); ++ix) {
987 for (
size_t j = 0; j < 2; ++j) {
988 ret(inode, 0) = x(ix) + dx *
static_cast<double>(j + 1);
989 ret(inode, 1) = y(iy) + dy;
990 ret(inode, 2) = z(iz);
998 else if (m_refine(iy) == 2) {
1000 double dz = m_h *
static_cast<double>(m_nhz(iy) / 3);
1001 double dy = m_h *
static_cast<double>(m_nhy(iy) / 2);
1003 for (
size_t iz = 0; iz < m_layer_nelz(iy); ++iz) {
1004 for (
size_t j = 0; j < 2; ++j) {
1005 for (
size_t ix = 0; ix < m_layer_nelx(iy) + 1; ++ix) {
1006 ret(inode, 0) = x(ix);
1007 ret(inode, 1) = y(iy) + dy;
1008 ret(inode, 2) = z(iz) + dz *
static_cast<double>(j + 1);
1016 for (
size_t iz = 0; iz < m_layer_nelz(iy) + 1; ++iz) {
1017 for (
size_t ix = 0; ix < m_layer_nelx(iy) + 1; ++ix) {
1018 ret(inode, 0) = x(ix);
1019 ret(inode, 1) = y(iy + 1);
1020 ret(inode, 2) = z(iz);
1029 array_type::tensor<size_t, 2> conn_impl()
const
1032 array_type::tensor<size_t, 2> ret = xt::empty<size_t>({m_nelem, m_nne});
1036 size_t nely =
static_cast<size_t>(m_nhy.size());
1037 size_t bot, mid, top;
1040 for (
size_t iy = 0; iy <
nely; ++iy) {
1042 bot = m_startNode(iy);
1043 mid = m_startNode(iy) + m_nnd(iy);
1044 top = m_startNode(iy + 1);
1047 if (m_refine(iy) == -1) {
1048 for (
size_t iz = 0; iz < m_layer_nelz(iy); ++iz) {
1049 for (
size_t ix = 0; ix < m_layer_nelx(iy); ++ix) {
1050 ret(ielem, 0) = bot + ix + iz * (m_layer_nelx(iy) + 1);
1051 ret(ielem, 1) = bot + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1052 ret(ielem, 2) = top + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1053 ret(ielem, 3) = top + ix + iz * (m_layer_nelx(iy) + 1);
1054 ret(ielem, 4) = bot + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1055 ret(ielem, 5) = bot + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1056 ret(ielem, 6) = top + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1057 ret(ielem, 7) = top + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1064 else if (m_refine(iy) == 0 && iy <= (
nely - 1) / 2) {
1065 for (
size_t iz = 0; iz < m_layer_nelz(iy); ++iz) {
1066 for (
size_t ix = 0; ix < m_layer_nelx(iy); ++ix) {
1068 ret(ielem, 0) = bot + ix + iz * (m_layer_nelx(iy) + 1);
1069 ret(ielem, 1) = bot + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1070 ret(ielem, 2) = mid + (2 * ix + 1) + iz * (2 * m_layer_nelx(iy));
1071 ret(ielem, 3) = mid + (2 * ix) + iz * (2 * m_layer_nelx(iy));
1072 ret(ielem, 4) = bot + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1073 ret(ielem, 5) = bot + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1074 ret(ielem, 6) = mid + (2 * ix + 1) + (iz + 1) * (2 * m_layer_nelx(iy));
1075 ret(ielem, 7) = mid + (2 * ix) + (iz + 1) * (2 * m_layer_nelx(iy));
1078 ret(ielem, 0) = bot + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1079 ret(ielem, 1) = top + (3 * ix + 3) + iz * (3 * m_layer_nelx(iy) + 1);
1080 ret(ielem, 2) = top + (3 * ix + 2) + iz * (3 * m_layer_nelx(iy) + 1);
1081 ret(ielem, 3) = mid + (2 * ix + 1) + iz * (2 * m_layer_nelx(iy));
1082 ret(ielem, 4) = bot + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1083 ret(ielem, 5) = top + (3 * ix + 3) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1084 ret(ielem, 6) = top + (3 * ix + 2) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1085 ret(ielem, 7) = mid + (2 * ix + 1) + (iz + 1) * (2 * m_layer_nelx(iy));
1088 ret(ielem, 0) = mid + (2 * ix) + iz * (2 * m_layer_nelx(iy));
1089 ret(ielem, 1) = mid + (2 * ix + 1) + iz * (2 * m_layer_nelx(iy));
1090 ret(ielem, 2) = top + (3 * ix + 2) + iz * (3 * m_layer_nelx(iy) + 1);
1091 ret(ielem, 3) = top + (3 * ix + 1) + iz * (3 * m_layer_nelx(iy) + 1);
1092 ret(ielem, 4) = mid + (2 * ix) + (iz + 1) * (2 * m_layer_nelx(iy));
1093 ret(ielem, 5) = mid + (2 * ix + 1) + (iz + 1) * (2 * m_layer_nelx(iy));
1094 ret(ielem, 6) = top + (3 * ix + 2) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1095 ret(ielem, 7) = top + (3 * ix + 1) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1098 ret(ielem, 0) = bot + ix + iz * (m_layer_nelx(iy) + 1);
1099 ret(ielem, 1) = mid + (2 * ix) + iz * (2 * m_layer_nelx(iy));
1100 ret(ielem, 2) = top + (3 * ix + 1) + iz * (3 * m_layer_nelx(iy) + 1);
1101 ret(ielem, 3) = top + (3 * ix) + iz * (3 * m_layer_nelx(iy) + 1);
1102 ret(ielem, 4) = bot + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1103 ret(ielem, 5) = mid + (2 * ix) + (iz + 1) * (2 * m_layer_nelx(iy));
1104 ret(ielem, 6) = top + (3 * ix + 1) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1105 ret(ielem, 7) = top + (3 * ix) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1112 else if (m_refine(iy) == 0 && iy > (
nely - 1) / 2) {
1113 for (
size_t iz = 0; iz < m_layer_nelz(iy); ++iz) {
1114 for (
size_t ix = 0; ix < m_layer_nelx(iy); ++ix) {
1116 ret(ielem, 0) = bot + (3 * ix) + iz * (3 * m_layer_nelx(iy) + 1);
1117 ret(ielem, 1) = bot + (3 * ix + 1) + iz * (3 * m_layer_nelx(iy) + 1);
1118 ret(ielem, 2) = mid + (2 * ix) + iz * (2 * m_layer_nelx(iy));
1119 ret(ielem, 3) = top + ix + iz * (m_layer_nelx(iy) + 1);
1120 ret(ielem, 4) = bot + (3 * ix) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1121 ret(ielem, 5) = bot + (3 * ix + 1) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1122 ret(ielem, 6) = mid + (2 * ix) + (iz + 1) * (2 * m_layer_nelx(iy));
1123 ret(ielem, 7) = top + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1126 ret(ielem, 0) = bot + (3 * ix + 1) + iz * (3 * m_layer_nelx(iy) + 1);
1127 ret(ielem, 1) = bot + (3 * ix + 2) + iz * (3 * m_layer_nelx(iy) + 1);
1128 ret(ielem, 2) = mid + (2 * ix + 1) + iz * (2 * m_layer_nelx(iy));
1129 ret(ielem, 3) = mid + (2 * ix) + iz * (2 * m_layer_nelx(iy));
1130 ret(ielem, 4) = bot + (3 * ix + 1) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1131 ret(ielem, 5) = bot + (3 * ix + 2) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1132 ret(ielem, 6) = mid + (2 * ix + 1) + (iz + 1) * (2 * m_layer_nelx(iy));
1133 ret(ielem, 7) = mid + (2 * ix) + (iz + 1) * (2 * m_layer_nelx(iy));
1136 ret(ielem, 0) = bot + (3 * ix + 2) + iz * (3 * m_layer_nelx(iy) + 1);
1137 ret(ielem, 1) = bot + (3 * ix + 3) + iz * (3 * m_layer_nelx(iy) + 1);
1138 ret(ielem, 2) = top + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1139 ret(ielem, 3) = mid + (2 * ix + 1) + iz * (2 * m_layer_nelx(iy));
1140 ret(ielem, 4) = bot + (3 * ix + 2) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1141 ret(ielem, 5) = bot + (3 * ix + 3) + (iz + 1) * (3 * m_layer_nelx(iy) + 1);
1142 ret(ielem, 6) = top + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1143 ret(ielem, 7) = mid + (2 * ix + 1) + (iz + 1) * (2 * m_layer_nelx(iy));
1146 ret(ielem, 0) = mid + (2 * ix) + iz * (2 * m_layer_nelx(iy));
1147 ret(ielem, 1) = mid + (2 * ix + 1) + iz * (2 * m_layer_nelx(iy));
1148 ret(ielem, 2) = top + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1149 ret(ielem, 3) = top + ix + iz * (m_layer_nelx(iy) + 1);
1150 ret(ielem, 4) = mid + (2 * ix) + (iz + 1) * (2 * m_layer_nelx(iy));
1151 ret(ielem, 5) = mid + (2 * ix + 1) + (iz + 1) * (2 * m_layer_nelx(iy));
1152 ret(ielem, 6) = top + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1153 ret(ielem, 7) = top + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1160 else if (m_refine(iy) == 2 && iy <= (
nely - 1) / 2) {
1161 for (
size_t iz = 0; iz < m_layer_nelz(iy); ++iz) {
1162 for (
size_t ix = 0; ix < m_layer_nelx(iy); ++ix) {
1164 ret(ielem, 0) = bot + ix + iz * (m_layer_nelx(iy) + 1);
1165 ret(ielem, 1) = bot + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1166 ret(ielem, 2) = bot + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1167 ret(ielem, 3) = bot + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1168 ret(ielem, 4) = mid + ix + 2 * iz * (m_layer_nelx(iy) + 1);
1169 ret(ielem, 5) = mid + ix + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1170 ret(ielem, 6) = mid + (ix + 1) + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1171 ret(ielem, 7) = mid + (ix + 1) + 2 * iz * (m_layer_nelx(iy) + 1);
1174 ret(ielem, 0) = mid + ix + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1175 ret(ielem, 1) = mid + (ix + 1) + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1176 ret(ielem, 2) = top + (ix + 1) + (3 * iz + 2) * (m_layer_nelx(iy) + 1);
1177 ret(ielem, 3) = top + ix + (3 * iz + 2) * (m_layer_nelx(iy) + 1);
1178 ret(ielem, 4) = bot + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1179 ret(ielem, 5) = bot + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1180 ret(ielem, 6) = top + (ix + 1) + (3 * iz + 3) * (m_layer_nelx(iy) + 1);
1181 ret(ielem, 7) = top + ix + (3 * iz + 3) * (m_layer_nelx(iy) + 1);
1184 ret(ielem, 0) = mid + ix + (2 * iz) * (m_layer_nelx(iy) + 1);
1185 ret(ielem, 1) = mid + (ix + 1) + (2 * iz) * (m_layer_nelx(iy) + 1);
1186 ret(ielem, 2) = top + (ix + 1) + (3 * iz + 1) * (m_layer_nelx(iy) + 1);
1187 ret(ielem, 3) = top + ix + (3 * iz + 1) * (m_layer_nelx(iy) + 1);
1188 ret(ielem, 4) = mid + ix + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1189 ret(ielem, 5) = mid + (ix + 1) + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1190 ret(ielem, 6) = top + (ix + 1) + (3 * iz + 2) * (m_layer_nelx(iy) + 1);
1191 ret(ielem, 7) = top + ix + (3 * iz + 2) * (m_layer_nelx(iy) + 1);
1194 ret(ielem, 0) = bot + ix + iz * (m_layer_nelx(iy) + 1);
1195 ret(ielem, 1) = bot + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1196 ret(ielem, 2) = top + (ix + 1) + (3 * iz) * (m_layer_nelx(iy) + 1);
1197 ret(ielem, 3) = top + ix + (3 * iz) * (m_layer_nelx(iy) + 1);
1198 ret(ielem, 4) = mid + ix + (2 * iz) * (m_layer_nelx(iy) + 1);
1199 ret(ielem, 5) = mid + (ix + 1) + (2 * iz) * (m_layer_nelx(iy) + 1);
1200 ret(ielem, 6) = top + (ix + 1) + (3 * iz + 1) * (m_layer_nelx(iy) + 1);
1201 ret(ielem, 7) = top + ix + (3 * iz + 1) * (m_layer_nelx(iy) + 1);
1208 else if (m_refine(iy) == 2 && iy > (
nely - 1) / 2) {
1209 for (
size_t iz = 0; iz < m_layer_nelz(iy); ++iz) {
1210 for (
size_t ix = 0; ix < m_layer_nelx(iy); ++ix) {
1212 ret(ielem, 0) = bot + ix + (3 * iz) * (m_layer_nelx(iy) + 1);
1213 ret(ielem, 1) = bot + (ix + 1) + (3 * iz) * (m_layer_nelx(iy) + 1);
1214 ret(ielem, 2) = top + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1215 ret(ielem, 3) = top + ix + iz * (m_layer_nelx(iy) + 1);
1216 ret(ielem, 4) = bot + ix + (3 * iz + 1) * (m_layer_nelx(iy) + 1);
1217 ret(ielem, 5) = bot + (ix + 1) + (3 * iz + 1) * (m_layer_nelx(iy) + 1);
1218 ret(ielem, 6) = mid + (ix + 1) + (2 * iz) * (m_layer_nelx(iy) + 1);
1219 ret(ielem, 7) = mid + ix + (2 * iz) * (m_layer_nelx(iy) + 1);
1222 ret(ielem, 0) = bot + ix + (3 * iz + 1) * (m_layer_nelx(iy) + 1);
1223 ret(ielem, 1) = bot + (ix + 1) + (3 * iz + 1) * (m_layer_nelx(iy) + 1);
1224 ret(ielem, 2) = mid + (ix + 1) + (2 * iz) * (m_layer_nelx(iy) + 1);
1225 ret(ielem, 3) = mid + ix + (2 * iz) * (m_layer_nelx(iy) + 1);
1226 ret(ielem, 4) = bot + ix + (3 * iz + 2) * (m_layer_nelx(iy) + 1);
1227 ret(ielem, 5) = bot + (ix + 1) + (3 * iz + 2) * (m_layer_nelx(iy) + 1);
1228 ret(ielem, 6) = mid + (ix + 1) + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1229 ret(ielem, 7) = mid + ix + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1232 ret(ielem, 0) = bot + ix + (3 * iz + 2) * (m_layer_nelx(iy) + 1);
1233 ret(ielem, 1) = bot + (ix + 1) + (3 * iz + 2) * (m_layer_nelx(iy) + 1);
1234 ret(ielem, 2) = mid + (ix + 1) + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1235 ret(ielem, 3) = mid + ix + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1236 ret(ielem, 4) = bot + ix + (3 * iz + 3) * (m_layer_nelx(iy) + 1);
1237 ret(ielem, 5) = bot + (ix + 1) + (3 * iz + 3) * (m_layer_nelx(iy) + 1);
1238 ret(ielem, 6) = top + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1239 ret(ielem, 7) = top + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1242 ret(ielem, 0) = mid + ix + (2 * iz) * (m_layer_nelx(iy) + 1);
1243 ret(ielem, 1) = mid + (ix + 1) + (2 * iz) * (m_layer_nelx(iy) + 1);
1244 ret(ielem, 2) = top + (ix + 1) + iz * (m_layer_nelx(iy) + 1);
1245 ret(ielem, 3) = top + ix + iz * (m_layer_nelx(iy) + 1);
1246 ret(ielem, 4) = mid + ix + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1247 ret(ielem, 5) = mid + (ix + 1) + (2 * iz + 1) * (m_layer_nelx(iy) + 1);
1248 ret(ielem, 6) = top + (ix + 1) + (iz + 1) * (m_layer_nelx(iy) + 1);
1249 ret(ielem, 7) = top + ix + (iz + 1) * (m_layer_nelx(iy) + 1);
1259 array_type::tensor<size_t, 1> nodesFront_impl()
const
1262 size_t nely =
static_cast<size_t>(m_nhy.size());
1268 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1269 if (m_refine(iy) == 0) {
1270 n += m_layer_nelx(iy) * 3 + 1;
1273 n += m_layer_nelx(iy) + 1;
1277 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1278 if (m_refine(iy) == 0) {
1279 n += m_layer_nelx(iy) * 3 + 1;
1282 n += m_layer_nelx(iy) + 1;
1287 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({n});
1293 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1295 for (
size_t ix = 0; ix < m_layer_nelx(iy) + 1; ++ix) {
1296 ret(j) = m_startNode(iy) + ix;
1300 if (m_refine(iy) == 0) {
1301 for (
size_t ix = 0; ix < 2 * m_layer_nelx(iy); ++ix) {
1302 ret(j) = m_startNode(iy) + ix + m_nnd(iy);
1309 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1311 if (m_refine(iy) == 0) {
1312 for (
size_t ix = 0; ix < 2 * m_layer_nelx(iy); ++ix) {
1313 ret(j) = m_startNode(iy) + ix + m_nnd(iy);
1318 for (
size_t ix = 0; ix < m_layer_nelx(iy) + 1; ++ix) {
1319 ret(j) = m_startNode(iy + 1) + ix;
1327 array_type::tensor<size_t, 1> nodesBack_impl()
const
1330 size_t nely =
static_cast<size_t>(m_nhy.size());
1336 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1337 if (m_refine(iy) == 0) {
1338 n += m_layer_nelx(iy) * 3 + 1;
1341 n += m_layer_nelx(iy) + 1;
1345 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1346 if (m_refine(iy) == 0) {
1347 n += m_layer_nelx(iy) * 3 + 1;
1350 n += m_layer_nelx(iy) + 1;
1355 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({n});
1361 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1363 for (
size_t ix = 0; ix < m_layer_nelx(iy) + 1; ++ix) {
1364 ret(j) = m_startNode(iy) + ix + (m_layer_nelx(iy) + 1) * m_layer_nelz(iy);
1368 if (m_refine(iy) == 0) {
1369 for (
size_t ix = 0; ix < 2 * m_layer_nelx(iy); ++ix) {
1371 m_startNode(iy) + ix + m_nnd(iy) + 2 * m_layer_nelx(iy) * m_layer_nelz(iy);
1378 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1380 if (m_refine(iy) == 0) {
1381 for (
size_t ix = 0; ix < 2 * m_layer_nelx(iy); ++ix) {
1383 m_startNode(iy) + ix + m_nnd(iy) + 2 * m_layer_nelx(iy) * m_layer_nelz(iy);
1388 for (
size_t ix = 0; ix < m_layer_nelx(iy) + 1; ++ix) {
1389 ret(j) = m_startNode(iy + 1) + ix + (m_layer_nelx(iy) + 1) * m_layer_nelz(iy);
1397 array_type::tensor<size_t, 1> nodesLeft_impl()
const
1400 size_t nely =
static_cast<size_t>(m_nhy.size());
1406 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1407 if (m_refine(iy) == 2) {
1408 n += m_layer_nelz(iy) * 3 + 1;
1411 n += m_layer_nelz(iy) + 1;
1415 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1416 if (m_refine(iy) == 2) {
1417 n += m_layer_nelz(iy) * 3 + 1;
1420 n += m_layer_nelz(iy) + 1;
1425 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({n});
1431 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1433 for (
size_t iz = 0; iz < m_layer_nelz(iy) + 1; ++iz) {
1434 ret(j) = m_startNode(iy) + iz * (m_layer_nelx(iy) + 1);
1438 if (m_refine(iy) == 2) {
1439 for (
size_t iz = 0; iz < 2 * m_layer_nelz(iy); ++iz) {
1440 ret(j) = m_startNode(iy) + iz * (m_layer_nelx(iy) + 1) + m_nnd(iy);
1447 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1449 if (m_refine(iy) == 2) {
1450 for (
size_t iz = 0; iz < 2 * m_layer_nelz(iy); ++iz) {
1451 ret(j) = m_startNode(iy) + iz * (m_layer_nelx(iy) + 1) + m_nnd(iy);
1456 for (
size_t iz = 0; iz < m_layer_nelz(iy) + 1; ++iz) {
1457 ret(j) = m_startNode(iy + 1) + iz * (m_layer_nelx(iy) + 1);
1465 array_type::tensor<size_t, 1> nodesRight_impl()
const
1468 size_t nely =
static_cast<size_t>(m_nhy.size());
1474 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1475 if (m_refine(iy) == 2)
1476 n += m_layer_nelz(iy) * 3 + 1;
1478 n += m_layer_nelz(iy) + 1;
1481 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1482 if (m_refine(iy) == 2)
1483 n += m_layer_nelz(iy) * 3 + 1;
1485 n += m_layer_nelz(iy) + 1;
1489 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({n});
1495 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1497 for (
size_t iz = 0; iz < m_layer_nelz(iy) + 1; ++iz) {
1498 ret(j) = m_startNode(iy) + iz * (m_layer_nelx(iy) + 1) + m_layer_nelx(iy);
1502 if (m_refine(iy) == 2) {
1503 for (
size_t iz = 0; iz < 2 * m_layer_nelz(iy); ++iz) {
1504 ret(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_layer_nelx(iy) + 1) +
1512 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1514 if (m_refine(iy) == 2) {
1515 for (
size_t iz = 0; iz < 2 * m_layer_nelz(iy); ++iz) {
1516 ret(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_layer_nelx(iy) + 1) +
1522 for (
size_t iz = 0; iz < m_layer_nelz(iy) + 1; ++iz) {
1523 ret(j) = m_startNode(iy + 1) + iz * (m_layer_nelx(iy) + 1) + m_layer_nelx(iy);
1531 array_type::tensor<size_t, 1> nodesBottom_impl()
const
1534 size_t nely =
static_cast<size_t>(m_nhy.size());
1537 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nnd(
nely)});
1543 for (
size_t ix = 0; ix < m_layer_nelx(0) + 1; ++ix) {
1544 for (
size_t iz = 0; iz < m_layer_nelz(0) + 1; ++iz) {
1545 ret(j) = m_startNode(0) + ix + iz * (m_layer_nelx(0) + 1);
1553 array_type::tensor<size_t, 1> nodesTop_impl()
const
1556 size_t nely =
static_cast<size_t>(m_nhy.size());
1559 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_nnd(
nely)});
1565 for (
size_t ix = 0; ix < m_layer_nelx(
nely - 1) + 1; ++ix) {
1566 for (
size_t iz = 0; iz < m_layer_nelz(
nely - 1) + 1; ++iz) {
1567 ret(j) = m_startNode(
nely) + ix + iz * (m_layer_nelx(
nely - 1) + 1);
1575 array_type::tensor<size_t, 1> nodesFrontFace_impl()
const
1578 size_t nely =
static_cast<size_t>(m_nhy.size());
1584 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
1585 if (m_refine(iy) == 0) {
1586 n += m_layer_nelx(iy) * 3 - 1;
1589 n += m_layer_nelx(iy) - 1;
1593 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
1594 if (m_refine(iy) == 0) {
1595 n += m_layer_nelx(iy) * 3 - 1;
1598 n += m_layer_nelx(iy) - 1;
1603 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({n});
1609 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
1611 for (
size_t ix = 1; ix < m_layer_nelx(iy); ++ix) {
1612 ret(j) = m_startNode(iy) + ix;
1616 if (m_refine(iy) == 0) {
1617 for (
size_t ix = 0; ix < 2 * m_layer_nelx(iy); ++ix) {
1618 ret(j) = m_startNode(iy) + ix + m_nnd(iy);
1625 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
1627 if (m_refine(iy) == 0) {
1628 for (
size_t ix = 0; ix < 2 * m_layer_nelx(iy); ++ix) {
1629 ret(j) = m_startNode(iy) + ix + m_nnd(iy);
1634 for (
size_t ix = 1; ix < m_layer_nelx(iy); ++ix) {
1635 ret(j) = m_startNode(iy + 1) + ix;
1643 array_type::tensor<size_t, 1> nodesBackFace_impl()
const
1646 size_t nely =
static_cast<size_t>(m_nhy.size());
1652 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
1653 if (m_refine(iy) == 0) {
1654 n += m_layer_nelx(iy) * 3 - 1;
1657 n += m_layer_nelx(iy) - 1;
1661 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
1662 if (m_refine(iy) == 0) {
1663 n += m_layer_nelx(iy) * 3 - 1;
1666 n += m_layer_nelx(iy) - 1;
1671 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({n});
1677 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
1679 for (
size_t ix = 1; ix < m_layer_nelx(iy); ++ix) {
1680 ret(j) = m_startNode(iy) + ix + (m_layer_nelx(iy) + 1) * m_layer_nelz(iy);
1684 if (m_refine(iy) == 0) {
1685 for (
size_t ix = 0; ix < 2 * m_layer_nelx(iy); ++ix) {
1687 m_startNode(iy) + ix + m_nnd(iy) + 2 * m_layer_nelx(iy) * m_layer_nelz(iy);
1694 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
1696 if (m_refine(iy) == 0) {
1697 for (
size_t ix = 0; ix < 2 * m_layer_nelx(iy); ++ix) {
1699 m_startNode(iy) + ix + m_nnd(iy) + 2 * m_layer_nelx(iy) * m_layer_nelz(iy);
1704 for (
size_t ix = 1; ix < m_layer_nelx(iy); ++ix) {
1705 ret(j) = m_startNode(iy + 1) + ix + (m_layer_nelx(iy) + 1) * m_layer_nelz(iy);
1713 array_type::tensor<size_t, 1> nodesLeftFace_impl()
const
1716 size_t nely =
static_cast<size_t>(m_nhy.size());
1722 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
1723 if (m_refine(iy) == 2) {
1724 n += m_layer_nelz(iy) * 3 - 1;
1727 n += m_layer_nelz(iy) - 1;
1731 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
1732 if (m_refine(iy) == 2) {
1733 n += m_layer_nelz(iy) * 3 - 1;
1736 n += m_layer_nelz(iy) - 1;
1741 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({n});
1747 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
1749 for (
size_t iz = 1; iz < m_layer_nelz(iy); ++iz) {
1750 ret(j) = m_startNode(iy) + iz * (m_layer_nelx(iy) + 1);
1754 if (m_refine(iy) == 2) {
1755 for (
size_t iz = 0; iz < 2 * m_layer_nelz(iy); ++iz) {
1756 ret(j) = m_startNode(iy) + iz * (m_layer_nelx(iy) + 1) + m_nnd(iy);
1763 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
1765 if (m_refine(iy) == 2) {
1766 for (
size_t iz = 0; iz < 2 * m_layer_nelz(iy); ++iz) {
1767 ret(j) = m_startNode(iy) + iz * (m_layer_nelx(iy) + 1) + m_nnd(iy);
1772 for (
size_t iz = 1; iz < m_layer_nelz(iy); ++iz) {
1773 ret(j) = m_startNode(iy + 1) + iz * (m_layer_nelx(iy) + 1);
1781 array_type::tensor<size_t, 1> nodesRightFace_impl()
const
1784 size_t nely =
static_cast<size_t>(m_nhy.size());
1790 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
1791 if (m_refine(iy) == 2) {
1792 n += m_layer_nelz(iy) * 3 - 1;
1795 n += m_layer_nelz(iy) - 1;
1799 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
1800 if (m_refine(iy) == 2) {
1801 n += m_layer_nelz(iy) * 3 - 1;
1804 n += m_layer_nelz(iy) - 1;
1809 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({n});
1815 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
1817 for (
size_t iz = 1; iz < m_layer_nelz(iy); ++iz) {
1818 ret(j) = m_startNode(iy) + iz * (m_layer_nelx(iy) + 1) + m_layer_nelx(iy);
1822 if (m_refine(iy) == 2) {
1823 for (
size_t iz = 0; iz < 2 * m_layer_nelz(iy); ++iz) {
1824 ret(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_layer_nelx(iy) + 1) +
1832 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
1834 if (m_refine(iy) == 2) {
1835 for (
size_t iz = 0; iz < 2 * m_layer_nelz(iy); ++iz) {
1836 ret(j) = m_startNode(iy) + m_nnd(iy) + iz * (m_layer_nelx(iy) + 1) +
1842 for (
size_t iz = 1; iz < m_layer_nelz(iy); ++iz) {
1843 ret(j) = m_startNode(iy + 1) + iz * (m_layer_nelx(iy) + 1) + m_layer_nelx(iy);
1851 array_type::tensor<size_t, 1> nodesBottomFace_impl()
const
1854 array_type::tensor<size_t, 1> ret =
1855 xt::empty<size_t>({(m_layer_nelx(0) - 1) * (m_layer_nelz(0) - 1)});
1861 for (
size_t ix = 1; ix < m_layer_nelx(0); ++ix) {
1862 for (
size_t iz = 1; iz < m_layer_nelz(0); ++iz) {
1863 ret(j) = m_startNode(0) + ix + iz * (m_layer_nelx(0) + 1);
1871 array_type::tensor<size_t, 1> nodesTopFace_impl()
const
1874 size_t nely =
static_cast<size_t>(m_nhy.size());
1877 array_type::tensor<size_t, 1> ret =
1878 xt::empty<size_t>({(m_layer_nelx(
nely - 1) - 1) * (m_layer_nelz(
nely - 1) - 1)});
1884 for (
size_t ix = 1; ix < m_layer_nelx(
nely - 1); ++ix) {
1885 for (
size_t iz = 1; iz < m_layer_nelz(
nely - 1); ++iz) {
1886 ret(j) = m_startNode(
nely) + ix + iz * (m_layer_nelx(
nely - 1) + 1);
1894 array_type::tensor<size_t, 1> nodesFrontBottomEdge_impl()
const
1896 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelx(0) + 1});
1898 for (
size_t ix = 0; ix < m_layer_nelx(0) + 1; ++ix) {
1899 ret(ix) = m_startNode(0) + ix;
1905 array_type::tensor<size_t, 1> nodesFrontTopEdge_impl()
const
1907 size_t nely =
static_cast<size_t>(m_nhy.size());
1909 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelx(
nely - 1) + 1});
1911 for (
size_t ix = 0; ix < m_layer_nelx(
nely - 1) + 1; ++ix) {
1912 ret(ix) = m_startNode(
nely) + ix;
1918 array_type::tensor<size_t, 1> nodesFrontLeftEdge_impl()
const
1920 size_t nely =
static_cast<size_t>(m_nhy.size());
1922 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({
nely + 1});
1924 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1925 ret(iy) = m_startNode(iy);
1928 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1929 ret(iy + 1) = m_startNode(iy + 1);
1935 array_type::tensor<size_t, 1> nodesFrontRightEdge_impl()
const
1937 size_t nely =
static_cast<size_t>(m_nhy.size());
1939 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({
nely + 1});
1941 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1942 ret(iy) = m_startNode(iy) + m_layer_nelx(iy);
1945 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1946 ret(iy + 1) = m_startNode(iy + 1) + m_layer_nelx(iy);
1952 array_type::tensor<size_t, 1> nodesBackBottomEdge_impl()
const
1954 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelx(0) + 1});
1956 for (
size_t ix = 0; ix < m_layer_nelx(0) + 1; ++ix) {
1957 ret(ix) = m_startNode(0) + ix + (m_layer_nelx(0) + 1) * (m_layer_nelz(0));
1963 array_type::tensor<size_t, 1> nodesBackTopEdge_impl()
const
1965 size_t nely =
static_cast<size_t>(m_nhy.size());
1967 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelx(
nely - 1) + 1});
1969 for (
size_t ix = 0; ix < m_layer_nelx(
nely - 1) + 1; ++ix) {
1971 m_startNode(
nely) + ix + (m_layer_nelx(
nely - 1) + 1) * (m_layer_nelz(
nely - 1));
1977 array_type::tensor<size_t, 1> nodesBackLeftEdge_impl()
const
1979 size_t nely =
static_cast<size_t>(m_nhy.size());
1981 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({
nely + 1});
1983 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
1984 ret(iy) = m_startNode(iy) + (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy));
1987 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
1988 ret(iy + 1) = m_startNode(iy + 1) + (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy));
1994 array_type::tensor<size_t, 1> nodesBackRightEdge_impl()
const
1996 size_t nely =
static_cast<size_t>(m_nhy.size());
1998 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({
nely + 1});
2000 for (
size_t iy = 0; iy < (
nely + 1) / 2; ++iy) {
2002 m_startNode(iy) + m_layer_nelx(iy) + (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy));
2005 for (
size_t iy = (
nely - 1) / 2; iy <
nely; ++iy) {
2006 ret(iy + 1) = m_startNode(iy + 1) + m_layer_nelx(iy) +
2007 (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy));
2013 array_type::tensor<size_t, 1> nodesBottomLeftEdge_impl()
const
2015 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelz(0) + 1});
2017 for (
size_t iz = 0; iz < m_layer_nelz(0) + 1; ++iz) {
2018 ret(iz) = m_startNode(0) + iz * (m_layer_nelx(0) + 1);
2024 array_type::tensor<size_t, 1> nodesBottomRightEdge_impl()
const
2026 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelz(0) + 1});
2028 for (
size_t iz = 0; iz < m_layer_nelz(0) + 1; ++iz) {
2029 ret(iz) = m_startNode(0) + m_layer_nelx(0) + iz * (m_layer_nelx(0) + 1);
2035 array_type::tensor<size_t, 1> nodesTopLeftEdge_impl()
const
2037 size_t nely =
static_cast<size_t>(m_nhy.size());
2039 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelz(
nely - 1) + 1});
2041 for (
size_t iz = 0; iz < m_layer_nelz(
nely - 1) + 1; ++iz) {
2042 ret(iz) = m_startNode(
nely) + iz * (m_layer_nelx(
nely - 1) + 1);
2048 array_type::tensor<size_t, 1> nodesTopRightEdge_impl()
const
2050 size_t nely =
static_cast<size_t>(m_nhy.size());
2052 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelz(
nely - 1) + 1});
2054 for (
size_t iz = 0; iz < m_layer_nelz(
nely - 1) + 1; ++iz) {
2056 m_startNode(
nely) + m_layer_nelx(
nely - 1) + iz * (m_layer_nelx(
nely - 1) + 1);
2062 array_type::tensor<size_t, 1> nodesFrontBottomOpenEdge_impl()
const
2064 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelx(0) - 1});
2066 for (
size_t ix = 1; ix < m_layer_nelx(0); ++ix) {
2067 ret(ix - 1) = m_startNode(0) + ix;
2073 array_type::tensor<size_t, 1> nodesFrontTopOpenEdge_impl()
const
2075 size_t nely =
static_cast<size_t>(m_nhy.size());
2077 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelx(
nely - 1) - 1});
2079 for (
size_t ix = 1; ix < m_layer_nelx(
nely - 1); ++ix) {
2080 ret(ix - 1) = m_startNode(
nely) + ix;
2086 array_type::tensor<size_t, 1> nodesFrontLeftOpenEdge_impl()
const
2088 size_t nely =
static_cast<size_t>(m_nhy.size());
2090 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({
nely - 1});
2092 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
2093 ret(iy - 1) = m_startNode(iy);
2096 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
2097 ret(iy) = m_startNode(iy + 1);
2103 array_type::tensor<size_t, 1> nodesFrontRightOpenEdge_impl()
const
2105 size_t nely =
static_cast<size_t>(m_nhy.size());
2107 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({
nely - 1});
2109 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
2110 ret(iy - 1) = m_startNode(iy) + m_layer_nelx(iy);
2113 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
2114 ret(iy) = m_startNode(iy + 1) + m_layer_nelx(iy);
2120 array_type::tensor<size_t, 1> nodesBackBottomOpenEdge_impl()
const
2122 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelx(0) - 1});
2124 for (
size_t ix = 1; ix < m_layer_nelx(0); ++ix) {
2125 ret(ix - 1) = m_startNode(0) + ix + (m_layer_nelx(0) + 1) * (m_layer_nelz(0));
2131 array_type::tensor<size_t, 1> nodesBackTopOpenEdge_impl()
const
2133 size_t nely =
static_cast<size_t>(m_nhy.size());
2135 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelx(
nely - 1) - 1});
2137 for (
size_t ix = 1; ix < m_layer_nelx(
nely - 1); ++ix) {
2139 m_startNode(
nely) + ix + (m_layer_nelx(
nely - 1) + 1) * (m_layer_nelz(
nely - 1));
2145 array_type::tensor<size_t, 1> nodesBackLeftOpenEdge_impl()
const
2147 size_t nely =
static_cast<size_t>(m_nhy.size());
2149 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({
nely - 1});
2151 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
2152 ret(iy - 1) = m_startNode(iy) + (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy));
2155 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
2156 ret(iy) = m_startNode(iy + 1) + (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy));
2162 array_type::tensor<size_t, 1> nodesBackRightOpenEdge_impl()
const
2164 size_t nely =
static_cast<size_t>(m_nhy.size());
2166 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({
nely - 1});
2168 for (
size_t iy = 1; iy < (
nely + 1) / 2; ++iy) {
2170 m_startNode(iy) + m_layer_nelx(iy) + (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy));
2173 for (
size_t iy = (
nely - 1) / 2; iy <
nely - 1; ++iy) {
2174 ret(iy) = m_startNode(iy + 1) + m_layer_nelx(iy) +
2175 (m_layer_nelx(iy) + 1) * (m_layer_nelz(iy));
2181 array_type::tensor<size_t, 1> nodesBottomLeftOpenEdge_impl()
const
2183 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelz(0) - 1});
2185 for (
size_t iz = 1; iz < m_layer_nelz(0); ++iz) {
2186 ret(iz - 1) = m_startNode(0) + iz * (m_layer_nelx(0) + 1);
2192 array_type::tensor<size_t, 1> nodesBottomRightOpenEdge_impl()
const
2194 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelz(0) - 1});
2196 for (
size_t iz = 1; iz < m_layer_nelz(0); ++iz) {
2197 ret(iz - 1) = m_startNode(0) + m_layer_nelx(0) + iz * (m_layer_nelx(0) + 1);
2203 array_type::tensor<size_t, 1> nodesTopLeftOpenEdge_impl()
const
2205 size_t nely =
static_cast<size_t>(m_nhy.size());
2207 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelz(
nely - 1) - 1});
2209 for (
size_t iz = 1; iz < m_layer_nelz(
nely - 1); ++iz) {
2210 ret(iz - 1) = m_startNode(
nely) + iz * (m_layer_nelx(
nely - 1) + 1);
2216 array_type::tensor<size_t, 1> nodesTopRightOpenEdge_impl()
const
2218 size_t nely =
static_cast<size_t>(m_nhy.size());
2220 array_type::tensor<size_t, 1> ret = xt::empty<size_t>({m_layer_nelz(
nely - 1) - 1});
2222 for (
size_t iz = 1; iz < m_layer_nelz(
nely - 1); ++iz) {
2224 m_startNode(
nely) + m_layer_nelx(
nely - 1) + iz * (m_layer_nelx(
nely - 1) + 1);
2230 size_t nodesFrontBottomLeftCorner_impl()
const
2232 return m_startNode(0);
2235 size_t nodesFrontBottomRightCorner_impl()
const
2237 return m_startNode(0) + m_layer_nelx(0);
2240 size_t nodesFrontTopLeftCorner_impl()
const
2242 size_t nely =
static_cast<size_t>(m_nhy.size());
2243 return m_startNode(
nely);
2246 size_t nodesFrontTopRightCorner_impl()
const
2248 size_t nely =
static_cast<size_t>(m_nhy.size());
2249 return m_startNode(
nely) + m_layer_nelx(
nely - 1);
2252 size_t nodesBackBottomLeftCorner_impl()
const
2254 return m_startNode(0) + (m_layer_nelx(0) + 1) * (m_layer_nelz(0));
2257 size_t nodesBackBottomRightCorner_impl()
const
2259 return m_startNode(0) + m_layer_nelx(0) + (m_layer_nelx(0) + 1) * (m_layer_nelz(0));
2262 size_t nodesBackTopLeftCorner_impl()
const
2264 size_t nely =
static_cast<size_t>(m_nhy.size());
2265 return m_startNode(
nely) + (m_layer_nelx(
nely - 1) + 1) * (m_layer_nelz(
nely - 1));
2268 size_t nodesBackTopRightCorner_impl()
const
2270 size_t nely =
static_cast<size_t>(m_nhy.size());
2271 return m_startNode(
nely) + m_layer_nelx(
nely - 1) +
2272 (m_layer_nelx(
nely - 1) + 1) * (m_layer_nelz(
nely - 1));
2285 array_type::tensor<size_t, 1> m_layer_nelx;
2286 array_type::tensor<size_t, 1> m_layer_nelz;
2287 array_type::tensor<size_t, 1> m_nnd;
2288 array_type::tensor<size_t, 1> m_nhx;
2289 array_type::tensor<size_t, 1> m_nhy;
2290 array_type::tensor<size_t, 1> m_nhz;
2291 array_type::tensor<int, 1>
2293 array_type::tensor<size_t, 1> m_startElem;
2294 array_type::tensor<size_t, 1> m_startNode;
Mesh with fine middle layer, and coarser elements towards the top and bottom.
FineLayer(size_t nelx, size_t nely, size_t nelz, double h=1.0, size_t nfine=1)
Constructor.
array_type::tensor< size_t, 1 > elementsMiddleLayer() const
Elements in the middle (fine) layer.
Regular mesh: equi-sized elements.
Regular(size_t nelx, size_t nely, size_t nelz, double h=1.0)
Constructor.
CRTP base class for regular meshes in 3d.
auto nelz() const
Number of elements in y-direction == height of the mesh, in units of #h,.
CRTP base class for regular meshes.
auto nely() const
Number of elements in y-direction == height of the mesh, in units of h,.
auto h() const
Linear edge size of one 'block'.
auto nelx() const
Number of elements in x-direction == width of the mesh in units of h.
#define GOOSEFEM_ASSERT(expr)
All assertions are implementation as::
ElementType
Enumerator for element-types.
@ Hex8
Hexahedron: 8-noded element in 3-d.
xt::xtensor< T, N > tensor
Fixed (static) rank array.
Toolbox to perform finite element computations.