MechanicsNonlinearFEOperator.h

Go to the documentation of this file.

 
#ifndef included_AMP_MechanicsNonlinearFEOperator
#define included_AMP_MechanicsNonlinearFEOperator
 
/* AMP files */
#include "AMP/discretization/DOF_Manager.h"
#include "AMP/mesh/MeshElement.h"
#include "AMP/operators/libmesh/NonlinearFEOperator.h"
#include "AMP/operators/mechanics/MechanicsConstants.h"
#include "AMP/operators/mechanics/MechanicsNonlinearElement.h"
#include "AMP/operators/mechanics/MechanicsNonlinearFEOperatorParameters.h"
#include "AMP/operators/mechanics/MechanicsNonlinearUpdatedLagrangianElement.h"
#include "AMP/vectors/MultiVariable.h"
#include "AMP/vectors/Variable.h"
 
#include <vector>
 
namespace AMP::Operator {
 
class MechanicsNonlinearFEOperator : public NonlinearFEOperator
{
public:
    explicit MechanicsNonlinearFEOperator( std::shared_ptr<const OperatorParameters> params );
 
    virtual ~MechanicsNonlinearFEOperator() {}
 
    void reset( std::shared_ptr<const OperatorParameters> ) override;
 
    void setReferenceTemperature( AMP::LinearAlgebra::Vector::const_shared_ptr refTemp );
 
    void setVector( unsigned int id, AMP::LinearAlgebra::Vector::const_shared_ptr frozenVec );
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> getInputVariable() const override
    {
        return d_inpVariables;
    }
 
    std::shared_ptr<AMP::LinearAlgebra::Variable> getOutputVariable() const override
    {
        return d_outVariable;
    }
 
    void printStressAndStrain( AMP::LinearAlgebra::Vector::const_shared_ptr u,
                               const std::string &fname );
 
    std::shared_ptr<MechanicsMaterialModel> getMaterialModel() { return d_materialModel; }
 
protected:
    std::shared_ptr<OperatorParameters>
        getJacobianParameters( AMP::LinearAlgebra::Vector::const_shared_ptr ) override;
 
    void init();
 
    void preAssembly( AMP::LinearAlgebra::Vector::const_shared_ptr u,
                      std::shared_ptr<AMP::LinearAlgebra::Vector> r ) override;
 
    void postAssembly() override;
 
    void preElementOperation( const AMP::Mesh::MeshElement & ) override;
 
    void postElementOperation() override;
 
    AMP::LinearAlgebra::Vector::shared_ptr
    mySubsetVector( AMP::LinearAlgebra::Vector::shared_ptr vec,
                    std::shared_ptr<AMP::LinearAlgebra::Variable> var );
 
    AMP::LinearAlgebra::Vector::const_shared_ptr
    mySubsetVector( AMP::LinearAlgebra::Vector::const_shared_ptr vec,
                    std::shared_ptr<AMP::LinearAlgebra::Variable> var );
 
    void updateMaterialForElement( MechanicsNonlinearElement::MaterialUpdateType,
                                   const AMP::Mesh::MeshElement & );
 
    void updateMaterialForUpdatedLagrangianElement( MechanicsNonlinearElement::MaterialUpdateType,
                                                    const AMP::Mesh::MeshElement & );
 
    void updateMaterialForElementCommonFunction( const AMP::Mesh::MeshElement &,
                                                 std::vector<std::vector<double>> &,
                                                 std::vector<std::vector<double>> & );
 
    void getDofIndicesForCurrentElement( int varId, std::vector<std::vector<size_t>> &dofIds );
 
    MechanicsNonlinearFEOperator( std::shared_ptr<const MechanicsNonlinearFEOperatorParameters>,
                                  bool );
 
 
protected:
    std::vector<double> d_elementOutputVector; 
    std::shared_ptr<MechanicsNonlinearElement> d_mechNonlinElem; 
    std::shared_ptr<ElementOperation> d_mechLinElem; 
    std::shared_ptr<MechanicsNonlinearUpdatedLagrangianElement>
        d_mechNULElem; 
    std::shared_ptr<ElementOperation>
        d_mechLULElem; 
    std::shared_ptr<MechanicsMaterialModel> d_materialModel; 
    std::vector<AMP::LinearAlgebra::Vector::const_shared_ptr> d_inVec; 
    std::vector<AMP::LinearAlgebra::Vector::shared_ptr>
        d_inVec_pre; 
    AMP::LinearAlgebra::Vector::shared_ptr d_refXYZ; 
    AMP::LinearAlgebra::Vector::const_shared_ptr
        d_referenceTemperature; 
    AMP::LinearAlgebra::Vector::shared_ptr d_outVec; 
    bool d_resetReusesRadialReturn; 
    bool d_jacobianReusesRadialReturn; 
    std::vector<bool> d_isActive; 
    std::vector<bool> d_isFrozen; 
    bool d_useUpdatedLagrangian; 
    bool d_isInitialized; 
    std::shared_ptr<AMP::LinearAlgebra::MultiVariable> d_inpVariables; 
    std::shared_ptr<AMP::LinearAlgebra::Variable> d_outVariable; 
    std::shared_ptr<AMP::Discretization::DOFManager> d_dofMap[Mechanics::TOTAL_NUMBER_OF_VARIABLES];
 
    AMP::Mesh::MeshElementVectorPtr d_currNodes;
 
    std::vector<std::vector<size_t>> d_dofIndices; 
};
 
} // namespace AMP::Operator
 
#endif