625                       {
  628  if (Fext != NULL)
  629    bzero(Fext, 9 * sizeof(double));
  630  if (iFext != NULL)
  631    bzero(iFext, 9 * sizeof(double));
  632  ee = 0;
  633  for (; ee < 3; ee++) {
  634    int nb_dofs_edge = 
NBEDGE_H1(order_edge[ee]);
 
  635    if (nb_dofs_edge == 0)
  636      continue;
  637    if (Fext_edge != NULL)
  638      bzero(Fext_edge[ee], 3 * nb_dofs_edge * sizeof(double));
  639    if (iFext_edge != NULL)
  640      bzero(iFext_edge[ee], 3 * nb_dofs_edge * sizeof(double));
  641  }
  643  if (nb_dofs_face != 0) {
  644    if (Fext_face != NULL)
  645      bzero(Fext_face, 3 * nb_dofs_face * sizeof(double));
  646    if (iFext_face != NULL)
  647      bzero(iFext_face, 3 * nb_dofs_face * sizeof(double));
  648  }
  649  gg = 0;
  650  for (; gg < g_dim; gg++) {
  651    double traction[3] = {0, 0, 0};
  653                                 t_edge, t_face, traction, gg);
  656        
  657        
  658        order, order_edge, 
order, order_edge, diffN, diffN_face, diffN_edge,
 
  659        dofs_x, dofs_x_edge, dofs_x_face, idofs_x, idofs_x_edge, idofs_x_face,
  660        xnormal, xs1, xs2, gg);
  662    double normal_real[3], s1_real[3], s2_real[3];
  663    double normal_imag[3], s1_imag[3], s2_imag[3];
  664    for (dd = 0; 
dd < 3; 
dd++) {
 
  665      normal_real[
dd] = 0.5 * xnormal[
dd].
r;
 
  666      normal_imag[
dd] = 0.5 * xnormal[
dd].
i;
 
  667      s1_real[
dd] = 0.5 * xs1[
dd].
r;
 
  668      s1_imag[
dd] = 0.5 * xs1[
dd].
i;
 
  669      s2_real[
dd] = 0.5 * xs2[
dd].
r;
 
  670      s2_imag[
dd] = 0.5 * xs2[
dd].
i;
 
  671    }
  672    nn = 0;
  673    for (; nn < 3; nn++) {
  674      if (Fext != NULL)
  675        for (dd = 0; 
dd < 3; 
dd++) {
 
  676          
  677          
  678          
  680              g_w[gg] * 
N[3 * gg + nn] * normal_real[
dd] * traction[2];
 
  682              g_w[gg] * 
N[3 * gg + nn] * s1_real[
dd] * traction[0];
 
  684              g_w[gg] * 
N[3 * gg + nn] * s2_real[
dd] * traction[1];
 
  685        }
  686      if (iFext != NULL)
  687        for (dd = 0; 
dd < 3; 
dd++) {
 
  688          iFext[3 * nn + 
dd] +=
 
  689              g_w[gg] * 
N[3 * gg + nn] * normal_imag[
dd] * traction[2];
 
  690          iFext[3 * nn + 
dd] +=
 
  691              g_w[gg] * 
N[3 * gg + nn] * s1_imag[
dd] * traction[0];
 
  692          iFext[3 * nn + 
dd] +=
 
  693              g_w[gg] * 
N[3 * gg + nn] * s2_imag[
dd] * traction[1];
 
  694        }
  695    }
  696    ee = 0;
  697    for (; ee < 3; ee++) {
  698      int nb_dofs_edge = 
NBEDGE_H1(order_edge[ee]);
 
  699      if (nb_dofs_edge == 0)
  700        continue;
  701      int nn = 0;
  702      for (; nn < nb_dofs_edge; nn++) {
  703        if (Fext_edge != NULL)
  704          for (dd = 0; 
dd < 3; 
dd++) {
 
  705            Fext_edge[ee][3 * nn + 
dd] += g_w[gg] *
 
  706                                          N_edge[ee][gg * nb_dofs_edge + nn] *
  707                                          normal_real[
dd] * traction[2];
 
  708            Fext_edge[ee][3 * nn + 
dd] += g_w[gg] *
 
  709                                          N_edge[ee][gg * nb_dofs_edge + nn] *
  710                                          s1_real[
dd] * traction[0];
 
  711            Fext_edge[ee][3 * nn + 
dd] += g_w[gg] *
 
  712                                          N_edge[ee][gg * nb_dofs_edge + nn] *
  713                                          s2_real[
dd] * traction[1];
 
  714          }
  715        if (iFext_edge != NULL) {
  716          for (dd = 0; 
dd < 3; 
dd++) {
 
  717            iFext_edge[ee][3 * nn + 
dd] += g_w[gg] *
 
  718                                           N_edge[ee][gg * nb_dofs_edge + nn] *
  719                                           normal_imag[
dd] * traction[2];
 
  720            iFext_edge[ee][3 * nn + 
dd] += g_w[gg] *
 
  721                                           N_edge[ee][gg * nb_dofs_edge + nn] *
  722                                           s1_imag[
dd] * traction[0];
 
  723            iFext_edge[ee][3 * nn + 
dd] += g_w[gg] *
 
  724                                           N_edge[ee][gg * nb_dofs_edge + nn] *
  725                                           s2_imag[
dd] * traction[1];
 
  726          }
  727        }
  728      }
  729    }
  730    if (nb_dofs_face != 0) {
  731      nn = 0;
  732      for (; nn < nb_dofs_face; nn++) {
  733        if (Fext_face != NULL)
  734          for (dd = 0; 
dd < 3; 
dd++) {
 
  735            Fext_face[3 * nn + 
dd] += g_w[gg] * N_face[gg * nb_dofs_face + nn] *
 
  736                                      normal_real[
dd] * traction[2];
 
  737            Fext_face[3 * nn + 
dd] += g_w[gg] * N_face[gg * nb_dofs_face + nn] *
 
  738                                      s1_real[
dd] * traction[0];
 
  739            Fext_face[3 * nn + 
dd] += g_w[gg] * N_face[gg * nb_dofs_face + nn] *
 
  740                                      s2_real[
dd] * traction[1];
 
  741          }
  742        if (iFext_face != NULL)
  743          for (dd = 0; 
dd < 3; 
dd++) {
 
  744            iFext_face[3 * nn + 
dd] += g_w[gg] *
 
  745                                       N_face[gg * nb_dofs_face + nn] *
  746                                       normal_imag[
dd] * traction[2];
 
  747            iFext_face[3 * nn + 
dd] += g_w[gg] *
 
  748                                       N_face[gg * nb_dofs_face + nn] *
  749                                       s1_imag[
dd] * traction[0];
 
  750            iFext_face[3 * nn + 
dd] += g_w[gg] *
 
  751                                       N_face[gg * nb_dofs_face + nn] *
  752                                       s2_imag[
dd] * traction[1];
 
  753          }
  754      }
  755    }
  756  }
  758}
MoFEMErrorCode Traction_hierarchical(int order, int *order_edge, double *N, double *N_face, double *N_edge[], double *t, double *t_edge[], double *t_face, double *traction, int gg)
#define MoFEMFunctionReturnHot(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
#define MoFEMFunctionBeginHot
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define NBEDGE_H1(P)
Number of base function on edge for H1 space.
#define NBFACETRI_H1(P)
Number of base function on triangle for H1 space.
const Tensor2_symmetric_Expr< const ddTensor0< T, Dim, i, j >, typename promote< T, double >::V, Dim, i, j > dd(const Tensor0< T * > &a, const Index< i, Dim > index1, const Index< j, Dim > index2, const Tensor1< int, Dim > &d_ijk, const Tensor1< double, Dim > &d_xyz)
constexpr double t
plate stiffness