www.mooseframework.org
ADLAROMANCEStressUpdateBase.C
Go to the documentation of this file.
1 //* This file is part of the MOOSE framework
2 //* https://www.mooseframework.org
3 //*
4 //* All rights reserved, see COPYRIGHT for full restrictions
5 //* https://github.com/idaholab/moose/blob/master/COPYRIGHT
6 //*
7 //* Licensed under LGPL 2.1, please see LICENSE for details
8 //* https://www.gnu.org/licenses/lgpl-2.1.html
9 
10 #include "ADLAROMANCEStressUpdateBase.h"
11 
12 #include "Function.h"
13 #include "MathUtils.h"
14 
15 defineADLegacyParams(ADLAROMANCEStressUpdateBase);
16 
17 template <ComputeStage compute_stage>
18 InputParameters
19 ADLAROMANCEStressUpdateBase<compute_stage>::validParams()
20 {
21  InputParameters params = ADRadialReturnCreepStressUpdateBase<compute_stage>::validParams();
22  params.addClassDescription(
23  "Calculates the effective creep strain based on the rates predicted by a material "
24  "specific Los Alamos Reduced Order Model derived from a Visco-Plastic Self Consistent "
25  "calculations.");
26 
27  params.addRequiredCoupledVar("temperature", "The coupled temperature (K)");
28  params.addCoupledVar("environmental_factor", 0.0, "Optional coupled environmental factor");
29  params.addRangeCheckedParam<Real>("input_window_limit",
30  1.0,
31  "input_window_limit>0.0",
32  "Multiplier for the input minium/maximum input window");
33  MooseEnum window_failure("ERROR WARN IGNORE", "WARN");
34  params.addParam<MooseEnum>("input_window_failure_action",
35  window_failure,
36  "What to do if ROM input is outside the window of applicability.");
37  params.addParam<bool>("extrapolate_to_zero_stress",
38  true,
39  "Flag to allow for extrapolation of input J2 stress to zero");
40 
41  params.addRangeCheckedParam<Real>("initial_mobile_dislocation_density",
42  0.0,
43  "initial_mobile_dislocation_density >= 0.0",
44  "Initial density of mobile (glissile) dislocations (1/m^2)");
45  params.addRangeCheckedParam<Real>(
46  "max_relative_mobile_dislocation_increment",
47  0.5,
48  "max_relative_mobile_dislocation_increment > 0.0",
49  "Maximum increment of density of mobile (glissile) dislocations.");
50  params.addParam<FunctionName>(
51  "mobile_dislocation_density_forcing_function",
52  "Optional forcing function for immobile dislocation. If provided, the immobile dislocation "
53  "density will be reset to the function value at the beginning of the timestep. Used for "
54  "testing purposes only.");
55  params.addRangeCheckedParam<Real>("initial_immobile_dislocation_density",
56  0.0,
57  "initial_immobile_dislocation_density >= 0.0",
58  "Immobile (locked) dislocation density initial value (1/m^2).");
59  params.addRangeCheckedParam<Real>(
60  "max_relative_immobile_dislocation_increment",
61  0.5,
62  "max_relative_immobile_dislocation_increment > 0.0",
63  "Maximum increment of immobile (locked) dislocation density initial value (1/m^2).");
64  params.addParam<FunctionName>(
65  "immobile_dislocation_density_forcing_function",
66  "Optional forcing function for immobile dislocation. If provided, the immobile dislocation "
67  "density will be reset to the function value at the beginning of the timestep. Used for "
68  "testing purposes only.");
69 
70  params.addParam<FunctionName>(
71  "old_creep_strain_forcing_function",
72  "Optional forcing function for the creep strain from the previous timestep. If provided, "
73  "the old creep strain will be reset to the function value at the beginning of the "
74  "timestep. Used for testing purposes only.");
75 
76  params.addParam<bool>("verbose", false, "Flag to add verbose output");
77 
78  params.addParamNamesToGroup(
79  "mobile_dislocation_density_forcing_function immobile_dislocation_density_forcing_function "
80  "old_creep_strain_forcing_function",
81  "Advanced");
82  return params;
83 }
84 
85 template <ComputeStage compute_stage>
86 ADLAROMANCEStressUpdateBase<compute_stage>::ADLAROMANCEStressUpdateBase(
87  const InputParameters & parameters)
88  : ADRadialReturnCreepStressUpdateBase<compute_stage>(parameters),
89  _temperature(adCoupledValue("temperature")),
90  _environmental(adCoupledValue("environmental_factor")),
91  _window(getParam<Real>("input_window_limit")),
92  _window_failure(
93  parameters.get<MooseEnum>("input_window_failure_action").getEnum<WindowFailure>()),
94  _extrapolate_stress(getParam<bool>("extrapolate_to_zero_stress")),
95  _verbose(getParam<bool>("verbose")),
96  _mobile_dislocations(declareADProperty<Real>(_base_name + "mobile_dislocations")),
97  _mobile_dislocations_old(getMaterialPropertyOld<Real>(_base_name + "mobile_dislocations")),
98  _initial_mobile_dislocations(getParam<Real>("initial_mobile_dislocation_density")),
99  _max_mobile_increment(getParam<Real>("max_relative_mobile_dislocation_increment")),
100  _mobile_function(isParamValid("mobile_dislocation_density_forcing_function")
101  ? &getFunction("mobile_dislocation_density_forcing_function")
102  : NULL),
103  _mobile_dislocation_increment(0.0),
104  _mobile_old(0.0),
105  _immobile_dislocations(declareADProperty<Real>(_base_name + "immobile_dislocations")),
106  _immobile_dislocations_old(getMaterialPropertyOld<Real>(_base_name + "immobile_dislocations")),
107  _initial_immobile_dislocations(getParam<Real>("initial_immobile_dislocation_density")),
108  _max_immobile_increment(getParam<Real>("max_relative_immobile_dislocation_increment")),
109  _immobile_function(isParamValid("immobile_dislocation_density_forcing_function")
110  ? &getFunction("immobile_dislocation_density_forcing_function")
111  : NULL),
112  _immobile_dislocation_increment(0.0),
113  _immobile_old(0.0),
114  _stress_index(2),
115 
116  _creep_strain_old_forcing_function(isParamValid("old_creep_strain_forcing_function")
117  ? &getFunction("old_creep_strain_forcing_function")
118  : NULL),
119 
120  _creep_rate(declareADProperty<Real>(_base_name + "creep_rate")),
121  _failed(declareProperty<Real>("ROM_failure")),
122 
123  _derivative(0.0)
124 {
125 }
126 
127 template <ComputeStage compute_stage>
128 void
129 ADLAROMANCEStressUpdateBase<compute_stage>::initialSetup()
130 {
131  _transform = getTransform();
132 
133  _num_outputs = _transform.size();
134  if (_num_outputs != 3)
135  mooseError("In ", _name, ": _num_outputs (", _num_outputs, ") is not 3");
136 
137  _num_inputs = _transform[0].size();
138  if (_num_inputs != 5 && _num_inputs != 6)
139  mooseError("In ", _name, ": _num_inputs (", _num_inputs, ") is not 5 or 6");
140  _use_env = _num_inputs == 6 ? true : false;
141 
142  _transform_coefs = getTransformCoefs();
143  if (_transform_coefs.size() != _num_outputs || _transform_coefs[0].size() != _num_inputs)
144  mooseError("In ", _name, ": transform_coef is the wrong shape!");
145 
146  _input_limits = getInputLimits();
147  if (_input_limits.size() != _num_inputs || _input_limits[0].size() != 2)
148  mooseError("In ", _name, ": input_limits is the wrong shape!");
149 
150  _coefs = getCoefs();
151  if (_coefs.size() != _num_outputs)
152  mooseError("In ", _name, ": coefs is the wrong shape!");
153 
154  _num_coefs = _coefs[0].size();
155  _degree = std::pow(_num_coefs, 1.0 / _num_inputs);
156  if (!_degree || _degree > 4)
157  mooseError("In ", _name, ": degree must be 1, 2, 3 or 4.");
158 
159  _transformed_limits = getTransformedLimits();
160  _makeframe_helper = getMakeFrameHelper();
161 
162  Moose::out << "ROM model info:\n name:\t" << _name << "\n number of outputs:\t" << _num_outputs
163  << "\n number of inputs:\t" << _num_inputs
164  << "\n degree (max Legendre degree + constant):\t" << _degree
165  << "\n number of coefficients:\t" << _num_coefs << std::endl;
166 }
167 
168 template <ComputeStage compute_stage>
169 void
170 ADLAROMANCEStressUpdateBase<compute_stage>::initQpStatefulProperties()
171 {
172  _mobile_dislocations[_qp] = _initial_mobile_dislocations;
173  _immobile_dislocations[_qp] = _initial_immobile_dislocations;
174 
175  ADRadialReturnCreepStressUpdateBase<compute_stage>::initQpStatefulProperties();
176 }
177 
178 template <ComputeStage compute_stage>
179 ADReal
180 ADLAROMANCEStressUpdateBase<compute_stage>::computeResidual(const ADReal & effective_trial_stress,
181  const ADReal & scalar)
182 {
183  if (_immobile_function)
184  _immobile_old = _immobile_function->value(_t, _q_point[_qp]);
185  else
186  _immobile_old = _immobile_dislocations_old[_qp];
187 
188  if (_mobile_function)
189  _mobile_old = _mobile_function->value(_t, _q_point[_qp]);
190  else
191  _mobile_old = _mobile_dislocations_old[_qp];
192 
193  const ADReal trial_stress_mpa = (effective_trial_stress - _three_shear_modulus * scalar) * 1.0e-6;
194 
195  if (trial_stress_mpa < 0.0)
196  mooseException("In ",
197  _name,
198  ": previously calculated scalar (",
199  MetaPhysicL::raw_value(scalar),
200  ") is too high resulting in a negative trial stress (",
201  MetaPhysicL::raw_value(trial_stress_mpa),
202  "). Cutting timestep.");
203 
204  Real effective_strain_old;
205  if (_creep_strain_old_forcing_function)
206  effective_strain_old = _creep_strain_old_forcing_function->value(_t, _q_point[_qp]);
207  else
208  effective_strain_old =
209  std::sqrt(_creep_strain_old[_qp].doubleContraction(_creep_strain_old[_qp]) / 1.5);
210 
211  ADReal rom_effective_strain = 0.0;
212  ADReal derivative_rom_effective_strain = 0.0;
213 
214  computeROMStrainRate(_dt,
215  _mobile_old,
216  _immobile_old,
217  trial_stress_mpa,
218  effective_strain_old,
219  _temperature[_qp],
220  _environmental[_qp],
221  _mobile_dislocation_increment,
222  _immobile_dislocation_increment,
223  rom_effective_strain,
224  derivative_rom_effective_strain);
225 
226  if (_verbose && compute_stage == RESIDUAL)
227  {
228  Moose::out << "Verbose information from " << _name << ": \n";
229  Moose::out << " dt: " << _dt << "\n";
230  Moose::out << " old mobile disl: " << _mobile_old << "\n";
231  Moose::out << " old immobile disl: " << _immobile_old << "\n";
232  Moose::out << " initial stress (MPa): " << effective_trial_stress * 1.0e-6 << "\n";
233  Moose::out << " temperature: " << _temperature[_qp] << "\n";
234  Moose::out << " environmental factor: " << _environmental[_qp] << "\n";
235  Moose::out << " calculated scalar strain value: " << scalar << "\n";
236  Moose::out << " trial stress into rom (MPa): " << trial_stress_mpa << "\n";
237  Moose::out << " old effective strain: " << effective_strain_old << "\n";
238  Moose::out << " ROM outputs \n";
239  Moose::out << " effective incremental strain from rom: " << rom_effective_strain << "\n";
240  Moose::out << " new effective strain: " << effective_strain_old + rom_effective_strain << "\n";
241  Moose::out << " new mobile dislocations: " << _mobile_old + _mobile_dislocation_increment
242  << "\n";
243  Moose::out << " new immobile dislocations: " << _immobile_old + _immobile_dislocation_increment
244  << "\n"
245  << std::endl;
246  }
247 
248  _creep_rate[_qp] = rom_effective_strain / _dt;
249  _derivative = derivative_rom_effective_strain * -_three_shear_modulus * 1.0e-6 - 1.0;
250 
251  return rom_effective_strain - scalar;
252 }
253 
254 template <ComputeStage compute_stage>
255 void
256 ADLAROMANCEStressUpdateBase<compute_stage>::computeStressFinalize(
257  const ADRankTwoTensor & plastic_strain_increment)
258 {
259  _mobile_dislocations[_qp] = _mobile_old + _mobile_dislocation_increment;
260  _immobile_dislocations[_qp] = _immobile_old + _immobile_dislocation_increment;
261 
262  if (_verbose && compute_stage == RESIDUAL)
263  {
264  Moose::out << "Finalized verbose information from " << _name << "\n";
265  Moose::out << " increment effective creep strain: "
266  << std::sqrt(2.0 / 3.0 *
267  plastic_strain_increment.doubleContraction(plastic_strain_increment))
268  << "\n";
269  Moose::out << " effective_creep_strain: "
270  << std::sqrt(2.0 / 3.0 * _creep_strain[_qp].doubleContraction(_creep_strain[_qp]))
271  << "\n";
272  Moose::out << " new mobile dislocations: " << _mobile_dislocations[_qp] << "\n";
273  Moose::out << " new immobile dislocations: " << _immobile_dislocations[_qp] << "\n"
274  << std::endl;
275  }
276 
277  ADRadialReturnCreepStressUpdateBase<compute_stage>::computeStressFinalize(
278  plastic_strain_increment);
279 }
280 
281 template <ComputeStage compute_stage>
282 Real
283 ADLAROMANCEStressUpdateBase<compute_stage>::computeTimeStepLimit()
284 {
285  Real limited_dt = ADRadialReturnStressUpdate<compute_stage>::computeTimeStepLimit();
286 
287  Real mobile_strain_inc = std::abs(MetaPhysicL::raw_value(_mobile_dislocation_increment));
288  if (mobile_strain_inc && _mobile_old)
289  limited_dt =
290  std::min(limited_dt, _dt * _max_mobile_increment * _mobile_old / mobile_strain_inc);
291  Real immobile_strain_inc = std::abs(MetaPhysicL::raw_value(_immobile_dislocation_increment));
292  if (immobile_strain_inc && _immobile_old)
293  limited_dt =
294  std::min(limited_dt, _dt * _max_immobile_increment * _immobile_old / immobile_strain_inc);
295 
296  return limited_dt;
297 }
298 
299 template <ComputeStage compute_stage>
300 void
301 ADLAROMANCEStressUpdateBase<compute_stage>::computeROMStrainRate(
302  const Real dt,
303  const Real & mobile_dislocations_old,
304  const Real & immobile_dislocations_old,
305  const ADReal & trial_stress,
306  const Real & effective_strain_old,
307  const ADReal & temperature,
308  const ADReal & environmental,
309  ADReal & mobile_dislocation_increment,
310  ADReal & immobile_dislocation_increment,
311  ADReal & rom_effective_strain,
312  ADReal & rom_effective_strain_derivative)
313 {
314  // Prepare input
315  std::vector<ADReal> input_values = {mobile_dislocations_old,
316  immobile_dislocations_old,
317  trial_stress,
318  effective_strain_old,
319  temperature};
320  if (_use_env)
321  input_values.push_back(environmental);
322 
323  std::vector<std::vector<ADReal>> rom_inputs(_num_outputs, std::vector<ADReal>(_num_inputs));
324  std::vector<std::vector<ADReal>> drom_inputs(_num_outputs, std::vector<ADReal>(_num_inputs));
325 
326  checkInputWindows(input_values);
327  convertInput(input_values, rom_inputs, drom_inputs);
328 
329  std::vector<ADReal> old_input_values = {
330  mobile_dislocations_old, immobile_dislocations_old, effective_strain_old};
331 
332  std::vector<std::vector<std::vector<ADReal>>> polynomial_inputs(
333  _num_outputs, std::vector<std::vector<ADReal>>(_num_inputs, std::vector<ADReal>(_degree)));
334  std::vector<ADReal> rom_outputs(_num_outputs);
335  std::vector<ADReal> input_value_increments(_num_outputs);
336 
337  std::vector<std::vector<std::vector<ADReal>>> dpolynomial_inputs(
338  _num_outputs, std::vector<std::vector<ADReal>>(_num_inputs, std::vector<ADReal>(_degree)));
339  std::vector<ADReal> drom_outputs(_num_outputs);
340  std::vector<ADReal> dinput_value_increments(_num_outputs);
341 
342  buildPolynomials(rom_inputs, drom_inputs, polynomial_inputs, dpolynomial_inputs);
343  computeValues(_coefs, polynomial_inputs, dpolynomial_inputs, rom_outputs, drom_outputs);
344  convertOutput(dt,
345  old_input_values,
346  rom_outputs,
347  drom_outputs,
348  input_value_increments,
349  dinput_value_increments);
350 
351  mobile_dislocation_increment = input_value_increments[0];
352  immobile_dislocation_increment = input_value_increments[1];
353  rom_effective_strain = input_value_increments[2];
354 
355  rom_effective_strain_derivative = dinput_value_increments[2];
356 }
357 
358 template <ComputeStage compute_stage>
359 void
360 ADLAROMANCEStressUpdateBase<compute_stage>::checkInputWindows(std::vector<ADReal> & input)
361 {
362  if (compute_stage != RESIDUAL)
363  return;
364 
365  _failed[_qp] = 0.0;
366  for (unsigned int i = 0; i < _num_outputs; ++i)
367  {
368  for (unsigned int j = 0; j < _num_inputs; ++j)
369  {
370  Real high_limit = _input_limits[j][1] * _window;
371  Real low_limit = _input_limits[j][0] * (2.0 - _window);
372  if (j == _stress_index && _extrapolate_stress)
373  low_limit = 0.0;
374  if (input[j] < low_limit || input[j] > high_limit)
375  {
376  _failed[_qp] += (j + 1) * (j + 1);
377  if (_window_failure == WindowFailure::WARN)
378  mooseWarning("In ",
379  _name,
380  ": input parameter number input=",
381  j,
382  " output=",
383  i,
384  " with value (",
385  input[j],
386  ") is out of range (",
387  _input_limits[j][0],
388  " - ",
389  _input_limits[j][1],
390  "), window (",
391  _window,
392  ")");
393  else if (_window_failure == WindowFailure::ERROR)
394  mooseError("In ",
395  _name,
396  ": input parameter number input=",
397  j,
398  " output=",
399  i,
400  " with value (",
401  input[j],
402  ") is out of range (",
403  _input_limits[j][0],
404  " - ",
405  _input_limits[j][1],
406  "), window (",
407  _window,
408  ")");
409  }
410  }
411  }
412 }
413 
414 template <ComputeStage compute_stage>
415 void
416 ADLAROMANCEStressUpdateBase<compute_stage>::convertInput(
417  const std::vector<ADReal> & input,
418  std::vector<std::vector<ADReal>> & converted,
419  std::vector<std::vector<ADReal>> & dconverted)
420 {
421  for (unsigned int i = 0; i < _num_outputs; ++i)
422  {
423  for (unsigned int j = 0; j < _num_inputs; ++j)
424  {
425  ADReal x = input[j];
426  ADReal dx = 1.0;
427  if (_transform[i][j] == ROMInputTransform::EXP)
428  {
429  x = std::exp(x / _transform_coefs[i][j]);
430  dx = x / _transform_coefs[i][j];
431  }
432  else if (_transform[i][j] == ROMInputTransform::LOG)
433  {
434  dx = 1.0 / (x + _transform_coefs[i][j]);
435  x = std::log(x + _transform_coefs[i][j]);
436  }
437 
438  converted[i][j] = 2.0 * (x - _transformed_limits[i][j][0]) /
439  (_transformed_limits[i][j][1] - _transformed_limits[i][j][0]) -
440  1.0;
441  if (j == _stress_index)
442  dconverted[i][j] = dx * 2.0 / (_transformed_limits[i][j][1] - _transformed_limits[i][j][0]);
443  else
444  dconverted[i][j] = 0.0;
445  }
446  }
447 }
448 
449 template <ComputeStage compute_stage>
450 void
451 ADLAROMANCEStressUpdateBase<compute_stage>::buildPolynomials(
452  const std::vector<std::vector<ADReal>> & rom_inputs,
453  const std::vector<std::vector<ADReal>> & drom_inputs,
454  std::vector<std::vector<std::vector<ADReal>>> & polynomial_inputs,
455  std::vector<std::vector<std::vector<ADReal>>> & dpolynomial_inputs)
456 {
457  for (unsigned int i = 0; i < _num_outputs; ++i)
458  {
459  for (unsigned int j = 0; j < _num_inputs; ++j)
460  {
461  for (unsigned int k = 0; k < _degree; ++k)
462  {
463  polynomial_inputs[i][j][k] = computePolynomial(rom_inputs[i][j], k);
464 
465  if (j != _stress_index)
466  dpolynomial_inputs[i][j][k] = 0.0;
467  else
468  {
469  // This is not the true derivative, but rather an optimization for computeValues
470  dpolynomial_inputs[i][j][k] = drom_inputs[i][j] *
471  computePolynomial(rom_inputs[i][j], k, true) /
472  polynomial_inputs[i][j][k];
473  }
474  }
475  }
476  }
477 }
478 
479 template <ComputeStage compute_stage>
480 void
481 ADLAROMANCEStressUpdateBase<compute_stage>::computeValues(
482  const std::vector<std::vector<Real>> & coefs,
483  const std::vector<std::vector<std::vector<ADReal>>> & polynomial_inputs,
484  const std::vector<std::vector<std::vector<ADReal>>> & dpolynomial_inputs,
485  std::vector<ADReal> & rom_outputs,
486  std::vector<ADReal> & drom_outputs)
487 {
488  for (unsigned int i = 0; i < _num_outputs; ++i)
489  {
490  rom_outputs[i] = 0.0;
491  drom_outputs[i] = 0.0;
492  for (unsigned int j = 0; j < _num_coefs; ++j)
493  {
494  ADReal xvals = coefs[i][j];
495  ADReal dxvals = 0.0;
496  for (unsigned int k = 0; k < _num_inputs; ++k)
497  {
498  xvals *= polynomial_inputs[i][k][_makeframe_helper[j][k]];
499  dxvals += dpolynomial_inputs[i][k][_makeframe_helper[j][k]];
500  }
501 
502  rom_outputs[i] += xvals;
503  drom_outputs[i] += dxvals * xvals;
504  }
505  }
506 }
507 
508 template <ComputeStage compute_stage>
509 void
510 ADLAROMANCEStressUpdateBase<compute_stage>::convertOutput(
511  const Real dt,
512  const std::vector<ADReal> & old_input_values,
513  const std::vector<ADReal> & rom_outputs,
514  const std::vector<ADReal> & drom_outputs,
515  std::vector<ADReal> & input_value_increments,
516  std::vector<ADReal> & dinput_value_increments)
517 {
518  for (unsigned int i = 0; i < _num_outputs; ++i)
519  {
520  input_value_increments[i] = std::exp(rom_outputs[i]) * dt;
521  if (i == 0 || i == 1)
522  {
523  dinput_value_increments[i] = 0.0;
524  input_value_increments[i] *= old_input_values[i];
525  if (i == 0)
526  input_value_increments[i] *= -1.0;
527  }
528  else
529  dinput_value_increments[i] = input_value_increments[i] * drom_outputs[i];
530  }
531 }
532 
533 template <ComputeStage compute_stage>
534 ADReal
535 ADLAROMANCEStressUpdateBase<compute_stage>::computePolynomial(const ADReal & value,
536  const unsigned int degree,
537  const bool derivative)
538 {
539  if (degree == 0)
540  {
541  if (derivative)
542  return 0.0;
543  return 1.0;
544  }
545  else if (degree == 1)
546  {
547  if (derivative)
548  return 1.0;
549  return value;
550  }
551  else if (degree == 2)
552  {
553  if (derivative)
554  return 3.0 * value;
555  return 1.5 * Utility::pow<2>(value) - 0.5;
556  }
557  else
558  {
559  if (derivative)
560  return 7.5 * Utility::pow<2>(value) - 1.5;
561  return 2.5 * Utility::pow<3>(value) - 1.5 * value;
562  }
563 }
564 
565 template <ComputeStage compute_stage>
566 std::vector<std::vector<std::vector<Real>>>
567 ADLAROMANCEStressUpdateBase<compute_stage>::getTransformedLimits() const
568 {
569  std::vector<std::vector<std::vector<Real>>> transformed_limits(
570  _num_outputs, std::vector<std::vector<Real>>(_num_inputs, std::vector<Real>(2)));
571 
572  for (unsigned int i = 0; i < _num_outputs; ++i)
573  {
574  for (unsigned int j = 0; j < _num_inputs; ++j)
575  {
576  for (unsigned int k = 0; k < 2; ++k)
577  {
578  if (_transform[i][j] == ROMInputTransform::EXP)
579  transformed_limits[i][j][k] = std::exp(_input_limits[j][k] / _transform_coefs[i][j]);
580  else if (_transform[i][j] == ROMInputTransform::LOG)
581  transformed_limits[i][j][k] = std::log(_input_limits[j][k] + _transform_coefs[i][j]);
582  else
583  transformed_limits[i][j][k] = _input_limits[j][k];
584  }
585  }
586  }
587 
588  return transformed_limits;
589 }
590 
591 template <ComputeStage compute_stage>
592 std::vector<std::vector<unsigned int>>
593 ADLAROMANCEStressUpdateBase<compute_stage>::getMakeFrameHelper() const
594 {
595  std::vector<std::vector<unsigned int>> v(_num_coefs, std::vector<unsigned int>(_num_inputs));
596 
597  for (unsigned int numcoeffs = 0; numcoeffs < _num_coefs; ++numcoeffs)
598  for (unsigned int invar = 0; invar < _num_inputs; ++invar)
599  v[numcoeffs][invar] = numcoeffs / MathUtils::pow(_degree, invar) % _degree;
600 
601  return v;
602 }
603 
604 // explicit instantiation is required for AD base classes
605 adBaseClass(ADLAROMANCEStressUpdateBase);
ADLAROMANCEStressUpdateBase::computeROMStrainRate
void computeROMStrainRate(const Real dt, const Real &mobile_dislocations_old, const Real &immobile_dislocations_old, const ADReal &trial_stress, const Real &effective_strain_old, const ADReal &temperature, const ADReal &environmental, ADReal &mobile_dislocation_increment, ADReal &immobile_dislocation_increment, ADReal &rom_effective_strain, ADReal &rom_effective_strain_derivative)
Computes the ROM Strain rate.
Definition: ADLAROMANCEStressUpdateBase.C:301
ADLAROMANCEStressUpdateBase::checkInputWindows
void checkInputWindows(std::vector< ADReal > &input)
Function to check input values against applicability windows set by ROM data set.
Definition: ADLAROMANCEStressUpdateBase.C:360
ADRadialReturnCreepStressUpdateBase::validParams
static InputParameters validParams()
Definition: ADRadialReturnCreepStressUpdateBase.C:17
ADLAROMANCEStressUpdateBase::computeResidual
virtual ADReal computeResidual(const ADReal &effective_trial_stress, const ADReal &scalar) override
Compute the residual for a predicted value of the scalar.
Definition: ADLAROMANCEStressUpdateBase.C:180
pow
ExpressionBuilder::EBTerm pow(const ExpressionBuilder::EBTerm &left, T exponent)
Definition: ExpressionBuilder.h:673
ADLAROMANCEStressUpdateBase.h
ROMInputTransform::EXP
ADLAROMANCEStressUpdateBase::WindowFailure
WindowFailure
Enum to error, warn, or ignore checks that ensure ROM input is within applicability window.
Definition: ADLAROMANCEStressUpdateBase.h:220
ADLAROMANCEStressUpdateBase::convertOutput
void convertOutput(const Real dt, const std::vector< ADReal > &old_input_values, const std::vector< ADReal > &rom_outputs, const std::vector< ADReal > &drom_outputs, std::vector< ADReal > &input_value_increments, std::vector< ADReal > &dinput_value_increments)
Computes the output variable increments from the ROM predictions by bringing out of the normalized ma...
Definition: ADLAROMANCEStressUpdateBase.C:510
ADLAROMANCEStressUpdateBase::initQpStatefulProperties
virtual void initQpStatefulProperties() override
Definition: ADLAROMANCEStressUpdateBase.C:170
ADLAROMANCEStressUpdateBase::initialSetup
virtual void initialSetup() override
Definition: ADLAROMANCEStressUpdateBase.C:129
ADLAROMANCEStressUpdateBase::ADLAROMANCEStressUpdateBase
ADLAROMANCEStressUpdateBase(const InputParameters &parameters)
Definition: ADLAROMANCEStressUpdateBase.C:86
ADLAROMANCEStressUpdateBase::computeValues
void computeValues(const std::vector< std::vector< Real >> &coefs, const std::vector< std::vector< std::vector< ADReal >>> &polynomial_inputs, const std::vector< std::vector< std::vector< ADReal >>> &dpolynomial_inputs, std::vector< ADReal > &rom_outputs, std::vector< ADReal > &drom_outputs)
Arranges the calculated Legendre polynomials into the order expected by the ROM coefficients and ulti...
Definition: ADLAROMANCEStressUpdateBase.C:481
ADLAROMANCEStressUpdateBase::getMakeFrameHelper
std::vector< std::vector< unsigned int > > getMakeFrameHelper() const
Definition: ADLAROMANCEStressUpdateBase.C:593
ADLAROMANCEStressUpdateBase::buildPolynomials
void buildPolynomials(const std::vector< std::vector< ADReal >> &rom_inputs, const std::vector< std::vector< ADReal >> &drom_inputs, std::vector< std::vector< std::vector< ADReal >>> &polynomial_inputs, std::vector< std::vector< std::vector< ADReal >>> &dpolynomial_inputs)
Assemble the array of Legendre polynomials to be multiplied by the ROM coefficients.
Definition: ADLAROMANCEStressUpdateBase.C:451
ADLAROMANCEStressUpdateBase::computeTimeStepLimit
virtual Real computeTimeStepLimit() override
Compute the limiting value of the time step for this material.
Definition: ADLAROMANCEStressUpdateBase.C:283
ROMInputTransform::LOG
ADRadialReturnCreepStressUpdateBase
This class provides baseline functionallity for creep models based on the stress update material in a...
Definition: ADRadialReturnCreepStressUpdateBase.h:21
defineADLegacyParams
defineADLegacyParams(ADLAROMANCEStressUpdateBase)
ADLAROMANCEStressUpdateBase::computePolynomial
ADReal computePolynomial(const ADReal &value, const unsigned int degree, const bool derivative=false)
Calculate the value or derivative of Legendre polynomial up to 3rd order.
Definition: ADLAROMANCEStressUpdateBase.C:535
ADLAROMANCEStressUpdateBase::getTransformedLimits
std::vector< std::vector< std::vector< Real > > > getTransformedLimits() const
Definition: ADLAROMANCEStressUpdateBase.C:567
ADRadialReturnCreepStressUpdateBase::computeStressFinalize
virtual void computeStressFinalize(const ADRankTwoTensor &plastic_strain_increment) override
Perform any necessary steps to finalize state after return mapping iterations.
Definition: ADRadialReturnCreepStressUpdateBase.C:53
NS::temperature
const std::string temperature
Definition: NS.h:26
ADLAROMANCEStressUpdateBase::computeStressFinalize
virtual void computeStressFinalize(const ADRankTwoTensor &plastic_strain_increment) override
Perform any necessary steps to finalize state after return mapping iterations.
Definition: ADLAROMANCEStressUpdateBase.C:256
ADLAROMANCEStressUpdateBase
Definition: ADLAROMANCEStressUpdateBase.h:22
ADRadialReturnCreepStressUpdateBase::initQpStatefulProperties
virtual void initQpStatefulProperties() override
Definition: ADRadialReturnCreepStressUpdateBase.C:35
ADRadialReturnStressUpdate::computeTimeStepLimit
virtual Real computeTimeStepLimit() override
Compute the limiting value of the time step for this material.
Definition: ADRadialReturnStressUpdate.C:141
ADLAROMANCEStressUpdateBase::convertInput
void convertInput(const std::vector< ADReal > &input, std::vector< std::vector< ADReal >> &converted, std::vector< std::vector< ADReal >> &dconverted)
Convert the input variables into the form expected by the ROM Legendre polynomials to have a normaliz...
Definition: ADLAROMANCEStressUpdateBase.C:416
ADLAROMANCEStressUpdateBase::validParams
static InputParameters validParams()
Definition: ADLAROMANCEStressUpdateBase.C:19
adBaseClass
adBaseClass(ADLAROMANCEStressUpdateBase)
Generated on Sat Jan 25 2020 12:04:45 for www.mooseframework.org by   doxygen 1.8.16