BaseQNAcceleration.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <algorithm>
#include <deque>
#include <fstream>
#include <map>
#include <sstream>
#include <string>
#include <vector>
#include "acceleration/Acceleration.hpp"
#include "acceleration/impl/QRFactorization.hpp"
#include "acceleration/impl/SharedPointer.hpp"
#include "logging/Logger.hpp"
 
/* ****************************************************************************
 *
 * A few comments concerning the present design choice.
 *
 * All the functions from the base class BAseQNAcceleration are specialized in
 * the sub classes as needed. This is done vi overwriting the base functions in
 * the specialized sub classes and calling the respective base function after
 * performing the specialized stuff (in order to perform the common, generalized
 * computations i.e. handling of V,W matrices etc.)
 * However, for the performAcceleration Method we decided (for better readability)
 * to have this method only in the base class, while introducing a function
 * performPPSecondaryData that handles all the specialized stuff concerning acceleration
 * processing for the secondary data in the sub classes.
 *
 * Another possibility would have been to introduce a bunch of functions like
 * initializeSpecialized(), removeMatrixColumnSpecialized(),
 * iterationsConvergedSpecialized(), etc
 * and call those function from the base class top down to the sub classes.
 *
 * The third possibility was to separate the approximation of the Jacobian from
 * the common stuff like handling V,W matrices in the acceleration.
 * Here, we have a class QNAcceleration that handles the V,W stuff an d the basic
 * scheme of the QN update. Furthermore we have a base class (or rather interface)
 * JacobianApproximation with sub classes IQNIMVJAPX and IQNAPX that handle all the
 * specialized stuff like Jacobian approximation, handling of secondary data etc.
 * However, this approach is not feasible, as we have to call the function
 * removeMatrixColumn() down in the specialized sub classes IQNIMVJApx and IQNApx.
 * This is not possible as the function works on the V, W matrices that are
 * completely treated by QNAcceleration.
 *
 * ****************************************************************************
 */
 
// ----------------------------------------------------------- CLASS DEFINITION
 
namespace precice {
namespace io {
class TXTReader;
class TXTWriter;
} // namespace io
 
namespace acceleration {
 
class BaseQNAcceleration : public Acceleration {
public:
  BaseQNAcceleration(
      double                  initialRelaxation,
      bool                    forceInitialRelaxation,
      int                     maxIterationsUsed,
      int                     timeWindowsReused,
      int                     filter,
      double                  singularityLimit,
      std::vector<int>        dataIDs,
      impl::PtrPreconditioner preconditioner);
 
  virtual ~BaseQNAcceleration()
  {
    // not necessary for user, only for developer, if needed, this should be configurable
    //     if (utils::IntraComm::isPrimary() || !utils::IntraComm::isParallel()) {
    //       _infostream.open("precice-accelerationInfo.log", std::ios_base::out);
    //       _infostream << std::setprecision(16);
    //       _infostream << _infostringstream.str();
    //     }
  }
 
  virtual std::vector<int> getDataIDs() const
  {
    return _dataIDs;
  }
 
  virtual void initialize(const DataMap &cplData);
 
  virtual void performAcceleration(DataMap &cplData);
 
  virtual void iterationsConverged(const DataMap &cplData);
 
  virtual void exportState(io::TXTWriter &writer);
 
  virtual void importState(io::TXTReader &reader);
 
  virtual int getDeletedColumns() const;
 
  virtual int getDroppedColumns() const;
 
  virtual int getLSSystemCols() const;
 
protected:
  logging::Logger _log{"acceleration::BaseQNAcceleration"};
 
  impl::PtrPreconditioner _preconditioner;
 
  double _initialRelaxation;
 
  int _maxIterationsUsed;
 
  int _timeWindowsReused;
 
  std::vector<int> _dataIDs;
 
  std::vector<int> _secondaryDataIDs;
 
  bool _firstIteration = true;
 
  /* @brief Indicates the first time window, where constant relaxation is used
   *        later, we replace the constant relaxation by a qN-update from last time window.
   */
  bool _firstTimeWindow = true;
 
  /*
   * @brief True if this process has nodes at the coupling interface
   */
  bool _hasNodesOnInterface = true;
 
  /* @brief If true, the QN-scheme always performs a underrelaxation in the first iteration of
   *        a new time window. Otherwise, the LS system from the previous time window is used in the
   *        first iteration.
   */
  bool _forceInitialRelaxation;
 
  bool _resetLS = false;
 
  Eigen::VectorXd _oldXTilde;
 
  Eigen::VectorXd _residuals;
 
  std::map<int, Eigen::VectorXd> _secondaryResiduals;
 
  Eigen::MatrixXd _matrixV;
 
  Eigen::MatrixXd _matrixW;
 
  impl::QRFactorization _qrV;
 
  int _filter;
 
  double _singularityLimit;
 
  std::deque<int> _matrixCols;
 
  std::vector<int> _dimOffsets;
 
  std::ostringstream _infostringstream;
  std::fstream       _infostream;
 
  int getLSSystemRows();
 
  virtual void specializedIterationsConverged(const DataMap &cplData) = 0;
 
  virtual void updateDifferenceMatrices(const DataMap &cplData);
 
  virtual void splitCouplingData(const DataMap &cplData);
 
  virtual void applyFilter();
 
  virtual void computeUnderrelaxationSecondaryData(const DataMap &cplData) = 0;
 
  virtual void computeQNUpdate(const DataMap &cplData, Eigen::VectorXd &xUpdate) = 0;
 
  virtual void removeMatrixColumn(int columnIndex);
 
  void writeInfo(const std::string &s, bool allProcs = false);
 
  int its = 0, tWindows = 0;
 
private:
  Eigen::VectorXd _values;
 
  Eigen::VectorXd _oldValues;
 
  Eigen::VectorXd _oldResiduals;
 
  Eigen::MatrixXd _matrixVBackup;
  Eigen::MatrixXd _matrixWBackup;
  std::deque<int> _matrixColsBackup;
 
  int _nbDelCols = 0;
 
  int _nbDropCols = 0;
};
} // namespace acceleration
} // namespace precice