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_INTERFACE_MACROSCOPICSOLVERINTERFACE_H_
       6              : #define _MOLECULARDYNAMICS_COUPLING_INTERFACE_MACROSCOPICSOLVERINTERFACE_H_
       7              : 
       8              : #include "coupling/CouplingMDDefinitions.h"
       9              : #include "tarch/la/Vector.h"
      10              : #include <vector>
      11              : 
      12              : namespace coupling {
      13              : namespace interface {
      14              : template <unsigned int dim> class MacroscopicSolverInterface;
      15              : }
      16              : } // namespace coupling
      17              : 
      18              : /** This class provides
      19              :  *      @brief interface for the macroscopic, i.e. continuum solver
      20              :  *      @tparam dim Number of dimensions; it can be 1, 2 or 3
      21              :  *  @author Philipp Neumann
      22              :  */
      23              : template <unsigned int dim> class coupling::interface::MacroscopicSolverInterface {
      24              : 
      25              : public:
      26              :   /** Costructor */
      27            4 :   MacroscopicSolverInterface() {}
      28              :   /** Destructor */
      29            0 :   virtual ~MacroscopicSolverInterface() {}
      30              : 
      31              :   /* This function defines an offset of cells which is considered to be the outer region.
      32              :    * It replaces the legacy functions 'receiveMacroscopicQuantityFromMDSolver' and 'sendMacroscopicQuantityToMDSolver'
      33              :    * from older versions of MaMiCo. Data are sent to MD solver for cells that are not in the ghost layer
      34              :    * and not part of the inner region. Data needs so be send from micro to macro solver for all inner cells.
      35              :    *  @return number of cells in outer region per direction at each boundary, e.g. 3
      36              :    */
      37              :   virtual unsigned int getOuterRegion() = 0;
      38              : 
      39              :   /** This function determines all the ranks on which the macroscopic solver
      40              :    *holds data of the coupling cell at index idx. By default,
      41              :    *this method is used for send/recv operations. However, there are situations
      42              :    *where the target and source rank definitions (target rank=rank of
      43              :    *macroscopic solver that shall receive data from MD; source rank=rank of
      44              :    *macroscopic solver that shall send data to MD) may differ. For example,
      45              :    *assume a domain decomposition using ghost layers. You may want to send data
      46              :    *from cells inside a process-local domain and want to receive data in all
      47              :    *copies of a given coupling cell (incl. ghost cells), but you may not be
      48              :    *able to provide valid data on every process for each cell instance (e.g., if
      49              :    *this cell is part of a ghost layer). For this case, the method
      50              :    *getSourceRanks() and getTargetRanks() can be implemented accordingly.
      51              :    *    @param idx
      52              :    *    @return all the ranks on which the macroscopic solver holds data of the
      53              :    *coupling cell at index idx.
      54              :    */
      55              :   virtual std::vector<unsigned int> getRanks(I01 idx) = 0;
      56              : 
      57              :   /** This function determines the source ranks for the global coupling cell
      58              :    *at index idx. A "source rank" is defined as a rank of the
      59              :    *macroscopic solver that provides a valid copy of the cell at idx
      60              :    *to the coupling tool. You may have multiple source ranks; however, each
      61              :    *source rank should hold a valid copy. Default: return all ranks that the
      62              :    *cell at idx is associated to.
      63              :    *    @param idx
      64              :    *    @return the source ranks for the global coupling cell at index
      65              :    *idx.
      66              :    */
      67            0 :   virtual std::vector<unsigned int> getSourceRanks(I01 idx) { return getRanks(idx); }
      68              : 
      69              :   /** This function determines the target ranks for the global coupling cell
      70              :    *at index idx. A "target rank" is defined as a rank of the
      71              :    *macroscopic solver that obtains a valid copy of the cell at idx
      72              :    *from the coupling tool. You may have multiple target ranks. Default: return
      73              :    *all ranks that the cell at idx is associated to.
      74              :    *    @param idx
      75              :    *    @return the target ranks for the global coupling cell at index
      76              :    *idx
      77              :    */
      78            0 :   virtual std::vector<unsigned int> getTargetRanks(I01 idx) { return getRanks(idx); }
      79              : };
      80              : #endif // _MOLECULARDYNAMICS_COUPLING_INTERFACE_MACROSCOPICSOLVERINTERFACE_H_