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::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,
      OnBoundViolation               onBoundViolation,
      const impl::PtrPreconditioner &preconditioner,
      bool                           alwaysBuildJacobian,
      int                            imvjRestartType,
      int                            chunkSize,
      int                            RSLSreusedTimeWindows,
      double                         RSSVDtruncationEps,
      bool                           reducedTimeGrid);

  ~IQNIMVJAcceleration() override;

  void specializedIterationsConverged(const DataMap &cplData) override;
 
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;

  const int _imvjRestartType;

  const bool _imvjRestart;

  int _chunkSize;

  int _RSLSreusedTimeWindows;

  int _nbRestarts;
 
  // DEBUG
  // std::fstream _info2;
  double _avgRank;

  void computeQNUpdate(Eigen::VectorXd &xUpdate) override;

  void updateDifferenceMatrices(const DataMap &cplData) override;

  void computeNewtonUpdate(Eigen::VectorXd &update);

  void computeNewtonUpdateEfficient(Eigen::VectorXd &update);

  void pseudoInverse(Eigen::MatrixXd &pseudoInverse);

  void buildJacobian();

  void buildWtil();

  void restartIMVJ();

  void removeMatrixColumn(int columnIndex) override;

  void specializedInitializeVectorsAndPreconditioner(const DataMap &cplData) final override;

  void removeMatrixColumnRSLS(int columnINdex);
};
} // namespace precice::acceleration
 
#endif /* PRECICE_NO_MPI */