solution_strategy.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosSolidMechanicsApplication $
//   Created by:          $Author:            JMCarbonell $
//   Last modified by:    $Co-Author:                     $
//   Date:                $Date:               March 2018 $
//   Revision:            $Revision:                  0.0 $
//
//
 
#if !defined(KRATOS_SOLUTION_STRATEGY_H_INCLUDED)
#define KRATOS_SOLUTION_STRATEGY_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_solvers/solution_schemes/solution_scheme.hpp"
#include "custom_solvers/solution_builders_and_solvers/solution_builder_and_solver.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
template<class TSparseSpace,
         class TDenseSpace,
         class TLinearSolver //= LinearSolver<TSparseSpace,TDenseSpace>
         >
class SolutionStrategy : public Flags
{
 public:
 
  typedef SolverLocalFlags                                                           LocalFlagType;
  typedef ModelPart::DofsArrayType                                                   DofsArrayType;
 
  typedef typename TSparseSpace::MatrixType                                       SystemMatrixType;
  typedef typename TSparseSpace::VectorType                                       SystemVectorType;
  typedef typename TSparseSpace::MatrixPointerType                         SystemMatrixPointerType;
  typedef typename TSparseSpace::VectorPointerType                         SystemVectorPointerType;
 
  typedef SolutionScheme<TSparseSpace, TDenseSpace>                                     SchemeType;
  typedef SolutionBuilderAndSolver<TSparseSpace, TDenseSpace, TLinearSolver>  BuilderAndSolverType;
 
 
  KRATOS_CLASS_POINTER_DEFINITION(SolutionStrategy);
 
 
 
 
  SolutionStrategy(ModelPart& rModelPart) : Flags(), mrModelPart(rModelPart) { mEchoLevel = 0; }
 
  SolutionStrategy(ModelPart& rModelPart, Flags& rOptions) : Flags(), mOptions(rOptions), mrModelPart(rModelPart) {mEchoLevel = 0; }
 
  ~SolutionStrategy() override {}
 
 
 
  virtual bool Solve()
  {
    KRATOS_TRY
 
    this->InitializeSolutionStep();
 
    bool converged = this->SolveSolutionStep();
 
    // implementation of the adaptive time reduction
    if( this->IsNot(LocalFlagType::ADAPTIVE_SOLUTION) )
      converged = true;
    
    if(converged)
      this->FinalizeSolutionStep();
 
    return converged;
 
    KRATOS_CATCH("")
  }
 
  virtual void InitializeSolutionStep() {}
 
  virtual void FinalizeSolutionStep() {}
 
  virtual bool SolveSolutionStep() {return true;}
 
  virtual bool SolveIteration() {return true;}
 
  virtual void Clear() {}
 
  virtual int Check()
  {
    KRATOS_TRY
 
    for (ModelPart::ElementsContainerType::iterator it_elem = GetModelPart().ElementsBegin();
         it_elem != GetModelPart().ElementsEnd(); it_elem++)
    {
      it_elem->Check(GetModelPart().GetProcessInfo());
    }
 
    for (ModelPart::ConditionsContainerType::iterator it_cond = GetModelPart().ConditionsBegin();
         it_cond != GetModelPart().ConditionsEnd(); it_cond++)
    {
      it_cond->Check(GetModelPart().GetProcessInfo());
    }
 
    return 0;
 
    KRATOS_CATCH("")
  }
 
 
  virtual void SetEchoLevel(const int Level)
  {
    mEchoLevel = Level;
  }
 
  virtual int GetEchoLevel()
  {
    return mEchoLevel;
  }
 
 
  void SetOptions(Flags& rOptions)
  {
    mOptions = rOptions;
  }
 
  Flags& GetOptions()
  {
    return mOptions;
  }
 
 
  virtual unsigned int GetMaxIterationNumber()
  {
    return 0;
  }
 
  inline ModelPart& GetModelPart()
  {
    return mrModelPart;
  };
 
 
 
 
 protected:
 
 
  // Flags to set options
  Flags mOptions;
 
  // Level of echo for the solution strategy
  int mEchoLevel;
 
 
  virtual void Initialize(){};
 
  virtual void Predict(){};
 
  virtual void Update(){};
 
  virtual void Finalize(){};
 
 
 private:
 
 
  ModelPart& mrModelPart;
 
 
  SolutionStrategy(SolutionStrategy const& Other) {};
 
 
}; 
 
 
 
 
 
 
}  // namespace Kratos.
#endif // KRATOS_SOLUTION_STRATEGY_H_INCLUDED defined