b2material_stress_2d_mixed.H

//------------------------------------------------------------------------
// b2material_stress_2d_mixed --
//
//     Base class for materials used by 2D displacement/pressure
//     elements.
//
// written by Thomas Ludwig
//            Neda Ebrahimi Pour <neda.ebrahimipour@dlr.de>
//
// (c) 2009-2012,2016 SMR Engineering & Development SA
//               2502 Bienne, Switzerland
//
// (c) 2023 Deutsches Zentrum für Luft- und Raumfahrt (DLR) e.V.
//          Linder Höhe, 51147 Köln
//
// All Rights Reserved.  Proprietary source code.  The contents of
// this file may not be disclosed to third parties, copied or
// duplicated in any form, in whole or in part, without the prior
// written permission of SMR.
//------------------------------------------------------------------------
 
#ifndef B2MATERIAL_STRESS_2D_MIXED_H_
#define B2MATERIAL_STRESS_2D_MIXED_H_
 
#include "elements/properties/b2solid_mechanics.H"
#include "utils/b2tensor_calculus.H"
 
namespace b2000 {
 
class MaterialStress2DMixed : virtual public SolidMechanics {
public:
    // Return the number of layers.
    virtual int number_of_layer() const { return 1; }
 
    // Return the laminate geometric position relative to the
    // mid-surface of the element.
    virtual void laminate(
          const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
          double& laminate_begin, double& laminate_end) const {
        laminate_begin = -1;
        laminate_end = 1;
    }
 
    // Return the layer geometric position relative to the
    // mid-surface of the element.
    virtual void layer(
          const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
          const int layer_id, double& layer_begin, double& layer_end) const {
        layer_begin = -1;
        layer_end = 1;
    }
 
    virtual double get_density(const int layer_id) const {
        UnimplementedError() << THROW;
        return 0.0;
    }
 
    virtual void get_stress(
          Model* model, const bool linear, const EquilibriumSolution equilibrium_solution,
          const double time, const double delta_time, GradientContainer* gradient_container,
          SolverHints* solver_hints, const Element* element, const double el_coordinates[3],
          const int layer_id,
          const b2linalg::Vector<double, b2linalg::Vdense_constref> nodes_interpolation,
          const double bg_coordinates[3], const double covariant_base[2][2], const double volume,
          const double deformation_gradient[2][2], const double velocity[2],
          const double acceleration[2], const double interpolated_pressure, double stress[3],
          double& pressure, double CUU[6], double CUP[3], double& CPP, double inertia_force[2],
          double& density) = 0;
 
protected:
    inline void eval_linear_strain(const double F[2][2], double E[3]) const {
        const double f00 = F[0][0];
        const double f01 = F[1][0];
        const double f10 = F[0][1];
        const double f11 = F[1][1];
 
        E[0] = f00 - 1.0;
        E[1] = f11 - 1.0;
        E[2] = f01 + f10;
    }
 
    inline void eval_green_lagrange_strain(const double F[2][2], double E[3]) const {
        const double f00 = F[0][0];
        const double f01 = F[1][0];
        const double f10 = F[0][1];
        const double f11 = F[1][1];
 
        E[0] = 0.5 * (f00 * f00 + f10 * f10 - 1.0);
        E[1] = 0.5 * (f01 * f01 + f11 * f11 - 1.0);
        E[2] = f00 * f01 + f10 * f11;
    }
 
    inline double delta(const int a, const int b) { return (a == b ? 1.0 : 0.0); }
 
    inline void s_eq_c_mul_e(double s[3], const double c[6], const double e[3]) {
        const int ind[3][3] = {{0, 1, 2}, {1, 3, 4}, {2, 4, 5}};
        for (int i = 0; i < 3; ++i) {
            double value = 0.0;
 
            const int* iind = ind[i];
            for (int j = 0; j < 3; ++j) { value += c[iind[j]] * e[j]; }
            s[i] = value;
        }
    }
 
    // Transform the 2nd Piola-Kirchhoff stress to the Cauchy
    // stress.  The stresses are in the Voight notation [sxx, syy,
    // sxy].
    static inline void piola_2_stress_to_cauchy_stress(
          const double F[2][2],  // Deformation gradient, column-major.
          const double S[3],     // 2nd Piola-Kirchhoff stress (Voight not.).
          double T[3]            // Cauchy stress (Voight notation).
    ) {
        const double f00 = F[0][0];
        const double f01 = F[1][0];
        const double f10 = F[0][1];
        const double f11 = F[1][1];
 
        // Get the determinant of the deformation gradient tensor..
        const double det = determinant_2_2(F);
        const double det_inv = 1.0 / det;
 
        T[0] = f00 * f00 * S[0] + f01 * f01 * S[1] + 2 * f00 * f01 * S[2];
 
        T[1] = f10 * f10 * S[0] + f11 * f11 * S[1] + 2 * f10 * f11 * S[2];
 
        T[2] = f00 * f10 * S[0] + f01 * f11 * S[1] + (f00 * f11 + f01 * f10) * S[2];
 
        for (int i = 0; i < 3; ++i) { T[i] *= det_inv; }
    }
 
    static inline void expand_strain_or_stress_2d_to_3d(const double t2d[3], double t3d[6]) {
        t3d[0] = t2d[0];
        t3d[1] = t2d[1];
        t3d[2] = 0.0;
        t3d[3] = t2d[2];
        t3d[4] = 0.0;
        t3d[5] = 0.0;
    }
};
 
}  // namespace b2000
 
#endif  // B2_MATERIAL_STRESS_2D_MIXED_H_