PSCF v1.1
ParamComposite.h
1#ifndef UTIL_PARAM_COMPOSITE_H
2#define UTIL_PARAM_COMPOSITE_H
3
4/*
5* Util Package - C++ Utilities for Scientific Computation
6*
7* Copyright 2010 - 2017, The Regents of the University of Minnesota
8* Distributed under the terms of the GNU General Public License.
9*/
10
11#include <util/global.h>
12#include <util/param/ParamComponent.h> // base class
13#include <util/param/ScalarParam.h> // member function template
14#include <util/param/CArrayParam.h> // member function template
15#include <util/param/DArrayParam.h> // member function template
16#include <util/param/FArrayParam.h> // member function template
17#include <util/param/FSArrayParam.h> // member function template
18#include <util/param/CArray2DParam.h> // member function template
19#include <util/param/DMatrixParam.h> // member function template
20#include <util/param/DSymmMatrixParam.h> // member function template
21#include <util/archives/Serializable_includes.h>
22
23#include <vector>
24
25namespace Util
26{
27
28 class Begin;
29 class End;
30 class Blank;
31 template <class Data> class Factory;
32
90 class ParamComposite : public ParamComponent
91 {
92
93 public:
94
98 ParamComposite();
99
103 ParamComposite(const ParamComposite& other);
104
112 ParamComposite(int capacity);
113
117 virtual ~ParamComposite();
118
127 void resetParam();
128
130
131
148 virtual void readParam(std::istream &in);
149
165 virtual void readParamOptional(std::istream &in);
166
181 virtual void readParameters(std::istream &in)
182 {};
183
193 virtual void writeParam(std::ostream &out) const;
194
196
198
210 virtual void load(Serializable::IArchive &ar);
211
219 virtual void loadOptional(Serializable::IArchive &ar);
220
234 virtual void loadParameters(Serializable::IArchive &ar)
235 {};
236
256 virtual void save(Serializable::OArchive &ar);
257
263 void saveOptional(Serializable::OArchive &ar);
264
266
271
272
280 void
281 readParamComposite(std::istream &in, ParamComposite &child,
282 bool next = true);
283
291 void
292 readParamCompositeOptional(std::istream &in,
293 ParamComposite &child, bool next = true);
294
304 template <typename Type>
305 ScalarParam<Type>& read(std::istream &in, const char *label,
306 Type &value);
307
317 template <typename Type>
318 ScalarParam<Type>&
319 readOptional(std::istream &in, const char *label, Type &value);
320
330 template <typename Type>
331 CArrayParam<Type>&
332 readCArray(std::istream &in, const char *label, Type *value, int n);
333
343 template <typename Type>
344 CArrayParam<Type>&
345 readOptionalCArray(std::istream &in, const char *label,
346 Type *value, int n);
347
357 template <typename Type>
358 DArrayParam<Type>&
359 readDArray(std::istream &in, const char *label,
360 DArray<Type>& array, int n);
361
371 template <typename Type>
372 DArrayParam<Type>&
373 readOptionalDArray(std::istream &in, const char *label,
374 DArray<Type>& array, int n);
375
384 template <typename Type, int N>
385 FArrayParam<Type, N>&
386 readFArray(std::istream &in, const char *label,
387 FArray<Type, N >& array);
388
397 template <typename Type, int N>
398 FArrayParam<Type, N>&
399 readOptionalFArray(std::istream &in, const char *label,
400 FArray<Type, N >& array);
401
411 template <typename Type, int N>
412 FSArrayParam<Type, N>&
413 readFSArray(std::istream &in, const char *label,
414 FSArray<Type, N >& array, int size);
415
425 template <typename Type, int N>
426 FSArrayParam<Type, N>&
427 readOptionalFSArray(std::istream &in, const char *label,
428 FSArray<Type, N >& array, int size);
429
441 template <typename Type>
442 CArray2DParam<Type>&
443 readCArray2D(std::istream &in, const char *label,
444 Type *value, int m, int n, int np);
445
457 template <typename Type>
458 CArray2DParam<Type>&
459 readOptionalCArray2D(std::istream &in, const char *label,
460 Type *value, int m, int n, int np);
461
472 template <typename Type>
473 DMatrixParam<Type>&
474 readDMatrix(std::istream &in, const char *label,
475 DMatrix<Type>& matrix, int m, int n);
476
487 template <typename Type>
488 DMatrixParam<Type>&
489 readOptionalDMatrix(std::istream &in, const char *label,
490 DMatrix<Type>& matrix, int m, int n);
491
501 template <typename Type>
502 DSymmMatrixParam<Type>&
503 readDSymmMatrix(std::istream &in, const char *label,
504 DMatrix<Type>& matrix, int n);
505
515 template <typename Type>
516 DSymmMatrixParam<Type>&
517 readOptionalDSymmMatrix(std::istream &in, const char *label,
518 DMatrix<Type>& matrix, int n);
519
528 Begin& readBegin(std::istream &in, const char* label,
529 bool isRequired = true);
530
537 End& readEnd(std::istream &in);
538
545 Blank& readBlank(std::istream &in);
546
548
557
558
566 void
567 loadParamComposite(Serializable::IArchive &ar,
568 ParamComposite &child, bool next = true);
569
580 void
581 loadParamCompositeOptional(Serializable::IArchive &ar,
582 ParamComposite &child, bool next = true);
583
597 template <typename Type>
598 ScalarParam<Type>& loadParameter(Serializable::IArchive &ar,
599 const char *label, Type &value,
600 bool isRequired);
601
612 template <typename Type>
613 ScalarParam<Type>& loadParameter(Serializable::IArchive &ar,
614 const char *label, Type &value);
615
626 template <typename Type>
627 CArrayParam<Type>&
628 loadCArray(Serializable::IArchive &ar, const char *label,
629 Type *value, int n, bool isRequired);
630
642 template <typename Type>
643 CArrayParam<Type>&
644 loadCArray(Serializable::IArchive &ar, const char *label,
645 Type *value, int n);
646
657 template <typename Type>
658 DArrayParam<Type>&
659 loadDArray(Serializable::IArchive &ar, const char *label,
660 DArray<Type>& array, int n, bool isRequired);
661
673 template <typename Type>
674 DArrayParam<Type>&
675 loadDArray(Serializable::IArchive &ar, const char *label,
676 DArray<Type>& array, int n);
677
687 template <typename Type, int N>
688 FArrayParam<Type, N>&
689 loadFArray(Serializable::IArchive &ar, const char *label,
690 FArray<Type, N >& array, bool isRequired);
691
702 template <typename Type, int N>
703 FArrayParam<Type, N>&
704 loadFArray(Serializable::IArchive &ar, const char *label,
705 FArray<Type, N >& array)
706 { return loadFArray<Type, N>(ar, label, array, true); }
707
718 template <typename Type, int N>
719 FSArrayParam<Type, N>&
720 loadFSArray(Serializable::IArchive &ar, const char *label,
721 FSArray<Type, N >& array, int size, bool isRequired);
722
734 template <typename Type, int N>
735 FSArrayParam<Type, N>&
736 loadFSArray(Serializable::IArchive &ar, const char *label,
737 FSArray<Type, N >& array, int size)
738 { return loadFSArray<Type, N>(ar, label, array, size, true); }
739
752 template <typename Type>
753 CArray2DParam<Type>&
754 loadCArray2D(Serializable::IArchive &ar, const char *label,
755 Type *value, int m, int n, int np, bool isRequired);
756
770 template <typename Type>
771 CArray2DParam<Type>&
772 loadCArray2D(Serializable::IArchive &ar, const char *label,
773 Type *value, int m, int n, int np);
774
786 template <typename Type>
787 DMatrixParam<Type>&
788 loadDMatrix(Serializable::IArchive &ar, const char *label,
789 DMatrix<Type>& matrix, int m, int n, bool isRequired);
790
801 template <typename Type>
802 DMatrixParam<Type>&
803 loadDMatrix(Serializable::IArchive &ar, const char *label,
804 DMatrix<Type>& matrix, int m, int n);
805
816 template <typename Type>
817 DSymmMatrixParam<Type>&
818 loadDSymmMatrix(Serializable::IArchive &ar, const char *label,
819 DMatrix<Type>& matrix, int n, bool isRequired);
820
830 template <typename Type>
831 DSymmMatrixParam<Type>&
832 loadDSymmMatrix(Serializable::IArchive &ar, const char *label,
833 DMatrix<Type>& matrix, int n);
834
836
840
841
848 void addParamComposite(ParamComposite& child, bool next = true);
849
856 Begin& addBegin(const char* label);
857
863 End& addEnd();
864
870 Blank& addBlank();
871
873
875
879 std::string className() const;
880
884 bool isRequired() const;
885
889 bool isActive() const;
890
892
893 protected:
894
900 void setClassName(const char* className);
901
909 void setIsRequired(bool isRequired);
910
918 void setIsActive(bool isActive);
919
929 void setParent(ParamComponent& param, bool next = true);
930
937 void addComponent(ParamComponent& param, bool isLeaf = true);
938
948 template <typename Type>
949 ScalarParam<Type>& add(std::istream &in, const char *label,
950 Type &value, bool isRequired = true);
951
962 template <typename Type>
963 CArrayParam<Type>&
964 addCArray(std::istream &in, const char *label,
965 Type *value, int n, bool isRequired = true);
966
977 template <typename Type>
978 DArrayParam<Type>&
979 addDArray(std::istream &in, const char *label,
980 DArray<Type>& array, int n, bool isRequired = true);
981
991 template <typename Type, int N>
992 FArrayParam<Type, N>&
993 addFArray(std::istream &in, const char *label,
994 FArray<Type, N >& array, bool isRequired = true);
995
1006 template <typename Type, int N>
1007 FSArrayParam<Type, N>&
1008 addFSArray(std::istream &in, const char *label,
1009 FSArray<Type, N >& array, int size,
1010 bool isRequired = true);
1011
1024 template <typename Type>
1025 CArray2DParam<Type>&
1026 addCArray2D(std::istream &in, const char *label,
1027 Type *value, int m, int n, int np,
1028 bool isRequired = true);
1029
1041 template <typename Type>
1042 DMatrixParam<Type>&
1043 addDMatrix(std::istream &in, const char *label,
1044 DMatrix<Type>& matrix, int m, int n,
1045 bool isRequired = true);
1046
1047 private:
1048
1050 std::vector<ParamComponent*> list_;
1051
1053 std::vector<bool> isLeaf_;
1054
1056 int size_;
1057
1059 std::string className_;
1060
1062 bool isRequired_;
1063
1065 bool isActive_;
1066
1075 template <typename Type>
1076 ScalarParam<Type>& read_(std::istream &in, const char *label,
1077 Type &value, bool isRequired);
1078
1089 template <typename Type>
1090 CArrayParam<Type>&
1091 readCArray_(std::istream &in, const char *label, Type *value,
1092 int n, bool isRequired);
1093
1104 template <typename Type>
1105 DArrayParam<Type>&
1106 readDArray_(std::istream &in, const char *label,
1107 DArray<Type>& array, int n, bool isRequired);
1108
1118 template <typename Type, int N>
1119 FArrayParam<Type, N>&
1120 readFArray_(std::istream &in, const char *label,
1121 FArray<Type, N >& array, bool isRequired);
1122
1133 template <typename Type, int N>
1134 FSArrayParam<Type, N>&
1135 readFSArray_(std::istream &in, const char *label,
1136 FSArray<Type, N >& array, int size, bool isRequired);
1137
1152 template <typename Type>
1153 CArray2DParam<Type>&
1154 readCArray2D_(std::istream &in, const char *label,
1155 Type *value, int m, int n, int np, bool isRequired);
1156
1168 template <typename Type>
1169 DMatrixParam<Type>&
1170 readDMatrix_(std::istream &in, const char *label,
1171 DMatrix<Type>& matrix, int m, int n, bool isRequired);
1172
1183 template <typename Type>
1184 DSymmMatrixParam<Type>&
1185 readDSymmMatrix_(std::istream &in, const char *label,
1186 DMatrix<Type>& matrix, int n, bool isRequired);
1187
1188 };
1189
1190 // Inline accessor functions
1191
1192 /*
1193 * Get class name string.
1194 */
1195 inline std::string ParamComposite::className() const
1196 { return className_; }
1197
1198 /*
1199 * Is this ParamComposite required in the input file?
1200 */
1201 inline bool ParamComposite::isRequired() const
1202 { return isRequired_; }
1203
1204 /*
1205 * Is this parameter active?
1206 */
1207 inline bool ParamComposite::isActive() const
1208 { return isActive_; }
1209
1210 // Function templates for scalar parameters
1211
1212 /*
1213 * Add and read a scalar parameter (private).
1214 */
1215 template <typename Type>
1216 ScalarParam<Type>&
1217 ParamComposite::read_(std::istream &in, const char *label, Type &value,
1218 bool isRequired)
1219 {
1220 ScalarParam<Type>* ptr;
1221 ptr = new ScalarParam<Type>(label, value, isRequired);
1222 setParent(*ptr);
1223 ptr->readParam(in);
1224 addComponent(*ptr);
1225 return *ptr;
1226 }
1227
1228 /*
1229 * Add (but do not read) a scalar parameter (protected).
1230 */
1231 template <typename Type>
1232 ScalarParam<Type>&
1233 ParamComposite::add(std::istream &in, const char *label, Type &value,
1234 bool isRequired)
1235 {
1236 ScalarParam<Type>* ptr;
1237 ptr = new ScalarParam<Type>(label, value, isRequired);
1238 setParent(*ptr);
1239 addComponent(*ptr);
1240 return *ptr;
1241 }
1242
1243 /*
1244 * Add and read a required scalar parameter.
1245 */
1246 template <typename Type>
1247 ScalarParam<Type>&
1248 ParamComposite::read(std::istream &in, const char *label, Type &value)
1249 { return read_<Type>(in, label, value, true); }
1250
1251 /*
1252 * Add and read a new optional ScalarParam < Type > object.
1253 */
1254 template <typename Type>
1255 inline ScalarParam<Type>&
1256 ParamComposite::readOptional(std::istream &in, const char *label,
1257 Type &value)
1258 { return read_<Type>(in, label, value, false); }
1259
1260 /*
1261 * Add a new ScalarParam< Type > object, and load its value from an archive.
1262 */
1263 template <typename Type>
1264 ScalarParam<Type>&
1265 ParamComposite::loadParameter(Serializable::IArchive &ar, const char *label,
1266 Type &value, bool isRequired)
1267 {
1268 ScalarParam<Type>* ptr;
1269 ptr = new ScalarParam<Type>(label, value, isRequired);
1270 setParent(*ptr);
1271 ptr->load(ar);
1272 addComponent(*ptr);
1273 return *ptr;
1274 }
1275
1276 /*
1277 * Add a new required ScalarParam< Type > object, and load from an archive.
1278 */
1279 template <typename Type>
1280 inline ScalarParam<Type>&
1281 ParamComposite::loadParameter(Serializable::IArchive &ar, const char *label,
1282 Type &value)
1283 { return loadParameter<Type>(ar, label, value, true); }
1284
1285 // Templates for 1D C Arrays
1286
1287 /*
1288 * Add and read a CArrayParam associated with a built-in C-array (private).
1289 */
1290 template <typename Type>
1291 CArrayParam<Type>&
1292 ParamComposite::readCArray_(std::istream &in, const char *label,
1293 Type *value, int n, bool isRequired)
1294 {
1295 CArrayParam<Type>* ptr;
1296 ptr = new CArrayParam<Type>(label, value, n, isRequired);
1297 setParent(*ptr);
1298 ptr->readParam(in);
1299 addComponent(*ptr);
1300 return *ptr;
1301 }
1302
1303 /*
1304 * Add a CArrayParam built-in C-array parameter (protected).
1305 */
1306 template <typename Type>
1307 CArrayParam<Type>&
1308 ParamComposite::addCArray(std::istream &in, const char *label,
1309 Type *value, int n, bool isRequired)
1310 {
1311 CArrayParam<Type>* ptr;
1312 ptr = new CArrayParam<Type>(label, value, n, isRequired);
1313 setParent(*ptr);
1314 addComponent(*ptr);
1315 return *ptr;
1316 }
1317
1318 /*
1319 * Add and read a required CArrayParam.
1320 */
1321 template <typename Type>
1322 inline CArrayParam<Type>&
1323 ParamComposite::readCArray(std::istream &in, const char *label,
1324 Type *value, int n)
1325 { return readCArray_<Type>(in, label, value, n, true); }
1326
1327 /*
1328 * Add and read an optional CArrayParam.
1329 */
1330 template <typename Type>
1331 inline CArrayParam<Type>&
1332 ParamComposite::readOptionalCArray(std::istream &in, const char *label,
1333 Type *value, int n)
1334 { return readCArray_<Type>(in, label, value, n, false); }
1335
1336 /*
1337 * Add and load a C array parameter.
1338 */
1339 template <typename Type>
1340 CArrayParam<Type>&
1341 ParamComposite::loadCArray(Serializable::IArchive &ar, const char *label,
1342 Type *value, int n, bool isRequired)
1343 {
1344 CArrayParam<Type>* ptr;
1345 ptr = new CArrayParam<Type>(label, value, n, isRequired);
1346 setParent(*ptr);
1347 ptr->load(ar);
1348 addComponent(*ptr);
1349 return *ptr;
1350 }
1351
1352 /*
1353 * Add and load a required C array parameter.
1354 */
1355 template <typename Type>
1356 inline CArrayParam<Type>&
1357 ParamComposite::loadCArray(Serializable::IArchive &ar, const char *label,
1358 Type *value, int n)
1359 { return loadCArray<Type>(ar, label, value, n, true); }
1360
1361 // Templates for DArray parameters
1362
1363 /*
1364 * Add and read a DArrayParam associated with a DArray<Type> (private).
1365 */
1366 template <typename Type>
1367 DArrayParam<Type>&
1368 ParamComposite::readDArray_(std::istream &in, const char *label,
1369 DArray<Type>& array, int n, bool isRequired)
1370 {
1371 DArrayParam<Type>* ptr;
1372 ptr = new DArrayParam<Type>(label, array, n, isRequired);
1373 setParent(*ptr);
1374 ptr->readParam(in);
1375 addComponent(*ptr);
1376 return *ptr;
1377 }
1378
1379 /*
1380 * Add a DArray<Type> DArray parameter (protected).
1381 */
1382 template <typename Type>
1383 DArrayParam<Type>&
1384 ParamComposite::addDArray(std::istream &in, const char *label,
1385 DArray<Type>& array, int n, bool isRequired)
1386 {
1387 DArrayParam<Type>* ptr;
1388 ptr = new DArrayParam<Type>(label, array, n, isRequired);
1389 setParent(*ptr);
1390 addComponent(*ptr);
1391 return *ptr;
1392 }
1393
1394 /*
1395 * Add and read a required DArrayParam.
1396 */
1397 template <typename Type>
1398 inline
1399 DArrayParam<Type>&
1400 ParamComposite::readDArray(std::istream &in, const char *label,
1401 DArray<Type>& array, int n)
1402 { return readDArray_<Type>(in, label, array, n, true); }
1403
1404 /*
1405 * Add and read an optional DArrayParam.
1406 */
1407 template <typename Type>
1408 inline
1409 DArrayParam<Type>&
1410 ParamComposite::readOptionalDArray(std::istream &in, const char *label,
1411 DArray<Type>& array, int n)
1412 { return readDArray_<Type>(in, label, array, n, false); }
1413
1414 /*
1415 * Add a DArray < Type > parameter, and load its elements.
1416 */
1417 template <typename Type>
1418 DArrayParam<Type>&
1419 ParamComposite::loadDArray(Serializable::IArchive &ar, const char* label,
1420 DArray<Type>& array, int n, bool isRequired)
1421 {
1422 DArrayParam<Type>* ptr;
1423 ptr = new DArrayParam<Type>(label, array, n, isRequired);
1424 setParent(*ptr);
1425 ptr->load(ar);
1426 addComponent(*ptr);
1427 return *ptr;
1428 }
1429
1430 /*
1431 * Add a required DArray < Type > parameter, and load its elements.
1432 */
1433 template <typename Type>
1434 inline DArrayParam<Type>&
1435 ParamComposite::loadDArray(Serializable::IArchive &ar, const char *label,
1436 DArray<Type>& array, int n)
1437 { return loadDArray<Type>(ar, label, array, n, true); }
1438
1439
1440
1441 // Templates for fixed size FArray array objects.
1442
1443 /*
1444 * Add and read an FArrayParam<Type, N> fixed size array (private).
1445 */
1446 template <typename Type, int N>
1447 FArrayParam<Type, N>&
1448 ParamComposite::readFArray_(std::istream &in, const char *label,
1449 FArray<Type, N>& array, bool isRequired)
1450 {
1451 FArrayParam<Type, N>* ptr;
1452 ptr = new FArrayParam<Type, N>(label, array, isRequired);
1453 setParent(*ptr);
1454 ptr->readParam(in);
1455 addComponent(*ptr);
1456 return *ptr;
1457 }
1458
1459 /*
1460 * Add a FArrayParam<Type, N> parameter (protected).
1461 */
1462 template <typename Type, int N>
1463 FArrayParam<Type, N>&
1464 ParamComposite::addFArray(std::istream &in, const char *label,
1465 FArray<Type, N>& array, bool isRequired)
1466 {
1467 FArrayParam<Type, N>* ptr;
1468 ptr = new FArrayParam<Type, N>(label, array, isRequired);
1469 setParent(*ptr);
1470 addComponent(*ptr);
1471 return *ptr;
1472 }
1473
1474 /*
1475 * Add and read a required FArray < Type, N > array parameter.
1476 */
1477 template <typename Type, int N>
1478 inline
1479 FArrayParam<Type, N>&
1480 ParamComposite::readFArray(std::istream &in, const char *label,
1481 FArray<Type, N >& array)
1482 { return readFArray_<Type>(in, label, array, true); }
1483
1484 /*
1485 * Add and read an optional FArray < Type, N > array parameter.
1486 */
1487 template <typename Type, int N>
1488 inline
1489 FArrayParam<Type, N>&
1490 ParamComposite::readOptionalFArray(std::istream &in, const char *label,
1491 FArray<Type, N >& array)
1492 { return readFArray_<Type>(in, label, array, false); }
1493
1494 /*
1495 * Add and load an FArray < Type, N > fixed-size array parameter.
1496 */
1497 template <typename Type, int N>
1498 FArrayParam<Type, N>&
1499 ParamComposite::loadFArray(Serializable::IArchive &ar, const char *label,
1500 FArray<Type, N >& array, bool isRequired)
1501 {
1502 FArrayParam<Type, N>* ptr;
1503 ptr = new FArrayParam<Type, N>(label, array, isRequired);
1504 setParent(*ptr);
1505 ptr->load(ar);
1506 addComponent(*ptr);
1507 return *ptr;
1508 }
1509
1510 // Templates for fixed size FSArray array objects.
1511
1512 /*
1513 * Add and read an FSArrayParam<Type, N> fixed size array (private).
1514 */
1515 template <typename Type, int N>
1516 FSArrayParam<Type, N>&
1517 ParamComposite::readFSArray_(std::istream &in, const char *label,
1518 FSArray<Type, N>& array, int size,
1519 bool isRequired)
1520 {
1521 FSArrayParam<Type, N>* ptr;
1522 ptr = new FSArrayParam<Type, N>(label, array, size, isRequired);
1523 setParent(*ptr);
1524 ptr->readParam(in);
1525 addComponent(*ptr);
1526 return *ptr;
1527 }
1528
1529 /*
1530 * Add a FSArrayParam<Type, N> parameter (protected).
1531 */
1532 template <typename Type, int N>
1533 FSArrayParam<Type, N>&
1534 ParamComposite::addFSArray(std::istream &in, const char *label,
1535 FSArray<Type, N>& array, int size,
1536 bool isRequired)
1537 {
1538 FSArrayParam<Type, N>* ptr;
1539 ptr = new FSArrayParam<Type, N>(label, array, size, isRequired);
1540 setParent(*ptr);
1541 addComponent(*ptr);
1542 return *ptr;
1543 }
1544
1545 /*
1546 * Add and read a required FSArray < Type, N > array parameter.
1547 */
1548 template <typename Type, int N>
1549 inline
1550 FSArrayParam<Type, N>&
1551 ParamComposite::readFSArray(std::istream &in, const char *label,
1552 FSArray<Type, N >& array, int size)
1553 { return readFSArray_<Type>(in, label, array, size, true); }
1554
1555 /*
1556 * Add and read an optional FSArray < Type, N > array parameter.
1557 */
1558 template <typename Type, int N>
1559 inline
1560 FSArrayParam<Type, N>&
1561 ParamComposite::readOptionalFSArray(std::istream &in,
1562 const char *label,
1563 FSArray<Type, N >& array,
1564 int size)
1565 { return readFSArray_<Type>(in, label, array, size, false); }
1566
1567 /*
1568 * Add and load an FSArray < Type, N > fixed-size array parameter.
1569 */
1570 template <typename Type, int N>
1571 FSArrayParam<Type, N>&
1572 ParamComposite::loadFSArray(Serializable::IArchive &ar,
1573 const char *label,
1574 FSArray<Type, N >& array, int size,
1575 bool isRequired)
1576 {
1577 FSArrayParam<Type, N>* ptr;
1578 ptr = new FSArrayParam<Type, N>(label, array, size, isRequired);
1579 setParent(*ptr);
1580 ptr->load(ar);
1581 addComponent(*ptr);
1582 return *ptr;
1583 }
1584
1585 // Templates for built-in two-dimensional C Arrays
1586
1587 /*
1588 * Add and read a CArray2DParam 2D C array (private).
1589 */
1590 template <typename Type>
1591 CArray2DParam<Type>&
1592 ParamComposite::readCArray2D_(std::istream &in, const char *label,
1593 Type *value, int m, int n, int np,
1594 bool isRequired)
1595 {
1596 CArray2DParam<Type>* ptr;
1597 ptr = new CArray2DParam<Type>(label, value, m, n, np, isRequired);
1598 setParent(*ptr);
1599 ptr->readParam(in);
1600 addComponent(*ptr);
1601 return *ptr;
1602 }
1603
1604 /*
1605 * Add a CArray2DParam 2D C array (protected).
1606 */
1607 template <typename Type>
1608 CArray2DParam<Type>&
1609 ParamComposite::addCArray2D(std::istream &in, const char *label,
1610 Type *value, int m, int n, int np,
1611 bool isRequired)
1612 {
1613 CArray2DParam<Type>* ptr;
1614 ptr = new CArray2DParam<Type>(label, value, m, n, np, isRequired);
1615 setParent(*ptr);
1616 addComponent(*ptr);
1617 return *ptr;
1618 }
1619
1620 /*
1621 * Add and read a required CArray2DParam.
1622 */
1623 template <typename Type>
1624 inline CArray2DParam<Type>&
1625 ParamComposite::readCArray2D(std::istream &in, const char *label,
1626 Type *value, int m, int n, int np)
1627 { return readCArray2D_<Type>(in, label, value, m, n, np, true); }
1628
1629 /*
1630 * Add and read an optional CArray2DParam.
1631 */
1632 template <typename Type>
1633 inline CArray2DParam<Type>&
1634 ParamComposite::readOptionalCArray2D(std::istream &in,
1635 const char *label, Type *value,
1636 int m, int n, int np)
1637 { return readCArray2D_<Type>(in, label, value, m, n, np, false); }
1638
1639 /*
1640 * Add and load a CArray2DParam < Type > 2D C array parameter.
1641 */
1642 template <typename Type>
1643 CArray2DParam<Type>&
1644 ParamComposite::loadCArray2D(Serializable::IArchive &ar,
1645 const char *label,
1646 Type *value, int m, int n, int np,
1647 bool isRequired)
1648 {
1649 CArray2DParam<Type>* ptr;
1650 ptr = new CArray2DParam<Type>(label, value, m, n, np, isRequired);
1651 setParent(*ptr);
1652 ptr->load(ar);
1653 addComponent(*ptr);
1654 return *ptr;
1655 }
1656
1657 /*
1658 * Add and load a required CArray2DParam < Type > 2D C array.
1659 */
1660 template <typename Type>
1661 CArray2DParam<Type>&
1662 ParamComposite::loadCArray2D(Serializable::IArchive &ar,
1663 const char *label,
1664 Type *value, int m, int n, int np)
1665 { return loadCArray2D<Type>(ar, label, value, m, n, np, true); }
1666
1667 // Templates for DMatrix containers
1668
1669 /*
1670 * Add and read a DMatrixParam DMatrix<Type> parameter (private).
1671 */
1672 template <typename Type>
1673 DMatrixParam<Type>&
1674 ParamComposite::readDMatrix_(std::istream &in, const char *label,
1675 DMatrix<Type>& matrix, int m, int n,
1676 bool isRequired)
1677 {
1678 DMatrixParam<Type>* ptr;
1679 ptr = new DMatrixParam<Type>(label, matrix, m, n, isRequired);
1680 setParent(*ptr);
1681 ptr->readParam(in);
1682 addComponent(*ptr);
1683 return *ptr;
1684 }
1685
1686 /*
1687 * Add a DMatrixParam DMatrix<Type> parameter (protected).
1688 */
1689 template <typename Type>
1690 DMatrixParam<Type>&
1691 ParamComposite::addDMatrix(std::istream &in, const char *label,
1692 DMatrix<Type>& matrix, int m, int n,
1693 bool isRequired)
1694 {
1695 DMatrixParam<Type>* ptr;
1696 ptr = new DMatrixParam<Type>(label, matrix, m, n, isRequired);
1697 setParent(*ptr);
1698 addComponent(*ptr);
1699 return *ptr;
1700 }
1701
1702 /*
1703 * Add and read a required DMatrixParam.
1704 */
1705 template <typename Type>
1706 inline DMatrixParam<Type>&
1707 ParamComposite::readDMatrix(std::istream &in, const char *label,
1708 DMatrix<Type>& matrix, int m, int n)
1709 { return readDMatrix_<Type>(in, label, matrix, m, n, true); }
1710
1711 /*
1712 * Add and read an optional DMatrixParam.
1713 */
1714 template <typename Type>
1715 inline DMatrixParam<Type>&
1716 ParamComposite::readOptionalDMatrix(std::istream &in, const char *label,
1717 DMatrix<Type>& matrix, int m, int n)
1718 { return readDMatrix_<Type>(in, label, matrix, m, n, false); }
1719
1720 /*
1721 * Add and load a DMatrix < Type > C two-dimensional matrix parameter.
1722 */
1723 template <typename Type>
1724 DMatrixParam<Type>&
1725 ParamComposite::loadDMatrix(Serializable::IArchive &ar, const char *label,
1726 DMatrix<Type>& matrix, int m, int n,
1727 bool isRequired)
1728 {
1729 DMatrixParam<Type>* ptr;
1730 ptr = new DMatrixParam<Type>(label, matrix, m, n, isRequired);
1731 setParent(*ptr);
1732 ptr->load(ar);
1733 addComponent(*ptr);
1734 return *ptr;
1735 }
1736
1737 /*
1738 * Add and load a required DMatrixParam< Type> matrix parameter.
1739 */
1740 template <typename Type>
1741 inline DMatrixParam<Type>&
1742 ParamComposite::loadDMatrix(Serializable::IArchive &ar, const char *label,
1743 DMatrix<Type>& matrix, int m, int n)
1744 { return loadDMatrix<Type>(ar, label, matrix, m, n, true); }
1745
1746 // Templates for Symmetric DMatrix containers
1747
1748 /*
1749 * Add and read a symmetric DMatrixParam DMatrix (private).
1750 */
1751 template <typename Type>
1752 DSymmMatrixParam<Type>&
1753 ParamComposite::readDSymmMatrix_(std::istream &in,
1754 const char *label,
1755 DMatrix<Type>& matrix,
1756 int n,
1757 bool isRequired)
1758 {
1759 DSymmMatrixParam<Type>* ptr;
1760 ptr = new DSymmMatrixParam<Type>(label, matrix, n, isRequired);
1761 setParent(*ptr);
1762 ptr->readParam(in);
1763 addComponent(*ptr);
1764 return *ptr;
1765 }
1766
1767 /*
1768 * Add and read a required DMatrixParam.
1769 */
1770 template <typename Type>
1771 inline DSymmMatrixParam<Type>&
1772 ParamComposite::readDSymmMatrix(std::istream& in,
1773 const char *label,
1774 DMatrix<Type>& matrix,
1775 int n)
1776 { return readDSymmMatrix_<Type>(in, label, matrix, n, true); }
1777
1778 /*
1779 * Add and read an optional DMatrixParam.
1780 */
1781 template <typename Type>
1782 inline DSymmMatrixParam<Type>&
1783 ParamComposite::readOptionalDSymmMatrix(std::istream &in,
1784 const char *label,
1785 DMatrix<Type>& matrix,
1786 int n)
1787 { return readDMatrix_<Type>(in, label, matrix, n, false); }
1788
1789 /*
1790 * Add and load a DMatrix < Type > C two-dimensional matrix parameter.
1791 */
1792 template <typename Type>
1793 DSymmMatrixParam<Type>&
1794 ParamComposite::loadDSymmMatrix(Serializable::IArchive &ar,
1795 const char *label,
1796 DMatrix<Type>& matrix,
1797 int n,
1798 bool isRequired)
1799 {
1800 DSymmMatrixParam<Type>* ptr;
1801 ptr = new DSymmMatrixParam<Type>(label, matrix, n, isRequired);
1802 setParent(*ptr);
1803 ptr->load(ar);
1804 addComponent(*ptr);
1805 return *ptr;
1806 }
1807
1808 /*
1809 * Add and load a required DMatrixParam< Type> matrix parameter.
1810 */
1811 template <typename Type>
1812 inline DSymmMatrixParam<Type>&
1813 ParamComposite::loadDSymmMatrix(Serializable::IArchive &ar,
1814 const char *label,
1815 DMatrix<Type>& matrix,
1816 int n)
1817 { return loadDSymmMatrix<Type>(ar, label, matrix, n, true); }
1818
1819}
1820#endif
Util::ArrayParam::load
virtual void load(Serializable::IArchive &ar)
Load from an archive.
Definition: Parameter.cpp:104
Util::Begin
Beginning line of a composite parameter block.
Definition: Begin.h:25
Util::BinaryFileIArchive
Saving archive for binary istream.
Definition: BinaryFileIArchive.h:31
Util::BinaryFileOArchive
Saving / output archive for binary ostream.
Definition: BinaryFileOArchive.h:31
Util::Blank
An empty line within a parameter file.
Definition: Blank.h:25
Util::CArray2DParam
A Parameter associated with a 2D built-in C array.
Definition: CArray2DParam.h:30
Util::CArrayParam
A Parameter associated with a 1D C array.
Definition: CArrayParam.h:23
Util::DArrayParam
A Parameter associated with a DArray container.
Definition: DArrayParam.h:27
Util::DArray
Dynamically allocatable contiguous array template.
Definition: DArray.h:32
Util::DMatrixParam
A Parameter associated with a 2D built-in C array.
Definition: DMatrixParam.h:30
Util::DMatrix
Dynamically allocated Matrix.
Definition: DMatrix.h:25
Util::DSymmMatrixParam
A Parameter associated with a square symmetric DMatrix.
Definition: DSymmMatrixParam.h:49
Util::End
End bracket of a ParamComposite parameter block.
Definition: End.h:25
Util::FArrayParam
A Parameter associated with a FArray container.
Definition: FArrayParam.h:27
Util::FArray
A fixed size (static) contiguous array template.
Definition: FArray.h:47
Util::FSArrayParam
A Parameter associated with a FSArray container.
Definition: FSArrayParam.h:27
Util::FSArray
A fixed capacity (static) contiguous array with a variable logical size.
Definition: FSArray.h:38
Util::MatrixParam::load
virtual void load(Serializable::IArchive &ar)
Load from an archive.
Definition: Parameter.cpp:104
Util::ParamComponent
Abstract base class for classes that input and ouput parameters to file.
Definition: ParamComponent.h:32
Util::ParamComposite
An object that can read multiple parameters from file.
Definition: ParamComposite.h:91
Util::ParamComposite::load
virtual void load(Serializable::IArchive &ar)
Load all parameters from an input archive.
Definition: ParamComposite.cpp:131
Util::ParamComposite::add
ScalarParam< Type > & add(std::istream &in, const char *label, Type &value, bool isRequired=true)
Add a new required ScalarParam < Type > object.
Definition: ParamComposite.h:1233
Util::ParamComposite::loadOptional
virtual void loadOptional(Serializable::IArchive &ar)
Load an optional ParamComposite.
Definition: ParamComposite.cpp:152
Util::ParamComposite::addFSArray
FSArrayParam< Type, N > & addFSArray(std::istream &in, const char *label, FSArray< Type, N > &array, int size, bool isRequired=true)
Add (but do not read) a FSArray < Type, N > array parameter.
Definition: ParamComposite.h:1534
Util::ParamComposite::readOptionalFSArray
FSArrayParam< Type, N > & readOptionalFSArray(std::istream &in, const char *label, FSArray< Type, N > &array, int size)
Add and read an optional FSArray < Type, N > array parameter.
Definition: ParamComposite.h:1561
Util::ParamComposite::readDSymmMatrix
DSymmMatrixParam< Type > & readDSymmMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int n)
Add and read a required symmetrix DMatrix.
Definition: ParamComposite.h:1772
Util::ParamComposite::readDArray
DArrayParam< Type > & readDArray(std::istream &in, const char *label, DArray< Type > &array, int n)
Add and read a required DArray < Type > parameter.
Definition: ParamComposite.h:1400
Util::ParamComposite::readOptionalDArray
DArrayParam< Type > & readOptionalDArray(std::istream &in, const char *label, DArray< Type > &array, int n)
Add and read an optional DArray < Type > parameter.
Definition: ParamComposite.h:1410
Util::ParamComposite::readParameters
virtual void readParameters(std::istream &in)
Read the body of parameter block, without begin and end lines.
Definition: ParamComposite.h:181
Util::ParamComposite::readOptionalFArray
FArrayParam< Type, N > & readOptionalFArray(std::istream &in, const char *label, FArray< Type, N > &array)
Add and read an optional FArray < Type, N > array parameter.
Definition: ParamComposite.h:1490
Util::ParamComposite::read
ScalarParam< Type > & read(std::istream &in, const char *label, Type &value)
Add and read a new required ScalarParam < Type > object.
Definition: ParamComposite.h:1248
Util::ParamComposite::loadFArray
FArrayParam< Type, N > & loadFArray(Serializable::IArchive &ar, const char *label, FArray< Type, N > &array, bool isRequired)
Add and load an FArray < Type, N > fixed-size array parameter.
Definition: ParamComposite.h:1499
Util::ParamComposite::readFArray
FArrayParam< Type, N > & readFArray(std::istream &in, const char *label, FArray< Type, N > &array)
Add and read a required FArray < Type, N > array parameter.
Definition: ParamComposite.h:1480
Util::ParamComposite::readBegin
Begin & readBegin(std::istream &in, const char *label, bool isRequired=true)
Add and read a class label and opening bracket.
Definition: ParamComposite.cpp:316
Util::ParamComposite::addParamComposite
void addParamComposite(ParamComposite &child, bool next=true)
Add a child ParamComposite object to the format array.
Definition: ParamComposite.cpp:249
Util::ParamComposite::saveOptional
void saveOptional(Serializable::OArchive &ar)
Saves isActive flag, and then calls save() iff isActive is true.
Definition: ParamComposite.cpp:198
Util::ParamComposite::setClassName
void setClassName(const char *className)
Set class name string.
Definition: ParamComposite.cpp:377
Util::ParamComposite::setIsRequired
void setIsRequired(bool isRequired)
Set or unset the isActive flag.
Definition: ParamComposite.cpp:383
Util::ParamComposite::readDMatrix
DMatrixParam< Type > & readDMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int m, int n)
Add and read a required DMatrix < Type > matrix parameter.
Definition: ParamComposite.h:1707
Util::ParamComposite::readFSArray
FSArrayParam< Type, N > & readFSArray(std::istream &in, const char *label, FSArray< Type, N > &array, int size)
Add and read a required FSArray < Type, N > array parameter.
Definition: ParamComposite.h:1551
Util::ParamComposite::resetParam
void resetParam()
Resets ParamComposite to its empty state.
Definition: ParamComposite.cpp:209
Util::ParamComposite::~ParamComposite
virtual ~ParamComposite()
Virtual destructor.
Definition: ParamComposite.cpp:68
Util::ParamComposite::save
virtual void save(Serializable::OArchive &ar)
Saves all parameters to an archive.
Definition: ParamComposite.cpp:188
Util::ParamComposite::addBegin
Begin & addBegin(const char *label)
Add a Begin object representing a class name and bracket.
Definition: ParamComposite.cpp:305
Util::ParamComposite::readCArray2D
CArray2DParam< Type > & readCArray2D(std::istream &in, const char *label, Type *value, int m, int n, int np)
Add and read a required CArray2DParam < Type > 2D C-array.
Definition: ParamComposite.h:1625
Util::ParamComposite::addDArray
DArrayParam< Type > & addDArray(std::istream &in, const char *label, DArray< Type > &array, int n, bool isRequired=true)
Add (but do not read) a DArray < Type > parameter.
Definition: ParamComposite.h:1384
Util::ParamComposite::setIsActive
void setIsActive(bool isActive)
Set or unset the isActive flag.
Definition: ParamComposite.cpp:394
Util::ParamComposite::writeParam
virtual void writeParam(std::ostream &out) const
Write all parameters to an output stream.
Definition: ParamComposite.cpp:119
Util::ParamComposite::readOptional
ScalarParam< Type > & readOptional(std::istream &in, const char *label, Type &value)
Add and read a new optional ScalarParam < Type > object.
Definition: ParamComposite.h:1256
Util::ParamComposite::loadParamComposite
void loadParamComposite(Serializable::IArchive &ar, ParamComposite &child, bool next=true)
Add and load a required child ParamComposite.
Definition: ParamComposite.cpp:282
Util::ParamComposite::addCArray
CArrayParam< Type > & addCArray(std::istream &in, const char *label, Type *value, int n, bool isRequired=true)
Add (but do not read) a required C array parameter.
Definition: ParamComposite.h:1308
Util::ParamComposite::loadCArray
CArrayParam< Type > & loadCArray(Serializable::IArchive &ar, const char *label, Type *value, int n, bool isRequired)
Add a C array parameter and load its elements.
Definition: ParamComposite.h:1341
Util::ParamComposite::readCArray
CArrayParam< Type > & readCArray(std::istream &in, const char *label, Type *value, int n)
Add and read a required C array parameter.
Definition: ParamComposite.h:1323
Util::ParamComposite::readParam
virtual void readParam(std::istream &in)
Read the parameter file block.
Definition: ParamComposite.cpp:88
Util::ParamComposite::addBlank
Blank & addBlank()
Create and add a new Blank object, representing a blank line.
Definition: ParamComposite.cpp:356
Util::ParamComposite::isActive
bool isActive() const
Is this parameter active?
Definition: ParamComposite.h:1207
Util::ParamComposite::addFArray
FArrayParam< Type, N > & addFArray(std::istream &in, const char *label, FArray< Type, N > &array, bool isRequired=true)
Add (but do not read) a FArray < Type, N > array parameter.
Definition: ParamComposite.h:1464
Util::ParamComposite::loadParameter
ScalarParam< Type > & loadParameter(Serializable::IArchive &ar, const char *label, Type &value, bool isRequired)
Add and load a new ScalarParam < Type > object.
Definition: ParamComposite.h:1265
Util::ParamComposite::loadFSArray
FSArrayParam< Type, N > & loadFSArray(Serializable::IArchive &ar, const char *label, FSArray< Type, N > &array, int size)
Add and load a required FSArray < Type > array parameter.
Definition: ParamComposite.h:736
Util::ParamComposite::addEnd
End & addEnd()
Add a closing bracket.
Definition: ParamComposite.cpp:333
Util::ParamComposite::ParamComposite
ParamComposite()
Constructor.
Definition: ParamComposite.cpp:23
Util::ParamComposite::className
std::string className() const
Get class name string.
Definition: ParamComposite.h:1195
Util::ParamComposite::loadParamCompositeOptional
void loadParamCompositeOptional(Serializable::IArchive &ar, ParamComposite &child, bool next=true)
Add and load an optional child ParamComposite if isActive.
Definition: ParamComposite.cpp:293
Util::ParamComposite::loadDMatrix
DMatrixParam< Type > & loadDMatrix(Serializable::IArchive &ar, const char *label, DMatrix< Type > &matrix, int m, int n, bool isRequired)
Add and load a DMatrixParam < Type > matrix parameter.
Definition: ParamComposite.h:1725
Util::ParamComposite::addCArray2D
CArray2DParam< Type > & addCArray2D(std::istream &in, const char *label, Type *value, int m, int n, int np, bool isRequired=true)
Add (but do not read) a CArray2DParam < Type > 2D C-array.
Definition: ParamComposite.h:1609
Util::ParamComposite::readBlank
Blank & readBlank(std::istream &in)
Add and read a new Blank object, representing a blank line.
Definition: ParamComposite.cpp:367
Util::ParamComposite::loadCArray2D
CArray2DParam< Type > & loadCArray2D(Serializable::IArchive &ar, const char *label, Type *value, int m, int n, int np, bool isRequired)
Add and load a CArray2DParam < Type > C 2D array parameter.
Definition: ParamComposite.h:1644
Util::ParamComposite::loadFSArray
FSArrayParam< Type, N > & loadFSArray(Serializable::IArchive &ar, const char *label, FSArray< Type, N > &array, int size, bool isRequired)
Add and load an FSArray < Type, N > array parameter.
Definition: ParamComposite.h:1572
Util::ParamComposite::readParamComposite
void readParamComposite(std::istream &in, ParamComposite &child, bool next=true)
Add and read a required child ParamComposite.
Definition: ParamComposite.cpp:260
Util::ParamComposite::addDMatrix
DMatrixParam< Type > & addDMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int m, int n, bool isRequired=true)
Add and read a required DMatrix < Type > matrix parameter.
Definition: ParamComposite.h:1691
Util::ParamComposite::readOptionalDSymmMatrix
DSymmMatrixParam< Type > & readOptionalDSymmMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int n)
Add and read an optional DMatrix matrix parameter.
Definition: ParamComposite.h:1783
Util::ParamComposite::readOptionalCArray
CArrayParam< Type > & readOptionalCArray(std::istream &in, const char *label, Type *value, int n)
Add and read an optional C array parameter.
Definition: ParamComposite.h:1332
Util::ParamComposite::readParamOptional
virtual void readParamOptional(std::istream &in)
Read optional parameter file block.
Definition: ParamComposite.cpp:101
Util::ParamComposite::readParamCompositeOptional
void readParamCompositeOptional(std::istream &in, ParamComposite &child, bool next=true)
Add and attempt to read an optional child ParamComposite.
Definition: ParamComposite.cpp:271
Util::ParamComposite::loadDSymmMatrix
DSymmMatrixParam< Type > & loadDSymmMatrix(Serializable::IArchive &ar, const char *label, DMatrix< Type > &matrix, int n, bool isRequired)
Add and load a symmetric DSymmMatrixParam < Type > matrix parameter.
Definition: ParamComposite.h:1794
Util::ParamComposite::readEnd
End & readEnd(std::istream &in)
Add and read the closing bracket.
Definition: ParamComposite.cpp:344
Util::ParamComposite::setParent
void setParent(ParamComponent &param, bool next=true)
Set this to the parent of a child component.
Definition: ParamComposite.cpp:224
Util::ParamComposite::loadDArray
DArrayParam< Type > & loadDArray(Serializable::IArchive &ar, const char *label, DArray< Type > &array, int n, bool isRequired)
Add an load a DArray < Type > array parameter.
Definition: ParamComposite.h:1419
Util::ParamComposite::loadParameters
virtual void loadParameters(Serializable::IArchive &ar)
Load state from archive, without adding Begin and End lines.
Definition: ParamComposite.h:234
Util::ParamComposite::addComponent
void addComponent(ParamComponent &param, bool isLeaf=true)
Add a new ParamComponent object to the format array.
Definition: ParamComposite.cpp:237
Util::ParamComposite::readOptionalDMatrix
DMatrixParam< Type > & readOptionalDMatrix(std::istream &in, const char *label, DMatrix< Type > &matrix, int m, int n)
Add and read an optional DMatrix < Type > matrix parameter.
Definition: ParamComposite.h:1716
Util::ParamComposite::loadFArray
FArrayParam< Type, N > & loadFArray(Serializable::IArchive &ar, const char *label, FArray< Type, N > &array)
Add and load a required FArray < Type > array parameter.
Definition: ParamComposite.h:704
Util::ParamComposite::readOptionalCArray2D
CArray2DParam< Type > & readOptionalCArray2D(std::istream &in, const char *label, Type *value, int m, int n, int np)
Add and read an optional CArray2DParam < Type > 2D C-array parameter.
Definition: ParamComposite.h:1634
Util::ParamComposite::isRequired
bool isRequired() const
Is this ParamComposite required in the input file?
Definition: ParamComposite.h:1201
Util::Parameter::readParam
virtual void readParam(std::istream &in)
Read a label and (if the label matches) a parameter value.
Definition: Parameter.cpp:42
Util::Parameter::load
virtual void load(Serializable::IArchive &ar)
Load from an archive.
Definition: Parameter.cpp:104
Util::ScalarParam
Template for a Parameter object associated with a scalar variable.
Definition: ScalarParam.h:35
global.h
File containing preprocessor macros for error handling.
Util
Utility classes for scientific computation.
Definition: accumulators.mod:1
Generated on Wed Sep 20 2023 00:52:46 for PSCF by doxygen 1.9.5