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             : 
       7             : // #define DEBUG_FILTER_PIPELINE
       8             : #define POST_MULTI_INSTANCE_FILTERING_YES true
       9             : #define POST_MULTI_INSTANCE_FILTERING_NO false
      10             : 
      11             : // include dependencies
      12             : #include "coupling/filtering/sequencing/AsymmetricalFilterJunction.h"
      13             : #include "coupling/filtering/sequencing/FilterJunction.h"
      14             : #include "coupling/filtering/sequencing/FilterSequence.h"
      15             : #include "tarch/configuration/ParseConfiguration.h"
      16             : #include "tarch/tinyxml2/tinyxml2.h"
      17             : 
      18             : using tarch::configuration::ParseConfiguration;
      19             : 
      20             : namespace coupling {
      21             : namespace filtering {
      22             : template <class CellIndex_T, unsigned int dim> class FilterPipeline;
      23             : 
      24             : /*
      25             :  * Used as member of FilterPipeline. Displays where that FP is used.
      26             :  * per instance:                apply filtering for each MD instance
      27             :  * individually, before merging instances post multi instance:  apply filtering
      28             :  * after MD instances have been merged
      29             :  */
      30             : enum class Scope { perInstance, postMultiInstance };
      31             : } // namespace filtering
      32             : } // namespace coupling
      33             : 
      34             : /*
      35             :  * Manages different branches of filtering sequences.
      36             :  * These filtering sequences may be interdependant by using another's sequences
      37             :  * input or completely isolated. As this entire filtering process is applied
      38             :  * during MD to Macro communication, it uses the MD simulation's output
      39             :  * Macro-Cells as input and output. All configuration is made using an
      40             :  * XML-config file and does not require recompilation when modified.
      41             :  *
      42             :  * @author Felix Maurer
      43             :  */
      44             : template <class CellIndex_T, unsigned int dim> class coupling::filtering::FilterPipeline {
      45             : public:
      46             :   FilterPipeline(const coupling::datastructures::CellContainer<CellIndex_T, dim> inputCells, const coupling::filtering::Scope scope,
      47             :                  const tarch::utils::MultiMDService<dim>& multiMDService, const char* cfgpath);
      48             : 
      49           0 :   ~FilterPipeline() {
      50           0 :     for (auto sequence : _sequences)
      51           0 :       delete sequence;
      52             :       // TODO: do i have to delete the _...cells as well?
      53             : 
      54             : #ifdef DEBUG_FILTER_PIPELINE
      55             :     std::cout << "FP: FilterPipeline deconstructed." << std::endl;
      56             : #endif
      57           0 :   }
      58             : 
      59             :   /*
      60             :    * Applies each FilterSequence in order of their appearance in the config
      61             :    * file. Ouput of the specified output-FilterSequence will be written to
      62             :    * _md2MacroCells.
      63             :    *
      64             :    * @returns The runtime of the filter pipeline in usec.
      65             :    */
      66             :   double operator()();
      67             : 
      68             :   /*
      69             :    * Getters for FilterSequences.
      70             :    * Not that Junction is a subtype of Sequence, so this is how to get Junctions
      71             :    * as well.
      72             :    */
      73             :   coupling::filtering::FilterSequence<dim>* getSequence(const char* identifier) const;
      74             :   std::vector<coupling::filtering::FilterSequence<dim>*> getAllSequences() const { return _sequences; }
      75             : 
      76             : #if (COUPLING_MD_PARALLEL == COUPLING_MD_YES)
      77             :   /*
      78             :    * Get MPI communicator used by all parallel filters.
      79             :    */
      80             :   MPI_Comm getFilteringCommunicator() { return _comm; };
      81             : #endif
      82             : 
      83             : private:
      84             :   /*
      85             :    * Detects errors in XML config file.
      86             :    */
      87             :   bool configIsValid(ParseConfiguration::XMLConfiguration& xmlConfig);
      88             : 
      89             :   /*
      90             :    * Interprets configuration of sequences and intializes them. Parameters
      91             :    * known:
      92             :    *   -"input": Name of another FilterSequence previously defined (optional,
      93             :    * uses MD output (i.e. _md2MacroCells) by default)
      94             :    *
      95             :    * Also detects which sequence will be used as output to this FilterPipeline.
      96             :    */
      97             :   void loadSequencesFromXML(tinyxml2::XMLElement* metaNode);
      98             : 
      99             :   /*
     100             :    * Input cells within the local, md2macro, ghost layer excluding domain
     101             :    */
     102             :   std::vector<coupling::datastructures::CouplingCell<dim>*> _md2MacroCells;
     103             :   /*
     104             :    * Input cells that do not match the criteria to be in _md2MacroCells.
     105             :    */
     106             :   std::vector<coupling::datastructures::CouplingCell<dim>*> _outerCells;
     107             : 
     108             :   ParseConfiguration::XMLConfiguration _config;
     109             : 
     110             :   /*
     111             :    * Scope in which this FilterPipeline is applied. Cf. coupling::Scope
     112             :    * definition.
     113             :    */
     114             :   const coupling::filtering::Scope _scope;
     115             : 
     116             :   std::vector<coupling::filtering::FilterSequence<dim>*> _sequences;
     117             : 
     118             : #if (COUPLING_MD_PARALLEL == COUPLING_MD_YES)
     119             :   MPI_Comm _comm;
     120             : #endif
     121             : };
     122             : 
     123             : // include implementation of header
     124             : #include "FilterPipeline.cpph"