IQNIMVJAcceleration.hpp

Go to the documentation of this file.

#ifndef PRECICE_NO_MPI
 
#pragma once
 
#include <Eigen/Core>
#include <deque>
#include <vector>
#include "acceleration/Acceleration.hpp"
#include "acceleration/BaseQNAcceleration.hpp"
#include "acceleration/impl/ParallelMatrixOperations.hpp"
#include "acceleration/impl/SVDFactorization.hpp"
#include "acceleration/impl/SharedPointer.hpp"
#include "com/SharedPointer.hpp"
 
// ----------------------------------------------------------- CLASS DEFINITION
 
namespace precice {
namespace acceleration {
 
class IQNIMVJAcceleration : public BaseQNAcceleration {
public:
  static const int NO_RESTART = 0;
  static const int RS_ZERO    = 1;
  static const int RS_LS      = 2;
  static const int RS_SVD     = 3;
  static const int RS_SLIDE   = 4;
 
  IQNIMVJAcceleration(
      double                         initialRelaxation,
      bool                           forceInitialRelaxation,
      int                            maxIterationsUsed,
      int                            pastTimeWindowsReused,
      int                            filter,
      double                         singularityLimit,
      std::vector<int>               dataIDs,
      const impl::PtrPreconditioner &preconditioner,
      bool                           alwaysBuildJacobian,
      int                            imvjRestartType,
      int                            chunkSize,
      int                            RSLSreusedTimeWindows,
      double                         RSSVDtruncationEps);
 
  virtual ~IQNIMVJAcceleration();
 
  virtual void initialize(const DataMap &cplData);
 
  virtual void specializedIterationsConverged(const DataMap &cplData);
 
private:
  Eigen::MatrixXd _invJacobian;
 
  Eigen::MatrixXd _oldInvJacobian;
 
  Eigen::MatrixXd _Wtil;
 
  std::vector<Eigen::MatrixXd> _WtilChunk;
 
  std::vector<Eigen::MatrixXd> _pseudoInverseChunk;
 
  Eigen::MatrixXd _matrixV_RSLS;
 
  Eigen::MatrixXd _matrixW_RSLS;
 
  std::deque<int> _matrixCols_RSLS;
 
  impl::PtrParMatrixOps _parMatrixOps;
 
  impl::SVDFactorization _svdJ;
 
  bool _alwaysBuildJacobian;
 
  int _imvjRestartType;
 
  bool _imvjRestart;
 
  int _chunkSize;
 
  int _RSLSreusedTimeWindows;
 
  int _nbRestarts;
 
  // DEBUG
  // std::fstream _info2;
  double _avgRank;
 
  virtual void computeQNUpdate(const DataMap &cplData, Eigen::VectorXd &xUpdate);
 
  virtual void updateDifferenceMatrices(const DataMap &cplData);
 
  virtual void computeUnderrelaxationSecondaryData(const DataMap &cplData);
 
  void computeNewtonUpdate(const DataMap &cplData, Eigen::VectorXd &update);
 
  void computeNewtonUpdateEfficient(const DataMap &cplData, Eigen::VectorXd &update);
 
  void pseudoInverse(Eigen::MatrixXd &pseudoInverse);
 
  void buildJacobian();
 
  void buildWtil();
 
  void restartIMVJ();
 
  virtual void removeMatrixColumn(int columnIndex);
 
  void removeMatrixColumnRSLS(int columnINdex);
};
} // namespace acceleration
} // namespace precice
 
#endif /* PRECICE_NO_MPI */