b2element_klt_compute_strain.H

//------------------------------------------------------------------------
// b2element_klt_compute_strain.H --
//
//     Compute the position vector and derivatives of a particle.
//
// Copyright (c) 2015,2016
//     SMR Engineering & Development SA
//     2502 Bienne, Switzerland
//
// 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 _B2ELEMENT_KLT_COMPUTE_STRAIN_H_
#define _B2ELEMENT_KLT_COMPUTE_STRAIN_H_
 
#include "b2element_klt_util.H"
#include "utils/b2right_stretch_tensor.H"
 
namespace b2000 { namespace klt {
 
class ComputeStrain {
public:
    void compute_strain_covariant(
          const DofVec3d& g1, const DofVec3d& g2, const double G1[3], const double G2[3],
          const bool first, const bool second, const bool a3_second, DofVector<3>& strain) {
        if (a3_second) {
            compute_green_lagrange_strain_covariant_d2(g1, g2, G1, G2, first, second, strain);
        } else {
            compute_green_lagrange_strain_covariant_d1(g1, g2, G1, G2, first, second, strain);
        }
    }
 
    void compute_strain_ts_covariant(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a3, const bool first,
          const bool second, const bool a3_second, DofScalar& gamma13, DofScalar& gamma23) {
        if (a3_second) {
            compute_green_lagrange_strain_ts_covariant_d2(
                  a1, a2, a3, first, second, gamma13, gamma23);
        } else {
            compute_green_lagrange_strain_ts_covariant_d1(
                  a1, a2, a3, first, second, gamma13, gamma23);
        }
    }
 
    void compute_deformation_gradient(
          const DofVec3d& g1, const DofVec3d& g2, const DofVec3d& g3, const double G1[3],
          const double G2[3], const double G3[3], double F[3][3]);
 
private:
    void compute_green_lagrange_strain_covariant_d2(
          const DofVec3d& g1, const DofVec3d& g2, const double G1[3], const double G2[3],
          const bool first, const bool second, DofVector<3>& strain);
 
    void compute_green_lagrange_strain_covariant_d1(
          const DofVec3d& g1, const DofVec3d& g2, const double G1[3], const double G2[3],
          const bool first, const bool second, DofVector<3>& strain);
 
    void compute_green_lagrange_strain_ts_covariant_d1(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a3, const bool first,
          const bool second, DofScalar& gamma13, DofScalar& gamma23);
 
    void compute_green_lagrange_strain_ts_covariant_d2(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a3, const bool first,
          const bool second, DofScalar& gamma13, DofScalar& gamma23);
};
 
class ComputeStrainPreintegration {
public:
    void compute_strain_covariant(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a31, const DofVec3d& a32,
          const double A1[3], const double A2[3], const double A31[3], const double A32[3],
          const bool first, const bool second, const bool a3_second, DofVector<3>& strain0,
          DofVector<3>& strain1) {
        if (a3_second) {
            compute_green_lagrange_strain_covariant_d2(
                  a1, a2, a31, a32, A1, A2, A31, A32, first, second, strain0, strain1);
        } else {
            compute_green_lagrange_strain_covariant_d1(
                  a1, a2, a31, a32, A1, A2, A31, A32, first, second, strain0, strain1);
        }
    }
 
    void compute_strain_ts_covariant(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a3, const bool first,
          const bool second, const bool a3_second, DofScalar& gamma13, DofScalar& gamma23) {
        if (a3_second) {
            compute_green_lagrange_strain_ts_covariant_d2(
                  a1, a2, a3, first, second, gamma13, gamma23);
        } else {
            compute_green_lagrange_strain_ts_covariant_d1(
                  a1, a2, a3, first, second, gamma13, gamma23);
        }
    }
 
    void compute_strain_covariant(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a3, const DofVec3d& a3d1,
          const DofVec3d& a3d2, const double A1[3], const double A2[3], const double A3[3],
          const double A3d1[3], const double A3d2[3], const bool first, const bool second,
          const bool a3_second, DofVector<8>& strain) {
        if (a3_second) {
            compute_green_lagrange_strain_covariant_d2(
                  a1, a2, a3, a3d1, a3d2, A1, A2, A3, A3d1, A3d2, first, second, strain);
        } else {
            compute_green_lagrange_strain_covariant_d1(
                  a1, a2, a3, a3d1, a3d2, A1, A2, A3, A3d1, A3d2, first, second, strain);
        }
    }
 
    void compute_strain_covariant_nitsche(
          const DofVec3d& an, const DofVec3d& a3r, const bool first, const bool second,
          const bool a3_second, DofScalar& gamma) {
        if (a3_second) {
            compute_green_lagrange_strain_covariant_nitsche_d2(an, a3r, first, second, gamma);
        } else {
            compute_green_lagrange_strain_covariant_nitsche_d1(an, a3r, first, second, gamma);
        }
    }
 
private:
    void compute_green_lagrange_strain_covariant_d2(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a31, const DofVec3d& a32,
          const double A1[3], const double A2[3], const double A31[3], const double A32[3],
          const bool first, const bool second, DofVector<3>& strain_0, DofVector<3>& strain_1);
 
    void compute_green_lagrange_strain_covariant_d1(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a31, const DofVec3d& a32,
          const double A1[3], const double A2[3], const double A31[3], const double A32[3],
          const bool first, const bool second, DofVector<3>& strain_0, DofVector<3>& strain_1);
 
    void compute_green_lagrange_strain_ts_covariant_d1(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a3, const bool first,
          const bool second, DofScalar& gamma13, DofScalar& gamma23);
 
    void compute_green_lagrange_strain_ts_covariant_d2(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a3, const bool first,
          const bool second, DofScalar& gamma13, DofScalar& gamma23);
 
    void compute_green_lagrange_strain_covariant_d2(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a3, const DofVec3d& a31,
          const DofVec3d& a32, const double A1[3], const double A2[3], const double A3[3],
          const double A31[3], const double A32[3], const bool first, const bool second,
          DofVector<8>& strain);
 
    void compute_green_lagrange_strain_covariant_d1(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a3, const DofVec3d& a31,
          const DofVec3d& a32, const double A1[3], const double A2[3], const double A3[3],
          const double A31[3], const double A32[3], const bool first, const bool second,
          DofVector<8>& strain);
 
    void compute_green_lagrange_strain_covariant_nitsche_d1(
          const DofVec3d& an, const DofVec3d& a3r, const bool first, const bool second,
          DofScalar& gamma);
 
    void compute_green_lagrange_strain_covariant_nitsche_d2(
          const DofVec3d& an, const DofVec3d& a3r, const bool first, const bool second,
          DofScalar& gamma);
};
 
class ComputeStrainMembrane {
public:
    void compute_strain_covariant(
          const DofVec3d& a1, const DofVec3d& a2, const double A1[3], const double A2[3],
          const int component, const bool first, const bool second, DofScalar& strain) {
        if (component == 0) {
            compute_strain_covariant_11(a1, a2, A1, A2, first, second, strain);
        } else if (component == 1) {
            compute_strain_covariant_22(a1, a2, A1, A2, first, second, strain);
        } else {
            compute_strain_covariant_12(a1, a2, A1, A2, first, second, strain);
        }
    }
 
    void compute_strain_covariant_11(
          const DofVec3d& a1, const DofVec3d& a2, const double A1[3], const double A2[3],
          const bool first, const bool second, DofScalar& strain);
 
    void compute_strain_covariant_22(
          const DofVec3d& a1, const DofVec3d& a2, const double A1[3], const double A2[3],
          const bool first, const bool second, DofScalar& strain);
 
    void compute_strain_covariant_12(
          const DofVec3d& a1, const DofVec3d& a2, const double A1[3], const double A2[3],
          const bool first, const bool second, DofScalar& strain);
};
 
class ComputeStrainBending {
public:
    void compute_strain_covariant(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a31, const DofVec3d& a32,
          const double A1[3], const double A2[3], const double A31[3], const double A32[3],
          const int component, const bool first, const bool second, DofScalar& strain) {
        if (component == 0) {
            compute_strain_covariant_11(a1, a2, a31, a32, A1, A2, A31, A32, first, second, strain);
        } else if (component == 1) {
            compute_strain_covariant_22(a1, a2, a31, a32, A1, A2, A31, A32, first, second, strain);
        } else {
            compute_strain_covariant_12(a1, a2, a31, a32, A1, A2, A31, A32, first, second, strain);
        }
    }
 
    void compute_strain_covariant_11(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a31, const DofVec3d& a32,
          const double A1[3], const double A2[3], const double A31[3], const double A32[3],
          const bool first, const bool second, DofScalar& strain);
 
    void compute_strain_covariant_22(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a31, const DofVec3d& a32,
          const double A1[3], const double A2[3], const double A31[3], const double A32[3],
          const bool first, const bool second, DofScalar& strain);
 
    void compute_strain_covariant_12(
          const DofVec3d& a1, const DofVec3d& a2, const DofVec3d& a31, const DofVec3d& a32,
          const double A1[3], const double A2[3], const double A31[3], const double A32[3],
          const bool first, const bool second, DofScalar& strain);
};
 
}}  // namespace b2000::klt
 
#endif /* _B2ELEMENT_KLT_COMPUTE_STRAIN_H_ */