v0.15.0
Loading...
Searching...
No Matches
Namespaces | Macros
SeriesRecorder.cpp File Reference

Record and save data series in time or load steps. More...

Go to the source code of this file.

Namespaces

namespace  MoFEM
 implementation of Data Operators for Forces and Sources
 

Macros

#define SeriesRecorderFunctionBegin
 

Detailed Description

Record and save data series in time or load steps.

Definition in file SeriesRecorder.cpp.

Macro Definition Documentation

◆ SeriesRecorderFunctionBegin

#define SeriesRecorderFunctionBegin
Value:
MoFEMFunctionBegin; \
MOFEM_LOG_CHANNEL("WORLD"); \
MOFEM_LOG_CHANNEL("SYNC"); \
MOFEM_LOG_FUNCTION(); \
MOFEM_LOG_TAG("SYNC", "SeriesRecorder"); \
MOFEM_LOG_TAG("WORLD", "SeriesRecorder")
MoFEMFunctionBegin
#define MoFEMFunctionBegin
First executable line of each MoFEM function, used for error handling. Final line of MoFEM functions ...
Definition definitions.h:359

Definition at line 6 of file SeriesRecorder.cpp.

13 {
14
15// const static int debug = 1;
16
17MoFEMErrorCode
18SeriesRecorder::query_interface(boost::typeindex::type_index type_index,
19 UnknownInterface **iface) const {
20 *iface = const_cast<SeriesRecorder *>(this);
21 return 0;
22}
23
24SeriesRecorder::SeriesRecorder(const Core &core)
25 : cOre(const_cast<Core &>(core)) {}
26
27MoFEMErrorCode SeriesRecorder::getTags(int verb) {
28
29 Interface &m_field = cOre;
30 moab::Interface &moab = m_field.get_moab();
31 MoFEMFunctionBegin;
32 const int def_val_len = 0;
33 CHKERR moab.tag_get_handle(
34 "_SeriesName", def_val_len, MB_TYPE_OPAQUE, th_SeriesName,
35 MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
36 MoFEMFunctionReturn(0);
37}
38
39MoFEMErrorCode SeriesRecorder::clearMap() {
40 MoFEMFunctionBegin;
41 sEries.clear();
42 seriesSteps.clear();
43 MoFEMFunctionReturn(0);
44}
45
46MoFEMErrorCode SeriesRecorder::initialiseDatabaseFromMesh(int verb) {
47 Interface &m_field = cOre;
48 moab::Interface &moab = m_field.get_moab();
49 SeriesRecorderFunctionBegin;
50 Range meshsets;
51 const int def_val_len = 0;
52 CHKERR moab.tag_get_handle(
53 "_SeriesName", def_val_len, MB_TYPE_OPAQUE, th_SeriesName,
54 MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
55
56 CHKERR moab.get_entities_by_type(0, MBENTITYSET, meshsets, false);
57 for (Range::iterator mit = meshsets.begin(); mit != meshsets.end(); mit++) {
58 const void *tagName;
59 int tagNameSize;
60 rval = moab.tag_get_by_ptr(th_SeriesName, &*mit, 1, (const void **)&tagName,
61 &tagNameSize);
62 if (rval == MB_SUCCESS) {
63 std::pair<Series_multiIndex::iterator, bool> p =
64 sEries.insert(FieldSeries(moab, *mit));
65 if (verb > QUIET)
66 MOFEM_LOG("SYNC", Sev::inform) << "read series " << *p.first;
67 }
68 }
69 // //build series steps
70 for (Series_multiIndex::iterator sit = sEries.begin(); sit != sEries.end();
71 sit++) {
72 int nb_steps;
73 CHKERR sit->get_nb_steps(moab, nb_steps);
74 int ss = 0;
75 for (; ss < nb_steps; ss++) {
76 std::pair<SeriesStep_multiIndex::iterator, bool> p =
77 seriesSteps.insert(FieldSeriesStep(moab, &*sit, ss));
78 if (verb > QUIET)
79 MOFEM_LOG("SYNC", Sev::inform) << "add series step " << *p.first;
80 }
81 }
82 MOFEM_LOG_CHANNEL("WORLD");
83 MOFEM_LOG_CHANNEL("SYNC");
84 MOFEM_LOG_CHANNEL("SELF");
85 MoFEMFunctionReturn(0);
86}
87
88MoFEMErrorCode
89SeriesRecorder::add_series_recorder(const std::string &series_name) {
90
91 Interface &m_field = cOre;
92 moab::Interface &moab = m_field.get_moab();
93 MoFEMFunctionBegin;
94 EntityHandle meshset;
95 CHKERR moab.create_meshset(MESHSET_SET, meshset);
96 void const *tag_data[] = {series_name.c_str()};
97 int tag_sizes[1];
98 tag_sizes[0] = series_name.size();
99 CHKERR moab.tag_set_by_ptr(th_SeriesName, &meshset, 1, tag_data, tag_sizes);
100 std::pair<Series_multiIndex::iterator, bool> p =
101 sEries.insert(FieldSeries(moab, meshset));
102 if (!p.second) {
103 SETERRQ(PETSC_COMM_SELF, 1, "series recorder <%s> is already there",
104 series_name.c_str());
105 }
106 MoFEMFunctionReturn(0);
107}
108
109MoFEMErrorCode
110SeriesRecorder::delete_recorder_series(const std::string &series_name) {
111
112 Interface &m_field = cOre;
113 moab::Interface &moab = m_field.get_moab();
114 MoFEMFunctionBegin;
115 SeriesStep_multiIndex::index<SeriesName_mi_tag>::type::iterator ssit, hi_ssit;
116 ssit = seriesSteps.get<SeriesName_mi_tag>().lower_bound(series_name);
117 hi_ssit = seriesSteps.get<SeriesName_mi_tag>().upper_bound(series_name);
118 seriesSteps.get<SeriesName_mi_tag>().erase(ssit, hi_ssit);
119 Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit;
120 sit = sEries.get<SeriesName_mi_tag>().find(series_name);
121 if (sit == sEries.get<SeriesName_mi_tag>().end()) {
122 SETERRQ(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
123 "series recorder <%s> not exist and can be deleted",
124 series_name.c_str());
125 }
126 EntityHandle series_meshset = sit->getMeshset();
127 CHKERR moab.tag_delete(sit->th_SeriesTime);
128 CHKERR moab.tag_delete(sit->th_SeriesDataHandles);
129 CHKERR moab.tag_delete(sit->th_SeriesDataUIDs);
130 CHKERR moab.tag_delete(sit->th_SeriesData);
131 sEries.get<SeriesName_mi_tag>().erase(sit);
132 std::vector<EntityHandle> contained;
133 CHKERR moab.get_contained_meshsets(series_meshset, contained);
134 CHKERR moab.remove_entities(series_meshset, &contained[0], contained.size());
135 CHKERR moab.delete_entities(&contained[0], contained.size());
136 CHKERR moab.delete_entities(&series_meshset, 1);
137 MoFEMFunctionReturn(0);
138}
139
140MoFEMErrorCode SeriesRecorder::record_problem(const std::string &serie_name,
141 const Problem *problemPtr,
142 RowColData rc) {
143 MoFEMFunctionBegin;
144
145 Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
146 sEries.get<SeriesName_mi_tag>().find(serie_name);
147 if (sit == sEries.get<SeriesName_mi_tag>().end()) {
148 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
149 "series recorder <%s> not exist", serie_name.c_str());
150 }
151 switch (rc) {
152 case ROW:
153 CHKERR const_cast<FieldSeries *>(&*sit)->push_dofs(
154 problemPtr->numeredRowDofsPtr->begin(),
155 problemPtr->numeredRowDofsPtr->end());
156 break;
157 case COL:
158 CHKERR const_cast<FieldSeries *>(&*sit)->push_dofs(
159 problemPtr->numeredColDofsPtr->begin(),
160 problemPtr->numeredColDofsPtr->end());
161 break;
162 default:
163 SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
164 }
165 MoFEMFunctionReturn(0);
166}
167
168MoFEMErrorCode SeriesRecorder::record_problem(const std::string &serie_name,
169 const std::string &problem_name,
170 RowColData rc) {
171
172 Interface &m_field = cOre;
173 MoFEMFunctionBegin;
174 const Problem *problem_ptr;
175 CHKERR m_field.get_problem(problem_name, &problem_ptr);
176 CHKERR record_problem(serie_name, problem_ptr, rc);
177 MoFEMFunctionReturn(0);
178}
179
180MoFEMErrorCode SeriesRecorder::record_field(const std::string &serie_name,
181 const std::string &field_name,
182 const BitRefLevel &bit,
183 const BitRefLevel &mask) {
184 Interface &m_field = cOre;
185 auto dofs_ptr = m_field.get_dofs();
186 MoFEMFunctionBegin;
187 Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
188 sEries.get<SeriesName_mi_tag>().find(serie_name);
189 if (sit == sEries.get<SeriesName_mi_tag>().end()) {
190 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "serie recorder <%s> not exist",
191 serie_name.c_str());
192 }
193
194 const auto bit_number = m_field.get_field_bit_number(field_name);
195
196 auto dit = dofs_ptr->get<Unique_mi_tag>().lower_bound(
197 FieldEntity::getLoBitNumberUId(bit_number));
198 if (dit == dofs_ptr->get<Unique_mi_tag>().end())
199 SETERRQ(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "field <%s> not exist", field_name.c_str());
200 auto hi_dit = dofs_ptr->get<Unique_mi_tag>().upper_bound(
201 FieldEntity::getHiBitNumberUId(bit_number));
202
203 for (; dit != hi_dit; dit++) {
204 const BitRefLevel &dof_bit = (*dit)->getBitRefLevel();
205 if ((dof_bit & mask) != dof_bit)
206 continue;
207 if ((dof_bit & bit).any()) {
208 EntityHandle ent = (*dit)->getEnt();
209 ShortId uid = (*dit)->getNonNonuniqueShortId();
210 FieldData val = (*dit)->getFieldData();
211 CHKERR const_cast<FieldSeries *>(&*sit)->push_dofs(ent, uid, val);
212 }
213 }
214 MoFEMFunctionReturn(0);
215}
216
217MoFEMErrorCode SeriesRecorder::record_begin(const std::string &serie_name) {
218
219 MoFEMFunctionBegin;
220 Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
221 sEries.get<SeriesName_mi_tag>().find(serie_name);
222 if (sit == sEries.get<SeriesName_mi_tag>().end()) {
223 SETERRQ(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
224 serie_name.c_str());
225 }
226 CHKERR const_cast<FieldSeries *>(&*sit)->begin();
227 MoFEMFunctionReturn(0);
228}
229
230MoFEMErrorCode SeriesRecorder::record_end(const std::string &serie_name,
231 double time) {
232
233 MoFEMFunctionBegin;
234 Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
235 sEries.get<SeriesName_mi_tag>().find(serie_name);
236 if (sit == sEries.get<SeriesName_mi_tag>().end()) {
237 SETERRQ(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
238 serie_name.c_str());
239 }
240 CHKERR const_cast<FieldSeries *>(&*sit)->end(time);
241 MoFEMFunctionReturn(0);
242}
243
244MoFEMErrorCode
245SeriesRecorder::initialize_series_recorder(const std::string &serie_name) {
246
247 Interface &m_field = cOre;
248 moab::Interface &moab = m_field.get_moab();
249 MoFEMFunctionBegin;
250 Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
251 sEries.get<SeriesName_mi_tag>().find(serie_name);
252 if (sit == sEries.get<SeriesName_mi_tag>().end()) {
253 SETERRQ(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
254 serie_name.c_str());
255 }
256 CHKERR const_cast<FieldSeries *>(&*sit)->read(moab);
257 const_cast<FieldSeries *>(&*sit)->record_begin = false;
258 const_cast<FieldSeries *>(&*sit)->record_end = false;
259 MoFEMFunctionReturn(0);
260}
261
262MoFEMErrorCode
263SeriesRecorder::finalize_series_recorder(const std::string &serie_name) {
264
265 Interface &m_field = cOre;
266 moab::Interface &moab = m_field.get_moab();
267 MoFEMFunctionBegin;
268 Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
269 sEries.get<SeriesName_mi_tag>().find(serie_name);
270 if (sit == sEries.get<SeriesName_mi_tag>().end()) {
271 SETERRQ(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
272 serie_name.c_str());
273 }
274 CHKERR sit->save(moab);
275 int nb_steps;
276 CHKERR sit->get_nb_steps(moab, nb_steps);
277 int ss = 0;
278 for (; ss < nb_steps; ss++) {
279 /*std::pair<SeriesStep_multiIndex::iterator,bool> p =*/seriesSteps.insert(
280 FieldSeriesStep(moab, &*sit, ss));
281 }
282 MoFEMFunctionReturn(0);
283}
284
285MoFEMErrorCode SeriesRecorder::print_series_steps() {
286 SeriesRecorderFunctionBegin;
287
288 for (auto &sit : sEries.get<SeriesName_mi_tag>())
289 MOFEM_LOG("SYNC", Sev::inform) << "series " << sit;
290
291 for (auto &ssit : seriesSteps.get<SeriesName_mi_tag>())
292 MOFEM_LOG("SYNC", Sev::inform) << "series steps " << ssit;
293
294 MOFEM_LOG_CHANNEL("WORLD");
295 MOFEM_LOG_CHANNEL("SYNC");
296 MOFEM_LOG_CHANNEL("SELF");
297 MoFEMFunctionReturn(0);
298}
299
300bool SeriesRecorder::check_series(const std::string &name) const {
301 Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
302 sEries.get<SeriesName_mi_tag>().find(name);
303 if (sit != sEries.get<SeriesName_mi_tag>().end())
304 return true;
305 return false;
306}
307
308MoFEMErrorCode SeriesRecorder::load_series_data(const std::string &serie_name,
309 const int step_number) {
310
311 Interface &m_field = cOre;
312 moab::Interface &moab = m_field.get_moab();
313 auto dofs_ptr = m_field.get_dofs();
314 MoFEMFunctionBegin;
315 SeriesStep_multiIndex::index<
316 Composite_SeriesName_And_Step_mi_tag>::type::iterator sit;
317 sit = seriesSteps.get<Composite_SeriesName_And_Step_mi_tag>().find(
318 boost::make_tuple(serie_name, step_number));
319 if (sit == seriesSteps.get<Composite_SeriesName_And_Step_mi_tag>().end()) {
320 SETERRQ(PETSC_COMM_SELF, 1, "series <%s> and step %d not found",
321 serie_name.c_str(), step_number);
322 }
323 CHKERR sit->get(moab, *(const_cast<DofEntity_multiIndex *>(dofs_ptr)));
324 MoFEMFunctionReturn(0);
325}
326
327SeriesStep_multiIndex::index<SeriesName_mi_tag>::type::iterator
328SeriesRecorder::get_series_steps_byName_begin(const std::string &name) {
329 return seriesSteps.get<SeriesName_mi_tag>().lower_bound(name);
330}
331
332SeriesStep_multiIndex::index<SeriesName_mi_tag>::type::iterator
333SeriesRecorder::get_series_steps_byName_end(const std::string &name) {
334 return seriesSteps.get<SeriesName_mi_tag>().upper_bound(name);
335}
336
337} // namespace MoFEM
SeriesRecorderFunctionBegin
#define SeriesRecorderFunctionBegin
Definition SeriesRecorder.cpp:6
QUIET
@ QUIET
Definition definitions.h:221
RowColData
RowColData
RowColData.
Definition definitions.h:136
COL
@ COL
Definition definitions.h:136
ROW
@ ROW
Definition definitions.h:136
MOFEM_NOT_FOUND
@ MOFEM_NOT_FOUND
Definition definitions.h:33
MOFEM_DATA_INCONSISTENCY
@ MOFEM_DATA_INCONSISTENCY
Definition definitions.h:31
MoFEMFunctionReturn
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
Definition definitions.h:432
CHKERR
#define CHKERR
Inline error check.
Definition definitions.h:551
DofEntity_multiIndex
multi_index_container< boost::shared_ptr< DofEntity >, indexed_by< ordered_unique< tag< Unique_mi_tag >, const_mem_fun< DofEntity, UId, &DofEntity::getLocalUniqueId > >, ordered_non_unique< tag< Ent_mi_tag >, const_mem_fun< DofEntity, EntityHandle, &DofEntity::getEnt > > > > DofEntity_multiIndex
MultiIndex container keeps DofEntity.
Definition DofsMultiIndices.hpp:317
MoFEM::CoreInterface::get_problem
virtual const Problem * get_problem(const std::string problem_name) const =0
Get the problem object.
MoFEM::CoreInterface::get_dofs
virtual const DofEntity_multiIndex * get_dofs() const =0
Get the dofs object.
MOFEM_LOG
#define MOFEM_LOG(channel, severity)
Log.
Definition LogManager.hpp:316
MOFEM_LOG_CHANNEL
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
Definition LogManager.hpp:292
bit
auto bit
set bit
Definition hanging_node_approx.cpp:75
MoFEM::Exceptions::MoFEMErrorCode
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
Definition Exceptions.hpp:56
MoFEM::Types::FieldData
double FieldData
Field data type.
Definition Types.hpp:25
MoFEM::Types::BitRefLevel
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
Definition Types.hpp:40
MoFEM::Types::ShortId
int ShortId
Unique Id in the field.
Definition Types.hpp:32
MoFEM::Core
CoreTmp< 0 > Core
Definition Core.hpp:1148
MoFEM::Sev
MoFEM::LogManager::SeverityLevel Sev
Definition CoreTemplates.hpp:17
MoFEM::Interface
DeprecatedCoreInterface Interface
Definition Interface.hpp:2124
field_name
constexpr auto field_name
Definition poisson_2d_homogeneous.cpp:13
MoFEM::CoreInterface::get_moab
virtual moab::Interface & get_moab()=0
Generated by Doxygen 1.9.8 and hosted at University of Glasgow