MechanicsNonlinearUpdatedLagrangianElement.h

Go to the documentation of this file.

#ifndef included_AMP_MechanicsNonlinearUpdatedLagrangianElement
#define included_AMP_MechanicsNonlinearUpdatedLagrangianElement
 
#include "AMP/operators/mechanics/MechanicsConstants.h"
#include "AMP/operators/mechanics/MechanicsElement.h"
#include "AMP/operators/mechanics/MechanicsNonlinearElement.h"
#include "AMP/operators/mechanics/UpdatedLagrangianUtils.h"
 
#include <memory>
#include <vector>
 
 
namespace AMP::Operator {
 
 
class MechanicsNonlinearUpdatedLagrangianElement : public MechanicsElement
{
public:
    explicit MechanicsNonlinearUpdatedLagrangianElement(
        std::shared_ptr<const ElementOperationParameters> params )
        : MechanicsElement( params ), d_elementOutputVector( nullptr )
    {
        d_JxW = &( d_fe->get_JxW() );
 
        d_dphi = &( d_fe->get_dphi() );
 
        d_phi = &( d_fe->get_phi() );
 
        d_xyz = &( d_fe->get_xyz() );
 
        d_onePointShearIntegration = false;
 
        d_gaussPtCnt = 0;
    }
 
    virtual ~MechanicsNonlinearUpdatedLagrangianElement() {}
 
    void setElementVectors( const std::vector<std::vector<double>> &elementInputVectors,
                            const std::vector<std::vector<double>> &elementInputVectors_pre,
                            std::vector<double> &elementOutputVector )
    {
        d_elementInputVectors     = elementInputVectors;
        d_elementInputVectors_pre = elementInputVectors_pre;
        d_elementOutputVector     = &( elementOutputVector );
    }
 
    void apply() override
    {
        if ( d_useReducedIntegration ) {
            apply_Reduced();
        } else {
            apply_Normal();
        }
    }
 
    void initMaterialModel( const std::vector<double> &initTempVector );
 
    void updateMaterialModel( MechanicsNonlinearElement::MaterialUpdateType type,
                              const std::vector<std::vector<double>> &elementInputVectors,
                              const std::vector<std::vector<double>> &elementInputVectors_pre );
 
    void printStressAndStrain( FILE *fp, const std::vector<std::vector<double>> &inputVec );
 
    void computeStressAndStrain( const std::vector<std::vector<double>> &inputVec,
                                 std::vector<double> &stressVec,
                                 std::vector<double> &strainVec );
 
    void computeDeformationGradient( const std::vector<std::vector<libMesh::RealGradient>> &dphi,
                                     const std::vector<libMesh::Point> &xyz,
                                     unsigned int num_nodes,
                                     unsigned int qp,
                                     double F[3][3] );
 
    void initializeReferenceXYZ( std::vector<double> &elementRefXYZ );
 
    void assignReferenceXYZ( const std::vector<double> &elementRefXYZ )
    {
        d_elementRefXYZ = elementRefXYZ;
    }
 
    void preNonlinearElementInit();
 
    void zeroOutGaussPointCount() { d_gaussPtCnt = 0; }
 
    void resetElementInfo()
    {
        if ( ( d_useJaumannRate == false ) && ( d_useFlanaganTaylorElem == true ) ) {
            d_leftStretchV_n = d_leftStretchV_np1;
            d_rotationR_n    = d_rotationR_np1;
        }
    }
 
protected:
    void materialModelPreNonlinearElementOperation( MechanicsNonlinearElement::MaterialUpdateType );
 
    void materialModelPreNonlinearGaussPointOperation(
        MechanicsNonlinearElement::MaterialUpdateType );
 
    void materialModelNonlinearGaussPointOperation( MechanicsNonlinearElement::MaterialUpdateType,
                                                    const std::vector<std::vector<double>> &,
                                                    double[3][3],
                                                    double[3][3] );
 
    void materialModelPostNonlinearGaussPointOperation(
        MechanicsNonlinearElement::MaterialUpdateType );
 
    void
        materialModelPostNonlinearElementOperation( MechanicsNonlinearElement::MaterialUpdateType );
 
    void apply_Normal();
 
    void apply_Reduced();
 
    const std::vector<libMesh::Real> *d_JxW; 
    const std::vector<std::vector<libMesh::RealGradient>>
        *d_dphi; 
    const std::vector<std::vector<libMesh::Real>>
        *d_phi; 
    const std::vector<libMesh::Point>
        *d_xyz; 
    std::vector<std::vector<double>> d_elementInputVectors; 
    std::vector<std::vector<double>>
        d_elementInputVectors_pre; 
    std::vector<double> *d_elementOutputVector; 
    bool d_onePointShearIntegration;
 
    std::vector<double> d_elementRefXYZ;
 
    std::vector<double> d_leftStretchV_n;
 
    std::vector<double> d_leftStretchV_np1;
 
    std::vector<double> d_rotationR_n;
 
    std::vector<double> d_rotationR_np1;
 
    int d_gaussPtCnt;
 
private:
};
 
 
} // namespace AMP::Operator
 
#endif