451 {
453
457 const int nb_gauss_pts = pts.size2();
458
459 auto ©_base_fun = data.dataOnEntities[MBVERTEX][0].getN(copy_base);
460 auto ©_diff_base_fun =
461 data.dataOnEntities[MBVERTEX][0].getDiffN(copy_base);
462
463 if (nb_gauss_pts != copy_base_fun.size1())
465 "Wrong number of gauss pts");
466
467 if (nb_gauss_pts != copy_diff_base_fun.size1())
469 "Wrong number of gauss pts");
470
471
472 if (data.spacesOnEntities[MBEDGE].test(
HCURL)) {
473 std::array<int, 12> sense;
474 std::array<int, 12>
order;
475 if (data.dataOnEntities[MBEDGE].size() != 12)
477 "Expected 12 edges data structures on Hex");
478
479 std::array<double *, 12> hcurl_edge_n;
480 std::array<double *, 12> diff_hcurl_edge_n;
481 bool sum_nb_dofs = false;
482
483 for (int ee = 0; ee != 12; ++ee) {
484 if (data.dataOnEntities[MBEDGE][ee].getSense() == 0)
486 "Sense on edge <%d> on Hex not set", ee);
487
488 sense[ee] = data.dataOnEntities[MBEDGE][ee].getSense();
489 order[ee] = data.dataOnEntities[MBEDGE][ee].getOrder();
491 data.dataOnEntities[MBEDGE][ee].getN(base).resize(nb_gauss_pts,
492 3 * nb_dofs, false);
493 data.dataOnEntities[MBEDGE][ee].getDiffN(base).resize(nb_gauss_pts,
494 9 * nb_dofs, false);
495 hcurl_edge_n[ee] =
496 &*data.dataOnEntities[MBEDGE][ee].getN(base).data().begin();
497 diff_hcurl_edge_n[ee] =
498 &*data.dataOnEntities[MBEDGE][ee].getDiffN(base).data().begin();
499
500 sum_nb_dofs |= (nb_dofs > 0);
501 }
502
503 if (sum_nb_dofs) {
505 sense.data(),
order.data(), &*copy_base_fun.data().begin(),
506 &*copy_diff_base_fun.data().begin(), hcurl_edge_n.data(),
507 diff_hcurl_edge_n.data(), nb_gauss_pts);
508 }
509
510 } else {
511 for (int ee = 0; ee != 12; ee++) {
512 data.dataOnEntities[MBEDGE][ee].getN(base).resize(nb_gauss_pts, 0, false);
513 data.dataOnEntities[MBEDGE][ee].getDiffN(base).resize(nb_gauss_pts, 0,
514 false);
515 }
516 }
517
518
519 if (data.spacesOnEntities[MBQUAD].test(
HCURL)) {
520
521 if (data.dataOnEntities[MBQUAD].size() != 6)
523 "Expected six data structures on Hex");
524
525 std::array<int, 6>
order;
526 double *face_family_ptr[6][2];
527 double *diff_face_family_ptr[6][2];
528
529 bool sum_nb_dofs = false;
530 for (int ff = 0; ff != 6; ff++) {
531 if (data.dataOnEntities[MBQUAD][ff].getSense() == 0)
533 "Sense pn quad <%d> not set", ff);
534
535 order[ff] = data.dataOnEntities[MBQUAD][ff].getOrder();
536 if (data.facesNodes.size1() != 6)
538 "Expected six faces");
539 if (data.facesNodes.size2() != 4)
541 "Expected four nodes on face");
542
543 const int nb_family_dofs =
545 faceFamily[ff].resize(2, 3 * nb_family_dofs * nb_gauss_pts,
false);
546 diffFaceFamily[ff].resize(2, 9 * nb_family_dofs * nb_gauss_pts,
false);
547
548 if (nb_family_dofs) {
549 face_family_ptr[ff][0] = &(
faceFamily[ff](0, 0));
550 face_family_ptr[ff][1] = &(
faceFamily[ff](1, 0));
553 }
554
555 sum_nb_dofs |= (nb_family_dofs > 0);
556 }
557
558 if (sum_nb_dofs) {
560 &*data.facesNodes.data().begin(),
561 &*data.facesNodesOrder.data().begin(),
order.data(),
562 &*copy_base_fun.data().begin(), &*copy_diff_base_fun.data().begin(),
563 face_family_ptr, diff_face_family_ptr, nb_gauss_pts);
564
565 for (int ff = 0; ff != 6; ++ff) {
566
567
568
570 if (nb_dofs) {
571 auto &face_n = data.dataOnEntities[MBQUAD][ff].getN(base);
572 auto &diff_face_n = data.dataOnEntities[MBQUAD][ff].getDiffN(base);
573 face_n.resize(nb_gauss_pts, 3 * nb_dofs, false);
574 diff_face_n.resize(nb_gauss_pts, 9 * nb_dofs, false);
575
578 double *ptr = &face_n(0, 0);
580 for (
int j = 0;
j != 3; ++
j) {
581 *ptr = *ptr_f0;
582 ++ptr;
583 ++ptr_f0;
584 }
585 for (
int j = 0;
j != 3; ++
j) {
586 *ptr = *ptr_f1;
587 ++ptr;
588 ++ptr_f1;
589 }
590 }
591
594 double *diff_ptr = &diff_face_n(0, 0);
596 for (
int j = 0;
j != 9; ++
j) {
597 *diff_ptr = *diff_ptr_f0;
598 ++diff_ptr;
599 ++diff_ptr_f0;
600 }
601 for (
int j = 0;
j != 9; ++
j) {
602 *diff_ptr = *diff_ptr_f1;
603 ++diff_ptr;
604 ++diff_ptr_f1;
605 }
606 }
607 }
608 }
609 } else {
610 for (int ff = 0; ff != 6; ff++) {
611 data.dataOnEntities[MBQUAD][ff].getN(base).resize(nb_gauss_pts, 0,
612 false);
613 data.dataOnEntities[MBQUAD][ff].getDiffN(base).resize(nb_gauss_pts, 0,
614 false);
615 }
616 }
617
618 } else {
619 for (int ff = 0; ff != 6; ff++) {
620 data.dataOnEntities[MBQUAD][ff].getN(base).resize(nb_gauss_pts, 0, false);
621 data.dataOnEntities[MBQUAD][ff].getDiffN(base).resize(nb_gauss_pts, 0,
622 false);
623 }
624 }
625
626
627 if (data.spacesOnEntities[MBHEX].test(
HCURL)) {
628
629 const int order = data.dataOnEntities[MBHEX][0].getOrder();
631
632 volFamily.resize(3, 3 * nb_dofs * nb_gauss_pts);
634 if (nb_dofs) {
635
638 std::array<double *, 3> diff_family_ptr = {
640
643 p.data(), &*copy_base_fun.data().begin(),
644 &*copy_diff_base_fun.data().begin(), family_ptr.data(),
645 diff_family_ptr.data(), nb_gauss_pts);
646
648 auto &face_n = data.dataOnEntities[MBHEX][0].getN(base);
649 auto &diff_face_n = data.dataOnEntities[MBHEX][0].getDiffN(base);
650 face_n.resize(nb_gauss_pts, 3 * nb_vol_dofs, false);
651 diff_face_n.resize(nb_gauss_pts, 9 * nb_vol_dofs, false);
652
656 double *ptr = &face_n(0, 0);
658 for (
int j = 0;
j != 3; ++
j) {
659 *ptr = *ptr_f0;
660 ++ptr;
661 ++ptr_f0;
662 }
663 for (
int j = 0;
j != 3; ++
j) {
664 *ptr = *ptr_f1;
665 ++ptr;
666 ++ptr_f1;
667 }
668 for (
int j = 0;
j != 3; ++
j) {
669 *ptr = *ptr_f2;
670 ++ptr;
671 ++ptr_f2;
672 }
673 }
674
678 double *diff_ptr = &diff_face_n(0, 0);
680 for (
int j = 0;
j != 9; ++
j) {
681 *diff_ptr = *diff_ptr_f0;
682 ++diff_ptr;
683 ++diff_ptr_f0;
684 }
685 for (
int j = 0;
j != 9; ++
j) {
686 *diff_ptr = *diff_ptr_f1;
687 ++diff_ptr;
688 ++diff_ptr_f1;
689 }
690 for (
int j = 0;
j != 9; ++
j) {
691 *diff_ptr = *diff_ptr_f2;
692 ++diff_ptr;
693 ++diff_ptr_f2;
694 }
695 }
696 } else {
697 data.dataOnEntities[MBHEX][0].getN(base).resize(nb_gauss_pts, 0, false);
698 data.dataOnEntities[MBHEX][0].getDiffN(base).resize(nb_gauss_pts, 0,
699 false);
700 }
701
702 } else {
703 data.dataOnEntities[MBHEX][0].getN(base).resize(nb_gauss_pts, 0, false);
704 data.dataOnEntities[MBHEX][0].getDiffN(base).resize(nb_gauss_pts, 0, false);
705 }
706
708}
FTensor::Index< 'n', SPACE_DIM > n
#define NBFACEQUAD_DEMKOWICZ_FAMILY_HCURL(P, Q)
Number of base functions on quad for Hcurl space.
#define NBEDGE_DEMKOWICZ_HCURL(P)
#define NBVOLUMEHEX_DEMKOWICZ_HCURL(P)
#define NBFACEQUAD_DEMKOWICZ_HCURL(P)
#define NBVOLUMEHEX_DEMKOWICZ_FAMILY_HCURL(P, Q, R)
FTensor::Index< 'j', 3 > j
MoFEMErrorCode Hcurl_EdgeShapeFunctions_ONHEX(int *sense, int *p, double *N, double *N_diff, double *edgeN[12], double *diff_edgeN[12], int nb_integration_pts)
MoFEMErrorCode Hcurl_FaceShapeFunctions_ONHEX(int *face_nodes, int *face_nodes_order, int *p, double *N, double *N_diff, double *faceN[6][2], double *diff_faceN[6][2], int nb_integration_pts)
MoFEMErrorCode Hcurl_InteriorShapeFunctions_ONHEX(int *p, double *N, double *N_diff, double *volN[3], double *diff_volN[3], int nb_integration_pts)
MatrixDouble diffVolFamily
std::array< MatrixDouble, 6 > faceFamily
std::array< MatrixDouble, 6 > diffFaceFamily