Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
/**
* \file
* \author Norbert Grunwald
* \date Sep 7, 2017
*
* \copyright
* Copyright (c) 2012-2019, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
*/
#include "CreateProperty.h"
#include <string>
#include <vector>
#include "BaseLib/ConfigTree.h"
#include "Properties/Properties.h"
#include "Component.h"
#include "Medium.h"
#include "Phase.h"
namespace
{
std::unique_ptr<MaterialPropertyLib::Property> createProperty(
BaseLib::ConfigTree const& config)
{
using namespace MaterialPropertyLib;
// Parsing the property type:
//! \ogs_file_param{properties__property__type}
auto const property_type = config.getConfigParameter<std::string>("type");
// If (and only if) the given property type is 'constant', a
// corresponding value is needed.
if (property_type == "Constant")
{
//! \ogs_file_param{properties__property__Constant__value}
std::vector<double> const values =
config.getConfigParameter<std::vector<double>>("value");
switch (values.size())
{
case 1:
{
// scalar
PropertyDataType property_value = values[0];
return std::make_unique<Constant>(property_value);
}
case 2:
{
// Pair
PropertyDataType property_value = Pair{values[0], values[1]};
return std::make_unique<Constant>(property_value);
}
case 3:
{
// Vector
PropertyDataType property_value =
Vector{values[0], values[1], values[2]};
return std::make_unique<Constant>(property_value);
}
case 6:
{
// Symmetric Tensor - xx, yy, zz, xy, xz, yz
PropertyDataType property_value =
SymmTensor{values[0], values[1], values[2],
values[3], values[4], values[5]};
return std::make_unique<Constant>(property_value);
}
case 9:
{
// Tensor
PropertyDataType property_value = Tensor{
values[0], values[1], values[2], values[3], values[4],
values[5], values[6], values[7], values[8]};
return std::make_unique<Constant>(property_value);
}
default:
{
OGS_FATAL(
"Creation of a constant property with %i components is not "
"implemented.",
values.size());
}
}
PropertyDataType property_value;
return std::make_unique<Constant>(property_value);
}
// Properties can be medium, phase, or component properties.
// Some of them require information about the respective material.
// Thus, we pass a pointer to the material that requests the property.
// In this method, this pointer is realized via typename MaterialType, which
// replaces either Medium*, Phase*, or Component*.
// Note that most property constructors (only those that request material
// pointers) must be overloaded for any type of material.
/* TODO Additional properties go here, for example:
if (boost::iequals(property_type, "BilinearTemperaturePressure"))
{
return createBilinearTemperaturePressure(config, material_type);
}
*/
// If none of the above property types are found, OGS throws an error.
OGS_FATAL("The specified component property type '%s' was not recognized",
property_type.c_str());
}
} // namespace
namespace MaterialPropertyLib
{
std::unique_ptr<PropertyArray> createProperties(
boost::optional<BaseLib::ConfigTree> const& config)
{
if (!config)
{
return nullptr;
}
//! \ogs_file_param{properties__property}
auto const& property_configs = config->getConfigSubtreeList("property");
if (property_configs.empty())
{
return nullptr;
}
auto properties = std::make_unique<PropertyArray>();
for (auto property_config : property_configs)
{
// Parsing the property name:
auto const property_name =
//! \ogs_file_param{properties__property__name}
property_config.getConfigParameter<std::string>("name");
// Create a new property based on the configuration subtree:
auto property = createProperty(property_config);
// Insert the new property at the right position into the components
// private PropertyArray:
(*properties)[convertStringToProperty(property_name)] =
std::move(property);
}
return properties;
}
} // namespace MaterialPropertyLib