BaseCouplingScheme.hpp

Go to the documentation of this file.

#pragma once
 
#include <Eigen/Core>
#include <algorithm>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
#include "Constants.hpp"
#include "CouplingData.hpp"
#include "CouplingScheme.hpp"
#include "SharedPointer.hpp"
#include "acceleration/SharedPointer.hpp"
#include "impl/ConvergenceMeasure.hpp"
#include "impl/SharedPointer.hpp"
#include "impl/TimeHandler.hpp"
#include "io/TXTTableWriter.hpp"
#include "logging/Logger.hpp"
#include "m2n/M2N.hpp"
#include "m2n/SharedPointer.hpp"
#include "mesh/SharedPointer.hpp"
 
namespace precice {
namespace io {
class TXTTableWriter;
} // namespace io
 
namespace cplscheme {
class CouplingData;
 
class BaseCouplingScheme : public CouplingScheme {
public:
  enum CouplingMode { Explicit,
                      Implicit,
                      Undefined };
  enum CouplingMode { Explicit, {…};
 
  BaseCouplingScheme(
      double                        maxTime,
      int                           maxTimeWindows,
      double                        timeWindowSize,
      std::string                   localParticipant,
      int                           minIterations,
      int                           maxIterations,
      CouplingMode                  cplMode,
      constants::TimesteppingMethod dtMethod);
 
  bool sendsInitializedData() const final override;
 
  bool isInitialized() const final override;
 
  bool addComputedTime(double timeToAdd) final override;
 
  bool willDataBeExchanged(double lastSolverTimeStepSize) const final override;
 
  bool hasDataBeenReceived() const final override;
 
  double getTime() const final override;
 
  double getTimeWindowStart() const final override;
 
  int getTimeWindows() const final override;
 
  bool hasTimeWindowSize() const final override;
 
  double getTimeWindowSize() const final override;
 
  double getNextTimeStepMaxSize() const final override;
 
  bool isCouplingOngoing() const final override;
 
  bool isTimeWindowComplete() const final override;
 
  bool isActionRequired(Action action) const final override;
 
  bool isActionFulfilled(Action action) const final override;
 
  void markActionFulfilled(Action action) final override;
 
  void requireAction(Action action) final override;
 
  std::string printCouplingState() const override;
 
  void finalize() final override;
 
  void initialize() final override;
 
  void reinitialize() final override;
 
  ChangedMeshes firstSynchronization(const ChangedMeshes &changes) final override;
 
  void firstExchange() final override;
 
  ChangedMeshes secondSynchronization() final override;
 
  void secondExchange() final override;
 
  void addConvergenceMeasure(
      int                         dataID,
      bool                        suffices,
      bool                        strict,
      impl::PtrConvergenceMeasure measure);
 
  void setAcceleration(const acceleration::PtrAcceleration &acceleration);
 
  bool doesFirstStep() const;
 
  virtual bool hasAnySendData() = 0;
 
  virtual void determineInitialDataExchange() = 0;
 
  bool isImplicitCouplingScheme() const override;
 
  bool hasConverged() const override;
 
protected:
  DataMap _allData;
 
  acceleration::PtrAcceleration _acceleration;
 
  void sendTimes(const m2n::PtrM2N &m2n, precice::span<double const> times);
 
  void sendData(const m2n::PtrM2N &m2n, const DataMap &sendData);
 
  std::vector<double> receiveTimes(const m2n::PtrM2N &m2n);
 
  void receiveData(const m2n::PtrM2N &m2n, const DataMap &receiveData);
 
  void receiveDataForWindowEnd(const m2n::PtrM2N &m2n, const DataMap &receiveData);
 
  void initializeWithZeroInitialData(const DataMap &receiveData);
 
  PtrCouplingData addCouplingData(const mesh::PtrData &data, mesh::PtrMesh mesh, bool requiresInitialization, bool exchangeSubsteps, CouplingData::Direction direction);
 
  bool isExplicitCouplingScheme() const;
 
  void setTimeWindowSize(double timeWindowSize);
 
  double getNextTimeWindowSize() const;
 
  void setNextTimeWindowSize(double timeWindowSize);
 
  void setDoesFirstStep(bool doesFirstStep);
 
  void notifyDataHasBeenReceived();
 
  bool receivesInitializedData() const;
 
  void setTimeWindows(int timeWindows);
 
  void sendConvergence(const m2n::PtrM2N &m2n);
 
  void receiveConvergence(const m2n::PtrM2N &m2n);
 
  void doImplicitStep();
 
  void moveToNextWindow();
 
  void storeIteration();
 
  void determineInitialSend(DataMap &sendData);
 
  void determineInitialReceive(DataMap &receiveData);
 
  bool reachedEndOfTimeWindow() const;
 
  bool requiresSubsteps() const final override;
 
  ImplicitData implicitDataToReceive() const override;
 
  std::string localParticipant() const final override;
 
protected:
  double getWindowEndTime() const;
 
  double getWindowStartTime() const;
 
private:
  CouplingMode _couplingMode = Undefined;
 
  mutable logging::Logger _log{"cplscheme::BaseCouplingScheme"};
 
  double _maxTime;
 
  int _maxTimeWindows;
 
  int _timeWindows = 0;
 
  double _timeWindowSize = UNDEFINED_TIME_WINDOW_SIZE;
 
  double _nextTimeWindowSize = UNDEFINED_TIME_WINDOW_SIZE;
 
  impl::TimeHandler _time;
 
  int _minIterations = -1;
 
  int _maxIterations = -1;
 
  int _iterations = -1;
 
  int _totalIterations = -1;
 
  bool _doesFirstStep = false;
 
  bool _isTimeWindowComplete = false;
 
  bool _sendsInitializedData = false;
 
  bool _receivesInitializedData = false;
 
  bool _hasDataBeenReceived = false;
 
  bool _isInitialized = false;
 
  std::set<Action> _requiredActions;
 
  std::set<Action> _fulfilledActions;
 
  bool _hasConverged = false;
 
  std::shared_ptr<io::TXTTableWriter> _iterationsWriter;
 
  std::shared_ptr<io::TXTTableWriter> _convergenceWriter;
 
  std::string _localParticipant = "unknown";
 
  struct ConvergenceMeasureContext {
    PtrCouplingData             couplingData;
    bool                        suffices;
    bool                        strict;
    impl::PtrConvergenceMeasure measure;
 
    std::string logHeader() const
    {
      return fmt::format("Res{}({}:{})", measure->getAbbreviation(), couplingData->getMeshName(), couplingData->getDataName());
    }
    std::string logHeader() const {…}
  };
  struct ConvergenceMeasureContext {…};
 
  std::vector<ConvergenceMeasureContext> _convergenceMeasures;
 
 
  virtual void initializeReceiveDataStorage() = 0;
 
  virtual void exchangeInitialData() = 0;
 
 
  virtual void exchangeFirstData() = 0;
 
  virtual void exchangeSecondData() = 0;
 
  virtual DataMap &getAccelerationData() = 0;
 
  void checkCompletenessRequiredActions();
 
  void checkCouplingDataAvailable();
 
  void initializeTXTWriters();
 
  void advanceTXTWriters();
 
  std::string printBasicState(
      int    timeWindows,
      double time) const;
 
  std::string printActionsState() const;
 
  bool measureConvergence();
 
  void newConvergenceMeasurements();
 
  bool anyDataRequiresInitialization(DataMap &dataMap) const;
};
class BaseCouplingScheme : public CouplingScheme {…};
} // namespace cplscheme
} // namespace precice