Line data    Source code

       1           0 : // Distributed under the MIT License.
       2             : // See LICENSE.txt for details.
       3             : 
       4             : #include "PointwiseFunctions/Elasticity/ConstitutiveRelations/IsotropicHomogeneous.hpp"
       5             : 
       6             : #include <array>
       7             : #include <pup.h>  // IWYU pragma: keep
       8             : 
       9             : #include "DataStructures/DataVector.hpp"
      10             : #include "DataStructures/Tensor/Tensor.hpp"  // IWYU pragma: keep
      11             : #include "DataStructures/Tensor/TypeAliases.hpp"
      12             : #include "Utilities/GenerateInstantiations.hpp"
      13             : #include "Utilities/MakeWithValue.hpp"
      14             : // IWYU pragma: no_forward_declare Tensor
      15             : 
      16             : namespace Elasticity {
      17             : namespace ConstitutiveRelations {
      18             : 
      19             : template <size_t Dim>
      20             : IsotropicHomogeneous<Dim>::IsotropicHomogeneous(double bulk_modulus,
      21             :                                                 double shear_modulus) noexcept
      22             :     : bulk_modulus_(bulk_modulus), shear_modulus_(shear_modulus) {}
      23             : 
      24             : template <>
      25           0 : tnsr::II<DataVector, 3> IsotropicHomogeneous<3>::stress(
      26             :     const tnsr::ii<DataVector, 3>& strain,
      27             :     const tnsr::I<DataVector, 3>& /*x*/) const noexcept {
      28             :   auto result = make_with_value<tnsr::II<DataVector, 3>>(strain, 0.);
      29             :   for (size_t i = 0; i < 3; i++) {
      30             :     for (size_t j = 0; j <= i; j++) {
      31             :       result.get(i, j) = -2. * shear_modulus_ * strain.get(i, j);
      32             :     }
      33             :   }
      34             :   auto trace_term = make_with_value<DataVector>(strain, 0.);
      35             :   for (size_t i = 0; i < 3; i++) {
      36             :     trace_term += strain.get(i, i);
      37             :   }
      38             :   trace_term *= lame_parameter();
      39             :   for (size_t i = 0; i < 3; i++) {
      40             :     result.get(i, i) -= trace_term;
      41             :   }
      42             :   return result;
      43             : }
      44             : 
      45             : template <>
      46           0 : tnsr::II<DataVector, 2> IsotropicHomogeneous<2>::stress(
      47             :     const tnsr::ii<DataVector, 2>& strain,
      48             :     const tnsr::I<DataVector, 2>& /*x*/) const noexcept {
      49             :   auto result = make_with_value<tnsr::II<DataVector, 2>>(strain, 0.);
      50             :   for (size_t i = 0; i < 2; i++) {
      51             :     for (size_t j = 0; j <= i; j++) {
      52             :       result.get(i, j) = -2. * shear_modulus_ * strain.get(i, j);
      53             :     }
      54             :   }
      55             :   auto trace_term = make_with_value<DataVector>(strain, 0.);
      56             :   for (size_t i = 0; i < 2; i++) {
      57             :     trace_term += strain.get(i, i);
      58             :   }
      59             :   trace_term *= 2. * (3. * bulk_modulus_ - 2. * shear_modulus_) *
      60             :                 shear_modulus_ / (3. * bulk_modulus_ + 4. * shear_modulus_);
      61             :   for (size_t i = 0; i < 2; i++) {
      62             :     result.get(i, i) -= trace_term;
      63             :   }
      64             :   return result;
      65             : }
      66             : 
      67             : template <size_t Dim>
      68             : double IsotropicHomogeneous<Dim>::bulk_modulus() const noexcept {
      69             :   return bulk_modulus_;
      70             : }
      71             : 
      72             : template <size_t Dim>
      73             : double IsotropicHomogeneous<Dim>::shear_modulus() const noexcept {
      74             :   return shear_modulus_;
      75             : }
      76             : 
      77             : template <size_t Dim>
      78             : double IsotropicHomogeneous<Dim>::lame_parameter() const noexcept {
      79             :   return bulk_modulus_ - 2. * shear_modulus_ / 3.;
      80             : }
      81             : 
      82             : template <size_t Dim>
      83             : double IsotropicHomogeneous<Dim>::youngs_modulus() const noexcept {
      84             :   return 9. * bulk_modulus_ * shear_modulus_ /
      85             :          (3. * bulk_modulus_ + shear_modulus_);
      86             : }
      87             : 
      88             : template <size_t Dim>
      89             : double IsotropicHomogeneous<Dim>::poisson_ratio() const noexcept {
      90             :   return (3. * bulk_modulus_ - 2. * shear_modulus_) /
      91             :          (6. * bulk_modulus_ + 2. * shear_modulus_);
      92             : }
      93             : 
      94             : template <size_t Dim>
      95             : void IsotropicHomogeneous<Dim>::pup(PUP::er& p) noexcept {
      96             :   p | bulk_modulus_;
      97             :   p | shear_modulus_;
      98             : }
      99             : 
     100             : template <size_t Dim>
     101           0 : bool operator==(const IsotropicHomogeneous<Dim>& lhs,
     102             :                 const IsotropicHomogeneous<Dim>& rhs) noexcept {
     103             :   return lhs.bulk_modulus() == rhs.bulk_modulus() and
     104             :          lhs.shear_modulus() == rhs.shear_modulus();
     105             : }
     106             : template <size_t Dim>
     107           0 : bool operator!=(const IsotropicHomogeneous<Dim>& lhs,
     108             :                 const IsotropicHomogeneous<Dim>& rhs) noexcept {
     109             :   return not(lhs == rhs);
     110             : }
     111             : 
     112             : /// \cond
     113             : #define DIM(data) BOOST_PP_TUPLE_ELEM(0, data)
     114             : 
     115             : #define INSTANTIATE(_, data)                                \
     116             :   template class IsotropicHomogeneous<DIM(data)>;           \
     117             :   template bool operator==(                                 \
     118             :       const IsotropicHomogeneous<DIM(data)>& lhs,           \
     119             :       const IsotropicHomogeneous<DIM(data)>& rhs) noexcept; \
     120             :   template bool operator!=(                                 \
     121             :       const IsotropicHomogeneous<DIM(data)>& lhs,           \
     122             :       const IsotropicHomogeneous<DIM(data)>& rhs) noexcept;
     123             : 
     124             : GENERATE_INSTANTIATIONS(INSTANTIATE, (2, 3))
     125             : 
     126             : #undef DIM
     127             : #undef INSTANTIATE
     128             : 
     129             : /// \endcond
     130             : 
     131             : }  // namespace ConstitutiveRelations
     132             : }  // namespace Elasticity