Compute objective function contributions at element level. 
Evaluates Python objective function with current displacement and stress state, and accumulates global objective value and gradients. 
 1825                                                        {
 1827 
 1828    
 1833 
 1836 
 1838 
 1840 
 1841    auto nb_gauss_pts = getGaussPts().size2();
 1842    auto objective_ptr = boost::make_shared<VectorDouble>(nb_gauss_pts);
 1843    auto objective_dstress =
 1844        boost::make_shared<MatrixDouble>(symm_size, nb_gauss_pts);
 1845    auto objective_dstrain =
 1846        boost::make_shared<MatrixDouble>(symm_size, nb_gauss_pts);
 1847    auto obj_grad = boost::make_shared<MatrixDouble>(
SPACE_DIM, nb_gauss_pts);
 
 1848 
 1849    auto evaluate_python = [&]() {
 1851      auto &coords = OP::getCoordsAtGaussPts();
 1854          objective_ptr);
 1857          objective_dstress);
 1860          objective_dstrain);
 1861 
 1862      auto t_grad_u =
 1863          getFTensor2FromMat<SPACE_DIM, SPACE_DIM>(*(
commPtr->matGradPtr));
 
 1864      auto t_D =
 1865          getFTensor4DdgFromMat<SPACE_DIM, SPACE_DIM, 0>(*(
commPtr->matDPtr));
 
 1866      auto t_jac = getFTensor2FromMat<SPACE_DIM, SPACE_DIM>(*(
jacPtr));
 
 1867      auto t_diff_jac = getFTensor2FromMat<SPACE_DIM, SPACE_DIM>(*(
diffJacPtr));
 
 1869      auto t_d_grad = getFTensor2FromMat<SPACE_DIM, SPACE_DIM>(*(
dGradPtr));
 
 1870 
 1872      auto t_obj_dstress =
 1873          getFTensor2SymmetricFromMat<SPACE_DIM>(*objective_dstress);
 1874      auto t_obj_dstrain =
 1875          getFTensor2SymmetricFromMat<SPACE_DIM>(*objective_dstrain);
 1876 
 1877      auto vol = OP::getMeasure();
 1878      auto t_w = getFTensor0IntegrationWeight();
 1879      for (auto gg = 0; gg != nb_gauss_pts; ++gg) {
 1880 
 1884 
 1886        t_diff_inv_jac(
i, 
j) =
 
 1887            -(t_inv_jac(
i, 
I) * t_diff_jac(
I, 
J)) * t_inv_jac(
J, 
j);
 
 1889        t_diff_grad(
i, 
j) = t_grad_u(
i, 
k) * t_diff_inv_jac(
k, 
j);
 
 1890 
 1892        t_d_strain(
i, 
j) = t_diff_symm(
i, 
j, 
k, 
l) * (
 
 1893 
 1895 
 1896                                                         +
 1897 
 1899 
 1900                                                     );
 1901 
 1902        auto alpha = t_w * vol;
 1903 
 1904        (*globObjectivePtr) += alpha * t_obj;
 1905        (*globObjectiveGradPtr) +=
 1906            alpha *
 1907            (
 1908 
 1909                t_obj_dstress(
i, 
j) * (t_D(
i, 
j, 
k, 
l) * t_d_strain(
k, 
l))
 
 1910 
 1911                +
 1912 
 1913                t_obj_dstrain(
i, 
j) * t_d_strain(
i, 
j)
 
 1914 
 1915                +
 1916 
 1917                t_obj * t_cof
 1918 
 1919            );
 1920 
 1921        ++t_w;
 1922        ++t_jac;
 1923        ++t_diff_jac;
 1924        ++t_cof;
 1925 
 1926        ++t_obj;
 1927        ++t_obj_dstress;
 1928        ++t_obj_dstrain;
 1929 
 1930        ++t_grad_u;
 1931        ++t_d_grad;
 1932      }
 1934    };
 1935 
 1936    CHKERR evaluate_python();
 
 1937 
 1939  }
#define FTENSOR_INDEX(DIM, I)
auto diff_symmetrize(FTensor::Number< DIM >)
constexpr int SPACE_DIM
[Define dimension]
constexpr IntegrationType I
Use Gauss quadrature for integration.
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
FTensor::Index< 'i', SPACE_DIM > i
FTensor::Index< 'J', DIM1 > J
FTensor::Index< 'l', 3 > l
FTensor::Index< 'j', 3 > j
FTensor::Index< 'k', 3 > k
static MoFEMErrorCode invertTensor(FTensor::Tensor2< T1, DIM, DIM > &t, T2 &det, FTensor::Tensor2< T3, DIM, DIM > &inv_t)
static auto determinantTensor(FTensor::Tensor2< T, DIM, DIM > &t)
Calculate the determinant of a tensor of rank DIM.
static auto getFTensor0FromVec(ublas::vector< T, A > &data)
Get tensor rank 0 (scalar) form data vector.