38{
40 config.checkConfigParameter("type", "PHASE_FIELD");
41 DBUG(
"Create PhaseFieldProcess.");
42
43 auto const coupling_scheme =
45 config.getConfigParameterOptional<std::string>("coupling_scheme");
46 const bool use_monolithic_scheme =
47 !(coupling_scheme && (*coupling_scheme == "staggered"));
48
50
52 auto const pv_config = config.getConfigSubtree("process_variables");
53
56 std::vector<std::vector<std::reference_wrapper<ProcessVariable>>>
57 process_variables;
58 if (use_monolithic_scheme)
59 {
60 OGS_FATAL(
"Monolithic implementation is not available.");
61 }
62 else
63 {
64 using namespace std::string_literals;
65 for (
68 auto const& variable_name :
69 {
70 "displacement"s,
72 "phasefield"s})
73 {
74 auto per_process_variables =
75 findProcessVariables(variables, pv_config, {variable_name});
76 process_variables.push_back(std::move(per_process_variables));
77 }
78 variable_u = &process_variables[0][0].get();
79 variable_ph = &process_variables[1][0].get();
80 }
81
82 DBUG(
"Associate displacement with process variable '{:s}'.",
84
86 {
88 "Number of components of the process variable '{:s}' is different "
89 "from the displacement dimension: got {:d}, expected {:d}",
92 DisplacementDim);
93 }
94
95 DBUG(
"Associate phase field with process variable '{:s}'.",
98 {
100 "Phasefield process variable '{:s}' is not a scalar variable but "
101 "has {:d} components.",
104 }
106 auto solid_constitutive_relations =
107 MaterialLib::Solids::createConstitutiveRelations<DisplacementDim>(
108 parameters, local_coordinate_system, config);
109
110 auto const phasefield_parameters_config =
112 config.getConfigSubtree("phasefield_parameters");
113
114
115 auto const& residual_stiffness = ParameterLib::findParameter<double>(
116 phasefield_parameters_config,
118 "residual_stiffness", parameters, 1);
119 DBUG(
"Use '{:s}' as residual stiffness.", residual_stiffness.name);
120
121
122 auto const& crack_resistance = ParameterLib::findParameter<double>(
123 phasefield_parameters_config,
125 "crack_resistance", parameters, 1);
126 DBUG(
"Use '{:s}' as crack resistance.", crack_resistance.name);
127
128
129 auto const& crack_length_scale = ParameterLib::findParameter<double>(
130 phasefield_parameters_config,
132 "crack_length_scale", parameters, 1);
133 DBUG(
"Use '{:s}' as crack length scale.", crack_length_scale.name);
134
135
136 auto const characteristic_length =
138 config.getConfigParameter<double>("characteristic_length", 1.0);
139
140
141 auto const& solid_density = ParameterLib::findParameter<double>(
142 config,
144 "solid_density", parameters, 1);
145 DBUG(
"Use '{:s}' as solid density parameter.", solid_density.name);
146
147
148 Eigen::Matrix<double, DisplacementDim, 1> specific_body_force;
149 {
150 std::vector<double> const b =
152 config.getConfigParameter<std::vector<double>>(
153 "specific_body_force");
154 if (b.size() != DisplacementDim)
155 {
157 "The size of the specific body force vector does not match the "
158 "displacement dimension. Vector size is {:d}, displacement "
159 "dimension is {:d}",
160 b.size(), DisplacementDim);
161 }
162
163 std::copy_n(b.data(), b.size(), specific_body_force.data());
164 }
165
166 auto const crack_scheme =
168 config.getConfigParameterOptional<std::string>(
169 "pressurized_crack_scheme");
170 if (crack_scheme &&
171 ((*crack_scheme != "propagating") && (*crack_scheme != "static")))
172 {
174 "crack_scheme must be 'propagating' or 'static' but '{:s}' "
175 "was given",
176 crack_scheme->c_str());
177 }
178
179 const bool pressurized_crack = crack_scheme.has_value();
180 const bool propagating_pressurized_crack =
181 (crack_scheme && (*crack_scheme == "propagating"));
182 const bool static_pressurized_crack =
183 (crack_scheme && (*crack_scheme == "static"));
184
185 auto const irreversible_threshold =
187 config.getConfigParameter<double>("irreversible_threshold", 0.05);
188
189 auto const phasefield_model = [&]
190 {
191 auto const phasefield_model_string =
193 config.getConfigParameter<std::string>("phasefield_model");
194
195 if (phasefield_model_string == "AT1")
196 {
197 return PhaseFieldModel::AT1;
198 }
199 if (phasefield_model_string == "AT2")
200 {
201 return PhaseFieldModel::AT2;
202 }
203 if (phasefield_model_string == "COHESIVE")
204 {
205 return PhaseFieldModel::COHESIVE;
206 }
208 "phasefield_model must be 'AT1', 'AT2' or 'COHESIVE' but '{:s}' "
209 "was given",
210 phasefield_model_string.c_str());
211 }();
212
213 auto const softening_curve = [&]
214 {
215 auto const softening_curve_string =
217 config.getConfigParameterOptional<std::string>("softening_curve");
218 if (softening_curve_string)
219 {
220 if (*softening_curve_string == "Linear")
221 {
222 return SofteningCurve::Linear;
223 }
224 if (*softening_curve_string == "Exponential")
225 {
226 return SofteningCurve::Exponential;
227 }
229 "softening_curve must be 'Linear' or 'Exponential' but '{:s}' "
230 "was given",
231 softening_curve_string->c_str());
232 }
233 return SofteningCurve::Linear;
234 }();
235
236 auto const energy_split_model = [&]
237 {
238 auto const energy_split_model_string =
240 config.getConfigParameter<std::string>("energy_split_model");
241
242 if (energy_split_model_string == "Isotropic")
243 {
244 return EnergySplitModel::Isotropic;
245 }
246 if (energy_split_model_string == "VolumetricDeviatoric")
247 {
248 return EnergySplitModel::VolDev;
249 }
250 if (energy_split_model_string == "EffectiveStress")
251 {
252 return EnergySplitModel::EffectiveStress;
253 }
254 if (energy_split_model_string == "OrthoVolDev")
255 {
256 return EnergySplitModel::OrthoVolDev;
257 }
258 if (energy_split_model_string == "OrthoMasonry")
259 {
260 return EnergySplitModel::OrthoMasonry;
261 }
263 "energy_split_model must be 'Isotropic' or 'VolumetricDeviatoric' "
264 "but '{:s}' was given",
265 energy_split_model_string);
266 }();
267
268 std::unique_ptr<DegradationDerivative> degradation_derivative;
269 if (phasefield_model == PhaseFieldModel::COHESIVE)
270 {
271 degradation_derivative =
272 std::make_unique<COHESIVE_DegradationDerivative>(
273 characteristic_length, softening_curve);
274 }
275 else
276 {
277 degradation_derivative = std::make_unique<AT_DegradationDerivative>();
278 }
279
280 PhaseFieldProcessData<DisplacementDim> process_data{
282 std::move(solid_constitutive_relations),
283 residual_stiffness,
284 crack_resistance,
285 crack_length_scale,
286 solid_density,
287 specific_body_force,
288 pressurized_crack,
289 propagating_pressurized_crack,
290 static_pressurized_crack,
291 irreversible_threshold,
292 phasefield_model,
293 energy_split_model,
294 softening_curve,
295 characteristic_length,
296 std::move(degradation_derivative)};
297
298 SecondaryVariableCollection secondary_variables;
299
301
302 return std::make_unique<PhaseFieldProcess<DisplacementDim>>(
303 std::move(name), mesh, std::move(jacobian_assembler), parameters,
304 integration_order, std::move(process_variables),
305 std::move(process_data), std::move(secondary_variables),
306 use_monolithic_scheme);
307}
void DBUG(fmt::format_string< Args... > fmt, Args &&... args)
std::string const & getName() const
int getNumberOfGlobalComponents() const
Returns the number of components of the process variable.
PropertyVector< int > const * materialIDs(Mesh const &mesh)
void createSecondaryVariables(BaseLib::ConfigTree const &config, SecondaryVariableCollection &secondary_variables)