CouplingSchemeConfiguration.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <string>
#include <tuple>
#include <vector>
 
#include "acceleration/SharedPointer.hpp"
#include "cplscheme/Constants.hpp"
#include "cplscheme/CouplingScheme.hpp"
#include "cplscheme/MultiCouplingScheme.hpp"
#include "cplscheme/SharedPointer.hpp"
#include "cplscheme/impl/SharedPointer.hpp"
#include "logging/Logger.hpp"
#include "m2n/config/M2NConfiguration.hpp"
#include "mesh/SharedPointer.hpp"
#include "precice/config/SharedPointer.hpp"
#include "precice/impl/MeshContext.hpp"
#include "precice/impl/Types.hpp"
#include "xml/XMLTag.hpp"
 
namespace precice {
namespace cplscheme {
class CompositionalCouplingScheme;
class BiCouplingScheme;
} // namespace cplscheme
} // namespace precice
 
// Forward declaration to friend the boost test struct
namespace CplSchemeTests {
namespace ParallelImplicitCouplingSchemeTests {
struct testParseConfigurationWithRelaxation;
}
namespace SerialImplicitCouplingSchemeTests {
struct testParseConfigurationWithRelaxation;
}
} // namespace CplSchemeTests
 
// ----------------------------------------------------------- CLASS DEFINITION
namespace precice {
namespace cplscheme {
class MultiCouplingScheme;
 
class CouplingSchemeConfiguration : public xml::XMLTag::Listener {
public:
  CouplingSchemeConfiguration(
      xml::XMLTag &                        parent,
      mesh::PtrMeshConfiguration           meshConfig,
      m2n::M2NConfiguration::SharedPointer m2nConfig,
      config::PtrParticipantConfiguration  participantConfig);
 
  void setExperimental(bool experimental);
 
  virtual ~CouplingSchemeConfiguration() {}
 
  bool hasCouplingScheme(const std::string &participantName) const;
 
  const PtrCouplingScheme &getCouplingScheme(const std::string &participantName) const;
 
  const std::string &getDataToExchange(int index) const;
 
  virtual void xmlTagCallback(const xml::ConfigurationContext &context, xml::XMLTag &callingTag);
 
  virtual void xmlEndTagCallback(const xml::ConfigurationContext &context, xml::XMLTag &callingTag);
 
  void addCouplingScheme(const PtrCouplingScheme &cplScheme, const std::string &participantName);
 
private:
  mutable logging::Logger _log{"cplscheme::CouplingSchemeConfiguration"};
 
  const std::string TAG;
  const std::string TAG_PARTICIPANTS;
  const std::string TAG_PARTICIPANT;
  const std::string TAG_EXCHANGE;
  const std::string TAG_MAX_TIME;
  const std::string TAG_MAX_TIME_WINDOWS;
  const std::string TAG_TIME_WINDOW_SIZE;
  const std::string TAG_ABS_CONV_MEASURE;
  const std::string TAG_ABS_OR_REL_CONV_MEASURE;
  const std::string TAG_REL_CONV_MEASURE;
  const std::string TAG_RES_REL_CONV_MEASURE;
  const std::string TAG_MIN_ITERATIONS;
  const std::string TAG_MAX_ITERATIONS;
 
  const std::string ATTR_DATA;
  const std::string ATTR_MESH;
  const std::string ATTR_PARTICIPANT;
  const std::string ATTR_INITIALIZE;
  const std::string ATTR_EXCHANGE_SUBSTEPS;
  const std::string ATTR_TYPE;
  const std::string ATTR_FIRST;
  const std::string ATTR_SECOND;
  const std::string ATTR_VALUE;
  const std::string ATTR_METHOD;
  const std::string ATTR_LIMIT;
  const std::string ATTR_ABS_LIMIT;
  const std::string ATTR_REL_LIMIT;
  const std::string ATTR_NAME;
  const std::string ATTR_FROM;
  const std::string ATTR_TO;
  const std::string ATTR_SUFFICES;
  const std::string ATTR_STRICT;
  const std::string ATTR_CONTROL;
 
  const std::string VALUE_SERIAL_EXPLICIT;
  const std::string VALUE_PARALLEL_EXPLICIT;
  const std::string VALUE_SERIAL_IMPLICIT;
  const std::string VALUE_PARALLEL_IMPLICIT;
  const std::string VALUE_MULTI;
  const std::string VALUE_FIXED;
  const std::string VALUE_FIRST_PARTICIPANT;
 
  static const int DEFAULT_MIN_ITERATIONS;
  static const int DEFAULT_MAX_ITERATIONS;
 
  struct ConvergenceMeasureDefintion {
    mesh::PtrData               data;
    bool                        suffices;
    bool                        strict;
    std::string                 meshName;
    impl::PtrConvergenceMeasure measure;
    bool                        doesLogging;
  };
 
  struct Config {
    std::string                   type;
    std::string                   name;
    std::vector<std::string>      participants;
    std::string                   controller;
    bool                          setController  = false;
    double                        maxTime        = CouplingScheme::UNDEFINED_MAX_TIME;
    int                           maxTimeWindows = CouplingScheme::UNDEFINED_TIME_WINDOWS;
    double                        timeWindowSize = CouplingScheme::UNDEFINED_TIME_WINDOW_SIZE;
    constants::TimesteppingMethod dtMethod       = constants::FIXED_TIME_WINDOW_SIZE;
 
    struct Exchange {
      mesh::PtrData data;
      mesh::PtrMesh mesh;
      std::string   from;
      std::string   to;
      bool          requiresInitialization;
      bool          exchangeSubsteps;
    };
    std::vector<Exchange>                    exchanges;
    std::vector<ConvergenceMeasureDefintion> convergenceMeasureDefinitions;
    int                                      maxIterations = DEFAULT_MAX_ITERATIONS;
    int                                      minIterations = DEFAULT_MIN_ITERATIONS;
 
    bool hasExchange(const Exchange &totest) const
    {
      return std::any_of(exchanges.begin(), exchanges.end(), [&totest](const auto &ex) {
        return ex.from == totest.from && ex.to == totest.to && ex.data->getName() == totest.data->getName() && ex.mesh->getName() == totest.mesh->getName();
      });
    }
  } _config;
 
  mesh::PtrMeshConfiguration _meshConfig;
 
  m2n::M2NConfiguration::SharedPointer _m2nConfig;
 
  acceleration::PtrAccelerationConfiguration _accelerationConfig;
 
  precice::config::PtrParticipantConfiguration _participantConfig;
 
  std::map<std::string, PtrCouplingScheme> _couplingSchemes;
 
  std::map<std::string, CompositionalCouplingScheme *> _couplingSchemeCompositions;
 
  void addTypespecifcSubtags(const std::string &type, xml::XMLTag &tag);
 
  void addTransientLimitTags(const std::string &type, xml::XMLTag &tag);
 
  void addTagParticipants(xml::XMLTag &tag);
 
  void addTagParticipant(xml::XMLTag &tag);
 
  void addTagExchange(xml::XMLTag &tag);
 
  void addTagAbsoluteConvergenceMeasure(xml::XMLTag &tag);
 
  void addTagAbsoluteOrRelativeConvergenceMeasure(xml::XMLTag &tag);
 
  void addTagRelativeConvergenceMeasure(xml::XMLTag &tag);
 
  void addTagResidualRelativeConvergenceMeasure(xml::XMLTag &tag);
 
  void addBaseAttributesTagConvergenceMeasure(xml::XMLTag &tag);
 
  void addTagMinIterations(xml::XMLTag &tag);
 
  void addTagMaxIterations(xml::XMLTag &tag);
 
  void addTagAcceleration(xml::XMLTag &tag);
 
  void addAbsoluteConvergenceMeasure(
      const std::string &dataName,
      const std::string &meshName,
      double             limit,
      bool               suffices,
      bool               strict);
 
  void addAbsoluteOrRelativeConvergenceMeasure(
      const std::string &dataName,
      const std::string &meshName,
      double             absLimit,
      double             relLimit,
      bool               suffices,
      bool               strict);
 
  void addRelativeConvergenceMeasure(
      const std::string &dataName,
      const std::string &meshName,
      double             limit,
      bool               suffices,
      bool               strict);
 
  void addResidualRelativeConvergenceMeasure(
      const std::string &dataName,
      const std::string &meshName,
      double             limit,
      bool               suffices,
      bool               strict);
 
  mesh::PtrData getData(
      const std::string &dataName,
      const std::string &meshName) const;
 
  mesh::PtrData findDataByID(
      int ID) const;
 
  PtrCouplingScheme createSerialExplicitCouplingScheme(
      const std::string &accessor) const;
 
  PtrCouplingScheme createParallelExplicitCouplingScheme(
      const std::string &accessor) const;
 
  PtrCouplingScheme createSerialImplicitCouplingScheme(
      const std::string &accessor) const;
 
  PtrCouplingScheme createParallelImplicitCouplingScheme(
      const std::string &accessor) const;
 
  PtrCouplingScheme createMultiCouplingScheme(
      const std::string &accessor) const;
 
  constants::TimesteppingMethod getTimesteppingMethod(
      const std::string &method) const;
 
  void addDataToBeExchanged(
      BiCouplingScheme & scheme,
      const std::string &accessor) const;
 
  void addMultiDataToBeExchanged(
      MultiCouplingScheme &scheme,
      const std::string &  accessor) const;
 
  void checkIfDataIsExchanged(
      DataID dataID) const;
 
  void checkSerialImplicitAccelerationData(
      DataID dataID, const std::string &first, const std::string &second) const;
 
  void addConvergenceMeasures(
      BaseCouplingScheme *                            scheme,
      const std::string &                             participant,
      const std::vector<ConvergenceMeasureDefintion> &convergenceMeasureDefinitions) const;
 
  void setSerialAcceleration(
      BaseCouplingScheme *scheme,
      const std::string & first,
      const std::string & second) const;
 
  void setParallelAcceleration(
      BaseCouplingScheme *scheme,
      const std::string & participant) const;
 
  friend struct CplSchemeTests::ParallelImplicitCouplingSchemeTests::testParseConfigurationWithRelaxation; // For whitebox tests
  friend struct CplSchemeTests::SerialImplicitCouplingSchemeTests::testParseConfigurationWithRelaxation;   // For whitebox tests
 
  void checkSubstepExchangeWaveformDegree(const Config::Exchange &exchange) const;
 
  void updateConfigForImplicitCoupling();
 
  void checkIterationLimits() const;
};
} // namespace cplscheme
} // namespace precice