preCICE v3.1.2
Loading...
Searching...
No Matches
AccelerationConfiguration.cpp
Go to the documentation of this file.
1#include "acceleration/config/AccelerationConfiguration.hpp"
2#include <algorithm>
3#include <memory>
4#include <ostream>
5#include <stdexcept>
6#include <utility>
7#include <vector>
8#include "acceleration/Acceleration.hpp"
9#include "acceleration/AitkenAcceleration.hpp"
10#include "acceleration/ConstantRelaxationAcceleration.hpp"
11#include "acceleration/IQNILSAcceleration.hpp"
12#include "acceleration/IQNIMVJAcceleration.hpp"
13#include "acceleration/impl/ConstantPreconditioner.hpp"
14#include "acceleration/impl/QRFactorization.hpp"
15#include "acceleration/impl/ResidualPreconditioner.hpp"
16#include "acceleration/impl/ResidualSumPreconditioner.hpp"
17#include "acceleration/impl/ValuePreconditioner.hpp"
18#include "logging/LogMacros.hpp"
19#include "mesh/Data.hpp"
20#include "mesh/Mesh.hpp"
21#include "mesh/config/MeshConfiguration.hpp"
22#include "utils/assertion.hpp"
23#include "xml/ConfigParser.hpp"
24#include "xml/XMLAttribute.hpp"
25#include "xml/XMLTag.hpp"
26
27namespace precice::acceleration {
28
29using namespace precice::acceleration::impl;
30
31AccelerationConfiguration::AccelerationConfiguration(
32 const mesh::PtrMeshConfiguration &meshConfig)
33 : TAG("acceleration"),
34 TAG_RELAX("relaxation"),
35 TAG_INIT_RELAX("initial-relaxation"),
36 TAG_MAX_USED_ITERATIONS("max-used-iterations"),
37 TAG_TIME_WINDOWS_REUSED("time-windows-reused"),
38 TAG_DATA("data"),
39 TAG_FILTER("filter"),
40 TAG_ESTIMATEJACOBIAN("estimate-jacobian"),
41 TAG_PRECONDITIONER("preconditioner"),
42 TAG_IMVJRESTART("imvj-restart-mode"),
43 ATTR_NAME("name"),
44 ATTR_MESH("mesh"),
45 ATTR_SCALING("scaling"),
46 ATTR_VALUE("value"),
47 ATTR_ENFORCE("enforce"),
48 ATTR_SINGULARITYLIMIT("limit"),
49 ATTR_TYPE("type"),
50 ATTR_BUILDJACOBIAN("always-build-jacobian"),
51 ATTR_IMVJCHUNKSIZE("chunk-size"),
52 ATTR_RSLS_REUSED_TIME_WINDOWS("reused-time-windows-at-restart"),
53 ATTR_RSSVD_TRUNCATIONEPS("truncation-threshold"),
54 ATTR_PRECOND_NONCONST_TIME_WINDOWS("freeze-after"),
55 VALUE_CONSTANT("constant"),
56 VALUE_AITKEN("aitken"),
57 VALUE_IQNILS("IQN-ILS"),
58 VALUE_IQNIMVJ("IQN-IMVJ"),
59 VALUE_QR1FILTER("QR1"),
60 VALUE_QR1_ABSFILTER("QR1-absolute"),
61 VALUE_QR2FILTER("QR2"),
62 VALUE_CONSTANT_PRECONDITIONER("constant"),
63 VALUE_VALUE_PRECONDITIONER("value"),
64 VALUE_RESIDUAL_PRECONDITIONER("residual"),
65 VALUE_RESIDUAL_SUM_PRECONDITIONER("residual-sum"),
66 VALUE_LS_RESTART("RS-LS"),
67 VALUE_ZERO_RESTART("RS-0"),
68 VALUE_SVD_RESTART("RS-SVD"),
69 VALUE_SLIDE_RESTART("RS-SLIDE"),
70 VALUE_NO_RESTART("no-restart"),
71 _meshConfig(meshConfig),
72 _acceleration(),
73 _neededMeshes(),
74 _preconditioner(),
75 _config()
76{
77 PRECICE_ASSERT(meshConfig.get() != nullptr);
78}
79
80void AccelerationConfiguration::connectTags(xml::XMLTag &parent)
81{
82 using namespace xml;
83
84 // static int recursionCounter = 0;
85 // recursionCounter++;
86
87 XMLTag::Occurrence occ = XMLTag::OCCUR_NOT_OR_ONCE;
88 std::vector<XMLTag> tags;
89 {
90 XMLTag tag(*this, VALUE_CONSTANT, occ, TAG);
91 tag.setDocumentation("Accelerates coupling data with constant underrelaxation.");
92 addTypeSpecificSubtags(tag);
93 tags.push_back(tag);
94 }
95 {
96 XMLTag tag(*this, VALUE_AITKEN, occ, TAG);
97 tag.setDocumentation("Accelerates coupling data with dynamic Aitken under-relaxation.");
98 addTypeSpecificSubtags(tag);
99 tags.push_back(tag);
100 }
101 {
102 XMLTag tag(*this, VALUE_IQNILS, occ, TAG);
103 tag.setDocumentation("Accelerates coupling data with the interface quasi-Newton inverse least-squares method.");
104 addTypeSpecificSubtags(tag);
105 tags.push_back(tag);
106 }
107 {
108 XMLTag tag(*this, VALUE_IQNIMVJ, occ, TAG);
109 tag.setDocumentation("Accelerates coupling data with the interface quasi-Newton inverse multi-vector Jacobian method.");
110
111 auto alwaybuildJacobian = makeXMLAttribute(ATTR_BUILDJACOBIAN, false)
112 .setDocumentation("If set to true, the IMVJ will set up the Jacobian matrix"
113 " in each coupling iteration, which is inefficient. If set to false (or not set)"
114 " the Jacobian is only build in the last iteration and the updates are computed using (relatively) cheap MATVEC products.");
115 tag.addAttribute(alwaybuildJacobian);
116
117 addTypeSpecificSubtags(tag);
118 tags.push_back(tag);
119 }
120
121 for (XMLTag &tag : tags) {
122 parent.addSubtag(tag);
123 }
124}
125
130
131void AccelerationConfiguration::xmlTagCallback(
132 const xml::ConfigurationContext &context,
133 xml::XMLTag & callingTag)
134{
135 PRECICE_TRACE(callingTag.getFullName());
136
137 if (callingTag.getNamespace() == TAG) {
138 _config.type = callingTag.getName();
139
140 if (_config.type == VALUE_IQNIMVJ)
141 _config.alwaysBuildJacobian = callingTag.getBooleanAttributeValue(ATTR_BUILDJACOBIAN);
142 }
143 if (callingTag.getName() == TAG_RELAX) {
144 _config.relaxationFactor = callingTag.getDoubleAttributeValue(ATTR_VALUE);
145 } else if (callingTag.getName() == TAG_DATA) {
146 std::string dataName = callingTag.getStringAttributeValue(ATTR_NAME);
147 std::string meshName = callingTag.getStringAttributeValue(ATTR_MESH);
148 auto success = _uniqueDataAndMeshNames.emplace(dataName, meshName);
149 PRECICE_CHECK(success.second,
150 "You have provided a subtag <data name=\"{}\" mesh=\"{}\"/> more than once in your <acceleration:.../>. "
151 "Please remove the duplicated entry.",
152 dataName, meshName);
153
154 _meshName = callingTag.getStringAttributeValue(ATTR_MESH);
155 double scaling = 1.0;
156 if (_config.type == VALUE_IQNILS || _config.type == VALUE_IQNIMVJ) {
157 scaling = callingTag.getDoubleAttributeValue(ATTR_SCALING);
158 }
159
160 PRECICE_CHECK(_meshConfig->hasMeshName(_meshName) && _meshConfig->getMesh(_meshName)->hasDataName(dataName),
161 "Data with name \"{0}\" associated to mesh \"{1}\" not found on configuration of acceleration. "
162 "Add \"{0}\" to the \"<mesh name={1}>\" tag, or change the data name in the acceleration scheme.",
163 dataName, _meshName);
164
165 const mesh::PtrMesh &mesh = _meshConfig->getMesh(_meshName);
166 const mesh::PtrData &data = mesh->data(dataName);
167 _config.dataIDs.push_back(data->getID());
168 _config.scalings.insert(std::make_pair(data->getID(), scaling));
169
170 _neededMeshes.push_back(_meshName);
171 } else if (callingTag.getName() == TAG_INIT_RELAX) {
172 _userDefinitions.definedRelaxationFactor = true;
173 _config.relaxationFactor = callingTag.getDoubleAttributeValue(ATTR_VALUE);
174 if (callingTag.hasAttribute(ATTR_ENFORCE)) {
175 _config.forceInitialRelaxation = callingTag.getBooleanAttributeValue(ATTR_ENFORCE);
176 } else {
177 _config.forceInitialRelaxation = false;
178 }
179 } else if (callingTag.getName() == TAG_MAX_USED_ITERATIONS) {
180 _userDefinitions.definedMaxIterationsUsed = true;
181 _config.maxIterationsUsed = callingTag.getIntAttributeValue(ATTR_VALUE);
182 } else if (callingTag.getName() == TAG_TIME_WINDOWS_REUSED) {
183 _userDefinitions.definedTimeWindowsReused = true;
184 _config.timeWindowsReused = callingTag.getIntAttributeValue(ATTR_VALUE);
185 } else if (callingTag.getName() == TAG_FILTER) {
186 _userDefinitions.definedFilter = true;
187 const auto &f = callingTag.getStringAttributeValue(ATTR_TYPE);
188 if (f == VALUE_QR1FILTER) {
189 _config.filter = Acceleration::QR1FILTER;
190 } else if (f == VALUE_QR1_ABSFILTER) {
191 _config.filter = Acceleration::QR1FILTER_ABS;
192 } else if (f == VALUE_QR2FILTER) {
193 _config.filter = Acceleration::QR2FILTER;
194 } else {
195 PRECICE_ASSERT(false);
196 }
197 _config.singularityLimit = callingTag.getDoubleAttributeValue(ATTR_SINGULARITYLIMIT);
198 } else if (callingTag.getName() == TAG_PRECONDITIONER) {
199 _userDefinitions.definedPreconditionerType = true;
200 _config.preconditionerType = callingTag.getStringAttributeValue(ATTR_TYPE);
201 _config.precond_nbNonConstTWindows = callingTag.getIntAttributeValue(ATTR_PRECOND_NONCONST_TIME_WINDOWS);
202 } else if (callingTag.getName() == TAG_IMVJRESTART) {
203
204#ifndef PRECICE_NO_MPI
205 _config.imvjChunkSize = callingTag.getIntAttributeValue(ATTR_IMVJCHUNKSIZE);
206 const auto &f = callingTag.getStringAttributeValue(ATTR_TYPE);
207 PRECICE_CHECK((f == VALUE_NO_RESTART) || (!_config.alwaysBuildJacobian), "IMVJ cannot be in restart mode while parameter always-build-jacobian is set to true. "
208 "Please remove 'always-build-jacobian' from the configuration file or do not run in restart mode.");
209 if (f == VALUE_NO_RESTART) {
210 _config.imvjRestartType = IQNIMVJAcceleration::NO_RESTART;
211 } else if (f == VALUE_ZERO_RESTART) {
212 _config.imvjRestartType = IQNIMVJAcceleration::RS_ZERO;
213 } else if (f == VALUE_LS_RESTART) {
214 _config.imvjRSLS_reusedTimeWindows = callingTag.getIntAttributeValue(ATTR_RSLS_REUSED_TIME_WINDOWS);
215 _config.imvjRestartType = IQNIMVJAcceleration::RS_LS;
216 } else if (f == VALUE_SVD_RESTART) {
217 _config.imvjRSSVD_truncationEps = callingTag.getDoubleAttributeValue(ATTR_RSSVD_TRUNCATIONEPS);
218 _config.imvjRestartType = IQNIMVJAcceleration::RS_SVD;
219 } else if (f == VALUE_SLIDE_RESTART) {
220 _config.imvjRestartType = IQNIMVJAcceleration::RS_SLIDE;
221 } else {
222 _config.imvjChunkSize = 0;
223 PRECICE_ASSERT(false);
224 }
225#else
226 PRECICE_ERROR("Acceleration IQN-IMVJ only works if preCICE is compiled with MPI");
227#endif
228 }
229}
230
231void AccelerationConfiguration::xmlEndTagCallback(
232 const xml::ConfigurationContext &context,
233 xml::XMLTag & callingTag)
234{
235 PRECICE_TRACE(callingTag.getName());
236 if (callingTag.getNamespace() == TAG) {
237
238 //create preconditioner
239 if (callingTag.getName() == VALUE_IQNILS || callingTag.getName() == VALUE_IQNIMVJ || callingTag.getName() == VALUE_AITKEN) {
240
241 // if imvj restart-mode is of type RS-SVD, max number of non-const preconditioned time windows is limited by the chunksize
242 if (callingTag.getName() == VALUE_IQNIMVJ && _config.imvjRestartType > 0)
243 if (_config.precond_nbNonConstTWindows > _config.imvjChunkSize)
244 _config.precond_nbNonConstTWindows = _config.imvjChunkSize;
245 if (_config.preconditionerType == VALUE_CONSTANT_PRECONDITIONER) {
246 _preconditioner = PtrPreconditioner(new ConstantPreconditioner(_config.scalingFactorsInOrder()));
247 } else if (_config.preconditionerType == VALUE_VALUE_PRECONDITIONER) {
248 _preconditioner = PtrPreconditioner(new ValuePreconditioner(_config.precond_nbNonConstTWindows));
249 } else if (_config.preconditionerType == VALUE_RESIDUAL_PRECONDITIONER) {
250 _preconditioner = PtrPreconditioner(new ResidualPreconditioner(_config.precond_nbNonConstTWindows));
251 } else if (_config.preconditionerType == VALUE_RESIDUAL_SUM_PRECONDITIONER) {
252 _preconditioner = PtrPreconditioner(new ResidualSumPreconditioner(_config.precond_nbNonConstTWindows));
253 } else {
254 // no preconditioner defined
255 _preconditioner = PtrPreconditioner(new ResidualSumPreconditioner(_defaultValuesIQNILS.precond_nbNonConstTWindows));
256 }
257 }
258
259 if (callingTag.getName() == VALUE_CONSTANT) {
260 _acceleration = PtrAcceleration(
261 new ConstantRelaxationAcceleration(
262 _config.relaxationFactor, _config.dataIDs));
263 } else if (callingTag.getName() == VALUE_AITKEN) {
264 _acceleration = PtrAcceleration(
265 new AitkenAcceleration(
266 _config.relaxationFactor, _config.dataIDs, _preconditioner));
267 } else if (callingTag.getName() == VALUE_IQNILS) {
268 _config.relaxationFactor = (_userDefinitions.definedRelaxationFactor) ? _config.relaxationFactor : _defaultValuesIQNILS.relaxationFactor;
269 _config.maxIterationsUsed = (_userDefinitions.definedMaxIterationsUsed) ? _config.maxIterationsUsed : _defaultValuesIQNILS.maxIterationsUsed;
270 _config.timeWindowsReused = (_userDefinitions.definedTimeWindowsReused) ? _config.timeWindowsReused : _defaultValuesIQNILS.timeWindowsReused;
271 _config.filter = (_userDefinitions.definedFilter) ? _config.filter : _defaultValuesIQNILS.filter;
272 _config.singularityLimit = (_userDefinitions.definedFilter) ? _config.singularityLimit : _defaultValuesIQNILS.singularityLimit;
273 _acceleration = PtrAcceleration(
274 new IQNILSAcceleration(
275 _config.relaxationFactor,
276 _config.forceInitialRelaxation,
277 _config.maxIterationsUsed,
278 _config.timeWindowsReused,
279 _config.filter, _config.singularityLimit,
280 _config.dataIDs,
281 _preconditioner));
282 } else if (callingTag.getName() == VALUE_IQNIMVJ) {
283#ifndef PRECICE_NO_MPI
284 _config.relaxationFactor = (_userDefinitions.definedRelaxationFactor) ? _config.relaxationFactor : _defaultValuesIQNIMVJ.relaxationFactor;
285 _config.maxIterationsUsed = (_userDefinitions.definedMaxIterationsUsed) ? _config.maxIterationsUsed : _defaultValuesIQNIMVJ.maxIterationsUsed;
286 _config.timeWindowsReused = (_userDefinitions.definedTimeWindowsReused) ? _config.timeWindowsReused : _defaultValuesIQNIMVJ.timeWindowsReused;
287 _config.filter = (_userDefinitions.definedFilter) ? _config.filter : _defaultValuesIQNILS.filter;
288 _config.singularityLimit = (_userDefinitions.definedFilter) ? _config.singularityLimit : _defaultValuesIQNILS.singularityLimit;
289 _acceleration = PtrAcceleration(
290 new IQNIMVJAcceleration(
291 _config.relaxationFactor,
292 _config.forceInitialRelaxation,
293 _config.maxIterationsUsed,
294 _config.timeWindowsReused,
295 _config.filter, _config.singularityLimit,
296 _config.dataIDs,
297 _preconditioner,
298 _config.alwaysBuildJacobian,
299 _config.imvjRestartType,
300 _config.imvjChunkSize,
301 _config.imvjRSLS_reusedTimeWindows,
302 _config.imvjRSSVD_truncationEps));
303#else
304 PRECICE_ERROR("Acceleration IQN-IMVJ only works if preCICE is compiled with MPI");
305#endif
306 } else {
307 PRECICE_ASSERT(false);
308 }
309 }
310}
311
318
319void AccelerationConfiguration::addCommonIQNSubtags(xml::XMLTag &tag)
320{
321 using namespace precice::xml;
322
323 XMLTag tagData(*this, TAG_DATA, XMLTag::OCCUR_ONCE_OR_MORE);
324 tagData.setDocumentation("The data used to compute the acceleration.");
325 XMLAttribute<std::string> attrName(ATTR_NAME);
326 attrName.setDocumentation("The name of the data.");
327 XMLAttribute<std::string> attrMesh(ATTR_MESH);
328 attrMesh.setDocumentation("The name of the mesh which holds the data.");
329 auto attrScaling = makeXMLAttribute(ATTR_SCALING, 1.0)
330 .setDocumentation(
331 "To improve the performance of a parallel or a multi coupling schemes, "
332 "each data set can be manually scaled using this scaling factor with preconditioner type = \"constant\". For all other preconditioner types, the factor is ignored. "
333 "We recommend, however, to use an automatic scaling via a preconditioner.");
334 tagData.addAttribute(attrScaling);
335 tagData.addAttribute(attrName);
336 tagData.addAttribute(attrMesh);
337 tag.addSubtag(tagData);
338
339 XMLTag tagFilter(*this, TAG_FILTER, XMLTag::OCCUR_NOT_OR_ONCE);
340 tagFilter.setDocumentation("Type of filtering technique that is used to "
341 "maintain good conditioning in the least-squares system. Possible filters:\n"
342 " - `QR1-filter`: updateQR-dec with (relative) test \\\\(R(i,i) < \\epsilon *\\lVert R\\rVert_F\\\\)\n"
343 " - `QR1_absolute-filter`: updateQR-dec with (absolute) test \\\\(R(i, i) < \\epsilon\\\\)\n"
344 " - `QR2-filter`: en-block QR-dec with test \\\\(\\lVert v_\\text{orth} \\rVert_2 < \\epsilon * \\lVert v \\rVert_2\\\\)\n\n"
345 "Please note that a QR1 is based on Given's rotations whereas QR2 uses "
346 "modified Gram-Schmidt. This can give different results even when no columns "
347 "are filtered out.\n"
348 "When this tag is not provided, the QR2-filter with the limit value 1e-2 is used.");
349 XMLAttribute<double> attrSingularityLimit(ATTR_SINGULARITYLIMIT, 1e-16);
350 attrSingularityLimit.setDocumentation("Limit eps of the filter.");
351 tagFilter.addAttribute(attrSingularityLimit);
352 auto attrFilterName = XMLAttribute<std::string>(ATTR_TYPE)
353 .setOptions({VALUE_QR1FILTER,
354 VALUE_QR1_ABSFILTER,
355 VALUE_QR2FILTER})
356 .setDocumentation("Type of the filter.");
357 tagFilter.addAttribute(attrFilterName);
358 tag.addSubtag(tagFilter);
359}
360
361void AccelerationConfiguration::addTypeSpecificSubtags(
362 xml::XMLTag &tag)
363{
364 using namespace xml;
365 if (tag.getName() == VALUE_CONSTANT) {
366 XMLTag tagRelax(*this, TAG_RELAX, XMLTag::OCCUR_ONCE);
367 XMLAttribute<double> attrValue(ATTR_VALUE);
368 attrValue.setDocumentation("Constant relaxation factor.");
369 tagRelax.addAttribute(attrValue);
370 tag.addSubtag(tagRelax);
371 } else if (tag.getName() == VALUE_AITKEN) {
372 XMLTag tagInitRelax(*this, TAG_INIT_RELAX, XMLTag::OCCUR_ONCE);
373 tagInitRelax.setDocumentation("Initial relaxation factor.");
374 XMLAttribute<double> attrValue(ATTR_VALUE);
375 attrValue.setDocumentation("Initial relaxation factor.");
376 tagInitRelax.addAttribute(attrValue);
377 tag.addSubtag(tagInitRelax);
378
379 XMLTag tagData(*this, TAG_DATA, XMLTag::OCCUR_ONCE_OR_MORE);
380 tagData.setDocumentation("The data used to compute the acceleration.");
381 XMLAttribute<std::string> attrName(ATTR_NAME);
382 attrName.setDocumentation("The name of the data.");
383 XMLAttribute<std::string> attrMesh(ATTR_MESH);
384 attrMesh.setDocumentation("The name of the mesh which holds the data.");
385 auto attrScaling = makeXMLAttribute(ATTR_SCALING, 1.0)
386 .setDocumentation(
387 "To improve the performance of a parallel or a multi coupling schemes, "
388 "each data set can be manually scaled using this scaling factor with preconditioner type = \"constant\". For all other preconditioner types, the factor is ignored. "
389 "We recommend, however, to use an automatic scaling via a preconditioner.");
390 tagData.addAttribute(attrScaling);
391 tagData.addAttribute(attrName);
392 tagData.addAttribute(attrMesh);
393 tag.addSubtag(tagData);
394
395 XMLTag tagPreconditioner(*this, TAG_PRECONDITIONER, XMLTag::OCCUR_NOT_OR_ONCE);
396 tagPreconditioner.setDocumentation("To improve the numerical stability of multiple data vectors a preconditioner"
397 " can be applied. A constant preconditioner scales every acceleration data by a constant value, which you can define as"
398 " an attribute of data. "
399 " A value preconditioner scales every acceleration data by the norm of the data in the previous time window."
400 " A residual preconditioner scales every acceleration data by the current residual."
401 " A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.");
402 auto attrPreconditionerType = XMLAttribute<std::string>(ATTR_TYPE)
403 .setOptions({VALUE_CONSTANT_PRECONDITIONER,
404 VALUE_VALUE_PRECONDITIONER,
405 VALUE_RESIDUAL_PRECONDITIONER,
406 VALUE_RESIDUAL_SUM_PRECONDITIONER})
407 .setDocumentation("The type of the preconditioner.");
408 tagPreconditioner.addAttribute(attrPreconditionerType);
409 auto nonconstTWindows = makeXMLAttribute(ATTR_PRECOND_NONCONST_TIME_WINDOWS, -1)
410 .setDocumentation(
411 "After the given number of time windows, the preconditioner weights "
412 "are frozen and the preconditioner acts like a constant preconditioner.");
413 tagPreconditioner.addAttribute(nonconstTWindows);
414 tag.addSubtag(tagPreconditioner);
415 } else if (tag.getName() == VALUE_IQNILS) {
416
417 XMLTag tagInitRelax(*this, TAG_INIT_RELAX, XMLTag::OCCUR_NOT_OR_ONCE);
418 tagInitRelax.setDocumentation("Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.1 is used.");
419 XMLAttribute<double> attrDoubleValue(ATTR_VALUE);
420 attrDoubleValue.setDocumentation("Initial relaxation factor.");
421 tagInitRelax.addAttribute(attrDoubleValue);
422 XMLAttribute<bool> attrEnforce(ATTR_ENFORCE, false);
423 attrEnforce.setDocumentation("Enforce initial relaxation in every time window.");
424 tagInitRelax.addAttribute(attrEnforce);
425 tag.addSubtag(tagInitRelax);
426
427 XMLTag tagMaxUsedIter(*this, TAG_MAX_USED_ITERATIONS, XMLTag::OCCUR_NOT_OR_ONCE);
428 tagMaxUsedIter.setDocumentation("Maximum number of columns used in low-rank approximation of Jacobian. If this tag is not provided, the attribute value of 100 is used.");
429 XMLAttribute<int> attrIntValue(ATTR_VALUE);
430 attrIntValue.setDocumentation("The number of columns.");
431 tagMaxUsedIter.addAttribute(attrIntValue);
432 tag.addSubtag(tagMaxUsedIter);
433
434 XMLTag tagTimeWindowsReused(*this, TAG_TIME_WINDOWS_REUSED, XMLTag::OCCUR_NOT_OR_ONCE);
435 tagTimeWindowsReused.setDocumentation("Number of past time windows from which columns are used to approximate Jacobian. If this tag is not provided, the default attribute value of 10 is used.");
436 XMLAttribute<int> attrNumTimeWindowsReused(ATTR_VALUE);
437 attrNumTimeWindowsReused.setDocumentation("The number of time windows.");
438 tagTimeWindowsReused.addAttribute(attrNumTimeWindowsReused);
439 tag.addSubtag(tagTimeWindowsReused);
440
441 addCommonIQNSubtags(tag);
442
443 XMLTag tagPreconditioner(*this, TAG_PRECONDITIONER, XMLTag::OCCUR_NOT_OR_ONCE);
444 tagPreconditioner.setDocumentation("To improve the performance of a parallel or a multi coupling schemes a preconditioner"
445 " can be applied. "
446 "- A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data. \n "
447 "- A value preconditioner scales every acceleration data by the norm of the data in the previous time window.\n"
448 "- A residual preconditioner scales every acceleration data by the current residual.\n"
449 "- A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.\n"
450 " If this tag is not provided, the residual-sum preconditioner is employed.");
451 auto attrPreconditionerType = XMLAttribute<std::string>(ATTR_TYPE)
452 .setOptions({VALUE_CONSTANT_PRECONDITIONER,
453 VALUE_VALUE_PRECONDITIONER,
454 VALUE_RESIDUAL_PRECONDITIONER,
455 VALUE_RESIDUAL_SUM_PRECONDITIONER})
456 .setDocumentation("The type of the preconditioner.");
457 tagPreconditioner.addAttribute(attrPreconditionerType);
458 auto nonconstTWindows = makeXMLAttribute(ATTR_PRECOND_NONCONST_TIME_WINDOWS, -1)
459 .setDocumentation(
460 "After the given number of time windows, the preconditioner weights "
461 "are frozen and the preconditioner acts like a constant preconditioner.");
462 tagPreconditioner.addAttribute(nonconstTWindows);
463 tag.addSubtag(tagPreconditioner);
464
465 } else if (tag.getName() == VALUE_IQNIMVJ) {
466 XMLTag tagInitRelax(*this, TAG_INIT_RELAX, XMLTag::OCCUR_NOT_OR_ONCE);
467 tagInitRelax.setDocumentation("Initial relaxation factor. If this tag is not provided, an initial relaxation of 0.1 is used.");
468 tagInitRelax.addAttribute(
469 XMLAttribute<double>(ATTR_VALUE).setDocumentation("Initial relaxation factor."));
470 tagInitRelax.addAttribute(
471 XMLAttribute<bool>(ATTR_ENFORCE, false).setDocumentation("Enforce initial relaxation in every time window."));
472 tag.addSubtag(tagInitRelax);
473
474 XMLTag tagIMVJRESTART(*this, TAG_IMVJRESTART, XMLTag::OCCUR_NOT_OR_ONCE);
475 auto attrRestartName = XMLAttribute<std::string>(ATTR_TYPE)
476 .setOptions({VALUE_NO_RESTART,
477 VALUE_ZERO_RESTART,
478 VALUE_LS_RESTART,
479 VALUE_SVD_RESTART,
480 VALUE_SLIDE_RESTART})
481 .setDefaultValue(VALUE_SVD_RESTART)
482 .setDocumentation("Type of the restart mode.");
483 tagIMVJRESTART.addAttribute(attrRestartName);
484 tagIMVJRESTART.setDocumentation("Type of IMVJ restart mode that is used:\n"
485 "- `no-restart`: IMVJ runs in normal mode with explicit representation of Jacobian\n"
486 "- `RS-ZERO`: IMVJ runs in restart mode. After M time windows all Jacobain information is dropped, restart with no information\n"
487 "- `RS-LS`: IMVJ runs in restart mode. After M time windows a IQN-LS like approximation for the initial guess of the Jacobian is computed.\n"
488 "- `RS-SVD`: IMVJ runs in restart mode. After M time windows a truncated SVD of the Jacobian is updated.\n"
489 "- `RS-SLIDE`: IMVJ runs in sliding window restart mode.\n"
490 "If this tag is not provided, IMVJ runs in normal mode with explicit representation of Jacobian.");
491 auto attrChunkSize = makeXMLAttribute(ATTR_IMVJCHUNKSIZE, 8)
492 .setDocumentation("Specifies the number of time windows M after which the IMVJ restarts, if run in restart-mode. Default value is M=8.");
493 auto attrReusedTimeWindowsAtRestart = makeXMLAttribute(ATTR_RSLS_REUSED_TIME_WINDOWS, 8)
494 .setDocumentation("If IMVJ restart-mode=RS-LS, the number of reused time windows at restart can be specified.");
495 auto attrRSSVD_truncationEps = makeXMLAttribute(ATTR_RSSVD_TRUNCATIONEPS, 1e-4)
496 .setDocumentation("If IMVJ restart-mode=RS-SVD, the truncation threshold for the updated SVD can be set.");
497 tagIMVJRESTART.addAttribute(attrChunkSize);
498 tagIMVJRESTART.addAttribute(attrReusedTimeWindowsAtRestart);
499 tagIMVJRESTART.addAttribute(attrRSSVD_truncationEps);
500 tag.addSubtag(tagIMVJRESTART);
501
502 XMLTag tagMaxUsedIter(*this, TAG_MAX_USED_ITERATIONS, XMLTag::OCCUR_NOT_OR_ONCE);
503 tagMaxUsedIter.setDocumentation("Maximum number of columns used in low-rank approximation of Jacobian. If this tag is not provided, the default attribute value of 20 is used.");
504 XMLAttribute<int> attrIntValue(ATTR_VALUE);
505 attrIntValue.setDocumentation("The number of columns.");
506 tagMaxUsedIter.addAttribute(attrIntValue);
507 tag.addSubtag(tagMaxUsedIter);
508
509 XMLTag tagTimeWindowsReused(*this, TAG_TIME_WINDOWS_REUSED, XMLTag::OCCUR_NOT_OR_ONCE);
510 tagTimeWindowsReused.setDocumentation("Number of past time windows from which columns are used to approximate Jacobian. If this tag is not provided, the attribute value of 0 is used.");
511 tagTimeWindowsReused.addAttribute(attrIntValue);
512 tag.addSubtag(tagTimeWindowsReused);
513
514 addCommonIQNSubtags(tag);
515
516 XMLTag tagPreconditioner(*this, TAG_PRECONDITIONER, XMLTag::OCCUR_NOT_OR_ONCE);
517 tagPreconditioner.setDocumentation(
518 "To improve the performance of a parallel or a multi coupling schemes a preconditioner can be applied."
519 "- A constant preconditioner scales every acceleration data by a constant value, which you can define as an attribute of data.\n"
520 "- A value preconditioner scales every acceleration data by the norm of the data in the previous time window.\n"
521 "- A residual preconditioner scales every acceleration data by the current residual.\n"
522 "- A residual-sum preconditioner scales every acceleration data by the sum of the residuals from the current time window.\n"
523 " If this tag is not provided, the residual-sum preconditioner is employed.");
524 auto attrPreconditionerType = XMLAttribute<std::string>(ATTR_TYPE)
525 .setOptions({VALUE_CONSTANT_PRECONDITIONER,
526 VALUE_VALUE_PRECONDITIONER,
527 VALUE_RESIDUAL_PRECONDITIONER,
528 VALUE_RESIDUAL_SUM_PRECONDITIONER})
529 .setDocumentation("Type of the preconditioner.");
530 tagPreconditioner.addAttribute(attrPreconditionerType);
531 auto nonconstTWindows = makeXMLAttribute(ATTR_PRECOND_NONCONST_TIME_WINDOWS, -1)
532 .setDocumentation("After the given number of time windows, the preconditioner weights are frozen and the preconditioner acts like a constant preconditioner.");
533 tagPreconditioner.addAttribute(nonconstTWindows);
534 tag.addSubtag(tagPreconditioner);
535
536 } else {
537 PRECICE_ERROR("Acceleration of type \"{}\" is unknown. Please choose a valid acceleration scheme or check the spelling in the configuration file.", tag.getName());
538 }
539}
540
549
550} // namespace precice::acceleration
PRECICE_ERROR
#define PRECICE_ERROR(...)
Definition LogMacros.hpp:15
PRECICE_TRACE
#define PRECICE_TRACE(...)
Definition LogMacros.hpp:95
PRECICE_CHECK
#define PRECICE_CHECK(check,...)
Definition LogMacros.hpp:35
PRECICE_ASSERT
#define PRECICE_ASSERT(...)
Definition assertion.hpp:87
std::map::at
T at(T... args)
precice::acceleration::AccelerationConfiguration::xmlEndTagCallback
virtual void xmlEndTagCallback(const xml::ConfigurationContext &context, xml::XMLTag &callingTag)
Callback method required when using xml::XMLTag.
Definition AccelerationConfiguration.cpp:231
precice::acceleration::AccelerationConfiguration::_uniqueDataAndMeshNames
std::set< std::pair< std::string, std::string > > _uniqueDataAndMeshNames
Definition AccelerationConfiguration.hpp:97
precice::acceleration::AccelerationConfiguration::_userDefinitions
struct precice::acceleration::AccelerationConfiguration::UserDefinitions _userDefinitions
precice::acceleration::AccelerationConfiguration::_config
struct precice::acceleration::AccelerationConfiguration::ConfigurationData _config
precice::acceleration::AccelerationConfiguration::_defaultValuesIQNIMVJ
const struct precice::acceleration::AccelerationConfiguration::DefaultValuesIMVJ _defaultValuesIQNIMVJ
precice::acceleration::AccelerationConfiguration::getAcceleration
PtrAcceleration getAcceleration()
Returns the configured coupling scheme.
Definition AccelerationConfiguration.cpp:126
precice::acceleration::AccelerationConfiguration::AccelerationConfiguration
AccelerationConfiguration(const mesh::PtrMeshConfiguration &meshConfig)
Definition AccelerationConfiguration.cpp:31
precice::acceleration::AccelerationConfiguration::_defaultValuesIQNILS
const struct precice::acceleration::AccelerationConfiguration::DefaultValuesIQN _defaultValuesIQNILS
precice::acceleration::AccelerationConfiguration::xmlTagCallback
virtual void xmlTagCallback(const xml::ConfigurationContext &context, xml::XMLTag &callingTag)
Callback method required when using xml::XMLTag.
Definition AccelerationConfiguration.cpp:131
precice::acceleration::IQNILSAcceleration
Interface quasi-Newton with interface least-squares approximation.
Definition IQNILSAcceleration.hpp:26
precice::acceleration::IQNIMVJAcceleration
Multi vector quasi-Newton update scheme.
Definition IQNIMVJAcceleration.hpp:33
precice::acceleration::impl::ConstantPreconditioner
Preconditioner that uses the constant user-defined factors to scale the quasi-Newton system.
Definition ConstantPreconditioner.hpp:15
precice::acceleration::impl::ResidualPreconditioner
Preconditioner that uses the recent residual to scale the quasi-Newton system.
Definition ResidualPreconditioner.hpp:15
precice::acceleration::impl::ResidualSumPreconditioner
Preconditioner that uses the residuals of all iterations of the current time window summed up to scal...
Definition ResidualSumPreconditioner.hpp:18
precice::acceleration::impl::ValuePreconditioner
Preconditioner that uses the values from the previous time window to scale the quasi-Newton system.
Definition ValuePreconditioner.hpp:13
precice::xml::XMLAttribute::setOptions
XMLAttribute & setOptions(std::vector< ATTRIBUTE_T > options)
Definition XMLAttribute.hpp:137
precice::xml::XMLAttribute::setDocumentation
XMLAttribute & setDocumentation(std::string documentation)
Sets a documentation string for the attribute.
Definition XMLAttribute.hpp:130
precice::xml::XMLTag
Represents an XML tag to be configured automatically.
Definition XMLTag.hpp:31
precice::xml::XMLTag::getNamespace
const std::string & getNamespace() const
Returns xml namespace.
Definition XMLTag.hpp:159
precice::xml::XMLTag::hasAttribute
bool hasAttribute(const std::string &attributeName)
Definition XMLTag.cpp:111
precice::xml::XMLTag::getStringAttributeValue
std::string getStringAttributeValue(const std::string &name, std::optional< std::string > default_value=std::nullopt) const
Definition XMLTag.cpp:142
precice::xml::XMLTag::getBooleanAttributeValue
bool getBooleanAttributeValue(const std::string &name, std::optional< bool > default_value=std::nullopt) const
Definition XMLTag.cpp:155
precice::xml::XMLTag::setDocumentation
XMLTag & setDocumentation(const std::string &documentation)
Adds a description of the purpose of this XML tag.
Definition XMLTag.cpp:29
precice::xml::XMLTag::getName
const std::string & getName() const
Returns name (without namespace).
Definition XMLTag.hpp:153
precice::xml::XMLTag::getFullName
const std::string & getFullName() const
Returns full name consisting of xml namespace + ":" + name.
Definition XMLTag.hpp:170
precice::xml::XMLTag::getIntAttributeValue
int getIntAttributeValue(const std::string &name, std::optional< int > default_value=std::nullopt) const
Definition XMLTag.cpp:129
precice::xml::XMLTag::getDoubleAttributeValue
double getDoubleAttributeValue(const std::string &name, std::optional< double > default_value=std::nullopt) const
Definition XMLTag.cpp:116
precice::xml::XMLTag::addAttribute
XMLTag & addAttribute(const XMLAttribute< double > &attribute)
Removes the XML subtag with given name.
Definition XMLTag.cpp:53
precice::xml::XMLTag::addSubtag
XMLTag & addSubtag(const XMLTag &tag)
Adds an XML tag as subtag by making a copy of the given tag.
Definition XMLTag.cpp:41
std::vector::clear
T clear(T... args)
std::set::emplace
T emplace(T... args)
std::shared_ptr::get
T get(T... args)
std::map::insert
T insert(T... args)
std::make_pair
T make_pair(T... args)
precice::acceleration::impl::PtrPreconditioner
std::shared_ptr< Preconditioner > PtrPreconditioner
Definition SharedPointer.hpp:12
precice::acceleration
contains implementations of acceleration schemes.
Definition Acceleration.cpp:5
precice::acceleration::PtrAcceleration
std::shared_ptr< Acceleration > PtrAcceleration
Definition SharedPointer.hpp:10
precice::xml
contains the XML configuration parser.
Definition CommunicationConfiguration.hpp:9
std::vector::push_back
T push_back(T... args)
precice::xml::ConfigurationContext
Tightly coupled to the parameters of Participant()
Definition XMLTag.hpp:24