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_DATAEXCHANGE_H_
       6             : #define _MOLECULARDYNAMICS_COUPLING_SENDRECV_DATAEXCHANGE_H_
       7             : 
       8             : #include "coupling/datastructures/CouplingCell.h"
       9             : #include "tarch/la/Vector.h"
      10             : 
      11             : namespace coupling {
      12             : namespace sendrecv {
      13             : template <class Cell_T, unsigned int dim> class DataExchange;
      14             : }
      15             : } // namespace coupling
      16             : 
      17             : /** This class holds information on the data exchange between processes. In
      18             :  *contrast to the SendReceiveBuffer which solely handles the technical part of
      19             :  *sending and receiving, this class needs to guarantee the validity in
      20             :  *communication, e.g. make sure that each source rank matches to a target rank
      21             :  *etc.
      22             :  *      @brief generic class for the the data exchange purposes.
      23             :  *      @tparam CouplingCell cell type
      24             :  *      @tparam dim Number of dimensions; it can be 1, 2 or 3
      25             :  *  @author Philipp Neumann
      26             :  */
      27             : template <class Cell_T, unsigned int dim> class coupling::sendrecv::DataExchange {
      28             : public:
      29             :   /** Constructor: assign an tag (_tag) to the DataExchange.
      30             :    * @param tag
      31             :    */
      32           4 :   DataExchange(unsigned int tag) : _tag(tag) {}
      33             :   /** Destructor */
      34           0 :   virtual ~DataExchange() {}
      35             : 
      36             :   /** returns the tag associated to messages for this DataExchange. @return
      37             :    * _tag*/
      38           0 :   unsigned int getTag() const { return _tag; }
      39             : 
      40             :   /** returns the ranks to which a particular cell (at index idx)
      41             :    * should be sent. This method should globally define the target ranks for
      42             :    * each global cell index of a coupling cell.
      43             :    *    @param idx unique global cell index
      44             :    */
      45             :   virtual std::vector<unsigned int> getTargetRanks(I01 idx) = 0;
      46             : 
      47             :   /** returns all ranks from which a particular cell (at index idx)
      48             :    * is sent. This method should globally define the source ranks for each
      49             :    * global cell index of a coupling cell.
      50             :    * @param idx unique global cell index
      51             :    */
      52             :   virtual std::vector<unsigned int> getSourceRanks(I01 idx) = 0;
      53             : 
      54             :   /** local rule to read from a coupling cell and write data to (e.g. send)
      55             :    * buffer
      56             :    *    @param buffer
      57             :    *    @param cell
      58             :    */
      59             :   virtual void readFromCell(double* const buffer, const Cell_T& cell) = 0;
      60             : 
      61             :   /** local rule to read from receive buffer and write data to coupling cell
      62             :    *    @param buffer
      63             :    *    @param cell
      64             :    */
      65             :   virtual void writeToCell(const double* const buffer, Cell_T& cell) = 0;
      66             : 
      67             :   /** returns the number of doubles that are sent per coupling cell. */
      68             :   virtual unsigned int getDoublesPerCell() const = 0;
      69             : 
      70             : private:
      71             :   /** tag to uniquely determine these kinds of messages that are sent between
      72             :    * processes. */
      73             :   const unsigned int _tag;
      74             : };
      75             : 
      76             : #endif // _MOLECULARDYNAMICS_COUPLING_SENDRECV_DATAEXCHANGE_H_