Line data Source code
1 : //* This file is part of the MOOSE framework
2 : //* https://mooseframework.inl.gov
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 : #pragma once
11 :
12 : #include "RadialReturnCreepStressUpdateBase.h"
13 : #include "nlohmann/json.h"
14 :
15 : template <bool is_ad>
16 : class LAROMANCEStressUpdateBaseTempl : public RadialReturnCreepStressUpdateBaseTempl<is_ad>
17 : {
18 :
19 : public:
20 : static InputParameters validParams();
21 :
22 : LAROMANCEStressUpdateBaseTempl(const InputParameters & parameters);
23 :
24 : virtual void resetIncrementalMaterialProperties() override;
25 : virtual void
26 : storeIncrementalMaterialProperties(const unsigned int total_number_substeps) override;
27 :
28 : protected:
29 : virtual void exportJSON();
30 :
31 : virtual bool substeppingCapabilityEnabled() override;
32 :
33 : enum class ROMInputTransform
34 : {
35 : LINEAR,
36 : LOG,
37 : EXP
38 : };
39 :
40 : virtual void initialSetup() override;
41 :
42 : // Setup unit conversion factors. The required units in the ROM are:
43 : // Cell dislocation density: m^-2
44 : // Wall dislocation density: m^-2
45 : // MX phase fracture: nondim.
46 : // stress: MPa
47 : // strain: nondim.
48 : // temperature: K
49 : virtual void setupUnitConversionFactors(const InputParameters & parameters);
50 :
51 : virtual void initQpStatefulProperties() override;
52 : virtual void
53 : computeStressInitialize(const GenericReal<is_ad> & effective_trial_stress,
54 : const GenericRankFourTensor<is_ad> & elasticity_tensor) override;
55 : virtual GenericReal<is_ad> computeResidual(const GenericReal<is_ad> & effective_trial_stress,
56 : const GenericReal<is_ad> & scalar) override;
57 :
58 : virtual GenericReal<is_ad>
59 455360 : computeDerivative(const GenericReal<is_ad> & /*effective_trial_stress*/,
60 : const GenericReal<is_ad> & /*scalar*/) override
61 : {
62 455360 : return _derivative;
63 : }
64 :
65 : virtual void
66 : computeStressFinalize(const GenericRankTwoTensor<is_ad> & plastic_strain_increment) override;
67 : virtual GenericReal<is_ad>
68 : maximumPermissibleValue(const GenericReal<is_ad> & effective_trial_stress) const override;
69 : virtual Real computeTimeStepLimit() override;
70 :
71 : void outputIterationSummary(std::stringstream * iter_output,
72 : const unsigned int total_it) override;
73 :
74 : virtual void outputIterationStep(std::stringstream * iter_output,
75 : const GenericReal<is_ad> & effective_trial_stress,
76 : const GenericReal<is_ad> & scalar,
77 : const Real reference_residual) override;
78 :
79 : /// Enum to error, warn, ignore, or extrapolate if input is outside of window of applicability
80 : enum class WindowFailure
81 : {
82 : ERROR,
83 : EXCEPTION,
84 : WARN,
85 : IGNORE,
86 : DONOTHING,
87 : USELIMIT,
88 : EXTRAPOLATE
89 : };
90 :
91 : /**
92 : * Precompute the ROM strain rate information for all inputs except for strain. Strain will be
93 : * computed in the radial return algorithm several times, while the remainder of the inputs remain
94 : * constant.
95 : * @param out_index Output index
96 : */
97 : void precomputeROM(const unsigned out_index);
98 :
99 : /**
100 : * Computes the ROM calculated increment for a given output and tile.
101 : * @param tile Tile index
102 : * @param partition Partition index
103 : * @param out_index Output index
104 : * @param derivative Optional flag to return derivative of ROM increment with respect to stress.
105 : * @return ROM computed increment
106 : */
107 : GenericReal<is_ad> computeROM(const unsigned int tile,
108 : const unsigned int partition,
109 : const unsigned out_index,
110 : const bool derivative = false);
111 :
112 : /**
113 : * Checks if the input combination is in a specific tile
114 : * @param p Partition index
115 : * @param t Tile index
116 : * @return bool if in tile
117 : */
118 : bool checkInTile(const unsigned int p, const unsigned int t) const;
119 :
120 : /**
121 : * Checks if two tile domains are equal
122 : * @param p Partition index
123 : * @param t Tile 1 index
124 : * @param tt Tile 2 index
125 : * @param in_index input index
126 : * @return integer 0 (false) or 1 (true)
127 : */
128 : bool areTilesNotIdentical(const unsigned int p,
129 : const unsigned int t,
130 : const unsigned int tt,
131 : const unsigned int in_index);
132 :
133 : /**
134 : * Convert the input variables into the form expected by the ROM Legendre polynomials to have a
135 : * normalized space from [-1, 1] so that every variable has equal weight
136 : * @param input Input value
137 : * @param transform ROMInputTransform enum indicating how the input is to be transformed
138 : * @param transform_coef Transform coefficient for the given input
139 : * @param transformed_limits Transformed limits for the given input
140 : * @param derivative Optional flag to return derivative of converted input with respect to stress.
141 : * @return Converted input
142 : */
143 : GenericReal<is_ad> normalizeInput(const GenericReal<is_ad> & input,
144 : const ROMInputTransform transform,
145 : const Real transform_coef,
146 : const std::vector<Real> & transformed_limits,
147 : const bool derivative = false);
148 :
149 : /**
150 : * Assemble the array of Legendre polynomials to be multiplied by the ROM coefficients
151 : * @param p Partition index
152 : * @param rom_input ROM input
153 : * @param polynomial_inputs Vector of transformed Legendre polynomials
154 : * @param drom_input Optional derivative of ROM input with respect to stress
155 : * @param derivative Optional flag to return derivative of converted input with respect to stress.
156 : */
157 : void buildPolynomials(const unsigned int p,
158 : const GenericReal<is_ad> & rom_input,
159 : std::vector<GenericReal<is_ad>> & polynomial_inputs,
160 3248768 : const GenericReal<is_ad> & drom_input = 0,
161 : const bool derivative = false);
162 :
163 : /**
164 : * Arranges the calculated Legendre polynomials into the proper oder and multiplies the Legendre
165 : * polynomials by the ROM coefficients to compute the predicted output values. This method works
166 : * with all inputs besides stress, while stress is handled by computeValues
167 : * @param p Partition index
168 : * @param coefs Legendre polynomial coefficients
169 : * @param polynomial_inputs Vector of transformed Legendre polynomial
170 : * @param precomputed Vector that holds the precomputed ROM values
171 : */
172 : void precomputeValues(const unsigned int p,
173 : const std::vector<Real> & coefs,
174 : const std::vector<std::vector<GenericReal<is_ad>>> & polynomial_inputs,
175 : std::vector<GenericReal<is_ad>> & precomputed);
176 :
177 : /**
178 : * Arranges the calculated Legendre polynomials into the proper oder and multiplies the Legendre
179 : * polynomials by the ROM coefficients to compute the predicted output values. This method only
180 : * manipulates the stress input, with all others handled in precomputeValues
181 : * @param p Partition index
182 : * @param precomputed Precomputed multiplication of polynomials
183 : * @param polynomial_inputs Vector of Legendre polynomial transformation
184 : * @param dpolynomial_inputs Vector of derivative of Legendre polynomial transformation with
185 : * respect to stress
186 : * @param derivative Optional flag to return derivative of converted computed values with respect
187 : * to stress.
188 : * @return ROM output
189 : */
190 : GenericReal<is_ad>
191 : computeValues(const unsigned int p,
192 : const std::vector<GenericReal<is_ad>> & precomputed,
193 : const std::vector<std::vector<GenericReal<is_ad>>> & polynomial_inputs,
194 : const std::vector<GenericReal<is_ad>> & dpolynomial_inputs = {},
195 : const bool derivative = false);
196 :
197 : /**
198 : * Computes the output variable increments from the ROM predictions by bringing out of the
199 : * normalized map to the actual physical values
200 : * @param p Partition index
201 : * @param old_input_values Previous timestep values of ROM inputs
202 : * @param rom_output Outputs from ROM
203 : * @param out_index Output index
204 : * @param drom_output Derivative of output with respect to stress
205 : * @param derivative Optional flag to return derivative of output with respect to stress.
206 : * @return Converted ROM output
207 : */
208 : virtual GenericReal<is_ad> convertOutput(const unsigned int p,
209 : const std::vector<Real> & old_input_values,
210 : const GenericReal<is_ad> & rom_output,
211 : const unsigned out_index,
212 1149372 : const GenericReal<is_ad> & drom_output = 0.0,
213 : const bool derivative = false);
214 :
215 : /**
216 : * Calculate the value or derivative of Legendre polynomial up to 3rd order
217 : * @param value Input to Legendre polynomial
218 : * @param degree Degree of Legendre polynomial
219 : * @param derivative Optional flag to return derivative of Legendre polynomial Legendre
220 : * @return Computed value from Legendre polynomial
221 : */
222 : GenericReal<is_ad> computePolynomial(const GenericReal<is_ad> & value,
223 : const unsigned int degree,
224 : const bool derivative = false);
225 :
226 : /**
227 : * Calculate the sigmoid function weighting for the input based on the limits
228 : * @param lower Lower limit
229 : * @param upper Upper limit
230 : * @param val Input value
231 : * @param derivative Optional flag to return derivative of the sigmoid w.r.t. the input
232 : * @return weight
233 : */
234 : GenericReal<is_ad> sigmoid(const Real lower,
235 : const Real upper,
236 : const GenericReal<is_ad> & val,
237 : const bool derivative = false);
238 :
239 : /**
240 : * Compute the contribution (weight) of each tile in each partition,
241 : * based on the input and tile boundaries (in terms of input domain).
242 : * @param weights Weights for each tile
243 : * @param input Input value
244 : * @param in_index Input index
245 : * @param derivative Optional flag to return derivative of the sigmoid w.r.t. the input
246 : */
247 : void computeTileWeight(std::vector<std::vector<GenericReal<is_ad>>> & weights,
248 : GenericReal<is_ad> & input,
249 : const unsigned int in_index,
250 : const bool derivative = false);
251 :
252 : /**
253 : * Compute the weight of the different partitions
254 : * @param weights Weights for each partition
255 : * @param derivative Optional flag to return derivative of the sigmoid w.r.t. the input
256 : */
257 386848 : virtual void computePartitionWeights(std::vector<GenericReal<is_ad>> & weights,
258 : std::vector<GenericReal<is_ad>> & dweights_dstress)
259 : {
260 386848 : if (_num_partitions != 1)
261 0 : mooseError("Internal error: If number of partitions is not one, then computePartitionWeights "
262 : "must be defined");
263 386848 : weights[0] = 1.0;
264 386848 : dweights_dstress[0] = 0.0;
265 386848 : }
266 :
267 : /**
268 : * Convert input based on the transform type
269 : * @param x Input value
270 : * @param transform Enum declaring transform to be performed
271 : * @param coef Coefficient applied during transformation
272 : * @param derivative Optional flag to return derivative of the sigmoid w.r.t. the input
273 : */
274 : template <typename T>
275 5304320 : void convertValue(T & x,
276 : const ROMInputTransform transform,
277 : const Real coef,
278 : const bool derivative = false)
279 : {
280 5304320 : if (transform == ROMInputTransform::EXP)
281 : {
282 : mooseAssert(coef != 0, "Coefficient must not be zero.");
283 242364 : if (derivative)
284 0 : x = std::exp(x / coef) / coef;
285 : else
286 242364 : x = std::exp(x / coef);
287 : }
288 5061956 : else if (transform == ROMInputTransform::LOG)
289 : {
290 : mooseAssert(x + coef > 0, "Sum must be greater than 0.");
291 3353064 : if (derivative)
292 467200 : x = 1.0 / (x + coef);
293 : else
294 2979208 : x = std::log(x + coef);
295 : }
296 1708892 : else if (transform == ROMInputTransform::LINEAR)
297 : {
298 : mooseAssert(coef == 0.0, "Coefficient cannot be supplied with linear transformation");
299 1708892 : if (derivative)
300 22940 : x = 1.0;
301 : }
302 5304320 : }
303 :
304 : /*
305 : * Calculates and returns vector utilized in assign values
306 : * @param p Partition index
307 : * @return Vector that preallocates indexing calculations for polynomial calculation
308 : */
309 : std::vector<unsigned int> getMakeFrameHelper(const unsigned int p) const;
310 :
311 : /*
312 : * Calculates and returns the transformed limits for the ROM calculations
313 : * Indexes are [partition][tile][output][input].
314 : * Inputs ordering is
315 : * input[0]: cell_old
316 : * input[1]: wall_old
317 : * input[2]: trial stress,
318 : * input[3]: effective strain old,
319 : * input[4]: temperature
320 : * input[5]: environmental factor (optional)
321 : * output ordering is:
322 : * output[0]: cell dislocations increment
323 : * output[1]: wall dislocations increment
324 : * output[2]: strain increment
325 : * @param p Partition index
326 : * @param limits Human readable limits
327 : * @return Multi-dimentional vector of transformed limits
328 : */
329 : std::vector<std::vector<std::vector<std::vector<Real>>>>
330 : getTransformedLimits(const unsigned int p,
331 : const std::vector<std::vector<std::vector<Real>>> limits);
332 :
333 : /*
334 : * Returns vector of the functions to use for the conversion of input variables.
335 : * Indexes are [partition][tile][output][input].
336 : * Inputs ordering is
337 : * input[0]: cell_old
338 : * input[1]: wall_old
339 : * input[2]: trial stress,
340 : * input[3]: effective strain old,
341 : * input[4]: temperature
342 : * input[5]: environmental factor (optional)
343 : * output ordering is:
344 : * output[0]: cell dislocations increment
345 : * output[1]: wall dislocations increment
346 : * output[2]: strain increment
347 : * @return vector of the functions to use for the conversion of input variables.
348 : */
349 54 : virtual std::vector<std::vector<std::vector<std::vector<ROMInputTransform>>>> getTransform()
350 : {
351 54 : checkJSONKey("transform");
352 : return _json["transform"]
353 108 : .template get<std::vector<std::vector<std::vector<std::vector<ROMInputTransform>>>>>();
354 : }
355 :
356 : /*
357 : * Returns factors for the functions for the conversion functions given in getTransform
358 : * Indexes are [partition][tile][output][input].
359 : * Inputs ordering is
360 : * input[0]: cell_old
361 : * input[1]: wall_old
362 : * input[2]: trial stress,
363 : * input[3]: effective strain old,
364 : * input[4]: temperature
365 : * input[5]: environmental factor (optional)
366 : * output ordering is:
367 : * output[0]: cell dislocations increment
368 : * output[1]: wall dislocations increment
369 : * output[2]: strain increment
370 : * @return factors for the functions for the conversion functions given in getTransform
371 : */
372 54 : virtual std::vector<std::vector<std::vector<std::vector<Real>>>> getTransformCoefs()
373 : {
374 54 : checkJSONKey("transform_coefs");
375 : return _json["transform_coefs"]
376 108 : .template get<std::vector<std::vector<std::vector<std::vector<Real>>>>>();
377 : }
378 :
379 : /* Optional method that returns human-readable limits used for normalization. Default is to just
380 : * use the input limits.
381 : * Indexes are [partition][tile][input][upper/lower].
382 : * Inputs ordering is
383 : * input[0]: cell_old
384 : * input[1]: wall_old
385 : * input[2]: trial stress,
386 : * input[3]: effective strain old,
387 : * input[4]: temperature
388 : * input[5]: environmental factor (optional)
389 : * @return human-readable limits for the normalization limits
390 : */
391 378 : virtual std::vector<std::vector<std::vector<std::vector<Real>>>> getNormalizationLimits()
392 : {
393 378 : if (_json.contains("normalization_limits"))
394 : return _json["normalization_limits"]
395 54 : .template get<std::vector<std::vector<std::vector<std::vector<Real>>>>>();
396 :
397 324 : return getInputLimits();
398 : }
399 :
400 : /* Returns human-readable limits for the inputs.
401 : * Indexes are [partition][tile][input][upper/lower].
402 : * Inputs ordering is
403 : * input[0]: cell_old
404 : * input[1]: wall_old
405 : * input[2]: trial stress,
406 : * input[3]: effective strain old,
407 : * input[4]: temperature
408 : * input[5]: environmental factor (optional)
409 : * @return human-readable limits for the input limits
410 : */
411 54 : virtual std::vector<std::vector<std::vector<std::vector<Real>>>> getInputLimits()
412 : {
413 54 : checkJSONKey("input_limits");
414 : return _json["input_limits"]
415 108 : .template get<std::vector<std::vector<std::vector<std::vector<Real>>>>>();
416 : }
417 :
418 : /*
419 : * Material specific coefficients multiplied by the Legendre polynomials for each of the input
420 : * variables
421 : * @return Legendre polynomial coefficients
422 : */
423 54 : virtual std::vector<std::vector<std::vector<std::vector<Real>>>> getCoefs()
424 : {
425 54 : checkJSONKey("coefs");
426 108 : return _json["coefs"].template get<std::vector<std::vector<std::vector<std::vector<Real>>>>>();
427 : }
428 :
429 : /*
430 : * Material specific orientations of tiling
431 : * variables. Indexing is partition, then input
432 : * @return Vector of a vector declaring tiling orientation
433 : */
434 378 : virtual std::vector<std::vector<unsigned int>> getTilings()
435 : {
436 378 : if (_json.contains("tiling"))
437 54 : return _json["tiling"].template get<std::vector<std::vector<unsigned int>>>();
438 :
439 324 : if (_environmental)
440 0 : return {{1, 1, 1, 1, 1, 1}};
441 648 : return {{1, 1, 1, 1, 1}};
442 648 : };
443 :
444 : /*
445 : * Minimum strain value allowed by the ROM. This is material specific, and needs to be overwritten
446 : * by individual roms and each partition
447 : * @return Vector of material specific ROM low strain value for each partition
448 : */
449 54 : virtual std::vector<Real> getStrainCutoff()
450 : {
451 54 : checkJSONKey("cutoff");
452 108 : return _json["cutoff"].template get<std::vector<Real>>();
453 : }
454 :
455 : /// Coupled temperature variable
456 : const GenericVariableValue<is_ad> & _temperature;
457 :
458 : /// Optionally coupled environmental factor
459 : const GenericMaterialProperty<Real, is_ad> * _environmental;
460 :
461 : /*
462 : * Vector of vectors WindowFailure enum that informs how to handle input that is outside of the
463 : * limits. Shape is number of inputs by 2 (lower and upper window enum)
464 : */
465 : std::vector<std::pair<WindowFailure, WindowFailure>> _window_failure;
466 :
467 : /// Flag to output verbose infromation
468 : const bool _verbose;
469 :
470 : ///@{Material properties for cell (glissile) dislocation densities (1/m^2)
471 : GenericMaterialProperty<Real, is_ad> & _cell_dislocations;
472 : const MaterialProperty<Real> & _cell_dislocations_old;
473 : ///@}
474 :
475 : /// Maximum cell dislocation increment
476 : const Real _max_cell_increment;
477 :
478 : /// Optional cell dislocation forcing function
479 : const Function * const _cell_function;
480 :
481 : /// Container for cell dislocation increment
482 : GenericReal<is_ad> _cell_dislocation_increment;
483 :
484 : ///@{Material properties for wall (locked) dislocation densities (1/m^2)
485 : GenericMaterialProperty<Real, is_ad> & _wall_dislocations;
486 : const MaterialProperty<Real> & _wall_dislocations_old;
487 : ///@}
488 :
489 : /// Maximum wall dislocation increment
490 : const Real _max_wall_increment;
491 :
492 : /// Optional wall dislocation forcing function
493 : const Function * const _wall_function;
494 :
495 : /// Optiontal effective stress forcing function
496 : const Function * const _stress_function;
497 :
498 : /// Container for wall dislocation increment
499 : GenericReal<is_ad> _wall_dislocation_increment;
500 :
501 : /// Index corresponding to the position for the dislocations with in the cell in the input vector
502 : const unsigned int _cell_input_index;
503 :
504 : /// Index corresponding to the position for the dislocations within the cell wall in the input vector
505 : const unsigned int _wall_input_index;
506 :
507 : /// Index corresponding to the position for the stress in the input vector
508 : const unsigned int _stress_input_index;
509 :
510 : /// Index corresponding to the position for the old strain in the input vector
511 : const unsigned int _old_strain_input_index;
512 :
513 : /// Index corresponding to the position for the tempeature in the input vector
514 : const unsigned int _temperature_input_index;
515 :
516 : /// Index corresponding to the position for the environmental factor in the input vector
517 : const unsigned int _environmental_input_index;
518 :
519 : /// Index corresponding to the position for cell dislocations increment in the output vector
520 : const unsigned int _cell_output_index;
521 :
522 : /// Index corresponding to the position for wall dislocations increment in the output vector
523 : const unsigned int _wall_output_index;
524 :
525 : /// Index corresponding to the position for strain increment in the output vector
526 : const unsigned int _strain_output_index;
527 :
528 : /// Optional old creep strain forcing function
529 : const Function * const _creep_strain_old_forcing_function;
530 :
531 : /// Number of partitions
532 : unsigned int _num_partitions;
533 :
534 : /// Number of ROM tiles per partition
535 : std::vector<unsigned int> _num_tiles;
536 :
537 : /// Number of inputs for the ROM data set
538 : unsigned int _num_inputs;
539 :
540 : /// Number of inputs to the ROM data set
541 : unsigned int _num_outputs;
542 :
543 : /// Legendre polynomial degree for the ROM data set for each partition
544 : std::vector<unsigned int> _degree;
545 :
546 : /// Total number of Legendre polynomial coefficients for the ROM data set in each parition
547 : std::vector<unsigned int> _num_coefs;
548 :
549 : /// Transform rules defined by the ROM data set for each partition
550 : std::vector<std::vector<std::vector<std::vector<ROMInputTransform>>>> _transform;
551 :
552 : /// Transform coefficients defined by the ROM data set for each partition
553 : std::vector<std::vector<std::vector<std::vector<Real>>>> _transform_coefs;
554 :
555 : /// Input limits defined by the ROM data set for each partition
556 : std::vector<std::vector<std::vector<std::vector<Real>>>> _input_limits;
557 :
558 : /// Normalization limits defined by the ROM data set for each partition
559 : std::vector<std::vector<std::vector<std::vector<Real>>>> _normalization_limits;
560 :
561 : /// Coefficients used with Legendre polynomials defined by the ROM data set for each partition
562 : std::vector<std::vector<std::vector<std::vector<Real>>>> _coefs;
563 :
564 : /// Limits transformed from readabile input to ROM readable limits for normalization
565 : std::vector<std::vector<std::vector<std::vector<std::vector<Real>>>>>
566 : _transformed_normalization_limits;
567 :
568 : /// Helper container defined by the ROM data set
569 : std::vector<std::vector<unsigned int>> _makeframe_helper;
570 :
571 : /// Creep rate material property
572 : GenericMaterialProperty<Real, is_ad> & _creep_rate;
573 :
574 : /// Cell dislocations rate of change
575 : GenericMaterialProperty<Real, is_ad> & _cell_rate;
576 :
577 : /// Wall dislocations rate of change
578 : GenericMaterialProperty<Real, is_ad> & _wall_rate;
579 :
580 : /// Material property to hold smootherstep applied in order to extrapolate.
581 : MaterialProperty<Real> & _extrapolation;
582 :
583 : /// Material property to store partition weight.
584 : GenericMaterialProperty<Real, is_ad> & _second_partition_weight;
585 :
586 : /// Container for derivative of creep increment with respect to strain
587 : GenericReal<is_ad> _derivative;
588 :
589 : /// Container for input values
590 : std::vector<GenericReal<is_ad>> _input_values;
591 :
592 : /// Container for old input values
593 : std::vector<Real> _old_input_values;
594 :
595 : /// Container for converted rom_inputs
596 : std::vector<std::vector<std::vector<GenericReal<is_ad>>>> _rom_inputs;
597 :
598 : /// Container for ROM polynomial inputs
599 : std::vector<std::vector<std::vector<std::vector<GenericReal<is_ad>>>>> _polynomial_inputs;
600 :
601 : /// Container for ROM precomputed values
602 : std::vector<std::vector<std::vector<GenericReal<is_ad>>>> _precomputed_vals;
603 :
604 : /// Container for global limits
605 : std::vector<std::pair<Real, Real>> _global_limits;
606 :
607 : /// Container for weights for each tile as computed for all input values beside stress
608 : std::vector<std::vector<GenericReal<is_ad>>> _non_stress_weights;
609 :
610 : /// Container for weights for each tile as computed for all input values beside stress
611 : std::vector<std::vector<GenericReal<is_ad>>> _weights;
612 :
613 : /// Container for weights for each tile as computed for all input values beside stress
614 : std::vector<GenericReal<is_ad>> _partition_weights;
615 :
616 : /// Container for d_parition_weights d_stress
617 : std::vector<GenericReal<is_ad>> _dpartition_weight_dstress;
618 :
619 : /// Container for tiling orientations
620 : std::vector<std::vector<unsigned int>> _tiling;
621 :
622 : /// Container for strain cutoff
623 : std::vector<Real> _cutoff;
624 :
625 : /// Unit conversion factors required to convert from the specified unit to MPa
626 : Real _stress_ucf;
627 :
628 : ///@{Material properties accumulated at substeps
629 : GenericMaterialProperty<Real, is_ad> & _wall_dislocations_step;
630 : GenericMaterialProperty<Real, is_ad> & _cell_dislocations_step;
631 : ///@}
632 :
633 : /// Total plastic strain increment in step (summing substep contributions)
634 : RankTwoTensor _plastic_strain_increment;
635 :
636 : /// Material property capturing number of substeps for output purposes (defaults to one if substepping isn't used)
637 : MaterialProperty<Real> & _number_of_substeps;
638 :
639 : /// index names for error output
640 : std::vector<std::string> _index_name;
641 :
642 : /// check if a JSON file was loaded and if the specified key exists
643 : void checkJSONKey(const std::string & key);
644 :
645 : /// JSON object constructed from the datafile
646 : nlohmann::json _json;
647 :
648 : usingTransientInterfaceMembers;
649 : using Material::_name;
650 : using Material::_q_point;
651 : using Material::_qp;
652 : using Material::coupledGenericValue;
653 : using RadialReturnCreepStressUpdateBaseTempl<is_ad>::computeResidual;
654 : using RadialReturnCreepStressUpdateBaseTempl<is_ad>::computeDerivative;
655 : using RadialReturnCreepStressUpdateBaseTempl<is_ad>::_apply_strain;
656 : using RadialReturnCreepStressUpdateBaseTempl<is_ad>::initQpStatefulProperties;
657 : using RadialReturnCreepStressUpdateBaseTempl<is_ad>::outputIterationStep;
658 : using RadialReturnCreepStressUpdateBaseTempl<is_ad>::outputIterationSummary;
659 : };
660 :
661 : typedef LAROMANCEStressUpdateBaseTempl<false> LAROMANCEStressUpdateBase;
662 : typedef LAROMANCEStressUpdateBaseTempl<true> ADLAROMANCEStressUpdateBase;
|
