convergence_criterion.hpp

Go to the documentation of this file.

//
//   Project Name:        KratosSolidMechanicsApplication $
//   Created by:          $Author:            JMCarbonell $
//   Last modified by:    $Co-Author:                     $
//   Date:                $Date:                 May 2018 $
//   Revision:            $Revision:                  0.0 $
//
//
 
#if !defined(KRATOS_CONVERGENCE_CRITERION_H_INCLUDED )
#define  KRATOS_CONVERGENCE_CRITERION_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_solvers/solution_local_flags.hpp"
#include "includes/model_part.h"
//#include "includes/dof.h"
 
namespace Kratos
{
 
 
 
 
 
 
 
template<class TSparseSpace, class TDenseSpace>
class ConvergenceCriterion : public Flags
{
 public:
 
  typedef CriterionLocalFlags                       LocalFlagType;
  typedef typename TSparseSpace::DataType                DataType;
  typedef ModelPart::DofsArrayType                  DofsArrayType;
  typedef typename TSparseSpace::MatrixType      SystemMatrixType;
  typedef typename TSparseSpace::VectorType      SystemVectorType;
  typedef typename TDenseSpace::MatrixType  LocalSystemMatrixType;
  typedef typename TDenseSpace::VectorType  LocalSystemVectorType;
 
  KRATOS_CLASS_POINTER_DEFINITION(ConvergenceCriterion);
 
 
  ConvergenceCriterion()
  {
    SetEchoLevel(1);
  }
 
  ConvergenceCriterion( ConvergenceCriterion const& rOther)
      :mEchoLevel(rOther.mEchoLevel)
  {
  }
 
  ~ConvergenceCriterion() override
  {
  }
 
 
 
  //*********************************************************************************
 
  virtual void SetEchoLevel(int Level)
  {
    mEchoLevel = Level;
  }
 
  int GetEchoLevel()
  {
    return mEchoLevel;
  }
 
 
  /*Criterias that need to be called before getting the solution */
  virtual bool PreCriteria(ModelPart& rModelPart,
                           DofsArrayType& rDofSet,
                           const SystemMatrixType& rA,
                           const SystemVectorType& rDx,
                           const SystemVectorType& rb)
  {
    return true;
  }
 
  /*Criterias that need to be called after getting the solution */
  virtual bool PostCriteria(ModelPart& rModelPart,
                            DofsArrayType& rDofSet,
                            const SystemMatrixType& rA,
                            const SystemVectorType& rDx,
                            const SystemVectorType& rb)
 
  {
    return true;
  }
 
  virtual void InitializeSolutionStep(ModelPart& rModelPart,
                                      DofsArrayType& rDofSet,
                                      const SystemMatrixType& rA,
                                      const SystemVectorType& rDx,
                                      const SystemVectorType& rb)
  {
  }
 
  virtual void FinalizeSolutionStep(ModelPart& rModelPart,
                                    DofsArrayType& rDofSet,
                                    const SystemMatrixType& rA,
                                    const SystemVectorType& rDx,
                                    const SystemVectorType& rb)
  {
  }
 
  virtual int Check(ModelPart& rModelPart)
  {
    KRATOS_TRY
 
    return 0;
 
    KRATOS_CATCH("")
  }
 
 
 
 
 
 
 protected:
 
 
  int  mEchoLevel;
 
 
 
 
 
 
 
 private:
 
 
 
 
 
 
 
 
};  // Class ConvergenceCriterion
 
 
 
 
 
 
 
}  // namespace Kratos.
 
#endif // KRATOS_CONVERGENCE_CRITERION_H_INCLUDED defined