v0.14.0
Public Member Functions | Public Attributes | Private Attributes | List of all members
EshelbianPlasticity::OpSpatialPhysical_du_du Struct Reference

#include <users_modules/eshelbian_plasticit/src/EshelbianPlasticity.hpp>

Inheritance diagram for EshelbianPlasticity::OpSpatialPhysical_du_du:
[legend]
Collaboration diagram for EshelbianPlasticity::OpSpatialPhysical_du_du:
[legend]

Public Member Functions

 OpSpatialPhysical_du_du (const std::string &row_field, const std::string &col_field, boost::shared_ptr< DataAtIntegrationPts > &data_ptr, const double alpha)
 
MoFEMErrorCode integrate (EntData &row_data, EntData &col_data)
 
MoFEMErrorCode integratePiola (EntData &row_data, EntData &col_data)
 
MoFEMErrorCode integrateHencky (EntData &row_data, EntData &col_data)
 
MoFEMErrorCode integratePolyconvexHencky (EntData &row_data, EntData &col_data)
 
- Public Member Functions inherited from EshelbianPlasticity::OpAssembleVolume
 OpAssembleVolume (const std::string &field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const char type)
 
 OpAssembleVolume (const std::string &row_field, const std::string &col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const char type, const bool assemble_symmetry)
 
- Public Member Functions inherited from EshelbianPlasticity::OpAssembleBasic< VolUserDataOperator >
 OpAssembleBasic (const std::string &field_name, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const char type)
 
 OpAssembleBasic (const std::string &row_field, const std::string &col_field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const char type, const bool assemble_symmetry, ScaleOff scale_off=[]() { return 1;})
 
virtual MoFEMErrorCode integrate (EntData &data)
 
virtual MoFEMErrorCode integrate (int row_side, EntityType row_type, EntData &data)
 
virtual MoFEMErrorCode assemble (EntData &data)
 
virtual MoFEMErrorCode assemble (int row_side, EntityType row_type, EntData &data)
 
virtual MoFEMErrorCode assemble (int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
 
MoFEMErrorCode doWork (int side, EntityType type, EntData &data)
 
MoFEMErrorCode doWork (int row_side, int col_side, EntityType row_type, EntityType col_type, EntData &row_data, EntData &col_data)
 

Public Attributes

const double alphaU
 
- Public Attributes inherited from EshelbianPlasticity::OpAssembleBasic< VolUserDataOperator >
const bool assembleSymmetry
 
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
 data at integration pts More...
 
VectorDouble nF
 local right hand side vector More...
 
MatrixDouble K
 local tangent matrix More...
 
MatrixDouble transposeK
 
ScaleOff scaleOff
 

Private Attributes

PetscBool polyConvex = PETSC_FALSE
 
MatrixDouble dP
 

Additional Inherited Members

- Public Types inherited from EshelbianPlasticity::OpAssembleBasic< VolUserDataOperator >
using ScaleOff = boost::function< double()>
 

Detailed Description

Definition at line 667 of file EshelbianPlasticity.hpp.

Constructor & Destructor Documentation

◆ OpSpatialPhysical_du_du()

EshelbianPlasticity::OpSpatialPhysical_du_du::OpSpatialPhysical_du_du ( const std::string &  row_field,
const std::string &  col_field,
boost::shared_ptr< DataAtIntegrationPts > &  data_ptr,
const double  alpha 
)
inline

Definition at line 669 of file EshelbianPlasticity.hpp.

673  : OpAssembleVolume(row_field, col_field, data_ptr, OPROWCOL, false),
674  alphaU(alpha) {
675  sYmm = false;
676 
677  CHK_MOAB_THROW(PetscOptionsGetBool(PETSC_NULL, "", "-poly_convex",
678  &polyConvex, PETSC_NULL),
679  "get ployconvex option failed");
680  }

Member Function Documentation

◆ integrate()

MoFEMErrorCode EshelbianPlasticity::OpSpatialPhysical_du_du::integrate ( EntData &  row_data,
EntData &  col_data 
)
virtual

Reimplemented from EshelbianPlasticity::OpAssembleBasic< VolUserDataOperator >.

Definition at line 1426 of file EshelbianOperators.cpp.

1427  {
1428  MoFEMFunctionBegin;
1429  if (dataAtPts->physicsPtr->dependentVariablesPiola.size()) {
1430  CHKERR integratePiola(row_data, col_data);
1431  } else {
1432  if (polyConvex) {
1433  CHKERR integratePolyconvexHencky(row_data, col_data);
1434  } else {
1435  CHKERR integrateHencky(row_data, col_data);
1436  }
1437  }
1438  MoFEMFunctionReturn(0);
1439 }

◆ integrateHencky()

MoFEMErrorCode EshelbianPlasticity::OpSpatialPhysical_du_du::integrateHencky ( EntData &  row_data,
EntData &  col_data 
)

Definition at line 1441 of file EshelbianOperators.cpp.

1442  {
1443  MoFEMFunctionBegin;
1444 
1445  FTensor::Index<'L', size_symm> L;
1446  FTensor::Index<'J', size_symm> J;
1447  auto t_L = symm_L_tensor();
1448  auto t_diff = diff_tensor();
1449 
1450  int nb_integration_pts = row_data.getN().size1();
1451  int row_nb_dofs = row_data.getIndices().size();
1452  int col_nb_dofs = col_data.getIndices().size();
1453 
1454  auto get_ftensor2 = [](MatrixDouble &m, const int r, const int c) {
1455  return FTensor::Tensor2<FTensor::PackPtr<double *, 6>, size_symm,
1456  size_symm>(
1457 
1458  &m(r + 0, c + 0), &m(r + 0, c + 1), &m(r + 0, c + 2), &m(r + 0, c + 3),
1459  &m(r + 0, c + 4), &m(r + 0, c + 5),
1460 
1461  &m(r + 1, c + 0), &m(r + 1, c + 1), &m(r + 1, c + 2), &m(r + 1, c + 3),
1462  &m(r + 1, c + 4), &m(r + 1, c + 5),
1463 
1464  &m(r + 2, c + 0), &m(r + 2, c + 1), &m(r + 2, c + 2), &m(r + 2, c + 3),
1465  &m(r + 2, c + 4), &m(r + 2, c + 5),
1466 
1467  &m(r + 3, c + 0), &m(r + 3, c + 1), &m(r + 3, c + 2), &m(r + 3, c + 3),
1468  &m(r + 3, c + 4), &m(r + 3, c + 5),
1469 
1470  &m(r + 4, c + 0), &m(r + 4, c + 1), &m(r + 4, c + 2), &m(r + 4, c + 3),
1471  &m(r + 4, c + 4), &m(r + 4, c + 5),
1472 
1473  &m(r + 5, c + 0), &m(r + 5, c + 1), &m(r + 5, c + 2), &m(r + 5, c + 3),
1474  &m(r + 5, c + 4), &m(r + 5, c + 5)
1475 
1476  );
1477  };
1478  FTensor::Index<'i', 3> i;
1479  FTensor::Index<'j', 3> j;
1480  FTensor::Index<'k', 3> k;
1481  FTensor::Index<'l', 3> l;
1482  FTensor::Index<'m', 3> m;
1483  FTensor::Index<'n', 3> n;
1484 
1485  auto v = getVolume();
1486  auto t_w = getFTensor0IntegrationWeight();
1487 
1488  auto t_approx_P_adjont_dstretch =
1489  getFTensor2FromMat<3, 3>(dataAtPts->adjointPdstretchAtPts);
1490  auto t_eigen_vals = getFTensor1FromMat<3>(dataAtPts->eigenVals);
1491  auto t_eigen_vecs = getFTensor2FromMat<3, 3>(dataAtPts->eigenVecs);
1492  auto &nbUniq = dataAtPts->nbUniq;
1493 
1494  int row_nb_base_functions = row_data.getN().size2();
1495  auto t_row_base_fun = row_data.getFTensor0N();
1496 
1497  auto get_dP = [&]() {
1498  dP.resize(size_symm * size_symm, nb_integration_pts, false);
1499  auto ts_a = getTSa();
1500 
1501  auto t_D = getFTensor4DdgFromMat<3, 3, 0>(dataAtPts->matD);
1502  FTensor::Tensor2<double, size_symm, size_symm> t_dP_tmp;
1503  t_dP_tmp(L, J) = -(1 + alphaU * ts_a) *
1504  (t_L(i, j, L) *
1505  ((t_D(i, j, m, n) * t_diff(m, n, k, l)) * t_L(k, l, J)));
1506 
1507 
1508  if (EshelbianCore::stretchSelector > LINEAR) {
1509  auto t_approx_P_adjont_dstretch =
1510  getFTensor2FromMat<3, 3>(dataAtPts->adjointPdstretchAtPts);
1511  auto t_eigen_vals = getFTensor1FromMat<3>(dataAtPts->eigenVals);
1512  auto t_eigen_vecs = getFTensor2FromMat<3, 3>(dataAtPts->eigenVecs);
1513  auto &nbUniq = dataAtPts->nbUniq;
1514 
1515  auto t_dP = getFTensor2FromMat<size_symm, size_symm>(dP);
1516  for (auto gg = 0; gg != nb_integration_pts; ++gg) {
1517 
1518  // Work of symmetric tensor on undefined tensor is equal to the work
1519  // of the symmetric part of it
1520  FTensor::Tensor2_symmetric<double, 3> t_sym;
1521  t_sym(i, j) = (t_approx_P_adjont_dstretch(i, j) ||
1522  t_approx_P_adjont_dstretch(j, i));
1523  t_sym(i, j) /= 2.0;
1524  auto t_diff2_uP2 = EigenMatrix::getDiffDiffMat(
1525  t_eigen_vals, t_eigen_vecs, EshelbianCore::f, EshelbianCore::d_f,
1526  EshelbianCore::dd_f, t_sym, nbUniq[gg]);
1527  t_dP(L, J) = t_L(i, j, L) *
1528  ((t_diff2_uP2(i, j, k, l) + t_diff2_uP2(k, l, i, j)) *
1529  t_L(k, l, J)) /
1530  2. +
1531  t_dP_tmp(L, J);
1532 
1533  ++t_dP;
1534  ++t_approx_P_adjont_dstretch;
1535  ++t_eigen_vals;
1536  ++t_eigen_vecs;
1537  }
1538  } else {
1539  auto t_dP = getFTensor2FromMat<size_symm, size_symm>(dP);
1540  for (auto gg = 0; gg != nb_integration_pts; ++gg) {
1541  t_dP(L, J) = t_dP_tmp(L, J);
1542  ++t_dP;
1543  }
1544  }
1545 
1546  return getFTensor2FromMat<size_symm, size_symm>(dP);
1547  };
1548 
1549  auto t_dP = get_dP();
1550  for (int gg = 0; gg != nb_integration_pts; ++gg) {
1551  double a = v * t_w;
1552 
1553  int rr = 0;
1554  for (; rr != row_nb_dofs / 6; ++rr) {
1555  auto t_col_base_fun = col_data.getFTensor0N(gg, 0);
1556  auto t_m = get_ftensor2(K, 6 * rr, 0);
1557  for (int cc = 0; cc != col_nb_dofs / 6; ++cc) {
1558  const double b = a * t_row_base_fun * t_col_base_fun;
1559  t_m(L, J) += b * t_dP(L, J);
1560  ++t_m;
1561  ++t_col_base_fun;
1562  }
1563  ++t_row_base_fun;
1564  }
1565 
1566  for (; rr != row_nb_base_functions; ++rr) {
1567  ++t_row_base_fun;
1568  }
1569 
1570  ++t_w;
1571  ++t_dP;
1572  }
1573  MoFEMFunctionReturn(0);
1574 }

◆ integratePiola()

MoFEMErrorCode EshelbianPlasticity::OpSpatialPhysical_du_du::integratePiola ( EntData &  row_data,
EntData &  col_data 
)

Definition at line 1744 of file EshelbianOperators.cpp.

1745  {
1746  MoFEMFunctionBegin;
1747 
1748  FTensor::Index<'L', size_symm> L;
1749  FTensor::Index<'J', size_symm> J;
1750  auto t_L = symm_L_tensor();
1751  auto t_diff = diff_tensor();
1752 
1753  int nb_integration_pts = row_data.getN().size1();
1754  int row_nb_dofs = row_data.getIndices().size();
1755  int col_nb_dofs = col_data.getIndices().size();
1756 
1757  auto get_ftensor2 = [](MatrixDouble &m, const int r, const int c) {
1758  return FTensor::Tensor2<FTensor::PackPtr<double *, 6>, size_symm,
1759  size_symm>(
1760 
1761  &m(r + 0, c + 0), &m(r + 0, c + 1), &m(r + 0, c + 2), &m(r + 0, c + 3),
1762  &m(r + 0, c + 4), &m(r + 0, c + 5),
1763 
1764  &m(r + 1, c + 0), &m(r + 1, c + 1), &m(r + 1, c + 2), &m(r + 1, c + 3),
1765  &m(r + 1, c + 4), &m(r + 1, c + 5),
1766 
1767  &m(r + 2, c + 0), &m(r + 2, c + 1), &m(r + 2, c + 2), &m(r + 2, c + 3),
1768  &m(r + 2, c + 4), &m(r + 2, c + 5),
1769 
1770  &m(r + 3, c + 0), &m(r + 3, c + 1), &m(r + 3, c + 2), &m(r + 3, c + 3),
1771  &m(r + 3, c + 4), &m(r + 3, c + 5),
1772 
1773  &m(r + 4, c + 0), &m(r + 4, c + 1), &m(r + 4, c + 2), &m(r + 4, c + 3),
1774  &m(r + 4, c + 4), &m(r + 4, c + 5),
1775 
1776  &m(r + 5, c + 0), &m(r + 5, c + 1), &m(r + 5, c + 2), &m(r + 5, c + 3),
1777  &m(r + 5, c + 4), &m(r + 5, c + 5)
1778 
1779  );
1780  };
1781  FTensor::Index<'i', 3> i;
1782  FTensor::Index<'j', 3> j;
1783  FTensor::Index<'k', 3> k;
1784  FTensor::Index<'l', 3> l;
1785  FTensor::Index<'m', 3> m;
1786  FTensor::Index<'n', 3> n;
1787 
1788  auto v = getVolume();
1789  auto t_w = getFTensor0IntegrationWeight();
1790 
1791  auto get_dP = [&]() {
1792  dP.resize(size_symm * size_symm, nb_integration_pts, false);
1793  auto ts_a = getTSa();
1794 
1795  auto t_P = getFTensor2FromMat<3, 3>(dataAtPts->PAtPts);
1796  auto r_P_du = getFTensor4FromMat<3, 3, 3, 3>(dataAtPts->P_du);
1797  auto t_approx_P_adjont_dstretch =
1798  getFTensor2FromMat<3, 3>(dataAtPts->adjointPdstretchAtPts);
1799  auto t_dot_log_u =
1800  getFTensor2SymmetricFromMat<3>(dataAtPts->logStretchDotTensorAtPts);
1801  auto t_u = getFTensor2SymmetricFromMat<3>(dataAtPts->stretchTensorAtPts);
1802  auto t_diff_u =
1803  getFTensor4DdgFromMat<3, 3, 1>(dataAtPts->diffStretchTensorAtPts);
1804  auto t_eigen_vals = getFTensor1FromMat<3>(dataAtPts->eigenVals);
1805  auto t_eigen_vecs = getFTensor2FromMat<3, 3>(dataAtPts->eigenVecs);
1806  auto &nbUniq = dataAtPts->nbUniq;
1807 
1808  auto t_dP = getFTensor2FromMat<size_symm, size_symm>(dP);
1809  for (auto gg = 0; gg != nb_integration_pts; ++gg) {
1810 
1811  FTensor::Tensor2<double, 3, 3> t_deltaP;
1812  t_deltaP(i, j) = t_approx_P_adjont_dstretch(i, j) - t_P(i, j);
1813 
1814  FTensor::Tensor3<double, 3, 3, size_symm> t_Ldiff_u;
1815  t_Ldiff_u(i, j, L) = t_diff_u(i, j, m, n) * t_L(m, n, L);
1816  t_dP(L, J) =
1817  -t_Ldiff_u(i, j, L) * (r_P_du(i, j, k, l) * t_Ldiff_u(k, l, J));
1818  // viscous stress derivative
1819  t_dP(L, J) -= (alphaU * ts_a) *
1820  (t_L(i, j, L) * (t_diff(i, j, k, l) * t_L(k, l, J)));
1821 
1822  if (EshelbianCore::stretchSelector > LINEAR) {
1823  FTensor::Tensor2_symmetric<double, 3> t_deltaP_sym;
1824  t_deltaP_sym(i, j) = (t_deltaP(i, j) || t_deltaP(j, i));
1825  t_deltaP_sym(i, j) /= 2.0;
1826  auto t_diff2_uP2 = EigenMatrix::getDiffDiffMat(
1827  t_eigen_vals, t_eigen_vecs, EshelbianCore::f, EshelbianCore::d_f,
1828  EshelbianCore::dd_f, t_deltaP_sym, nbUniq[gg]);
1829  t_dP(L, J) += t_L(i, j, L) * (t_diff2_uP2(i, j, k, l) * t_L(k, l, J));
1830  }
1831 
1832  ++t_P;
1833  ++t_dP;
1834  ++r_P_du;
1835  ++t_approx_P_adjont_dstretch;
1836  ++t_dot_log_u;
1837  ++t_u;
1838  ++t_diff_u;
1839  ++t_eigen_vals;
1840  ++t_eigen_vecs;
1841  }
1842 
1843  return getFTensor2FromMat<size_symm, size_symm>(dP);
1844  };
1845 
1846  int row_nb_base_functions = row_data.getN().size2();
1847  auto t_row_base_fun = row_data.getFTensor0N();
1848 
1849  auto t_dP = get_dP();
1850  for (int gg = 0; gg != nb_integration_pts; ++gg) {
1851  double a = v * t_w;
1852 
1853  int rr = 0;
1854  for (; rr != row_nb_dofs / 6; ++rr) {
1855  auto t_col_base_fun = col_data.getFTensor0N(gg, 0);
1856  auto t_m = get_ftensor2(K, 6 * rr, 0);
1857  for (int cc = 0; cc != col_nb_dofs / 6; ++cc) {
1858  const double b = a * t_row_base_fun * t_col_base_fun;
1859  t_m(L, J) += b * t_dP(L, J);
1860  ++t_m;
1861  ++t_col_base_fun;
1862  }
1863  ++t_row_base_fun;
1864  }
1865 
1866  for (; rr != row_nb_base_functions; ++rr) {
1867  ++t_row_base_fun;
1868  }
1869 
1870  ++t_w;
1871  ++t_dP;
1872  }
1873  MoFEMFunctionReturn(0);
1874 }

◆ integratePolyconvexHencky()

MoFEMErrorCode EshelbianPlasticity::OpSpatialPhysical_du_du::integratePolyconvexHencky ( EntData &  row_data,
EntData &  col_data 
)

Definition at line 1577 of file EshelbianOperators.cpp.

1578  {
1579  MoFEMFunctionBegin;
1580 
1581  FTensor::Index<'L', size_symm> L;
1582  FTensor::Index<'J', size_symm> J;
1583  auto t_L = symm_L_tensor();
1584  auto t_diff = diff_tensor();
1585 
1586  int nb_integration_pts = row_data.getN().size1();
1587  int row_nb_dofs = row_data.getIndices().size();
1588  int col_nb_dofs = col_data.getIndices().size();
1589 
1590  auto get_ftensor2 = [](MatrixDouble &m, const int r, const int c) {
1591  return FTensor::Tensor2<FTensor::PackPtr<double *, 6>, size_symm,
1592  size_symm>(
1593 
1594  &m(r + 0, c + 0), &m(r + 0, c + 1), &m(r + 0, c + 2), &m(r + 0, c + 3),
1595  &m(r + 0, c + 4), &m(r + 0, c + 5),
1596 
1597  &m(r + 1, c + 0), &m(r + 1, c + 1), &m(r + 1, c + 2), &m(r + 1, c + 3),
1598  &m(r + 1, c + 4), &m(r + 1, c + 5),
1599 
1600  &m(r + 2, c + 0), &m(r + 2, c + 1), &m(r + 2, c + 2), &m(r + 2, c + 3),
1601  &m(r + 2, c + 4), &m(r + 2, c + 5),
1602 
1603  &m(r + 3, c + 0), &m(r + 3, c + 1), &m(r + 3, c + 2), &m(r + 3, c + 3),
1604  &m(r + 3, c + 4), &m(r + 3, c + 5),
1605 
1606  &m(r + 4, c + 0), &m(r + 4, c + 1), &m(r + 4, c + 2), &m(r + 4, c + 3),
1607  &m(r + 4, c + 4), &m(r + 4, c + 5),
1608 
1609  &m(r + 5, c + 0), &m(r + 5, c + 1), &m(r + 5, c + 2), &m(r + 5, c + 3),
1610  &m(r + 5, c + 4), &m(r + 5, c + 5)
1611 
1612  );
1613  };
1614  FTensor::Index<'i', 3> i;
1615  FTensor::Index<'j', 3> j;
1616  FTensor::Index<'k', 3> k;
1617  FTensor::Index<'l', 3> l;
1618  FTensor::Index<'m', 3> m;
1619  FTensor::Index<'n', 3> n;
1620 
1621  auto v = getVolume();
1622  auto t_w = getFTensor0IntegrationWeight();
1623 
1624  int row_nb_base_functions = row_data.getN().size2();
1625  auto t_row_base_fun = row_data.getFTensor0N();
1626 
1627  auto get_dP = [&]() {
1628  dP.resize(size_symm * size_symm, nb_integration_pts, false);
1629  auto ts_a = getTSa();
1630 
1631  auto t_D = getFTensor4DdgFromMat<3, 3, 0>(dataAtPts->matD);
1632 
1633  constexpr double nohat_k = 1. / 4;
1634  constexpr double hat_k = 1. / 8;
1635  double mu = dataAtPts->mu;
1636  double lambda = dataAtPts->lambda;
1637 
1638  constexpr double third = boost::math::constants::third<double>();
1639  auto t_kd = FTensor::Kronecker_Delta_symmetric<int>();
1640  auto t_diff_deviator = diff_deviator(diff_tensor());
1641 
1642  auto t_approx_P_adjont_dstretch =
1643  getFTensor2FromMat<3, 3>(dataAtPts->adjointPdstretchAtPts);
1644  auto t_log_streach_h1 =
1645  getFTensor2SymmetricFromMat<3>(dataAtPts->logStretchTotalTensorAtPts);
1646  auto t_eigen_vals = getFTensor1FromMat<3>(dataAtPts->eigenVals);
1647  auto t_eigen_vecs = getFTensor2FromMat<3, 3>(dataAtPts->eigenVecs);
1648  auto &nbUniq = dataAtPts->nbUniq;
1649 
1650  auto t_dP = getFTensor2FromMat<size_symm, size_symm>(dP);
1651  for (auto gg = 0; gg != nb_integration_pts; ++gg) {
1652 
1653  double log_det = t_log_streach_h1(i, i);
1654  double log_det2 = log_det * log_det;
1655  FTensor::Tensor2_symmetric<double, 3> t_dev;
1656  t_dev(i, j) = t_log_streach_h1(i, j) - t_kd(i, j) * (third * log_det);
1657  double dev_norm2 = t_dev(i, j) * t_dev(i, j);
1658 
1659  auto A = 2 * mu * std::exp(nohat_k * dev_norm2);
1660  auto B = lambda * std::exp(hat_k * log_det2) * log_det;
1661 
1662  FTensor::Tensor2_symmetric<double, 3> t_A_diff, t_B_diff;
1663  t_A_diff(i, j) =
1664  (A * 2 * nohat_k) * (t_dev(k, l) * t_diff_deviator(k, l, i, j));
1665  t_B_diff(i, j) = (B * 2 * hat_k) * log_det * t_kd(i, j) +
1666  lambda * std::exp(hat_k * log_det2) * t_kd(i, j);
1667  FTensor::Ddg<double, 3, 3> t_dT;
1668  t_dT(i, j, k, l) =
1669  t_A_diff(i, j) * (t_dev(m, n) * t_diff_deviator(m, n, k, l))
1670 
1671  +
1672 
1673  A * t_diff_deviator(m, n, i, j) * t_diff_deviator(m, n, k, l)
1674 
1675  +
1676 
1677  t_B_diff(i, j) * t_kd(k, l);
1678 
1679  t_dP(L, J) = -t_L(i, j, L) *
1680  ((
1681 
1682  t_dT(i, j, k, l)
1683 
1684  +
1685 
1686  (alphaU * ts_a) * (t_D(i, j, m, n) * t_diff(m, n, k, l)
1687 
1688  )) *
1689  t_L(k, l, J));
1690 
1691  // Work of symmetric tensor on undefined tensor is equal to the work
1692  // of the symmetric part of it
1693  if (EshelbianCore::stretchSelector > LINEAR) {
1694  FTensor::Tensor2_symmetric<double, 3> t_sym;
1695  t_sym(i, j) = (t_approx_P_adjont_dstretch(i, j) ||
1696  t_approx_P_adjont_dstretch(j, i));
1697  t_sym(i, j) /= 2.0;
1698  auto t_diff2_uP2 = EigenMatrix::getDiffDiffMat(
1699  t_eigen_vals, t_eigen_vecs, EshelbianCore::f, EshelbianCore::d_f,
1700  EshelbianCore::dd_f, t_sym, nbUniq[gg]);
1701  t_dP(L, J) += t_L(i, j, L) *
1702  ((t_diff2_uP2(i, j, k, l) + t_diff2_uP2(k, l, i, j)) *
1703  t_L(k, l, J)) /
1704  2.;
1705  }
1706 
1707  ++t_dP;
1708  ++t_approx_P_adjont_dstretch;
1709  ++t_log_streach_h1;
1710  ++t_eigen_vals;
1711  ++t_eigen_vecs;
1712  }
1713 
1714  return getFTensor2FromMat<size_symm, size_symm>(dP);
1715  };
1716 
1717  auto t_dP = get_dP();
1718  for (int gg = 0; gg != nb_integration_pts; ++gg) {
1719  double a = v * t_w;
1720 
1721  int rr = 0;
1722  for (; rr != row_nb_dofs / 6; ++rr) {
1723  auto t_col_base_fun = col_data.getFTensor0N(gg, 0);
1724  auto t_m = get_ftensor2(K, 6 * rr, 0);
1725  for (int cc = 0; cc != col_nb_dofs / 6; ++cc) {
1726  const double b = a * t_row_base_fun * t_col_base_fun;
1727  t_m(L, J) += b * t_dP(L, J);
1728  ++t_m;
1729  ++t_col_base_fun;
1730  }
1731  ++t_row_base_fun;
1732  }
1733 
1734  for (; rr != row_nb_base_functions; ++rr) {
1735  ++t_row_base_fun;
1736  }
1737 
1738  ++t_w;
1739  ++t_dP;
1740  }
1741  MoFEMFunctionReturn(0);
1742 }

Member Data Documentation

◆ alphaU

const double EshelbianPlasticity::OpSpatialPhysical_du_du::alphaU

Definition at line 668 of file EshelbianPlasticity.hpp.

◆ dP

MatrixDouble EshelbianPlasticity::OpSpatialPhysical_du_du::dP
private

Definition at line 689 of file EshelbianPlasticity.hpp.

◆ polyConvex

PetscBool EshelbianPlasticity::OpSpatialPhysical_du_du::polyConvex = PETSC_FALSE
private

Definition at line 687 of file EshelbianPlasticity.hpp.

The documentation for this struct was generated from the following files:
CHK_MOAB_THROW
#define CHK_MOAB_THROW(err, msg)
Check error code of MoAB function and throw MoFEM exception.
Definition: definitions.h:576
EshelbianPlasticity::LINEAR
@ LINEAR
Definition: EshelbianPlasticity.hpp:21
EshelbianPlasticity::size_symm
constexpr static auto size_symm
Definition: EshelbianOperators.cpp:47
EshelbianPlasticity::EshelbianCore::dd_f
static boost::function< double(const double)> dd_f
Definition: EshelbianPlasticity.hpp:871
EshelbianPlasticity::OpSpatialPhysical_du_du::dP
MatrixDouble dP
Definition: EshelbianPlasticity.hpp:689
EshelbianPlasticity::OpSpatialPhysical_du_du::integrateHencky
MoFEMErrorCode integrateHencky(EntData &row_data, EntData &col_data)
Definition: EshelbianOperators.cpp:1441
MoFEM::Types::MatrixDouble
UBlasMatrix< double > MatrixDouble
Definition: Types.hpp:77
EshelbianPlasticity::diff_tensor
auto diff_tensor()
Definition: EshelbianOperators.cpp:49
A
constexpr AssemblyType A
Definition: operators_tests.cpp:30
J
FTensor::Index< 'J', DIM1 > J
Definition: level_set.cpp:30
FTensor::Tensor2_symmetric
Definition: Tensor2_symmetric_value.hpp:13
EshelbianPlasticity::EshelbianCore::d_f
static boost::function< double(const double)> d_f
Definition: EshelbianPlasticity.hpp:870
EshelbianPlasticity::OpSpatialPhysical_du_du::integratePolyconvexHencky
MoFEMErrorCode integratePolyconvexHencky(EntData &row_data, EntData &col_data)
Definition: EshelbianOperators.cpp:1577
sdf.r
int r
Definition: sdf.py:8
FTensor::Tensor2
Definition: Tensor2_value.hpp:16
EshelbianPlasticity::OpSpatialPhysical_du_du::alphaU
const double alphaU
Definition: EshelbianPlasticity.hpp:668
MoFEM::EntitiesFieldData::EntData::getFTensor0N
FTensor::Tensor0< FTensor::PackPtr< double *, 1 > > getFTensor0N(const FieldApproximationBase base)
Get base function as Tensor0.
Definition: EntitiesFieldData.hpp:1489
EshelbianPlasticity::OpSpatialPhysical_du_du::polyConvex
PetscBool polyConvex
Definition: EshelbianPlasticity.hpp:687
c
const double c
speed of light (cm/ns)
Definition: initial_diffusion.cpp:39
CHKERR
#define CHKERR
Inline error check.
Definition: definitions.h:535
FTensor::Tensor3
Definition: Tensor3_value.hpp:12
a
constexpr double a
Definition: approx_sphere.cpp:30
EshelbianPlasticity::EshelbianCore::stretchSelector
static enum StretchSelector stretchSelector
Definition: EshelbianPlasticity.hpp:866
EshelbianPlasticity::EshelbianCore::f
static boost::function< double(const double)> f
Definition: EshelbianPlasticity.hpp:869
MoFEM::EntitiesFieldData::EntData::getIndices
const VectorInt & getIndices() const
Get global indices of dofs on entity.
Definition: EntitiesFieldData.hpp:1201
MoFEM::L
VectorDouble L
Definition: Projection10NodeCoordsOnField.cpp:124
EshelbianPlasticity::OpAssembleBasic< VolUserDataOperator >::dataAtPts
boost::shared_ptr< DataAtIntegrationPts > dataAtPts
data at integration pts
Definition: EshelbianPlasticity.hpp:357
EshelbianPlasticity::diff_deviator
auto diff_deviator(FTensor::Ddg< double, 3, 3 > &&t_diff_stress)
Definition: EshelbianOperators.cpp:20
i
FTensor::Index< 'i', SPACE_DIM > i
Definition: hcurl_divergence_operator_2d.cpp:27
t_kd
constexpr auto t_kd
Definition: free_surface.cpp:137
EshelbianPlasticity::symm_L_tensor
auto symm_L_tensor()
Definition: EshelbianOperators.cpp:60
FTensor::Index
Definition: Index.hpp:23
convert.n
n
Definition: convert.py:82
v
const double v
phase velocity of light in medium (cm/ns)
Definition: initial_diffusion.cpp:40
MoFEM::EntitiesFieldData::EntData::getN
MatrixDouble & getN(const FieldApproximationBase base)
get base functions this return matrix (nb. of rows is equal to nb. of Gauss pts, nb....
Definition: EntitiesFieldData.hpp:1305
j
FTensor::Index< 'j', 3 > j
Definition: matrix_function.cpp:19
FTensor::Ddg< double, 3, 3 >
mu
double mu
Definition: dynamic_first_order_con_law.cpp:98
lambda
static double lambda
Definition: incompressible_elasticity.cpp:199
EigenMatrix::getDiffDiffMat
FTensor::Ddg< double, 3, 3 > getDiffDiffMat(Val< double, 3 > &t_val, Vec< double, 3 > &t_vec, Fun< double > f, Fun< double > d_f, Fun< double > dd_f, FTensor::Tensor2< double, 3, 3 > &t_S, const int nb)
Definition: MatrixFunction.cpp:78
m
FTensor::Index< 'm', 3 > m
Definition: shallow_wave.cpp:80
FTensor::Kronecker_Delta_symmetric
Kronecker Delta class symmetric.
Definition: Kronecker_Delta.hpp:49
EshelbianPlasticity::OpSpatialPhysical_du_du::integratePiola
MoFEMErrorCode integratePiola(EntData &row_data, EntData &col_data)
Definition: EshelbianOperators.cpp:1744
EshelbianPlasticity::OpAssembleVolume::OpAssembleVolume
OpAssembleVolume(const std::string &field, boost::shared_ptr< DataAtIntegrationPts > data_ptr, const char type)
Definition: EshelbianPlasticity.hpp:463
third
constexpr double third
Definition: EshelbianADOL-C.cpp:14
k
FTensor::Index< 'k', 3 > k
Definition: matrix_function.cpp:20
EshelbianPlasticity::OpAssembleBasic< VolUserDataOperator >::K
MatrixDouble K
local tangent matrix
Definition: EshelbianPlasticity.hpp:372
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition: definitions.h:416
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition: definitions.h:346
l
FTensor::Index< 'l', 3 > l
Definition: matrix_function.cpp:21
MoFEM::PetscOptionsGetBool
PetscErrorCode PetscOptionsGetBool(PetscOptions *, const char pre[], const char name[], PetscBool *bval, PetscBool *set)
Definition: DeprecatedPetsc.hpp:182
Generated by Doxygen 1.8.17 and hosted at University of Glasgow