Line data    Source code

       1             : //* This file is part of the RACCOON application
       2             : //* being developed at Dolbow lab at Duke University
       3             : //* http://dolbow.pratt.duke.edu
       4             : 
       5             : #include "RaccoonUtils.h"
       6             : #include "ADReal.h"
       7             : #include "MooseUtils.h"
       8             : #include "RankTwoTensorImplementation.h"
       9             : 
      10             : namespace RaccoonUtils
      11             : {
      12             : 
      13             : ADReal
      14     6718400 : Macaulay(const ADReal x, const bool deriv)
      15             : {
      16             :   using std::abs;
      17     6718400 :   if (deriv)
      18           0 :     return x > 0 ? 1 : 0;
      19    20155200 :   return 0.5 * (x + abs(x));
      20             : }
      21             : 
      22             : std::vector<ADReal>
      23     1582772 : Macaulay(const std::vector<ADReal> & v, const bool deriv)
      24             : {
      25     1582772 :   std::vector<ADReal> m = v;
      26     6331088 :   for (auto & x : m)
      27     4748316 :     x = Macaulay(x, deriv);
      28     1582772 :   return m;
      29             : }
      30             : 
      31             : ADRankTwoTensor
      32     1582772 : spectralDecomposition(const ADRankTwoTensor & r2t)
      33             : {
      34     1582772 :   ADRankTwoTensor eigvecs;
      35     1582772 :   std::vector<ADReal> eigvals(LIBMESH_DIM);
      36     1582772 :   r2t.symmetricEigenvaluesEigenvectors(eigvals, eigvecs);
      37             : 
      38     1582772 :   ADRankTwoTensor eigvals_pos;
      39     1582772 :   eigvals_pos.fillFromInputVector(Macaulay(eigvals));
      40     1582772 :   return eigvecs * eigvals_pos * eigvecs.transpose();
      41             : }
      42             : 
      43             : ADRankTwoTensor
      44      473464 : log(const ADRankTwoTensor & r2t)
      45             : {
      46             :   using std::log;
      47             :   std::vector<ADReal> d;
      48      473464 :   ADRankTwoTensor V, D;
      49      473464 :   r2t.symmetricEigenvaluesEigenvectors(d, V);
      50     1893856 :   for (auto & di : d)
      51     1420392 :     di = log(di);
      52      473464 :   D.fillFromInputVector(d);
      53      473464 :   return V * D * V.transpose();
      54             : }
      55             : 
      56             : ADRankTwoTensor
      57      214592 : exp(const ADRankTwoTensor & r2t)
      58             : {
      59             :   using std::exp;
      60             :   std::vector<ADReal> d;
      61      214592 :   ADRankTwoTensor V, D;
      62      214592 :   r2t.symmetricEigenvaluesEigenvectors(d, V);
      63      858368 :   for (auto & di : d)
      64      643776 :     di = exp(di);
      65      214592 :   D.fillFromInputVector(d);
      66      214592 :   return V * D * V.transpose();
      67             : }
      68             : 
      69             : } // end namespace MooseUtils