FilterInterface.h

// This file is part of the Mamico project. For conditions of distribution
// and use, please see the copyright notice in Mamico's main folder, or at
// www5.in.tum.de/mamico
 
#pragma once
#include <array>
#include <vector>
 
#include "coupling/indexing/CellIndex.h"
 
// #define DEBUG_FILTER_INTERFACE
 
namespace coupling {
namespace filtering {
template <unsigned int dim> class FilterInterface;
}
} // namespace coupling

template <unsigned int dim> class coupling::filtering::FilterInterface {
public:
  /*
   * Filter constructors are called during instanciation of their corresponding
   * FilterSequence. You can customize parameterization in
   * coupling::FilterSequence::loadFiltersFromXML(...).
   */
  FilterInterface(const std::vector<coupling::datastructures::CouplingCell<dim>*>& inputCellVector,
                  const std::vector<coupling::datastructures::CouplingCell<dim>*>& outputCellVector, const std::array<bool, 7> filteredValues, const char* type)
      :
 
        _inputCells(inputCellVector), _outputCells(outputCellVector), _type(type) {
    // microscopic mass
    if (filteredValues[0]) {
      _scalarAccessFunctionPairs.push_back(
          {&coupling::datastructures::CouplingCell<dim>::getMicroscopicMass, &coupling::datastructures::CouplingCell<dim>::setMicroscopicMass});
    }
    // microscopic momentum
    if (filteredValues[1]) {
      _vectorAccessFunctionPairs.push_back(
          {&coupling::datastructures::CouplingCell<dim>::getMicroscopicMomentum, &coupling::datastructures::CouplingCell<dim>::setMicroscopicMomentum});
    }
    // macroscopic mass
    if (filteredValues[2]) {
      _scalarAccessFunctionPairs.push_back(
          {&coupling::datastructures::CouplingCell<dim>::getMacroscopicMass, &coupling::datastructures::CouplingCell<dim>::setMacroscopicMass});
    }
    // macroscopic momentum
    if (filteredValues[3]) {
      _vectorAccessFunctionPairs.push_back(
          {&coupling::datastructures::CouplingCell<dim>::getMacroscopicMomentum, &coupling::datastructures::CouplingCell<dim>::setMacroscopicMomentum});
    }
    // potential energy
    if (filteredValues[4]) {
      _scalarAccessFunctionPairs.push_back(
          {&coupling::datastructures::CouplingCell<dim>::getPotentialEnergy, &coupling::datastructures::CouplingCell<dim>::setPotentialEnergy});
    }
    // velocity
    if (filteredValues[5]) {
      _vectorAccessFunctionPairs.push_back(
          {&coupling::datastructures::CouplingCell<dim>::getCurrentVelocity, &coupling::datastructures::CouplingCell<dim>::setCurrentVelocity});
    }
    // temperature
    if (filteredValues[6]) {
      _scalarAccessFunctionPairs.push_back(
          {&coupling::datastructures::CouplingCell<dim>::getTemperature, &coupling::datastructures::CouplingCell<dim>::setTemperature});
    }
  }
 
  FilterInterface(const char* type)
      : _type(type) { /* Used by incomplete implementations of FilterInterface.
                         Should be redesigned via meta class.*/
  }
 
  virtual ~FilterInterface() {};
 
  /*
   * Applies the filter to all cells that are within the filter's sequence's
   * domain.
   *
   * It is very important that this method provides complete output data,
   * i.e uses all elements of _scalarSetters and _vectorSetters on all elements
   * of _outputCells. If this is not the case, you dont want to use this
   * interface, but rather coupling::FilterInterfaceReadOnly and use its method
   * copyInputToOutput().
   */
  virtual void operator()() = 0;
 
  void updateCellData(const std::vector<coupling::datastructures::CouplingCell<dim>*>& new_inputCells,
                      const std::vector<coupling::datastructures::CouplingCell<dim>*>& new_outputCells) {
    if (new_inputCells.size() != new_outputCells.size())
      throw std::runtime_error("New input-, output-, and indexing vectors must "
                               "be of identical size.");
 
    _inputCells = new_inputCells;
    _outputCells = new_outputCells;
 
#ifdef DEBUG_FILTER_INTERFACE
    std::cout << "      FI: Updated cell data." << std::endl;
#endif
  }
 
  /*
   * Basic Getters/Setters
   */
  const char* getType() const { return _type; }
  std::vector<coupling::datastructures::CouplingCell<dim>*> getInputCells() const { return _inputCells; }
  std::vector<coupling::datastructures::CouplingCell<dim>*> getOutputCells() const { return _outputCells; }
 
  using CellIndex_T = coupling::indexing::CellIndex<dim, coupling::indexing::IndexTrait::local, coupling::indexing::IndexTrait::md2macro,
                                                    coupling::indexing::IndexTrait::noGhost>;
  /*
   * Advanced Getters/Setters
   */
  coupling::datastructures::CouplingCell<dim>* getInputCellOfIndex(const CellIndex_T& index) {
    if (index.get() < _inputCells.size) {
      return _inputCells[index.get()];
    } else {
      std::cout << "Index not found: " << index << std::endl;
      throw std::runtime_error("FilterInterface: getInputCellofIndex(): Could not find index.");
    }
  }
  coupling::datastructures::CouplingCell<dim>* getOutputCellOfIndex(const CellIndex_T& index) {
    if (index.get() < _outputCells.size) {
      return _outputCells[index.get()];
    } else {
      std::cout << "Index not found: " << index << std::endl;
      throw std::runtime_error("FilterInterface: getOutputCellofIndex(): Could not find index.");
    }
  }
 
  /*
   * Only used in one scenario:
   *  - this is at index 0 in FS
   *  - new filter gets dynamically linked into FS at index 0
   * In that case, this was previously getting input from MD but won't be any
   * longer. The newly added filter will provide input for this one instead.
   */
  void setInputCells(const std::vector<coupling::datastructures::CouplingCell<dim>*>& newInputCells) { _inputCells = newInputCells; }
 
  // Size = number of cells in this filter.
  int getSize() const { return _inputCells.size(); }
 
  /*
   * Used by filter implementations to iterate over physical properties stored
   * in a CouplingCell.
   *
   * Examplary usage:
   * 'for(auto scalar : _scalarAccessFunctionPairs)' loops over all scalar
   * properties (e.g. macro/micro mass, temperate) filtered by this specific
   * filter.
   */
  struct ScalarAccessFunctionPair {
    const double& (coupling::datastructures::CouplingCell<dim>::*get)() const; // getter function pointer
    void (coupling::datastructures::CouplingCell<dim>::*set)(const double&);   // setter function pointer
  };
  struct VectorAccessFunctionPair {
    const tarch::la::Vector<dim, double>& (coupling::datastructures::CouplingCell<dim>::*get)() const;
    void (coupling::datastructures::CouplingCell<dim>::*set)(const tarch::la::Vector<dim, double>&);
  };
 
protected:
  std::vector<coupling::datastructures::CouplingCell<dim>*> _inputCells;
  std::vector<coupling::datastructures::CouplingCell<dim>*> _outputCells;
 
  // scalars getters/setters
  std::vector<ScalarAccessFunctionPair> _scalarAccessFunctionPairs;
 
  // vectors getters/setters
  std::vector<VectorAccessFunctionPair> _vectorAccessFunctionPairs;
 
  // unique identifier per filter class
  const char* _type;
};