1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
|
/*
* Copyright (C) 2010-2015 Thorsten Liebig (Thorsten.Liebig@gmx.de)
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef PROCESSING_H
#define PROCESSING_H
#include <complex>
typedef std::complex<double> double_complex;
#define _I double_complex(0.0,1.0)
#include <iostream>
#include <fstream>
#include <cmath>
#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <string>
#include <vector>
#include "Common/engine_interface_base.h"
class Operator_Base;
class Processing
{
public:
virtual ~Processing();
enum MeshType { CARTESIAN_MESH, CYLINDRICAL_MESH};
//! Set the interface to the engine. Each processing needs its own engine interface. This class will take ownership and cleanup the interface on deletion!
void SetEngineInterface(Engine_Interface_Base* eng_if);
virtual void SetName(std::string val) {m_Name=val;}
virtual void SetName(std::string val, int number);
virtual std::string GetName() const {return m_Name;}
//! Get the name for this processing, will be used in file description.
virtual std::string GetProcessingName() const = 0;
virtual void InitProcess() {};
virtual void Reset();
virtual void DefineStartStopCoord(double* dstart, double* dstop);
virtual void ShowSnappedCoords();
void SetProcessInterval(unsigned int interval) {ProcessInterval=std::max((unsigned int)1,interval);}
void SetProcessStartStopTime(double start, double stop);
void AddStep(unsigned int step);
void AddSteps(std::vector<unsigned int> steps);
void AddFrequency(double freq);
void AddFrequency(std::vector<double> *freqs);
bool CheckTimestep();
//! Process data prior to the simulation run.
virtual void PreProcess() {};
//! Process data during simulation run.
virtual int Process() {return GetNextInterval();}
//! Process data after simulation has finished.
virtual void PostProcess();
//! If disabled, Process() will do nothing...
virtual void SetEnable(bool val) {Enabled=val;}
//! If disabled, Process() will do nothing...
virtual bool GetEnable() const {return Enabled;}
virtual void SetWeight(double weight) {m_weight=weight;}
virtual double GetWeight() {return m_weight;}
//! Invoke this flag to flush all stored data to disk
virtual void FlushNext() {m_Flush = true;}
virtual void FlushData() {};
void SetMeshType(MeshType meshType) {m_Mesh_Type=meshType;}
//! Set the dump precision
void SetPrecision(unsigned int val) {m_precision = val;}
//! Dump probe geometry to file (will obay main or dual mesh property)
virtual void DumpBox2File(std::string vtkfilenameprefix) const {DumpBox2File(vtkfilenameprefix,m_dualMesh);}
//! Dump probe geometry to file
virtual void DumpBox2File(std::string vtkfilenameprefix, bool dualMesh) const;
virtual void SetDualMesh(bool val) {m_dualMesh=val;}
virtual void SetDualTime(bool val) {m_dualTime=val;}
protected:
Processing(Engine_Interface_Base* eng_if);
Engine_Interface_Base* m_Eng_Interface;
const Operator_Base* Op;
MeshType m_Mesh_Type;
unsigned int m_precision;
std::string m_Name;
bool m_Flush;
double m_weight;
bool Enabled;
int GetNextInterval() const;
unsigned int ProcessInterval;
size_t m_PS_pos; //! current position in list of processing steps
std::vector<unsigned int> m_ProcessSteps; //! list of processing steps
//! Vector of frequency samples
std::vector<double> m_FD_Samples;
//! Number of samples already processed
unsigned int m_FD_SampleCount;
//! Sampling interval needed for the FD_Samples
unsigned int m_FD_Interval;
//! define if given coords are on main or dualMesh (default is false)
bool m_dualMesh;
//! define if given processing uses the dual time concept (default is false);
bool m_dualTime;
//! define the snap method used for this processing
int m_SnapMethod;
//! dimension of the snapped box
int m_Dimension;
//! define/store snapped start/stop coords as mesh index
unsigned int start[3];
unsigned int stop[3];
//! start/stop timestep
unsigned int startTS, stopTS;
//! define/store if snapped start/stop coords are inside the field domain
bool m_start_inside[3];
bool m_stop_inside[3];
std::ofstream file;
std::string m_filename;
virtual void OpenFile(std::string outfile);
};
class ProcessingArray
{
public:
ProcessingArray(unsigned int maximalInterval) {maxInterval=maximalInterval;}
~ProcessingArray() {};
void AddProcessing(Processing* proc);
void InitAll();
//! Invoke this flag to flush all stored data to disk for all processings on next Process()
void FlushNext();
void Reset();
//! Deletes all given processing's, can be helpful, but use carefull!!!
void DeleteAll();
//! Invoke PreProcess() on all Processings.
void PreProcess();
//! Invoke Process() on all Processings. Will return the smallest next iteration interval.
int Process();
//! Invoke PostProcess() on all Processings.
void PostProcess();
void DumpBoxes2File(std::string vtkfilenameprefix ) const;
size_t GetNumberOfProcessings() const {return ProcessArray.size();}
Processing* GetProcessing(size_t number) {return ProcessArray.at(number);}
protected:
unsigned int maxInterval;
std::vector<Processing*> ProcessArray;
};
#endif // PROCESSING_H
|
