Line data    Source code

       1             : // This file is part of the Mamico project. For conditions of distribution
       2             : // and use, please see the copyright notice in Mamico's main folder, or at
       3             : // www5.in.tum.de/mamico
       4             : 
       5             : #pragma once
       6             : #include "coupling/CouplingMDDefinitions.h"
       7             : #include "coupling/filtering/interfaces/FilterInterface.h"
       8             : #include "coupling/indexing/IndexingService.h"
       9             : #include <mpi.h>
      10             : 
      11             : #define FILTER_SEQUENTIAL true
      12             : #define FILTER_PARALLEL false
      13             : 
      14             : // #define DEBUG_SEQ_FILTER
      15             : // #define DEBUG_SEQ_FILTER_VERBOSE
      16             : 
      17             : namespace coupling {
      18             : namespace filtering {
      19             : template <unsigned int dim> class SequentialFilter;
      20             : }
      21             : } // namespace coupling
      22             : 
      23             : /*
      24             :  * Implementation of FilterInterface.h for filters which operate in a sequential
      25             :  * manner, i.e. process data on one master rank. For such filters, operator()()
      26             :  * will
      27             :  *              - contribute to one dedicated processing rank: by calling
      28             :  * contribute()
      29             :  *              - process on master rank only and then scatter data correctly:
      30             :  * by calling process()
      31             :  *
      32             :  * Meant to be used as a wrapper class, i.e. take a pointer to a filter object
      33             :  * and then sequentualizes it. Used in
      34             :  * coupling::FilterSequence<dim>::loadFiltersFromXML.
      35             :  *
      36             :  * Disclaimer: Sequential filters be added to a sequence via XML only. This
      37             :  * implies FFF with e.g. a python function is not compatible.
      38             :  *
      39             :  * @author Felix Maurer
      40             :  */
      41             : template <unsigned int dim> class coupling::filtering::SequentialFilter : public coupling::filtering::FilterInterface<dim> {
      42             : public:
      43             :   SequentialFilter(coupling::filtering::FilterInterface<dim>* filter, const MPI_Comm comm);
      44             : 
      45           0 :   ~SequentialFilter() {
      46           0 :     delete _filter;
      47           0 :     for (auto cell : _inputCells_Global)
      48           0 :       delete cell;
      49           0 :     for (auto cell : _outputCells_Global)
      50           0 :       delete cell;
      51           0 :   }
      52             : 
      53             :   /*
      54             :    * Implements FilterInterface's requirement of having a ()-operand defined.
      55             :    */
      56             :   virtual void operator()();
      57             : 
      58             : private:
      59             :   /*
      60             :    * When sequentialized, all ranks call this function.
      61             :    */
      62             :   virtual void contribute();
      63             : 
      64             :   /*
      65             :    * When sequentialized, only the processing rank calls this function. It acts
      66             :    * as a wrapper of _filter's operator() member function.
      67             :    */
      68             :   virtual void process(bool sequential);
      69             : 
      70             :   /*
      71             :    * Auxilliary functions providing an interface between low-level double
      72             :    * buffers used by MPI and Coupling Cells.
      73             :    */
      74             :   void couplingCellToBuffer(std::vector<double>& buf, const coupling::datastructures::CouplingCell<dim>* cell);
      75             : 
      76             :   void bufferToCouplingCell(const std::vector<double>& buf, coupling::datastructures::CouplingCell<dim>* cell);
      77             : 
      78             :   // The sequentialized Filter
      79             :   coupling::filtering::FilterInterface<dim>* _filter;
      80             : 
      81             :   // MPI related stuff
      82             :   const MPI_Comm _comm;
      83             :   int _commSize;
      84             :   int _processingRank;
      85             :   int _myRank;
      86             : 
      87             :   // Globalized variants of cell data structures (i.e spanning across all cells
      88             :   // of the global domain). Only the master rank uses these.
      89             :   std::vector<coupling::datastructures::CouplingCell<dim>*> _inputCells_Global;
      90             :   std::vector<coupling::datastructures::CouplingCell<dim>*> _outputCells_Global;
      91             : 
      92             :   // Used by the processing rank to remember from which rank it received cells
      93             :   // located at which global index TODO: use CellIndex?
      94             :   std::vector<unsigned int> _cellRanks;
      95             : 
      96             :   // Buffers coupling cells for MPI communication
      97             :   std::vector<double> _cellbuf;
      98             : 
      99             :   // Used by the processing rank to remember its local domain
     100             :   std::vector<coupling::datastructures::CouplingCell<dim>*> _inputCells_Local;
     101             :   std::vector<coupling::datastructures::CouplingCell<dim>*> _outputCells_Local;
     102             : };
     103             : 
     104             : #include "SequentialFilter.cpph"