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::cplscheme::tests {

class DummyCouplingScheme final : public CouplingScheme {
public:
  DummyCouplingScheme(
      int numberIterations,
      int maxTimeWindows);

  // virtual ~DummyCouplingScheme() {}

  void initialize() final override;
 
  void reinitialize() final override {};

  bool isInitialized() const final override
  {
    PRECICE_ASSERT(false);
    return false;
  }

  bool sendsInitializedData() const final override
  {
    PRECICE_ASSERT(false);
    return false;
  }
 
  bool addComputedTime(double timeToAdd) final override;

  // void advance() override final override;
 
  ChangedMeshes firstSynchronization(const ChangedMeshes &changes) override;
 
  void firstExchange() override;
 
  ChangedMeshes secondSynchronization() override;
 
  void secondExchange() final override;

  void finalize() final override;
 
  /*
   * @brief Not implemented.
   */
  std::vector<std::string> getCouplingPartners() const final override
  {
    PRECICE_ASSERT(false);
    return std::vector<std::string>();
  }
 
  std::string localParticipant() const final override
  {
    PRECICE_ASSERT(false);
    return "unknown";
  }

  bool willDataBeExchanged(double lastSolverTimeStepSize) const final override
  {
    PRECICE_ASSERT(false);
    return false;
  }

  bool hasDataBeenReceived() const final override
  {
    PRECICE_ASSERT(false);
    return false;
  }

  double getTime() const final override;
 
  double getTimeWindowStart() const final override;

  int getTimeWindows() const final override
  {
    return _timeWindows;
  }
 
  bool hasTimeWindowSize() const final override
  {
    return true;
  }

  double getTimeWindowSize() const final override
  {
    return 1.0;
  }

  double getNextTimeStepMaxSize() const final override
  {
    PRECICE_ASSERT(false);
    return 0;
  }

  bool isCouplingOngoing() const final override;

  bool isTimeWindowComplete() const final override
  {
    PRECICE_ASSERT(false);
    return false;
  }

  bool isActionRequired(Action action) const final override;
 
  bool isActionFulfilled(Action action) const final override
  {
    return true;
  }

  void markActionFulfilled(Action action) final override
  {
    PRECICE_ASSERT(false);
  }

  int getCheckpointTimestepInterval() const
  {
    PRECICE_ASSERT(false);
    return 0;
  }

  void requireAction(Action action) final override
  {
    PRECICE_ASSERT(false);
  }

  std::string printCouplingState() const final override
  {
    return std::string();
  }
 
  bool isImplicitCouplingScheme() const override
  {
    return _numberIterations > 1;
  }
 
  bool hasConverged() const override;
 
  bool requiresSubsteps() const final override
  {
    return true;
  }
 
  ImplicitData implicitDataToReceive() const final override
  {
    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 precice::cplscheme::tests