residual_based_newmark_displacement_scheme.hpp

Go to the documentation of this file.

//    |  /           |
//    ' /   __| _` | __|  _ \   __|
//    . \  |   (   | |   (   |\__ \.
//   _|\_\_|  \__,_|\__|\___/ ____/
//                   Multi-Physics
//
//  License:          BSD License
//  Main authors:  Josep Maria Carbonell
//                 Vicente Mataix Ferrandiz
//
 
#if !defined(KRATOS_RESIDUAL_BASED_NEWMARK_DISPLACEMENT_SCHEME )
#define  KRATOS_RESIDUAL_BASED_NEWMARK_DISPLACEMENT_SCHEME
 
/* System includes */
 
/* External includes */
 
/* Project includes */
#include "solving_strategies/schemes/residual_based_bossak_displacement_scheme.hpp"
 
namespace Kratos
{
 
template<class TSparseSpace,  class TDenseSpace >
class ResidualBasedNewmarkDisplacementScheme
    : public ResidualBasedBossakDisplacementScheme<TSparseSpace,TDenseSpace>
{
public:
    KRATOS_CLASS_POINTER_DEFINITION( ResidualBasedNewmarkDisplacementScheme );
 
    typedef Scheme<TSparseSpace,TDenseSpace>                                        BaseType;
 
    typedef ResidualBasedNewmarkDisplacementScheme<TSparseSpace, TDenseSpace>      ClassType;
 
    typedef typename BaseType::TDataType                                           TDataType;
 
    typedef typename BaseType::DofsArrayType                                   DofsArrayType;
 
    typedef typename Element::DofsVectorType                                  DofsVectorType;
 
    typedef typename BaseType::TSystemMatrixType                           TSystemMatrixType;
 
    typedef typename BaseType::TSystemVectorType                           TSystemVectorType;
 
    typedef typename BaseType::LocalSystemVectorType                   LocalSystemVectorType;
 
    typedef typename BaseType::LocalSystemMatrixType                   LocalSystemMatrixType;
 
    typedef ModelPart::ElementsContainerType                               ElementsArrayType;
 
    typedef ModelPart::ConditionsContainerType                           ConditionsArrayType;
 
    typedef typename BaseType::Pointer                                       BaseTypePointer;
 
    typedef ResidualBasedBossakDisplacementScheme<TSparseSpace,TDenseSpace>  DerivedBaseType;
 
 
    explicit ResidualBasedNewmarkDisplacementScheme(Parameters ThisParameters)
        :DerivedBaseType()
    {
        // Validate and assign defaults
        ThisParameters = this->ValidateAndAssignParameters(ThisParameters, this->GetDefaultParameters());
        this->AssignSettings(ThisParameters);
    }
 
    explicit ResidualBasedNewmarkDisplacementScheme()
      :DerivedBaseType(0.0)
    {
    }
 
    explicit ResidualBasedNewmarkDisplacementScheme(ResidualBasedNewmarkDisplacementScheme& rOther)
      :DerivedBaseType(rOther)
    {
    }
 
    BaseTypePointer Clone() override
    {
        return BaseTypePointer( new ResidualBasedNewmarkDisplacementScheme(*this) );
    }
 
    ~ResidualBasedNewmarkDisplacementScheme
    () override {}
 
    Parameters GetDefaultParameters() const override
    {
        Parameters default_parameters = Parameters(R"(
        {
            "name" : "newmark_scheme"
        })");
 
        // Getting base class default parameters
        const Parameters base_default_parameters = DerivedBaseType::GetDefaultParameters();
        default_parameters.RecursivelyAddMissingParameters(base_default_parameters);
        return default_parameters;
    }
 
    static std::string Name()
    {
        return "newmark_scheme";
    }
 
 
 
    typename BaseType::Pointer Create(Parameters ThisParameters) const override
    {
        return Kratos::make_shared<ClassType>(ThisParameters);
    }
 
 
 
 
    std::string Info() const override
    {
        return "ResidualBasedNewmarkDisplacementScheme";
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
        rOStream << Info();
    }
 
 
protected:
 
 
 
 
 
 
private:
 
 
 
 
 
}; /* Class ResidualBasedNewmarkDisplacementScheme */
}  /* namespace Kratos.*/
 
#endif /* KRATOS_RESIDUAL_BASED_NEWMARK_DISPLACEMENT_SCHEME E defined */