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_MD2MACRO_H_
       6             : #define _MOLECULARDYNAMICS_COUPLING_SENDRECV_MD2MACRO_H_
       7             : 
       8             : #include "coupling/CouplingMDDefinitions.h"
       9             : #include "coupling/datastructures/CellContainer.h"
      10             : #include "coupling/datastructures/FlexibleCellContainer.h"
      11             : #include "coupling/sendrecv/DataExchangeFromMD2Macro.h"
      12             : #include "coupling/sendrecv/SendReceiveBuffer.h"
      13             : #include <vector>
      14             : 
      15             : namespace coupling {
      16             : namespace sendrecv {
      17             : template <class Cell_T, unsigned int dim> class FromMD2Macro;
      18             : }
      19             : } // namespace coupling
      20             : 
      21             : /** extends the generic SendReceiveBuffer for send coupling cell information
      22             :  *from MaMiCo to the macroscopic solver.
      23             :  *      @brief sends coupling cell information from MaMiCo to the macroscopic
      24             :  *solver. Derived from the class coupling::sendrecv::SendReceiveBuffer
      25             :  *      @tparam Cell_T cell type
      26             :  *      @tparam dim Number of dimensions; it can be 1, 2 or 3
      27             :  *  @author Philipp Neumann
      28             :  */
      29             : template <class Cell_T, unsigned int dim> class coupling::sendrecv::FromMD2Macro : public coupling::sendrecv::SendReceiveBuffer<Cell_T, dim> {
      30             : 
      31             : public:
      32             :   /** Constructor, just calling the constructor of the
      33             :    * coupling::sendrecv::SendReceiveBuffer  */
      34           4 :   FromMD2Macro() : coupling::sendrecv::SendReceiveBuffer<Cell_T, dim>() {}
      35             :   /** Destructor */
      36           0 :   virtual ~FromMD2Macro() {}
      37             : 
      38             :   using Macro_Container_T = coupling::datastructures::FlexibleCellContainer<dim>;
      39             :   using Local_Container_T = coupling::datastructures::CellContainer<I02, dim>;
      40             : 
      41             :   /** sends information from the local coupling cells of MaMiCo (only inner
      42             :    * non-ghost cells of this process) to the macroscopic solver. Since the
      43             :    * macroscopic solver can have an arbitrary distribution of cells on the
      44             :    * processes, the buffer for receiving the cell data is provided to this
      45             :    * function in terms of an array of coupling cells including the respective
      46             :    * global cell indices. This function basically calls for these purposes
      47             :    * sendFromMD2MacroNonBlocking(...) and wait4SendFromMD2Macro(...) in a row.
      48             :    *    @param dataExchange
      49             :    *    @param src
      50             :    *  @param dst
      51             :    */
      52             :   void sendFromMD2Macro(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Local_Container_T& src, const Macro_Container_T& dst);
      53             : 
      54             :   /** reduces information from the local coupling cells of MaMiCo (only inner
      55             :    * non-ghost cells of this process) and sends it to the macroscopic solver.
      56             :    *    @param dataExchange
      57             :    *    @param src
      58             :    *  @param dst
      59             :    */
      60             :   template <class Container_T1, class Container_T2>
      61             :   void reduceFromMD2Macro(std::vector<coupling::sendrecv::DataExchangeFromMD2Macro<dim>*>& dataExchange, const Container_T1& src, const Container_T2& dst);
      62             : 
      63             :   /** triggers the send/recv operations for data transfer. After returning,
      64             :    * these data transfers do not necessarily need to be finished, according to
      65             :    * ISend/IRecv in MPI.
      66             :    *    @param dataExchange
      67             :    *    @param src
      68             :    *  @param dst
      69             :    */
      70             :   void sendFromMD2MacroNonBlocking(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Local_Container_T& src, const Macro_Container_T& dst);
      71             : 
      72             :   /** waits for the send operation--instantiated by
      73             :    * sendFromMD2MacroNonBlocking(...)--to be finished and writes the data to
      74             :    * couplingCellsFromMacroscopicSolver.
      75             :    *    @param dataExchange
      76             :    *    @param cells
      77             :    */
      78             :   void wait4SendFromMD2Macro(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Macro_Container_T& cells);
      79             : 
      80             : private:
      81             :   /** loops over the whole local Cartesian grid (only non-ghost cells!) and
      82             :    * writes respective cells to send buffer. For each cell,
      83             :    * writeToSendBuffer(...) of SendReceiveBuffer is used.
      84             :    *    @param dataExchange
      85             :    *    @param cells
      86             :    */
      87             :   void writeToSendBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Local_Container_T& cells);
      88             : 
      89             :   /** loops over the whole local Cartesian grid (only non-ghost cells!) and
      90             :    * writes respective cells to reduce buffer.
      91             :    *    @param dataExchange
      92             :    *    @param cells
      93             :    */
      94             :   void writeToReduceBuffer(coupling::sendrecv::DataExchangeFromMD2Macro<dim>& dataExchange, const Local_Container_T& cells);
      95             : 
      96             :   /** allocates the receive buffers for the macroscopic solver. Since we do not
      97             :    * know anything about the macroscopic solver, we only have a list of global
      98             :    * vector cell indices available for possible cells to be received on this
      99             :    * rank. For each global cell which is in the list,
     100             :    * allocateReceiveBuffers(...) of SendReceiveBuffer is called.
     101             :    *    @param dataExchange
     102             :    *    @param cells
     103             :    */
     104             :   void allocateReceiveBuffers(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Macro_Container_T& cells);
     105             : 
     106             :   /** allocates the reduce receive buffers for the macroscopic solver. Since we do not
     107             :    * know anything about the macroscopic solver, we only have a list of global
     108             :    * vector cell indices available for possible cells to be received on this
     109             :    * rank. For each global cell which is in the list,
     110             :    * allocateReduceBufferForReceiving(...) of SendReceiveBuffer is called.
     111             :    *    @param dataExchange
     112             :    *    @param cells
     113             :    */
     114             :   template <class Container_T> void allocateReduceBufferForReceiving(coupling::sendrecv::DataExchangeFromMD2Macro<dim>& dataExchange, const Container_T& cells);
     115             : 
     116             :   /** reads information from the receive buffer and stores the result in the
     117             :    * list of coupling cells. Since this is a receive for the coupling
     118             :    * cells on the side of the macroscopic solver, we just have a list of global
     119             :    * cell indices and corresponding coupling cell buffers. For each cell in
     120             :    * this list, readFromReceiveBuffer(...) of SendReceiveBuffer is called.
     121             :    *    @param dataExchange
     122             :    *    @param cells
     123             :    */
     124             :   void readFromReceiveBuffer(coupling::sendrecv::DataExchange<Cell_T, dim>& dataExchange, const Macro_Container_T& cells);
     125             : 
     126             :   /** reads information from the reduce buffer and stores the result in the
     127             :    * list of coupling cells. Since this is a receive for the coupling
     128             :    * cells on the side of the macroscopic solver, we just have a list of global
     129             :    * cell indices and corresponding coupling cell buffers. For each cell in
     130             :    * this list, readFromReduceBuffer(...) of SendReceiveBuffer is called.
     131             :    *    @param dataExchange
     132             :    *    @param cells
     133             :    */
     134             :   template <class Container_T> void readFromReduceBuffer(coupling::sendrecv::DataExchangeFromMD2Macro<dim>& dataExchange, const Container_T& cells);
     135             : };
     136             : 
     137             : #include "FromMD2Macro.cpph"
     138             : 
     139             : #endif // _MOLECULARDYNAMICS_COUPLING_SENDRECV_MD2MACRO_H_