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 <array>
7 : #include <vector>
8 :
9 : #include "coupling/indexing/CellIndex.h"
10 :
11 : // #define DEBUG_FILTER_INTERFACE
12 :
13 : namespace coupling {
14 : namespace filtering {
15 : template <unsigned int dim> class FilterInterface;
16 : }
17 : } // namespace coupling
18 :
19 : /**
20 : * Generic interface for filters that are to be applied to
21 : * coupling::CellContainer before MD to Macro transfer. Implementations can
22 : * be found in coupling/filtering/filters.
23 : *
24 : * If you wish to use a filter that does not alter its input data, i.e that is
25 : * read-only, you want to use coupling::FilterInterfaceReadOnly<dim> instead (as
26 : * provided in header file coupling/filtering/FilterPipelineReadOnly.h).
27 : * Examples for such filters are WriteToFile or Strouhal (in
28 : * coupling/filtering/filters).
29 : *
30 : * @author Felix Maurer
31 : */
32 : template <unsigned int dim> class coupling::filtering::FilterInterface {
33 : public:
34 : /*
35 : * Filter constructors are called during instanciation of their corresponding
36 : * FilterSequence. You can customize parameterization in
37 : * coupling::FilterSequence::loadFiltersFromXML(...).
38 : */
39 0 : FilterInterface(const std::vector<coupling::datastructures::CouplingCell<dim>*>& inputCellVector,
40 : const std::vector<coupling::datastructures::CouplingCell<dim>*>& outputCellVector, const std::array<bool, 7> filteredValues, const char* type)
41 : :
42 :
43 0 : _inputCells(inputCellVector), _outputCells(outputCellVector), _type(type) {
44 : // microscopic mass
45 0 : if (filteredValues[0]) {
46 0 : _scalarAccessFunctionPairs.push_back(
47 : {&coupling::datastructures::CouplingCell<dim>::getMicroscopicMass, &coupling::datastructures::CouplingCell<dim>::setMicroscopicMass});
48 : }
49 : // microscopic momentum
50 0 : if (filteredValues[1]) {
51 0 : _vectorAccessFunctionPairs.push_back(
52 : {&coupling::datastructures::CouplingCell<dim>::getMicroscopicMomentum, &coupling::datastructures::CouplingCell<dim>::setMicroscopicMomentum});
53 : }
54 : // macroscopic mass
55 0 : if (filteredValues[2]) {
56 0 : _scalarAccessFunctionPairs.push_back(
57 : {&coupling::datastructures::CouplingCell<dim>::getMacroscopicMass, &coupling::datastructures::CouplingCell<dim>::setMacroscopicMass});
58 : }
59 : // macroscopic momentum
60 0 : if (filteredValues[3]) {
61 0 : _vectorAccessFunctionPairs.push_back(
62 : {&coupling::datastructures::CouplingCell<dim>::getMacroscopicMomentum, &coupling::datastructures::CouplingCell<dim>::setMacroscopicMomentum});
63 : }
64 : // potential energy
65 0 : if (filteredValues[4]) {
66 0 : _scalarAccessFunctionPairs.push_back(
67 : {&coupling::datastructures::CouplingCell<dim>::getPotentialEnergy, &coupling::datastructures::CouplingCell<dim>::setPotentialEnergy});
68 : }
69 : // velocity
70 0 : if (filteredValues[5]) {
71 0 : _vectorAccessFunctionPairs.push_back(
72 : {&coupling::datastructures::CouplingCell<dim>::getCurrentVelocity, &coupling::datastructures::CouplingCell<dim>::setCurrentVelocity});
73 : }
74 : // temperature
75 0 : if (filteredValues[6]) {
76 0 : _scalarAccessFunctionPairs.push_back(
77 : {&coupling::datastructures::CouplingCell<dim>::getTemperature, &coupling::datastructures::CouplingCell<dim>::setTemperature});
78 : }
79 0 : }
80 :
81 0 : FilterInterface(const char* type)
82 0 : : _type(type) { /* Used by incomplete implementations of FilterInterface.
83 : Should be redesigned via meta class.*/
84 : }
85 :
86 0 : virtual ~FilterInterface() {};
87 :
88 : /*
89 : * Applies the filter to all cells that are within the filter's sequence's
90 : * domain.
91 : *
92 : * It is very important that this method provides complete output data,
93 : * i.e uses all elements of _scalarSetters and _vectorSetters on all elements
94 : * of _outputCells. If this is not the case, you dont want to use this
95 : * interface, but rather coupling::FilterInterfaceReadOnly and use its method
96 : * copyInputToOutput().
97 : */
98 : virtual void operator()() = 0;
99 :
100 0 : void updateCellData(const std::vector<coupling::datastructures::CouplingCell<dim>*>& new_inputCells,
101 : const std::vector<coupling::datastructures::CouplingCell<dim>*>& new_outputCells) {
102 0 : if (new_inputCells.size() != new_outputCells.size())
103 0 : throw std::runtime_error("New input-, output-, and indexing vectors must "
104 : "be of identical size.");
105 :
106 0 : _inputCells = new_inputCells;
107 0 : _outputCells = new_outputCells;
108 :
109 : #ifdef DEBUG_FILTER_INTERFACE
110 : std::cout << " FI: Updated cell data." << std::endl;
111 : #endif
112 0 : }
113 :
114 : /*
115 : * Basic Getters/Setters
116 : */
117 0 : const char* getType() const { return _type; }
118 0 : std::vector<coupling::datastructures::CouplingCell<dim>*> getInputCells() const { return _inputCells; }
119 0 : std::vector<coupling::datastructures::CouplingCell<dim>*> getOutputCells() const { return _outputCells; }
120 :
121 : using CellIndex_T = coupling::indexing::CellIndex<dim, coupling::indexing::IndexTrait::local, coupling::indexing::IndexTrait::md2macro,
122 : coupling::indexing::IndexTrait::noGhost>;
123 : /*
124 : * Advanced Getters/Setters
125 : */
126 : coupling::datastructures::CouplingCell<dim>* getInputCellOfIndex(const CellIndex_T& index) {
127 : if (index.get() < _inputCells.size) {
128 : return _inputCells[index.get()];
129 : } else {
130 : std::cout << "Index not found: " << index << std::endl;
131 : throw std::runtime_error("FilterInterface: getInputCellofIndex(): Could not find index.");
132 : }
133 : }
134 : coupling::datastructures::CouplingCell<dim>* getOutputCellOfIndex(const CellIndex_T& index) {
135 : if (index.get() < _outputCells.size) {
136 : return _outputCells[index.get()];
137 : } else {
138 : std::cout << "Index not found: " << index << std::endl;
139 : throw std::runtime_error("FilterInterface: getOutputCellofIndex(): Could not find index.");
140 : }
141 : }
142 :
143 : /*
144 : * Only used in one scenario:
145 : * - this is at index 0 in FS
146 : * - new filter gets dynamically linked into FS at index 0
147 : * In that case, this was previously getting input from MD but won't be any
148 : * longer. The newly added filter will provide input for this one instead.
149 : */
150 0 : void setInputCells(const std::vector<coupling::datastructures::CouplingCell<dim>*>& newInputCells) { _inputCells = newInputCells; }
151 :
152 : // Size = number of cells in this filter.
153 : int getSize() const { return _inputCells.size(); }
154 :
155 : /*
156 : * Used by filter implementations to iterate over physical properties stored
157 : * in a CouplingCell.
158 : *
159 : * Examplary usage:
160 : * 'for(auto scalar : _scalarAccessFunctionPairs)' loops over all scalar
161 : * properties (e.g. macro/micro mass, temperate) filtered by this specific
162 : * filter.
163 : */
164 : struct ScalarAccessFunctionPair {
165 : const double& (coupling::datastructures::CouplingCell<dim>::*get)() const; // getter function pointer
166 : void (coupling::datastructures::CouplingCell<dim>::*set)(const double&); // setter function pointer
167 : };
168 : struct VectorAccessFunctionPair {
169 : const tarch::la::Vector<dim, double>& (coupling::datastructures::CouplingCell<dim>::*get)() const;
170 : void (coupling::datastructures::CouplingCell<dim>::*set)(const tarch::la::Vector<dim, double>&);
171 : };
172 :
173 : protected:
174 : /**
175 : * Filters should read from input vector and write to output vector.
176 : * Both vectors use the same indexing by default.
177 : * All unmodified cells of the output vector are implicitly copied from
178 : *their respective input counterpart, i.e it is not mandatory to have any
179 : *output.
180 : */
181 : std::vector<coupling::datastructures::CouplingCell<dim>*> _inputCells;
182 : std::vector<coupling::datastructures::CouplingCell<dim>*> _outputCells;
183 :
184 : // scalars getters/setters
185 : std::vector<ScalarAccessFunctionPair> _scalarAccessFunctionPairs;
186 :
187 : // vectors getters/setters
188 : std::vector<VectorAccessFunctionPair> _vectorAccessFunctionPairs;
189 :
190 : // unique identifier per filter class
191 : const char* _type;
192 : };
|
