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 <functional>
7 : #include <map>
8 : #include <numeric>
9 : #include <sys/time.h>
10 :
11 : #include "coupling/filtering/interfaces/FilterInterface.h"
12 : #include "coupling/indexing/CellIndex.h"
13 : #include "tarch/configuration/ParseConfiguration.h"
14 :
15 : // INCLUDE ALL FILTER HEADERS HERE
16 : #include "coupling/filtering/filters/Constant.h"
17 : #include "coupling/filtering/filters/Gauss.h"
18 : #ifdef BUILD_WITH_EIGEN
19 : #include "coupling/filtering/filters/POD.h"
20 : #endif
21 : #include "coupling/filtering/filters/ReadFromFile.h"
22 : #include "coupling/filtering/filters/WriteToFile.h"
23 : /*
24 : #include "coupling/filtering/filters/Strouhal.h"
25 : */
26 : #include "coupling/filtering/filters/Copy.h"
27 : #include "coupling/filtering/filters/FilterFromFunction.h"
28 :
29 : #if (COUPLING_MD_PARALLEL == COUPLING_MD_YES)
30 : #include "coupling/filtering/SequentialFilter.h"
31 : #endif
32 :
33 : /*
34 : * Filter Sequences are used to group filters that will be applied in
35 : * chronological order. It is possible to customize
36 : * - sequence input
37 : * - filter parameters
38 : * - modifiablitiy of filter list
39 : * per Filter Sequence.
40 : *
41 : * A generalized version of this concept is FilterJunction.
42 : * @author Felix Maurer
43 : */
44 :
45 : namespace coupling {
46 : namespace filtering {
47 : template <unsigned int dim> class FilterSequence;
48 : }
49 : } // namespace coupling
50 :
51 : template <unsigned int dim> class coupling::filtering::FilterSequence {
52 : public:
53 : /*
54 : * Filter Sequences are constructed in
55 : * coupling::FilterPipeline::loadSequencesFromXML(...).
56 : */
57 0 : FilterSequence(const char* name, const std::vector<coupling::datastructures::CouplingCell<dim>*> inputCells,
58 : #if (COUPLING_MD_PARALLEL == COUPLING_MD_YES)
59 : MPI_Comm comm,
60 : #endif
61 : std::array<bool, 7> filteredValues = {true})
62 0 : : _name(name), _inputCellVector(inputCells),
63 : #if (COUPLING_MD_PARALLEL == COUPLING_MD_YES)
64 0 : _comm(comm),
65 : #endif
66 0 : _filteredValues(filteredValues), _isOutput(false), // potentially updated via loadSequencesFromXML
67 : // calling setAsOutput()
68 0 : _isModifiable(true), // TODO: allow const sequences via XML attribute
69 0 : _timestepsElapsed(0) {
70 : #ifdef DEBUG_FILTER_PIPELINE
71 : std::cout << PRINT_PREFIX() << "Now initializing." << std::endl;
72 : #endif
73 :
74 0 : initCellVectors();
75 :
76 0 : bool filtersAnything = false;
77 0 : for (unsigned int i = 0; i < 7; i++)
78 0 : if (_filteredValues[i]) {
79 : filtersAnything = true;
80 : break;
81 : }
82 0 : if (!filtersAnything)
83 : std::cout << "Warning: Filter sequence " << _name
84 0 : << " does not filter any values. Add 'filtered-values' "
85 : "attribute to XML element to change this."
86 0 : << std::endl;
87 : #ifdef DEBUG_FILTER_PIPELINE
88 : std::cout << PRINT_PREFIX() << "Finished initialization." << std::endl;
89 : #endif
90 0 : }
91 :
92 0 : virtual ~FilterSequence() {
93 : // Output average application times for all filters
94 : #ifdef DEBUG_FILTER_PIPELINE
95 : if (IDXS.getRank() == 0) {
96 : std::cout << PRINT_PREFIX() << "Average application times for filters in this sequence in \u03BCs:" << std::endl;
97 : for (auto filter : _filters) {
98 : std::cout << " " << filter->getType() << ": "
99 : << (double)std::accumulate(_filterTimes[filter].begin(), _filterTimes[filter].end(), 0) / (double)_timestepsElapsed << std::endl;
100 : }
101 : }
102 : #endif
103 :
104 0 : for (auto v1 : _cellVector1)
105 0 : delete v1;
106 0 : for (auto v2 : _cellVector2)
107 0 : delete v2;
108 0 : for (auto f : _filters)
109 0 : delete f;
110 : #ifdef DEBUG_FILTER_PIPELINE
111 : std::cout << PRINT_PREFIX() << "Deconstructed." << std::endl;
112 : #endif
113 0 : }
114 :
115 : /*
116 : * Each sequence operates on their own two copies of the md-to-macro domain.
117 : * Thus, before applying the sequence, we need to update these two copies.
118 : */
119 0 : void updateCellVectors() {
120 0 : for (unsigned int index = 0; index < _cellVector1.size(); index++) {
121 0 : *(_cellVector1[index]) = *(_inputCellVector[index]);
122 0 : *(_cellVector2[index]) = *(_inputCellVector[index]);
123 : }
124 0 : }
125 :
126 : /*
127 : * Applies all filters stored in _filters. Also measures performance times.
128 : */
129 0 : void operator()() {
130 0 : for (auto filter : _filters) {
131 : // measure time before application
132 : timeval before;
133 0 : gettimeofday(&before, NULL);
134 :
135 : // Apply the filter's operator()
136 0 : (*filter)();
137 :
138 : // measure time after application
139 : timeval after;
140 0 : gettimeofday(&after, NULL);
141 :
142 : // store time difference in usec in map
143 0 : _filterTimes[filter].push_back((after.tv_sec * 1000000 + after.tv_usec) - (before.tv_sec * 1000000 + before.tv_usec));
144 :
145 : #ifdef DEBUG_FILTER_PIPELINE
146 : std::cout << PRINT_PREFIX() << "Applied filter " << filter->getType() << ". Application time: " << _filterTimes[filter].back() << "\u03BCs" << std::endl;
147 : #endif
148 : }
149 0 : _timestepsElapsed++;
150 0 : }
151 :
152 : /*
153 : * Returns unique name identifier of this sequence.
154 : */
155 0 : const char* getName() { return _name; }
156 :
157 0 : bool isOutputToMacro() { return _isOutput; }
158 0 : void setAsOutputToMacro() {
159 : #ifdef DEBUG_FILTER_PIPELINE
160 : std::cout << PRINT_PREFIX() << " Setting as pipeline to macro solver output." << std::endl;
161 : #endif
162 0 : _isOutput = true;
163 0 : }
164 :
165 : /*
166 : * Modifiable sequences may have filters added dynamically via
167 : * FilterFromFunction.
168 : */
169 0 : bool isModifiable() { return _isModifiable; }
170 0 : void makeUnmodifiable() { _isModifiable = false; }
171 :
172 : std::vector<coupling::filtering::FilterInterface<dim>*> getFilters() { return _filters; }
173 :
174 : /*
175 : * All virtual functions below are redefined in case this sequence is actually
176 : * a FilterJunction. Read FilterJunction.h carefully.
177 : */
178 :
179 : /*
180 : * Interprets this sequence's filters' parameters (specified in
181 : * filter_pipeline.xml) and creates filter objects based on that. Since
182 : * different filters require vastly different parameters and thus different
183 : * means of instanciation, you need to add each new filter manually to this
184 : * method's "if/else-chain".
185 : *
186 : * Since after all filter objects are created it is possible to determine
187 : * whether _cellVector1 or _cellVector2 will be used as output, this is also
188 : * done in here.
189 : *
190 : * In addition to that, if this sequence is declared as unmodifibale, this
191 : * gets also detected in here.
192 : */
193 : virtual int loadFiltersFromXML(tinyxml2::XMLElement* sequenceNode);
194 :
195 : /*
196 : * This member function allows appendance and insertion of filters defined by
197 : * two processing functions to a modifiable sequence at runtime. Index -1
198 : * implies appending.
199 : */
200 : virtual void addFilter(
201 : const std::function<std::vector<double>(std::vector<double>, std::vector<std::array<unsigned int, dim>>)>* applyScalar,
202 : const std::function<std::vector<std::array<double, dim>>(std::vector<std::array<double, dim>>, std::vector<std::array<unsigned int, dim>>)>* applyVector,
203 : int filterIndex = -1);
204 :
205 : /*
206 : * Registers existence of a child sequence, i.e. a sequence using this
207 : * sequence's output as its input.
208 : */
209 0 : virtual void addChildSequence(coupling::filtering::FilterSequence<dim>* childSequence) { _childSequences.push_back(childSequence); }
210 :
211 : /*
212 : * Allows changing the input cells after init.
213 : */
214 0 : virtual void updateInputCellVector(const std::vector<coupling::datastructures::CouplingCell<dim>*> newInputCellVector) {
215 0 : _inputCellVector = newInputCellVector; // call copy constructor
216 :
217 : // cc this change to this sequence's first vector.
218 0 : if (!_filters.empty())
219 0 : _filters[0]->setInputCells(_inputCellVector);
220 0 : }
221 :
222 : /*
223 : * Which one of the two cell vectors are this sequence's output is solely
224 : * dependant on the number of filters the sequence contains, because each swap
225 : * (see loadFiltersFromXML) changes what is the sequence's final filter's
226 : * output.
227 : *
228 : * Some sequences have more than one output, thus the optional parameter. Has
229 : * no effect on a basic FilterSequence.
230 : */
231 0 : virtual const std::vector<coupling::datastructures::CouplingCell<dim>*>& getOutputCellVector(unsigned int outputIndex = 0) const {
232 0 : if (_filters.empty())
233 0 : return _inputCellVector;
234 :
235 0 : if (_filters.size() % 2 == 0)
236 0 : return _cellVector1;
237 :
238 0 : return _cellVector2;
239 : }
240 :
241 0 : virtual void printOutputCellVector() const {
242 0 : if (getOutputCellVector() == _inputCellVector)
243 0 : std::cout << "The sequence's input cell vector ";
244 0 : else if (getOutputCellVector() == _cellVector1)
245 0 : std::cout << "Cell vector 1 ";
246 0 : else if (getOutputCellVector() == _cellVector2)
247 0 : std::cout << "Cell vector 2 ";
248 : else { /*unreachable, see function definition above*/
249 : }
250 :
251 0 : std::cout << "will be used as output." << std::endl;
252 0 : }
253 :
254 : /*
255 : * This is trivial for the traditional sequence, i.e. non-Junction-case.
256 : */
257 0 : virtual unsigned int getNumInputs() { return 1; }
258 0 : virtual unsigned int getNumOutputs() { return 1; }
259 :
260 : /*
261 : * DUMMY HELPER FUNCTIONS
262 : */
263 :
264 0 : virtual void printFilters() {
265 0 : std::cout << "Filters in sequence " << _name << ": ";
266 0 : for (auto f : _filters)
267 0 : std::cout << f->getType() << " ";
268 0 : std::cout << std::endl;
269 0 : }
270 :
271 0 : virtual std::string PRINT_PREFIX() const { return std::string(" FS(").std::string::append(_name).std::string::append("): "); }
272 :
273 : private:
274 : /*
275 : * Copies all input cells to _cellVector1 and _cellVector2.
276 : *
277 : * Used in consctructor.
278 : *
279 : * Not implemented by FilterJunction: Equivalent procedure can be found in
280 : * that class' constructor.
281 : */
282 : void initCellVectors();
283 :
284 : protected:
285 : const char* _name;
286 :
287 : std::vector<coupling::datastructures::CouplingCell<dim>*> _inputCellVector; // points to (foreign) input vector
288 : std::vector<coupling::datastructures::CouplingCell<dim>*> _cellVector1; // allocated for this sequence only
289 : std::vector<coupling::datastructures::CouplingCell<dim>*> _cellVector2; // allocated for this sequence only
290 :
291 : #if (COUPLING_MD_PARALLEL == COUPLING_MD_YES)
292 : MPI_Comm _comm;
293 : #endif
294 :
295 : std::array<bool, 7> _filteredValues;
296 :
297 : bool _isOutput; // true if this sequence's output vector (see above) is the
298 : // Filter Pipeline's output
299 : bool _isModifiable; // true while filters can be added to sequence
300 :
301 : std::vector<coupling::filtering::FilterInterface<dim>*> _filters;
302 :
303 : // stores application times for all filters
304 : std::map<coupling::filtering::FilterInterface<dim>*, std::vector<unsigned int>> _filterTimes;
305 :
306 : // there must be some other place to get this from
307 : unsigned int _timestepsElapsed;
308 :
309 : // stores pointers to all sequences that use this sequence's output as their
310 : // input.
311 : std::vector<coupling::filtering::FilterSequence<dim>*> _childSequences;
312 : };
313 :
314 : // inlcude implementation
315 : #include "coupling/filtering/sequencing/FilterSequence.cpph"
|
