MechanicsMaterialModel.h

Go to the documentation of this file.

#ifndef included_AMP_MechanicsMaterialModel
#define included_AMP_MechanicsMaterialModel
 
#include <cstring>
 
#include "AMP/materials/Material.h"
#include "AMP/operators/ElementPhysicsModel.h"
#include "AMP/operators/mechanics/UpdatedLagrangianUtils.h"
#include <memory>
 
namespace AMP::Operator {
 
typedef ElementPhysicsModelParameters MechanicsMaterialModelParameters;
 
class MechanicsMaterialModel : public ElementPhysicsModel
{
public:
    explicit MechanicsMaterialModel( std::shared_ptr<MechanicsMaterialModelParameters> params )
        : ElementPhysicsModel( params )
    {
        d_useMaterialsLibrary =
            params->d_db->getWithDefault<bool>( "USE_MATERIALS_LIBRARY", false );
 
        d_useUpdatedLagrangian =
            params->d_db->getWithDefault<bool>( "USE_UPDATED_LAGRANGIAN", false );
 
        d_useJaumannRate = params->d_db->getWithDefault<bool>( "USE_JAUMANN_RATE", false );
 
        d_useContinuumTangent =
            params->d_db->getWithDefault<bool>( "USE_CONTINUUM_TANGENT", false );
 
        d_checkCladOrPellet = params->d_db->getWithDefault<bool>( "IS_IT_CLAD", false );
 
        if ( d_useMaterialsLibrary == true ) {
            AMP_INSIST( ( params->d_db->keyExists( "Material" ) ), "Key ''Material'' is missing!" );
            std::string matname = params->d_db->getString( "Material" );
            d_material          = AMP::Materials::getMaterial( matname );
        }
 
        d_currentTime  = 0;
        d_previousTime = 0;
    }
 
    virtual ~MechanicsMaterialModel() {}
 
    virtual void getConstitutiveMatrix( double *& ) {}
 
    virtual void getConstitutiveMatrixUpdatedLagrangian( double[6][6], double[3][3] ) {}
 
    virtual void getStressForUpdatedLagrangian( double[6] ) {}
 
    virtual void getInternalStress( const std::vector<std::vector<double>> &, double *& ) {}
 
    virtual void getInternalStress_UL(
        const std::vector<std::vector<double>> &, double *&, double[3][3], double[3][3], double )
    {
    }
 
    virtual void getEffectiveStress( double *& ) {}
 
    virtual void getEquivalentStrain( double *& ) {}
 
    virtual void getExternalStress( double *& ) {}
 
    /*
       A bunch of virtual functions have been implemented to allow the
       programmer to initialize, reset or update any of the variables within
       the material model from outside the gauss point calculation.
       Most of these functions are not implemented. The are added whenever it
       is required.
       */
 
    // For LinearOperator's Reset/Init
 
    virtual void preLinearAssembly() {}
 
    virtual void postLinearAssembly() {}
 
    virtual void preLinearElementOperation() {}
 
    virtual void postLinearElementOperation() {}
 
    virtual void preLinearGaussPointOperation() {}
 
    virtual void postLinearGaussPointOperation() {}
 
    // For NonlinearOperator's Init
 
    virtual void preNonlinearInit( bool, bool ) {}
 
    virtual void postNonlinearInit() {}
 
    virtual void preNonlinearInitElementOperation() {}
 
    virtual void postNonlinearInitElementOperation() {}
 
    virtual void preNonlinearInitGaussPointOperation() {}
 
    virtual void postNonlinearInitGaussPointOperation() {}
 
    virtual void nonlinearInitGaussPointOperation( double ) {}
 
    // For NonlinearOperator's Apply
 
    virtual void preNonlinearAssembly() {}
 
    virtual void postNonlinearAssembly() {}
 
    virtual void preNonlinearAssemblyElementOperation() {}
 
    virtual void postNonlinearAssemblyElementOperation() {}
 
    virtual void preNonlinearAssemblyGaussPointOperation() {}
 
    virtual void postNonlinearAssemblyGaussPointOperation() {}
 
    // For NonlinearOperator's Reset
 
    virtual void globalReset() {}
 
    virtual void preNonlinearReset() {}
 
    virtual void postNonlinearReset() {}
 
    virtual void preNonlinearResetElementOperation() {}
 
    virtual void postNonlinearResetElementOperation() {}
 
    virtual void preNonlinearResetGaussPointOperation() {}
 
    virtual void postNonlinearResetGaussPointOperation() {}
 
    virtual void nonlinearResetGaussPointOperation( const std::vector<std::vector<double>> & ) {}
 
    virtual void nonlinearResetGaussPointOperation_UL( const std::vector<std::vector<double>> &,
                                                       double[3][3],
                                                       double[3][3] )
    {
    }
 
    // For NonlinearOperator's GetJacobianParameters
 
    virtual void preNonlinearJacobian() {}
 
    virtual void postNonlinearJacobian() {}
 
    virtual void preNonlinearJacobianElementOperation() {}
 
    virtual void postNonlinearJacobianElementOperation() {}
 
    virtual void preNonlinearJacobianGaussPointOperation() {}
 
    virtual void postNonlinearJacobianGaussPointOperation() {}
 
    virtual void nonlinearJacobianGaussPointOperation( const std::vector<std::vector<double>> & ) {}
 
    virtual void nonlinearJacobianGaussPointOperation_UL( const std::vector<std::vector<double>> &,
                                                          double[3][3],
                                                          double[3][3] )
    {
    }
 
    void updateTime( double currTime )
    {
        d_previousTime = d_currentTime;
        d_currentTime  = currTime;
    }
 
    std::shared_ptr<AMP::Materials::Material> getMaterial() { return d_material; }
 
protected:
    double d_currentTime; 
    double d_previousTime; 
    bool d_useMaterialsLibrary; 
    bool d_useUpdatedLagrangian; 
    bool d_useJaumannRate; 
    bool d_useContinuumTangent; 
    bool d_checkCladOrPellet;
 
    std::shared_ptr<AMP::Materials::Material>
        d_material; 
private:
};
} // namespace AMP::Operator
 
#endif