static_scheme.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_STATIC_SCHEME_H_INCLUDED)
#define  KRATOS_STATIC_SCHEME_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_solvers/solution_schemes/solution_scheme.hpp"
 
namespace Kratos
{
 
  template<class TSparseSpace,  class TDenseSpace >
  class StaticScheme: public SolutionScheme<TSparseSpace,TDenseSpace>
  {
  public:
 
    KRATOS_CLASS_POINTER_DEFINITION( StaticScheme );
 
    typedef SolutionScheme<TSparseSpace,TDenseSpace>                             BaseType;
    typedef typename BaseType::SolutionSchemePointerType                  BasePointerType;
 
    typedef typename BaseType::NodeType                                          NodeType;
    typedef typename BaseType::DofsArrayType                                DofsArrayType;
    typedef typename Element::DofsVectorType                               DofsVectorType;
    typedef typename BaseType::SystemMatrixType                          SystemMatrixType;
    typedef typename BaseType::SystemVectorType                          SystemVectorType;
    typedef typename BaseType::LocalSystemVectorType                LocalSystemVectorType;
    typedef typename BaseType::LocalSystemMatrixType                LocalSystemMatrixType;
 
    typedef ModelPart::NodesContainerType                              NodesContainerType;
    typedef ModelPart::ElementsContainerType                        ElementsContainerType;
    typedef ModelPart::ConditionsContainerType                    ConditionsContainerType;
 
    typedef typename BaseType::IntegrationMethodsVectorType  IntegrationMethodsVectorType;
    typedef typename BaseType::IntegrationMethodsScalarType  IntegrationMethodsScalarType;
 
 
    StaticScheme(IntegrationMethodsVectorType& rTimeVectorIntegrationMethods, Flags& rOptions)
        :BaseType(rTimeVectorIntegrationMethods, rOptions)
    {
    }
 
    StaticScheme(IntegrationMethodsVectorType& rTimeVectorIntegrationMethods)
        :BaseType(rTimeVectorIntegrationMethods)
    {
    }
 
 
    StaticScheme(IntegrationMethodsScalarType& rTimeScalarIntegrationMethods, Flags& rOptions)
        :BaseType(rTimeScalarIntegrationMethods, rOptions)
    {
    }
 
    StaticScheme(IntegrationMethodsScalarType& rTimeScalarIntegrationMethods)
        :BaseType(rTimeScalarIntegrationMethods)
    {
    }
 
    StaticScheme(IntegrationMethodsVectorType& rTimeVectorIntegrationMethods,
                 IntegrationMethodsScalarType& rTimeScalarIntegrationMethods,
                 Flags& rOptions)
        :BaseType(rTimeVectorIntegrationMethods, rTimeScalarIntegrationMethods, rOptions)
    {
    }
 
    StaticScheme(IntegrationMethodsVectorType& rTimeVectorIntegrationMethods,
                 IntegrationMethodsScalarType& rTimeScalarIntegrationMethods)
        :BaseType(rTimeVectorIntegrationMethods, rTimeScalarIntegrationMethods)
    {
    }
 
    StaticScheme(StaticScheme& rOther)
        :BaseType(rOther)
    {
    }
 
    BasePointerType Clone() override
    {
      return BasePointerType( new StaticScheme(*this) );
    }
 
    ~StaticScheme() override {}
 
 
 
    void Initialize(ModelPart& rModelPart) override
    {
        KRATOS_TRY
 
    BaseType::Initialize(rModelPart);
 
    KRATOS_CATCH("")
    }
 
    void Update(ModelPart& rModelPart,
        DofsArrayType& rDofSet,
        SystemVectorType& rDx) override
    {
      KRATOS_TRY;
 
      this->UpdateDofs(rModelPart,rDofSet,rDx);
      this->UpdateVariables(rModelPart);
      this->MoveMesh(rModelPart);
 
      KRATOS_CATCH( "" );
    }
 
    void Predict(ModelPart& rModelPart,
         DofsArrayType& rDofSet,
         SystemVectorType& rDx) override
    {
      KRATOS_TRY;
 
      this->PredictVariables(rModelPart);
      this->MoveMesh(rModelPart);
 
      KRATOS_CATCH( "" );
    }
 
 
    int Check(ModelPart& rModelPart) override
    {
      KRATOS_TRY;
 
      // Perform base base checks
      int ErrorCode = 0;
      ErrorCode  = BaseType::Check(rModelPart);
 
      // Check that all required variables have been registered
 
      // Check that variables are correctly allocated
      // for(ModelPart::NodesContainerType::iterator it=rModelPart.NodesBegin(); it!=rModelPart.NodesEnd(); ++it)
      //   {
      //     // Nodal data
      //     KRATOS_CHECK_VARIABLE_IN_NODAL_DATA(DISPLACEMENT,(*it));
 
      //     // Nodal dofs
      //     KRATOS_CHECK_DOF_IN_NODE(DISPLACEMENT_X,(*it));
      //     KRATOS_CHECK_DOF_IN_NODE(DISPLACEMENT_Y,(*it));
      //     if( rModelPart.GetProcessInfo()[SPACE_DIMENSION] == 3 )
      //       KRATOS_CHECK_DOF_IN_NODE(DISPLACEMENT_Z,(*it));
      //   }
 
      // Check for minimum value of the buffer index
      if (rModelPart.GetBufferSize() < 2)
        {
      KRATOS_ERROR << "insufficient buffer size. Buffer size should be greater than 2. Current size is" << rModelPart.GetBufferSize() << std::endl;
        }
 
      if ( this->mTimeVectorIntegrationMethods.size() == 0  && this->mTimeScalarIntegrationMethods.size() == 0 ) {
        KRATOS_ERROR << "Time integration methods for Vector or Scalar variables NOT supplied" << std::endl;
      }
 
      return ErrorCode;
 
      KRATOS_CATCH( "" );
    }
 
 
 
 
    std::string Info() const override
    {
        std::stringstream buffer;
        buffer << "StaticScheme";
        return buffer.str();
    }
 
    void PrintInfo(std::ostream& rOStream) const override
    {
        rOStream << "StaticScheme";
    }
 
    void PrintData(std::ostream& rOStream) const override
    {
      rOStream << "StaticScheme Data";
    }
 
 
 
  protected:
 
 
 
 
 
 
 
 
 
  private:
 
 
 
 
 
 
 
 
 
  }; // Class StaticScheme
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_STATIC_SCHEME_H_INCLUDED defined