solution_builder_and_solver.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_BUILDER_AND_SOLVER_H_INCLUDED)
#define KRATOS_SOLUTION_BUILDER_AND_SOLVER_H_INCLUDED
 
// System includes
 
// External includes
 
// Project includes
#include "custom_solvers/solution_schemes/solution_scheme.hpp"
 
namespace Kratos
{
 
 
 
 
 
 
 
template<class TSparseSpace,
         class TDenseSpace, // = DenseSpace<double>,
         class TLinearSolver //= LinearSolver<TSparseSpace,TDenseSpace>
         >
class SolutionBuilderAndSolver : public Flags
{
public:
 
 
  KRATOS_CLASS_POINTER_DEFINITION(SolutionBuilderAndSolver);
 
  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 typename TDenseSpace::MatrixType                            LocalSystemMatrixType;
  typedef typename TDenseSpace::VectorType                            LocalSystemVectorType;
 
  typedef SolutionScheme<TSparseSpace, TDenseSpace>                              SchemeType;
  typedef typename SchemeType::Pointer                                    SchemePointerType;
 
  typedef typename TLinearSolver::Pointer                           LinearSolverPointerType;
 
 
  SolutionBuilderAndSolver() : Flags()
  {
    this->Set(LocalFlagType::DOFS_INITIALIZED, false);
 
    mpLinearSystemSolver = nullptr;
    mEchoLevel = 0;
  }
 
  SolutionBuilderAndSolver(LinearSolverPointerType pLinearSystemSolver) : Flags()
  {
    this->Set(LocalFlagType::DOFS_INITIALIZED, false);
 
    mpLinearSystemSolver = pLinearSystemSolver;
    mEchoLevel = 0;
  }
 
  ~SolutionBuilderAndSolver() override {}
 
 
 
 
  virtual void BuildLHS(SchemePointerType pScheme,
                        ModelPart& rModelPart,
                        SystemMatrixType& rA)
  {
  }
 
  virtual void BuildRHS(SchemePointerType pScheme,
                        ModelPart& rModelPart,
                        SystemVectorType& rb)
  {
  }
 
  virtual void Build(SchemePointerType pScheme,
                     ModelPart& rModelPart,
                     SystemMatrixType& rA,
                     SystemVectorType& rb)
  {
  }
 
  virtual void SystemSolve(SystemMatrixType& rA,
                           SystemVectorType& rDx,
                           SystemVectorType& rb
                           )
  {
  }
 
  virtual void BuildAndSolve(SchemePointerType pScheme,
                             ModelPart& rModelPart,
                             SystemMatrixType& rA,
                             SystemVectorType& rDx,
                             SystemVectorType& rb)
  {
  }
 
  virtual void BuildRHSAndSolve(SchemePointerType pScheme,
                                ModelPart& rModelPart,
                                SystemMatrixType& rA,
                                SystemVectorType& rDx,
                                SystemVectorType& rb)
  {
  }
 
  virtual void ApplyDirichletConditions(SchemePointerType pScheme,
                                        ModelPart& rModelPart,
                                        SystemMatrixType& rA,
                                        SystemVectorType& rDx,
                                        SystemVectorType& rb)
  {
  }
 
 
  // /**
  //  * @brief Performs all the required operations to reform dofs
  //  */
  // virtual void SetSystemDofs(SchemePointerType pScheme,
  //                            ModelPart& rModelPart)
  // {
  //   KRATOS_TRY
 
  //   if (this->mEchoLevel >= 2)
  //     KRATOS_INFO(" Reform Dofs ") << " Flag = " <<this->mOptions.Is(LocalFlagType::REFORM_DOFS) << std::endl;
 
  //   //set up the system, operation performed just once unless it is required to reform the dof set at each iteration
 
  //   //setting up the list of the DOFs to be solved
  //   double begin_time = OpenMPUtils::GetCurrentTime();
  //   this->SetUpDofSet(rModelPart);
  //   double end_time = OpenMPUtils::GetCurrentTime();
  //   if (this->mEchoLevel >= 2)
  //     KRATOS_INFO("setup_dofs_time") << "setup_dofs_time : " << end_time - begin_time << "\n" << LoggerMessage::Category::STATISTICS;
 
  //   //shaping correctly the system
  //   begin_time = OpenMPUtils::GetCurrentTime();
  //   this->SetUpSystem();
  //   end_time = OpenMPUtils::GetCurrentTime();
  //   if (this->mEchoLevel >= 2)
  //     KRATOS_INFO("setup_system_time") << ": setup_system_time : " << end_time - begin_time << "\n" << LoggerMessage::Category::STATISTICS;
 
  //   KRATOS_CATCH("")
  // }
 
 
  virtual void SetUpDofSet(SchemePointerType pScheme,
                           ModelPart& rModelPart)
  {
  }
 
  virtual void SetUpSystem()
  {
  }
 
 
  virtual void SetUpSystemMatrices(SchemePointerType pScheme,
                                   ModelPart& rModelPart,
                                   SystemMatrixPointerType& pA,
                                   SystemVectorPointerType& pDx,
                                   SystemVectorPointerType& pb)
  {
  }
 
 
  virtual void InitializeSolutionStep(SchemePointerType pScheme,
                                      ModelPart& rModelPart,
                                      SystemMatrixPointerType& pA,
                                      SystemVectorPointerType& pDx,
                                      SystemVectorPointerType& pb)
  {
  }
 
  virtual void FinalizeSolutionStep(SchemePointerType pScheme,
                                    ModelPart& rModelPart,
                                    SystemMatrixPointerType& pA,
                                    SystemVectorPointerType& pDx,
                                    SystemVectorPointerType& pb)
  {
  }
 
  virtual void CalculateReactions(SchemePointerType pScheme,
                                  ModelPart& rModelPart,
                                  SystemMatrixType& rA,
                                  SystemVectorType& rDx,
                                  SystemVectorType& rb)
  {
  }
 
  virtual void Clear()
  {
    this->mDofSet.clear();
 
    if(this->mpReactionsVector != nullptr)
      TSparseSpace::Clear(this->mpReactionsVector);
 
    if(this->mpLinearSystemSolver != nullptr)
      this->mpLinearSystemSolver->Clear();
 
    if (this->mEchoLevel > 0)
    {
      KRATOS_INFO("Builder and Solver Cleared")  << "Clear Function called" << std::endl;
    }
  }
 
 
  virtual int Check(ModelPart& rModelPart)
  {
    KRATOS_TRY
 
    return 0;
 
    KRATOS_CATCH("")
  }
 
 
 
  unsigned int GetEquationSystemSize()
  {
    return mEquationSystemSize;
  }
 
 
  LinearSolverPointerType GetLinearSystemSolver()
  {
    return mpLinearSystemSolver;
  }
 
 
  void SetOptions(Flags& rOptions)
  {
    mOptions = rOptions;
  }
 
  Flags& GetOptions()
  {
    return mOptions;
  }
 
 
  virtual void SetEchoLevel(const int Level)
  {
    mEchoLevel = Level;
  }
 
  virtual int GetEchoLevel()
  {
    return mEchoLevel;
  }
 
 
  virtual void EchoInfo(ModelPart& rModelPart,
                        SystemMatrixType& rA,
                        SystemVectorType& rDx,
                        SystemVectorType& rb)
  {
    KRATOS_TRY
 
    if (this->mEchoLevel == 2) //if it is needed to print the debug info
    {
      KRATOS_INFO("Dx")  << "Solution = " << rDx << std::endl;
      KRATOS_INFO("RHS") << "Vector = " << rb << std::endl;
    }
    else if (this->mEchoLevel == 3) //if it is needed to print the debug info
    {
      KRATOS_INFO("LHS") << "Matrix = " << rA << std::endl;
      KRATOS_INFO("Dx")  << "Solution = " << rDx << std::endl;
      KRATOS_INFO("RHS") << "Vector = " << rb << std::endl;
 
    }
    else if (this->mEchoLevel == 4) //print to matrix market file
    {
      unsigned int iteration_number = 0;
      if( rModelPart.GetProcessInfo().Has(NL_ITERATION_NUMBER) )
        iteration_number = rModelPart.GetProcessInfo()[NL_ITERATION_NUMBER];
 
      std::stringstream matrix_market_name;
      matrix_market_name << "A_" << rModelPart.GetProcessInfo()[TIME] << "_" << iteration_number << ".mm";
      TSparseSpace::WriteMatrixMarketMatrix((char *)(matrix_market_name.str()).c_str(), rA, false);
 
      std::stringstream matrix_market_vectname;
      matrix_market_vectname << "b_" << rModelPart.GetProcessInfo()[TIME] << "_" << iteration_number << ".mm.rhs";
      TSparseSpace::WriteMatrixMarketVector((char *)(matrix_market_vectname.str()).c_str(), rb);
    }
 
    KRATOS_CATCH("")
 
  }
 
 
  virtual DofsArrayType& GetDofSet()
  {
    return mDofSet;
  }
 
 
 
 
protected:
 
 
  // Pointer to the LinearSolver.
  LinearSolverPointerType mpLinearSystemSolver;
 
  // Container for de system dofs set
  DofsArrayType mDofSet;
 
  // Flags to set options
  Flags mOptions;
 
  // Number of degrees of freedom of the problem to be solved
  unsigned int mEquationSystemSize;
 
  // Level of echo for the builder and solver
  int mEchoLevel;
 
  // Reactions vector
  SystemVectorPointerType mpReactionsVector;
 
 
private:
 
 
}; 
 
 
 
 
 
 
} // namespace Kratos.
 
#endif // KRATOS_SOLUTION_BUILDER_AND_SOLVER_H_INCLUDED defined