simo_method.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosSolidMechanicsApplication $
//   Created by:          $Author:            JMCarbonell $
//   Last modified by:    $Co-Author:                     $
//   Date:                $Date:            November 2017 $
//   Revision:            $Revision:                  0.0 $
//
//
 
#if !defined(KRATOS_SIMO_METHOD_H_INCLUDED)
#define  KRATOS_SIMO_METHOD_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_solvers/time_integration_methods/bossak_method.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
 
  template<class TVariableType, class TValueType>
  class SimoMethod : public BossakMethod<TVariableType,TValueType>
  {
  public:
 
 
    typedef TimeIntegrationMethod<TVariableType,TValueType>  BaseType;
 
    typedef typename BaseType::Pointer                BasePointerType;
 
    typedef typename BaseType::NodeType                      NodeType;
 
    typedef typename BaseType::VariablePointer        VariablePointer;
 
    typedef BossakMethod<TVariableType,TValueType>        DerivedType;
 
 
    KRATOS_CLASS_POINTER_DEFINITION( SimoMethod );
 
 
 
    SimoMethod() : DerivedType() {}
 
    SimoMethod(const TVariableType& rVariable) : DerivedType(rVariable) {}
 
    SimoMethod(const TVariableType& rVariable, const TVariableType& rFirstDerivative, const TVariableType& rSecondDerivative) : DerivedType(rVariable,rFirstDerivative,rSecondDerivative) {}
 
    SimoMethod(const TVariableType& rVariable, const TVariableType& rFirstDerivative, const TVariableType& rSecondDerivative, const TVariableType& rPrimaryVariable) : DerivedType(rVariable,rFirstDerivative,rSecondDerivative,rPrimaryVariable) {}
 
    SimoMethod(SimoMethod& rOther) : DerivedType(rOther) {}
 
    BasePointerType Clone() override
    {
      return BasePointerType( new SimoMethod(*this) );
    }
 
    ~SimoMethod() override{}
 
 
 
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "SimoMethod";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "SimoMethod";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "SimoMethod Data";
    }
 
 
 
 
 
  protected:
 
 
 
 
 
 
    void AssignFromVariable(NodeType& rNode) override
    {
      KRATOS_TRY
 
 
      KRATOS_CATCH( "" )
    }
 
    void AssignFromFirstDerivative(NodeType& rNode) override
    {
      KRATOS_TRY
 
      // predict variable from first derivative
      TValueType& CurrentVariable                = rNode.FastGetSolutionStepValue(*this->mpVariable,         0);
      const TValueType& PreviousVariable         = rNode.FastGetSolutionStepValue(*this->mpVariable,         1);
 
      const TValueType& CurrentFirstDerivative   = rNode.FastGetSolutionStepValue(*this->mpFirstDerivative,  0);
 
      CurrentVariable  = PreviousVariable + CurrentFirstDerivative  * (1.0/this->mNewmark.c1);
 
      KRATOS_CATCH( "" )
    }
 
    void AssignFromSecondDerivative(NodeType& rNode) override
    {
      KRATOS_TRY
 
      // predict variable from second derivative
      TValueType& CurrentVariable                 = rNode.FastGetSolutionStepValue(*this->mpVariable,         0);
      const TValueType& PreviousVariable          = rNode.FastGetSolutionStepValue(*this->mpVariable,         1);
 
      const TValueType& CurrentFirstDerivative    = rNode.FastGetSolutionStepValue(*this->mpFirstDerivative,  0);
 
      const TValueType& CurrentSecondDerivative   = rNode.FastGetSolutionStepValue(*this->mpSecondDerivative, 0);
 
 
      CurrentVariable  = PreviousVariable + CurrentFirstDerivative * (1.0/this->mNewmark.c1) + CurrentSecondDerivative * (1.0/this->mNewmark.c0);
 
 
      KRATOS_CATCH( "" )
    }
 
    void PredictVariable(NodeType& rNode) override
    {
      KRATOS_TRY
 
      KRATOS_CATCH( "" )
    }
 
    void PredictFirstDerivative(NodeType& rNode) override
    {
      KRATOS_TRY
 
      const TValueType& CurrentVariable          = rNode.FastGetSolutionStepValue(*this->mpVariable,         0);
      TValueType& CurrentFirstDerivative         = rNode.FastGetSolutionStepValue(*this->mpFirstDerivative,  0);
 
      const TValueType& PreviousVariable         = rNode.FastGetSolutionStepValue(*this->mpVariable,         1);
 
      CurrentFirstDerivative = this->mNewmark.c1 * (CurrentVariable-PreviousVariable);
 
      KRATOS_CATCH( "" )
    }
 
    void PredictSecondDerivative(NodeType& rNode) override
    {
      KRATOS_TRY
 
      TValueType& CurrentSecondDerivative        = rNode.FastGetSolutionStepValue(*this->mpSecondDerivative, 0);
 
      const TValueType& CurrentFirstDerivative   = rNode.FastGetSolutionStepValue(*this->mpFirstDerivative,  0);
      const TValueType& PreviousFirstDerivative  = rNode.FastGetSolutionStepValue(*this->mpFirstDerivative,  1);
 
 
      CurrentSecondDerivative = (this->mNewmark.c0/this->mNewmark.c1) * (CurrentFirstDerivative-PreviousFirstDerivative);
 
 
      KRATOS_CATCH( "" )
    }
 
    void UpdateFromFirstDerivative(NodeType& rNode) override
    {
      KRATOS_TRY
 
      KRATOS_ERROR << " Calling UpdateFromFirstDerivative for Simo time integration method : NOT IMPLEMENTED " <<std::endl;
 
      KRATOS_CATCH( "" )
    }
 
    void UpdateVariable(NodeType& rNode) override
    {
      KRATOS_TRY
 
 
      KRATOS_CATCH( "" )
    }
 
    void UpdateFirstDerivative(NodeType& rNode) override
    {
      KRATOS_TRY
 
      const TValueType& CurrentVariable         = rNode.FastGetSolutionStepValue(*this->mpVariable,         0);
      TValueType& CurrentFirstDerivative        = rNode.FastGetSolutionStepValue(*this->mpFirstDerivative,  0);
 
      const TValueType& PreviousVariable        = rNode.FastGetSolutionStepValue(*this->mpVariable,         1);
 
      CurrentFirstDerivative = this->mNewmark.c1 * (CurrentVariable-PreviousVariable);
 
      KRATOS_CATCH( "" )
    }
 
    void UpdateSecondDerivative(NodeType& rNode) override
    {
      KRATOS_TRY
 
 
      const TValueType& CurrentFirstDerivative   = rNode.FastGetSolutionStepValue(*this->mpFirstDerivative,  0);
 
      const TValueType& PreviousFirstDerivative  = rNode.FastGetSolutionStepValue(*this->mpFirstDerivative,  1);
 
      TValueType& CurrentSecondDerivative        = rNode.FastGetSolutionStepValue(*this->mpSecondDerivative, 0);
 
      CurrentSecondDerivative = (this->mNewmark.c0/this->mNewmark.c1) * (CurrentFirstDerivative-PreviousFirstDerivative);
 
 
      KRATOS_CATCH( "" )
    }
 
 
 
 
 
 
 
  private:
 
 
 
 
 
 
    friend class Serializer;
 
    void save(Serializer& rSerializer) const override
    {
      KRATOS_SERIALIZE_SAVE_BASE_CLASS( rSerializer, DerivedType )
    };
 
    void load(Serializer& rSerializer) override
    {
      KRATOS_SERIALIZE_LOAD_BASE_CLASS( rSerializer, DerivedType )
    };
 
 
 
 
  }; // Class SimoMethod
 
 
 
 
 
  template<class TVariableType, class TValueType>
  inline std::istream & operator >> (std::istream & rIStream, SimoMethod<TVariableType,TValueType>& rThis)
  {
    return rIStream;
  }
 
  template<class TVariableType, class TValueType>
  inline std::ostream & operator << (std::ostream & rOStream, const SimoMethod<TVariableType,TValueType>& rThis)
  {
    return rOStream << rThis.Info();
  }
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_SIMO_METHOD_H_INCLUDED defined