DummyCouplingScheme.hpp

Go to the documentation of this file.

#pragma once
 
#include <string>
#include <vector>
#include "../CouplingScheme.hpp"
#include "logging/Logger.hpp"
#include "utils/assertion.hpp"
 
namespace precice {
namespace cplscheme {
namespace tests {
 
class DummyCouplingScheme final : public CouplingScheme {
public:
  DummyCouplingScheme(
      int numberIterations,
      int maxTimeWindows);
 
  //virtual ~DummyCouplingScheme() {}
 
  void initialize(
      double startTime,
      int    startTimeWindows) override final;
 
  bool isInitialized() const override final
  {
    PRECICE_ASSERT(false);
    return false;
  }
 
  bool sendsInitializedData() const override final
  {
    PRECICE_ASSERT(false);
    return false;
  }
 
  bool addComputedTime(double timeToAdd) override final;
 
  //void advance() override final;
 
  ChangedMeshes firstSynchronization(const ChangedMeshes &changes) override;
 
  void firstExchange() override;
 
  ChangedMeshes secondSynchronization() override;
 
  void secondExchange() final;
 
  void finalize() override final;
 
  /*
   * @brief Not implemented.
   */
  std::vector<std::string> getCouplingPartners() const override final
  {
    PRECICE_ASSERT(false);
    return std::vector<std::string>();
  }
 
  std::string localParticipant() const override final
  {
    PRECICE_ASSERT(false);
    return "unknown";
  }
 
  bool willDataBeExchanged(double lastSolverTimeStepSize) const override final
  {
    PRECICE_ASSERT(false);
    return false;
  }
 
  bool hasDataBeenReceived() const override final
  {
    PRECICE_ASSERT(false);
    return false;
  }
 
  double getTime() const override final;
 
  double getTimeWindowStart() const override final;
 
  int getTimeWindows() const override final
  {
    return _timeWindows;
  }
 
  bool hasTimeWindowSize() const override final
  {
    return true;
  }
 
  double getTimeWindowSize() const override final
  {
    return 1.0;
  }
 
  double getNextTimeStepMaxSize() const override final
  {
    PRECICE_ASSERT(false);
    return 0;
  }
 
  bool isCouplingOngoing() const override final;
 
  bool isTimeWindowComplete() const override final
  {
    PRECICE_ASSERT(false);
    return false;
  }
 
  bool isActionRequired(Action action) const override final;
 
  bool isActionFulfilled(Action action) const override final
  {
    return true;
  }
 
  void markActionFulfilled(Action action) override final
  {
    PRECICE_ASSERT(false);
  }
 
  int getCheckpointTimestepInterval() const
  {
    PRECICE_ASSERT(false);
    return 0;
  }
 
  void requireAction(Action action) override final
  {
    PRECICE_ASSERT(false);
  }
 
  std::string printCouplingState() const override final
  {
    return std::string();
  }
 
  bool isImplicitCouplingScheme() const override
  {
    return _numberIterations > 1;
  }
 
  bool hasConverged() const override;
 
  bool requiresSubsteps() const override final
  {
    return true;
  }
 
  ImplicitData implicitDataToReceive() const override final
  {
    return {};
  }
 
private:
  mutable logging::Logger _log{"cplscheme::tests::DummyCouplingScheme"};
 
  int _numberIterations;
 
  int _iterations = 0;
 
  int _maxTimeWindows;
 
  int _timeWindows = 0;
 
  bool _isInitialized = false;
 
  bool _isOngoing = false;
 
  bool _hasConverged = false;
};
 
} // namespace tests
} // namespace cplscheme
} // namespace precice