Line data    Source code

       1              : // Copyright (C) 2015 Technische Universitaet Muenchen
       2              : // This file is part of the Mamico project. For conditions of distribution
       3              : // and use, please see the copyright notice in Mamico's main folder, or at
       4              : // www5.in.tum.de/mamico
       5              : #ifndef _MOLECULARDYNAMICS_COUPLING_SENDRECV_FROMMACRO2MD_H_
       6              : #define _MOLECULARDYNAMICS_COUPLING_SENDRECV_FROMMACRO2MD_H_
       7              : 
       8              : #include "coupling/sendrecv/DataExchangeFromMacro2MD.h"
       9              : #include "coupling/sendrecv/SendReceiveBuffer.h"
      10              : #include <vector>
      11              : 
      12              : namespace coupling {
      13              : namespace sendrecv {
      14              : template <class Cell_T, unsigned int dim> class FromMacro2MD;
      15              : }
      16              : } // namespace coupling
      17              : 
      18              : /** extends the generic SendReceiveBuffer for transfer of quantities from a
      19              :  *macroscopic solver to the coupling cells of the coupling tool (incl. ghost
      20              :  *cells).
      21              :  *      @brief SendReceiveBuffer for transfer of quantities from a macroscopic
      22              :  *solver to the coupling cells. Derived from the class
      23              :  *coupling::sendrecv::SendReceiveBuffer
      24              :  *      @tparam Cell_T cell type
      25              :  *      @tparam dim Number of dimensions; it can be 1, 2 or 3
      26              :  *  @author Philipp Neumann
      27              :  */
      28              : template <class Cell_T, unsigned int dim> class coupling::sendrecv::FromMacro2MD : public coupling::sendrecv::SendReceiveBuffer<Cell_T, dim> {
      29              : 
      30              : public:
      31              :   /** Constructor, just calling the constructor of the
      32              :    * coupling::sendrecv::SendReceiveBuffer  */
      33            4 :   FromMacro2MD() : coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>() {}
      34              :   /** Destructor */
      35            0 :   virtual ~FromMacro2MD() {}
      36              : 
      37              :   using Local_Container_T = coupling::datastructures::CellContainer<I02, dim>;
      38              : 
      39              :   /** sends information from the local coupling cells of a macroscopic solver
      40              :    * to the coupling cells of MaMico (ghost cells are also allowed). Since
      41              :    * the macroscopic solver can have an arbitrary distribution of cells on the
      42              :    * processes, the buffer for sending the cell data is provided to this
      43              :    * function in terms of an array of coupling cells including the respective
      44              :    * global cell indices. This function calls sendFromMacro2MDNonBlocking(..)
      45              :    * and immediately subsequently wait4SendFromMacro2MD(...). Those two methods
      46              :    * may alternatively be used, e.g., for "non-blocking" communication.
      47              :    *    @param dataExchange
      48              :    *    @param dst
      49              :    *    @param src
      50              :    */
      51              :   template <class Container_T>
      52              :   void sendFromMacro2MD(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Local_Container_T& dst, const Container_T& src);
      53              : 
      54              :   template <class Container_T>
      55              :   void bcastFromMacro2MD(std::vector<coupling::sendrecv::DataExchangeFromMacro2MD<dim>*>& dataExchangeFromCouplingCellServices, const Container_T& src,
      56              :                          std::vector<Local_Container_T> dst);
      57              : 
      58              :   /** sends data from macro to MD. After returning, the data transfer may not be
      59              :    * completely finished, similar to a IRecv/ISend-call by MPI. Please use
      60              :    * wait4SendFromMacro2MD(...) to guarantee that the data transfer has been
      61              :    * finished.
      62              :    *    @param dataExchange
      63              :    *    @param cells
      64              :    */
      65              :   template <class Container_T> void sendFromMacro2MDNonBlocking(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Container_T& cells);
      66              : 
      67              :   /** waits for the data transfer--instantiated by
      68              :    * sendFromMacro2MDNonBlocking(..)--to be finished and fills the information
      69              :    * into the coupling cells from Mamico.
      70              :    *    @param dataExchange
      71              :    *    @param cells
      72              :    */
      73              :   void wait4SendFromMacro2MD(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Local_Container_T& cells);
      74              : 
      75              : private:
      76              :   /** given a coupling cell container (from the macroscopic solver), the data
      77              :    * from these cells are written to the send buffer.
      78              :    *    @param dataExchange
      79              :    *    @param cells
      80              :    *    @param globalCellIndices
      81              :    */
      82              :   template <class Container_T> void writeToSendBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Container_T& cells);
      83              : 
      84              :   template <class Container_T> void writeToSendBufferCollective(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Container_T& cells);
      85              : 
      86              :   /** allocates the receive buffers for the macroscopic solver. Since we want to
      87              :    * obtain data on the side of MaMiCo, we can just loop over all local
      88              :    * coupling cells of the coupling tool and call allocateReceiveBuffers(...)
      89              :    * of the SendReceiveBuffer for each respective cell.
      90              :    *    @param dataExchange
      91              :    */
      92              :   void allocateReceiveBuffers(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange);
      93              : 
      94              :   void allocateReceiveBuffersCollective(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange);
      95              : 
      96              :   /** reads information from the receive buffer and stores the result in the
      97              :    * coupling cells. Since this is a receive for the coupling cells on the
      98              :    * side of the coupling tool, we can consider a Cartesian grid topology for
      99              :    * the coupling cells. For each cell, readFromReceiveBuffer(...) of
     100              :    * SendReceiveBuffer is called.
     101              :    *    @param dataExchange
     102              :    *    @param cells
     103              :    */
     104              :   void readFromReceiveBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Local_Container_T& cells);
     105              : 
     106              :   void readFromCollectiveBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Local_Container_T& cells);
     107              : };
     108              : 
     109              : #include "FromMacro2MD.cpph"
     110              : 
     111              : #endif // _MOLECULARDYNAMICS_COUPLING_SENDRECV_FROMMACRO2MD_H_