MechanicsLinearUpdatedLagrangianElement.h

Go to the documentation of this file.

#ifndef included_AMP_MechanicsLinearUpdatedLagrangianElement
#define included_AMP_MechanicsLinearUpdatedLagrangianElement
 
#include "AMP/operators/mechanics/MechanicsConstants.h"
#include "AMP/operators/mechanics/MechanicsElement.h"
#include "AMP/operators/mechanics/UpdatedLagrangianUtils.h"
 
#include <memory>
#include <vector>
 
 
namespace AMP::Operator {
 
 
class MechanicsLinearUpdatedLagrangianElement : public MechanicsElement
{
public:
    explicit MechanicsLinearUpdatedLagrangianElement(
        std::shared_ptr<const ElementOperationParameters> params )
        : MechanicsElement( params ), d_elementStiffnessMatrix( nullptr )
    {
        d_JxW                      = &( d_fe->get_JxW() );
        d_dphi                     = &( d_fe->get_dphi() );
        d_xyz                      = &( d_fe->get_xyz() );
        d_onePointShearIntegration = false;
    }
 
    virtual ~MechanicsLinearUpdatedLagrangianElement() {}
 
    void setElementStiffnessMatrix( std::vector<std::vector<double>> &elementStiffnessMatrix )
    {
        d_elementStiffnessMatrix = &( elementStiffnessMatrix );
    }
 
    void apply() override
    {
        if ( d_useReducedIntegration ) {
            apply_Reduced();
        } else {
            apply_Normal();
        }
    }
 
    void printStressAndStrain( FILE *fp, const std::vector<double> &dispVec );
 
    void computeStressAndStrain( const std::vector<double> &dispVec,
                                 std::vector<double> &stressVec,
                                 std::vector<double> &strainVec );
 
    void setElementVectors( const std::vector<std::vector<double>> &elementInputVectors )
    {
        d_elementInputVectors = elementInputVectors;
    }
 
    void initializeReferenceXYZ( std::vector<double> &elementRefXYZ );
 
    void assignReferenceXYZ( const std::vector<double> &elementRefXYZ )
    {
        d_elementRefXYZ = elementRefXYZ;
    }
 
protected:
    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<libMesh::Point>
        *d_xyz; 
    std::vector<std::vector<double>> *d_elementStiffnessMatrix; 
    std::vector<std::vector<double>> d_elementInputVectors; 
    bool d_onePointShearIntegration;
 
    std::vector<double> d_elementRefXYZ;
 
private:
};
 
} // namespace AMP::Operator
 
#endif