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);
 
  void requestPrimaryRankConnection(const std::string &acceptorName,
                                    const std::string &requesterName);
 
  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 _intraComm;
 
  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;
};
 
struct WhiteboxAccessor {
  static auto useOnlyPrimaryCom(PtrM2N m2n) -> typename std::add_lvalue_reference<decltype(m2n->_useOnlyPrimaryCom)>::type
  {
    return m2n->_useOnlyPrimaryCom;
  }
};
 
} // namespace m2n
} // namespace precice