NeoHookeanLogarithmicMaterial.hpp

Go to the documentation of this file.

/**
 * @file NeoHookeanLogarithmicMaterial.hpp
 * @brief Neo-Hookean material law in orthonormal logarithmic coordinates.
 */
 
#ifndef NEOHOOKEAN_LOGARITHMIC_MATERIAL_HPP
#define NEOHOOKEAN_LOGARITHMIC_MATERIAL_HPP
 
namespace EshelbianPlasticity {
 
/** Stateless material evaluations, independent of mesh fields and solvers.
 *
 * The five coordinates use (11-22)/sqrt(2), (11+22-2*33)/sqrt(6),
 * sqrt(2)*12, sqrt(2)*13 and sqrt(2)*23. Their Euclidean pairing is the
 * Frobenius pairing of symmetric trace-free tensors.
 *
 * Call validateParameters after reading or changing material parameters and
 * before evaluating a state. Kernels recheck this precondition only in debug
 * builds; trial-state validity and numerical representability are always
 * checked.
 */
struct NeoHookeanLogarithmicMaterial {
  using Coordinates = FTensor::Tensor1<double, 5>;
  using SymmetricTensor = FTensor::Tensor2_symmetric<double, 3>;
  using Tangent = FTensor::Tensor2<double, 5, 5>;
 
  struct Parameters {
    double c10;
    double bulkModulus;
  };
 
  struct VolumeState {
    double jacobian;
    double energy;
    double firstDerivative;  ///< d[g(exp(theta))]/d theta
    double secondDerivative; ///< d2[g(exp(theta))]/d theta2
  };
 
  struct InverseState {
    Coordinates tMaterialDeviator;
    Tangent tCompliance;
    double deviatoricEnergy;
    double conjugateEnergy;
    double inverseResidual; ///< Sum of principal logarithms before projection
    int inverseIterations;
  };
 
  /// Check finite, strictly positive C10, K and representable mu = 2*C10.
  static MoFEMErrorCode validateParameters(const Parameters &parameters);
 
  /// Reconstruct H = D + theta*I/3 from the fixed five-coordinate basis.
  static SymmetricTensor getTensor(const Coordinates &t_coordinates,
                                   double theta = 0.);
 
  /// Project a symmetric tensor onto the fixed trace-free basis.
  static Coordinates getCoordinates(const SymmetricTensor &t_tensor);
 
  /// Evaluate f(D), optionally its five-component gradient and Hessian.
  static MoFEMErrorCode evaluateDeviator(const Parameters &parameters,
                                         const Coordinates &t_deviator,
                                         double &energy,
                                         Coordinates *stress_ptr = nullptr,
                                         Tangent *hessian_ptr = nullptr);
 
  /// Evaluate g(J) = K*(J-1)^2/2 and its logarithmic-volume derivatives.
  static MoFEMErrorCode evaluateVolume(const Parameters &parameters,
                                       double theta, VolumeState &state);
 
  /// Recover Dm(Td), its compliance and conjugate energy; no state is cached.
  static MoFEMErrorCode evaluateInverse(const Parameters &parameters,
                                        const Coordinates &t_stress,
                                        InverseState &state);
 
  /// Evaluate f(D) + f*(Td) - Td:D, optionally returning the computed f(D).
  /// The supplied inverse must correspond to the same Td.
  static MoFEMErrorCode evaluateFenchelGap(const Parameters &parameters,
                                           const Coordinates &t_deviator,
                                           const Coordinates &t_stress,
                                           const InverseState &inverse,
                                           double &gap,
                                           double *energy_ptr = nullptr);
};
 
} // namespace EshelbianPlasticity
 
#endif // NEOHOOKEAN_LOGARITHMIC_MATERIAL_HPP