645 tfel material add eshelby tensor in anisotropic medium

docs/web/release-notes-5.1.md

@@ -76,6 +76,18 @@ $ tfel-config-5.1.0-release --python-module-suffix
 5_1_0_release
 ~~~~
 
+# New `TFEL/Material` features
+
+## Homogenization
+
+### Ellipsoidal inclusion embedded in anisotropic matrix
+
+When \(\tenseur C_0\) is anisotropic, the Eshelby tensor can be computed
+with `computeAnisotropicEshelbyTensor` in 3D and `compute2DAnisotropicEshelbyTensor`
+in 2D. There are also `computeAnisotropicHillTensor`, `compute2DAnisotropicHillTensor`,
+and also `computeAnisotropicLocalisationTensor` and `compute2DAnisotropicLocalisationTensor`.
+
+
 # Python bindings
 
 Python bindings are now generated using the

docs/web/tfel-material.md

@@ -384,7 +384,7 @@ A specialization for elasticity is defined: `tfel::material::homogenization::ela
 
 ## Eshelby tensors
 
-The header `Eshelby.hxx` introduces
+The header `IsotropicEshelbyTensor.hxx` introduces
 the function `computeEshelbyTensor` which computes the Eshelby tensor
 of an ellipsoid.
 If we consider a constant stress-free strain \(\tenseur \varepsilon^\mathrm{T}\)
@@ -423,9 +423,15 @@ for `long double`.
 In the same way, the formulas for the axisymmetrical case are instable when the aspect
 ratio is near one, so a parameter allows to switch to the formula for a sphere.
 
+When \(\tenseur C_0\) is anisotropic, the Eshelby tensor can be computed
+with `computeAnisotropicEshelbyTensor` in 3D and `compute2DAnisotropicEshelbyTensor`
+in 2D. There are also `computeAnisotropicHillTensor`, `compute2DAnisotropicHillTensor`,
+and also `computeAnisotropicLocalisationTensor` and `compute2DAnisotropicLocalisationTensor`.
+These functions are introduced by the header `AnisotropicEshelbyTensor.hxx`.
+
 ## Strain localisation tensors
 
-The header `Eshelby.hxx` also introduces
+The header `IsotropicEshelbyTensor.hxx` also introduces
 three functions that compute the strain localisation tensor of an ellipsoid.
 If we consider an ellipsoid whose elasticity is \(\tenseur C_i\), embedded
 in an infinite homogeneous medium whose elasticity is \(\tenseur C_0\),
@@ -446,9 +452,10 @@ The functions then return the localisation tensors taking into account the orien
 ## Homogenization schemes
 
 Different schemes are implemented and return the homogenized stiffness of the material.
+These schemes are introduced by the header `LinearHomogenizationSchemes`.
 The scheme available are Mori-Tanaka scheme and dilute scheme.
 The available functions are `computeMoriTanakaScheme`, `computeDiluteScheme`,
-computeSphereDiluteScheme, computeSphereMoriTanakaScheme.
+`computeSphereDiluteScheme`, `computeSphereMoriTanakaScheme`.
 
 If a distribution of ellipsoids is considered, three types of distributions
 are considered : isotropic, transverse isotropic and with unique orientation.

include/CMakeLists.txt

@@ -500,10 +500,12 @@ install_header(TFEL/Material OrthotropicPlasticity.ixx)
 install_header(TFEL/Material Lame.hxx)
 install_header(TFEL/Material Hill.hxx)
 install_header(TFEL/Material Hill.ixx)
-install_header(TFEL/Material Eshelby.hxx)
-install_header(TFEL/Material Eshelby.ixx)
-install_header(TFEL/Material EshelbyBasedHomogenization.ixx)
-install_header(TFEL/Material EshelbyBasedHomogenization.hxx)
+install_header(TFEL/Material IsotropicEshelbyTensor.hxx)
+install_header(TFEL/Material IsotropicEshelbyTensor.ixx)
+install_header(TFEL/Material AnisotropicEshelbyTensor.hxx)
+install_header(TFEL/Material AnisotropicEshelbyTensor.ixx)
+install_header(TFEL/Material LinearHomogenizationSchemes.ixx)
+install_header(TFEL/Material LinearHomogenizationSchemes.hxx)
 install_header(TFEL/Material OrthotropicStressLinearTransformation.hxx)
 install_header(TFEL/Material OrthotropicStressLinearTransformation.ixx)
 install_header(TFEL/Material Hosford1972YieldCriterion.hxx)

include/TFEL/Material/AnisotropicEshelbyTensor.hxx

@@ -0,0 +1,192 @@
+/*!
+ * \file   include/TFEL/Material/AnisotropicEshelbyTensor.hxx
+ * \author Antoine Martin
+ * \date   18 November 2024
+ * \brief  This file declares the Eshelby tensor for an ellipsoidal inclusion
+ * embedded in an anisotropic matrix. \copyright Copyright (C) 2006-2018
+ * CEA/DEN, EDF R&D. All rights reserved. This project is publicly released
+ * under either the GNU GPL Licence or the CECILL-A licence. A copy of thoses
+ * licences are delivered with the sources of TFEL. CEA or EDF may also
+ * distribute this project under specific licensing conditions.
+ */
+
+#ifndef LIB_TFEL_MATERIAL_ANISOTROPICESHELBYTENSOR_HXX
+#define LIB_TFEL_MATERIAL_ANISOTROPICESHELBYTENSOR_HXX
+
+#include "TFEL/Math/st2tost2.hxx"
+#include "TFEL/Material/StiffnessTensor.hxx"
+#include <stdexcept>
+
+namespace tfel::material::homogenization::elasticity {
+
+  /*!
+   * This function builds the Hill tensor of a general 2d ellipse embedded
+   * in an ANISOTROPIC matrix.  The
+   * ellipse also has a specific orientation given by the vector
+   * \f$n_a\f$. A LOCAL basis can then be defined.
+   * The function returns the Hill tensor in th GLOBAL basis.
+   * \return an object of type
+   * st2tost2<2u,tfel::math::invert_type<StressType>> \tparam real:
+   * underlying type \tparam StressType: type of the elastic constants
+   * \param[in] C: stiffness tensor of the matrix
+   * \param [in] n_a: direction of the principal axis whose length is
+   * \f$a\f$ \param [in] a: length of semi-axis relative to the direction
+   * \f$n_a\f$ \param [in] b: length of semi-axis relative to the other
+   * direction \param[in] max_it: maximal number of iterations for integration
+   */
+  template <typename real, typename StressType>
+  TFEL_HOST_DEVICE static tfel::math::st2tost2<
+      2u,
+      typename tfel::math::invert_type<StressType>>
+  compute2DAnisotropicHillTensor(const tfel::math::st2tost2<2u, StressType>&,
+                                 const real&,
+                                 const std::size_t max_it = 12);
+
+  /*!
+   * This function builds the Eshelby tensor of a general 2d ellipse
+   * embedded in an ANISOTROPIC matrix. The
+   * ellipse also has a specific orientation given by the vector
+   * \f$n_a\f$. A LOCAL basis can then be defined.
+   * The function returns the Hill tensor in th GLOBAL basis.
+   * The function returns the Eshelby
+   * tensor in the global basis \return an object of
+   * type st2tost2<2u,real> \tparam real: underlying type \tparam
+   * StressType: type of the elastic constants \param[in] C: stiffness
+   * tensor of the matrix
+   * * \param [in] n_a: direction of the principal axis whose length is
+   * \f$a\f$ \param [in] a: length of semi-axis relative to the direction
+   * \f$n_a\f$ \param [in] b: length of semi-axis relative to the other
+   * direction \param[in] max_it: maximal number of iterations for integration
+   */
+  template <typename real, typename StressType>
+  TFEL_HOST_DEVICE static tfel::math::st2tost2<2u, real>
+  compute2DAnisotropicEshelbyTensor(const tfel::math::st2tost2<2u, StressType>&,
+                                    const real&,
+                                    const std::size_t max_it = 12);
+
+  /*!
+   * This function builds the Hill tensor of a general ellipsoid embedded in
+   * an ANISOTROPIC matrix. The function returns the Hill tensor in the
+   * global basis \return an object
+   * of type st2tost2<3u,tfel::math::invert_type<StressType>> \tparam real:
+   * underlying type \tparam LengthType: type of the dimensions of the
+   * ellipsoid \tparam StressType: type of the elastic constants \param[in]
+   * C: stiffness tensor of the matrix in the global basis
+   * \param [in] n_a: direction of the principal axis whose length is
+   * \f$a\f$ \param [in] a: length of semi-axis relative to the direction
+   * \f$n_a\f$ \param [in] n_b: direction of the principal axis whose length
+   * is \f$b\f$ \param [in] b: length of semi-axis relative to the direction
+   * \f$n_b\f$ \param [in] c: length of the remaining semi-axis
+   * \param[in] max_it: maximal number of iterations
+   * for integration
+   *
+   */
+  template <typename real, typename StressType, typename LengthType>
+  TFEL_HOST_DEVICE static tfel::math::
+      st2tost2<3u, typename tfel::math::invert_type<StressType>>
+      computeAnisotropicHillTensor(const tfel::math::st2tost2<3u, StressType>&,
+                                   const tfel::math::tvector<3u, real>&,
+                                   const LengthType&,
+                                   const tfel::math::tvector<3u, real>&,
+                                   const LengthType&,
+                                   const LengthType&,
+                                   const std::size_t max_it = 12);
+
+  /*!
+   * This function builds the Eshelby tensor of a general ellipsoid embedded
+   * in an ANISOTROPIC matrix. The function returns the Eshelby tensor in
+   * the global basi
+   * \return an object of type st2tost2<3u,real>
+   * \tparam real: underlying type
+   * \tparam LengthType: type of the dimensions of the ellipsoid
+   * \tparam StressType: type of the elastic constants
+   * \param[in] C: stiffness tensor of the
+   * matrix in the global basis
+   * \param [in] n_a: direction of the principal axis whose length is
+   * \f$a\f$ \param [in] a: length of semi-axis relative to the direction
+   * \f$n_a\f$ \param [in] n_b: direction of the principal axis whose length
+   * is \f$b\f$ \param [in] b: length of semi-axis relative to the direction
+   * \f$n_b\f$ \param [in] c: length of the remaining semi-axis
+   * \param[in] max_it: maximal number of iterations for integration
+   *
+   */
+  template <typename real, typename StressType, typename LengthType>
+  TFEL_HOST_DEVICE static tfel::math::st2tost2<3u, real>
+  computeAnisotropicEshelbyTensor(const tfel::math::st2tost2<3u, StressType>&,
+                                  const tfel::math::tvector<3u, real>&,
+                                  const LengthType&,
+                                  const tfel::math::tvector<3u, real>&,
+                                  const LengthType&,
+                                  const LengthType&,
+                                  const std::size_t max_it = 12);
+
+  /*!
+   * This function builds the strain localisation tensor of a general
+   * ellipsoid embedded in an ANISOTROPIC matrix. The localisation tensor
+   * \f$A\f$ is defined as follows : \f[\epsilon = A:E_0\f] where \f$E_0\f$
+   * is the uniform strain tensor imposed at infinity, and \f$\epsilon\f$ is
+   * the strain tensor solution of Eshelby problem for the ellipsoid. The
+   * ellipsoid also has a specific orientation given by the vectors
+   * \f$n_a\f$, \f$n_b\f$. A LOCAL basis can then be defined as n_a, n_b,
+   * n_c where n_c=cross_product(n_a,n_b) \return an object of type
+   * st2tost2<3u,real>, which is the fourth-order localisation tensor
+   * \f$A\f$ in the GLOBAL BASIS \tparam real: underlying type \tparam
+   * StressType: type of the elastic constants related to the matrix and the
+   * ellipsoid \tparam LengthType: type of the dimensions of the ellipsoid
+   * \param[in] C_0_glob: stiffness tensor of the matrix in the GLOBAL basis
+   * \param[in] C_i_loc: stiffness tensor of the inclusion in the LOCAL
+   * basis, which is the basis (n_a,n_b,n_c)
+   * \param [in] n_a: direction of the principal axis whose length is
+   * \f$a\f$ \param [in] a: length of semi-axis relative to the direction
+   * \f$n_a\f$ \param [in] n_b: direction of the principal axis whose length
+   * is \f$b\f$ \param [in] b: length of semi-axis relative to the direction
+   * \f$n_b\f$ \param [in] c: length of the remaining semi-axis
+   * \param[in] max_it: maximal number of iterations for integration
+   */
+  template <typename real, typename StressType, typename LengthType>
+  TFEL_HOST_DEVICE tfel::math::st2tost2<3u, real>
+  computeAnisotropicLocalisationTensor(
+      const tfel::math::st2tost2<3u, StressType>&,
+      const tfel::math::st2tost2<3u, StressType>&,
+      const tfel::math::tvector<3u, real>&,
+      const LengthType&,
+      const tfel::math::tvector<3u, real>&,
+      const LengthType&,
+      const LengthType&,
+      const std::size_t max_it = 12);
+
+  /*!
+   * This function builds the strain localisation tensor of a general 2d ellipse
+   * embedded in an ANISOTROPIC matrix. The localisation tensor
+   * \f$A\f$ is defined as follows : \f[\epsilon = A:E_0\f] where \f$E_0\f$
+   * is the uniform strain tensor imposed at infinity, and \f$\epsilon\f$ is
+   * the strain tensor solution of Eshelby problem for the ellipse. The
+   * ellipse also has a specific orientation given by the vector
+   * \f$n_a\f$. A LOCAL basis can then be defined.
+   * \return an object of type
+   * st2tost2<2u,real>, which is the fourth-order localisation tensor
+   * \f$A\f$ in the GLOBAL BASIS \tparam real: underlying type \tparam
+   * StressType: type of the elastic constants
+   * \param[in] C_0_glob: stiffness tensor of the matrix in the GLOBAL basis
+   * \param[in] C_i_loc: stiffness tensor of the inclusion in the LOCAL
+   * basis, which is the basis related to \f$n_a\f$
+   * \param [in] n_a: direction of the principal axis whose length is
+   * \f$a\f$ \param [in] a: length of semi-axis relative to the direction
+   * \f$n_a\f$ \param [in] b: length of semi-axis relative to the other
+   * direction \param[in] max_it: maximal number of iterations for integration
+   */
+  template <typename real, typename StressType, typename LengthType>
+  TFEL_HOST_DEVICE tfel::math::st2tost2<3u, real>
+  compute2DAnisotropicLocalisationTensor(
+      const tfel::math::st2tost2<2u, StressType>&,
+      const tfel::math::st2tost2<2u, StressType>&,
+      const tfel::math::tvector<2u, real>&,
+      const LengthType&,
+      const LengthType&,
+      const std::size_t max_it = 12);
+
+}  // namespace tfel::material::homogenization::elasticity
+
+#include "TFEL/Material/AnisotropicEshelbyTensor.ixx"
+
+#endif /* LIB_TFEL_MATERIAL_ANISOTROPICESHELBYTENSOR_HXX */