LCOV - code coverage report
Current view: top level - src/utils - ElasticityTensorTools.C (source / functions) Hit Total Coverage
Test: idaholab/moose tensor_mechanics: d6b47a Lines: 53 54 98.1 %
Date: 2024-02-27 11:53:14 Functions: 5 5 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //* This file is part of the MOOSE framework
       2             : //* https://www.mooseframework.org
       3             : //*
       4             : //* All rights reserved, see COPYRIGHT for full restrictions
       5             : //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
       6             : //*
       7             : //* Licensed under LGPL 2.1, please see LICENSE for details
       8             : //* https://www.gnu.org/licenses/lgpl-2.1.html
       9             : 
      10             : #include "MooseTypes.h"
      11             : #include "PermutationTensor.h"
      12             : #include "RankFourTensor.h"
      13             : #include "ElasticityTensorTools.h"
      14             : 
      15             : #include "libmesh/vector_value.h"
      16             : 
      17             : namespace ElasticityTensorTools
      18             : {
      19             : 
      20             : Real
      21   956284392 : elasticJacobian(const RankFourTensor & r4t,
      22             :                 unsigned int i,
      23             :                 unsigned int k,
      24             :                 const RealGradient & grad_test,
      25             :                 const RealGradient & grad_phi)
      26             : {
      27             :   // d(stress_ij*d(test)/dx_j)/du_k = d(C_ijmn*du_m/dx_n dtest/dx_j)/du_k (which is nonzero for m ==
      28             :   // k)
      29             : 
      30   956284392 :   const Real gt0 = grad_test(0);
      31   956284392 :   const Real gt1 = grad_test(1);
      32   956284392 :   const Real gt2 = grad_test(2);
      33   956284392 :   const Real gp0 = grad_phi(0);
      34   956284392 :   const Real gp1 = grad_phi(1);
      35   956284392 :   const Real gp2 = grad_phi(2);
      36             : 
      37             :   // clang-format off
      38             :   // This is the algorithm that is unrolled below:
      39             :   //
      40             :   //    Real sum = 0.0;
      41             :   //    for (const auto j: make_range(Moose::dim))
      42             :   //      for (const auto l: make_range(Moose::dim))
      43             :   //        sum += r4t(i, j, k, l) * grad_phi(l) * grad_test(j);
      44             :   //    return sum;
      45             : 
      46             :   return
      47             :      (
      48   956284392 :          r4t(i,0,k,0) * gp0
      49   956284392 :        + r4t(i,0,k,1) * gp1
      50   956284392 :        + r4t(i,0,k,2) * gp2
      51   956284392 :      ) * gt0
      52   956284392 :      +
      53             :      (
      54   956284392 :          r4t(i,1,k,0) * gp0
      55   956284392 :        + r4t(i,1,k,1) * gp1
      56   956284392 :        + r4t(i,1,k,2) * gp2
      57   956284392 :      ) * gt1
      58             :      +
      59             :      (
      60   956284392 :          r4t(i,2,k,0) * gp0
      61   956284392 :        + r4t(i,2,k,1) * gp1
      62   956284392 :        + r4t(i,2,k,2) * gp2
      63   956284392 :      ) * gt2;
      64             :   // clang-format on
      65             : }
      66             : 
      67             : Real
      68     6660096 : elasticJacobianWC(const RankFourTensor & r4t,
      69             :                   unsigned int i,
      70             :                   unsigned int k,
      71             :                   const RealGradient & grad_test,
      72             :                   Real phi)
      73             : {
      74             :   // d(stress_ij*d(test)/dx_j)/dw_k = d(C_ijmn*eps_mnp*w_p*dtest/dx_j)/dw_k (only nonzero for p ==
      75             :   // k)
      76             :   Real sum = 0.0;
      77    26640384 :   for (const auto j : make_range(Moose::dim))
      78    79921152 :     for (const auto m : make_range(Moose::dim))
      79   239763456 :       for (const auto n : make_range(Moose::dim))
      80   179822592 :         sum += r4t(i, j, m, n) * PermutationTensor::eps(m, n, k) * grad_test(j);
      81     6660096 :   return sum * phi;
      82             : }
      83             : 
      84             : Real
      85     6660096 : momentJacobian(const RankFourTensor & r4t,
      86             :                unsigned int i,
      87             :                unsigned int k,
      88             :                Real test,
      89             :                const RealGradient & grad_phi)
      90             : {
      91             :   // Jacobian entry: d(eps_ijm*stress_jm*test)/du_k = d(eps_ijm*C_jmln*du_l/dx_n*test)/du_k (only
      92             :   // nonzero for l == k)
      93             :   Real sum = 0.0;
      94    26640384 :   for (const auto j : make_range(Moose::dim))
      95    79921152 :     for (const auto m : make_range(Moose::dim))
      96   239763456 :       for (const auto n : make_range(Moose::dim))
      97   179822592 :         sum += PermutationTensor::eps(i, j, m) * r4t(j, m, k, n) * grad_phi(n);
      98     6660096 :   return test * sum;
      99             : }
     100             : 
     101             : Real
     102     4726784 : momentJacobianWC(const RankFourTensor & r4t, unsigned int i, unsigned int k, Real test, Real phi)
     103             : {
     104             :   // Jacobian entry: d(eps_ijm*stress_jm*test)/dw_k = d(eps_ijm*C_jmln*eps_lnp*w_p*test)/dw_k (only
     105             :   // nonzero for p ==k)
     106             :   Real sum = 0.0;
     107    18907136 :   for (const auto j : make_range(Moose::dim))
     108    56721408 :     for (const auto l : make_range(Moose::dim))
     109   170164224 :       for (const auto m : make_range(Moose::dim))
     110   510492672 :         for (const auto n : make_range(Moose::dim))
     111   382869504 :           sum +=
     112   382869504 :               PermutationTensor::eps(i, j, m) * r4t(j, m, l, n) * PermutationTensor::eps(l, n, k);
     113             : 
     114     4726784 :   return test * phi * sum;
     115             : }
     116             : 
     117             : void
     118     4321728 : toVoigtNotationIndexConversion(int k, int & a, int & b)
     119             : {
     120     4321728 :   if (k < 3 && k >= 0)
     121     2160864 :     a = b = k;
     122     2160864 :   else if (k == 3)
     123             :   {
     124      720288 :     a = 1;
     125      720288 :     b = 2;
     126             :   }
     127     1440576 :   else if (k == 4)
     128             :   {
     129      720288 :     a = 0;
     130      720288 :     b = 2;
     131             :   }
     132      720288 :   else if (k == 5)
     133             :   {
     134      720288 :     a = 0;
     135      720288 :     b = 1;
     136             :   }
     137             :   else
     138           0 :     mooseError("\nIndex out of bound while converting from tensor to voigt notation in "
     139             :                "toVoigtNotationIndexConversion");
     140     4321728 : }
     141             : }

Generated by: LCOV version 1.14