M2N.hpp

Go to the documentation of this file.

#pragma once
 
#include <map>
#include <memory>
#include <string>
#include <type_traits>
#include <vector>
#include "DistributedComFactory.hpp"
#include "SharedPointer.hpp"
#include "com/SharedPointer.hpp"
#include "logging/Logger.hpp"
#include "m2n/DistributedCommunication.hpp"
#include "mesh/SharedPointer.hpp"
 
namespace precice {
namespace mesh {
class Mesh;
} // namespace mesh
 
namespace m2n {
 
// Forward declaration to friend unit tests which only use the primary com
struct WhiteboxAccessor;

class M2N {
public:
  M2N(com::PtrCommunication intraComm, DistributedComFactory::SharedPointer distrFactory, bool useOnlyPrimaryCom = false, bool useTwoLevelInit = false);

  ~M2N();

  bool isConnected();

  void acceptPrimaryRankConnection(const std::string &acceptorName,
                                   const std::string &requesterName,
                                   std::string_view   configHash);

  void requestPrimaryRankConnection(const std::string &acceptorName,
                                    const std::string &requesterName,
                                    std::string_view   configHash);

  void acceptSecondaryRanksConnection(const std::string &acceptorName,
                                      const std::string &requesterName);

  void requestSecondaryRanksConnection(const std::string &acceptorName,
                                       const std::string &requesterName);

  void acceptSecondaryRanksPreConnection(const std::string &acceptorName,
                                         const std::string &requesterName);

  void requestSecondaryRanksPreConnection(const std::string &acceptorName,
                                          const std::string &requesterName);
 
  /*
   * @brief After preliminary communication channels were set up and after
   *        the mesh partitions were communicated locally for every mesh,
   *        call this function to update and complete the communication
   *        channels for every communicated mesh
   */
  void completeSecondaryRanksConnection();

  void prepareEstablishment(const std::string &acceptorName,
                            const std::string &requesterName);

  void cleanupEstablishment(const std::string &acceptorName,
                            const std::string &requesterName);

  void closeConnection();

  void closePrimaryRankConnection();

  void closeDistributedConnections();

  com::PtrCommunication getPrimaryRankCommunication();

  void createDistributedCommunication(const mesh::PtrMesh &mesh);

  void send(precice::span<double const> itemsToSend,
            int                         meshID,
            int                         valueDimension);

  void send(bool itemToSend);

  void send(double itemToSend);

  void send(precice::span<double const> itemsToSend);

  void send(int itemToSend);

  void broadcastSendMesh(mesh::Mesh &mesh);

  void scatterAllCommunicationMap(std::map<int, std::vector<int>> &localCommunicationMap, mesh::Mesh &mesh);

  void broadcastSend(int itemToSend, mesh::Mesh &mesh);

  void receive(precice::span<double> itemsToReceive,
               int                   meshID,
               int                   valueDimension);

  void receive(bool &itemToReceive);

  void receive(double &itemToReceive);

  void receive(precice::span<double> itemsToReceive);

  void receive(int &itemToReceive);

  void broadcastReceiveAllMesh(mesh::Mesh &mesh);

  void gatherAllCommunicationMap(std::map<int, std::vector<int>> &localCommunicationMap, mesh::Mesh &mesh);

  void broadcastReceiveAll(std::vector<int> &itemToReceive, mesh::Mesh &mesh);
 
  bool usesTwoLevelInitialization()
  {
    return _useTwoLevelInit;
  }
 
private:
  logging::Logger _log{"m2n::M2N"};

  std::map<int, DistributedCommunication::SharedPointer> _distComs;

  com::PtrCommunication _interComm;
 
  DistributedComFactory::SharedPointer _distrFactory;
 
  bool _isPrimaryRankConnected = false;
 
  bool _areSecondaryRanksConnected = false;
 
  // The following flag is (solely) needed for unit tests between two serial participants.
  // To also use the secondary communication would require a lengthy setup of meshes
  // and their re-partitioning, which could also not be moved to some fixture as the M2Ns
  // are created through the configuration.
  // See e.g. "CplSchemeTests/ExplicitCouplingSchemeTests/testConfiguredSimpleExplicitCoupling"
  // This flag gives a loophole. It is set to false for normal use and modified in the
  // respective tests through a friend declaration.

  bool _useOnlyPrimaryCom = false;

  bool _useTwoLevelInit = false;
 
  // @brief To allow access to _useOnlyPrimaryCom
  friend struct WhiteboxAccessor;

  void checkRemoteInfo(std::string_view localParticipant,
                       std::string_view remoteParticipant,
                       std::string_view localConfigHash,
                       std::string_view remoteInfo);
};

struct WhiteboxAccessor {
  static auto useOnlyPrimaryCom(PtrM2N m2n) -> typename std::add_lvalue_reference<decltype(m2n->_useOnlyPrimaryCom)>::type
  {
    return m2n->_useOnlyPrimaryCom;
  }
};
 
} // namespace m2n
} // namespace precice