Line data Source code
1 : /****************************************************************/
2 : /* DO NOT MODIFY THIS HEADER */
3 : /* BlackBear */
4 : /* */
5 : /* (c) 2017 Battelle Energy Alliance, LLC */
6 : /* ALL RIGHTS RESERVED */
7 : /* */
8 : /* Prepared by Battelle Energy Alliance, LLC */
9 : /* Under Contract No. DE-AC07-05ID14517 */
10 : /* With the U. S. Department of Energy */
11 : /* */
12 : /* See COPYRIGHT for full restrictions */
13 : /****************************************************************/
14 :
15 : #pragma once
16 :
17 : #include "MultiParameterPlasticityStressUpdate.h"
18 :
19 : class DamagePlasticityStressUpdate : public MultiParameterPlasticityStressUpdate
20 : {
21 : public:
22 : static InputParameters validParams();
23 : DamagePlasticityStressUpdate(const InputParameters & parameters);
24 :
25 171 : bool requiresIsotropicTensor() override { return true; }
26 :
27 : protected:
28 : virtual void initQpStatefulProperties() override;
29 : virtual void finalizeReturnProcess(const RankTwoTensor & rotation_increment) override;
30 :
31 : private:
32 : ///Yield function tolerance (user parameter)
33 : const Real _f_tol;
34 : ///dimensionless parameter involving biaxial & uniaxial compressive strengths (user parameter)
35 : const Real _alfa;
36 : ///dilatancy factor (user parameter)
37 : const Real _alfa_p;
38 : ///stiffness recovery factor (user parameter)
39 : const Real _s0;
40 : ///ft_ep_slope_factor_at_zero_ep (user parameter)
41 : const Real _Chi;
42 : ///tensile damage at half tensile strength (user parameter)
43 : const Real _Dt;
44 : ///yield strength in tension (user parameter)
45 : const Real _ft;
46 : ///fracture_energy in tension (user parameter)
47 : const Real _FEt;
48 : ///yield strength in compression (user parameter)
49 : const Real _fyc;
50 : ///compressive damage at maximum compressive strength (user parameter)
51 : const Real _Dc;
52 : ///maximum strength in compression (user parameter)
53 : const Real _fc;
54 : ///fracture energy in compression (user parameter)
55 : const Real _FEc;
56 : /// Maximum stress in tension without damage
57 : const Real _ft0;
58 : /// Maximum stress in compression without damage
59 : const Real _fc0;
60 :
61 : ///@{
62 : /** The following variables are intermediate and are calculated based on the user parameters given
63 : * above */
64 : const Real _at;
65 : const Real _ac;
66 : const Real _zt;
67 : const Real _zc;
68 : const Real _dt_bt;
69 : const Real _dc_bc;
70 :
71 : ///@}
72 :
73 : /// Intermediate variable calculated using user parameter tip_smoother
74 : const Real _small_smoother2;
75 :
76 : /// Square root of 3
77 : const Real _sqrt3;
78 :
79 : /// Whether to provide an estimate of the returned stress, based on perfect plasticity
80 : const bool _perfect_guess;
81 :
82 : /// Eigenvectors of the trial stress as a RankTwoTensor, in order to rotate the returned stress back to stress space
83 : RankTwoTensor _eigvecs;
84 : ///damage state in tension
85 : MaterialProperty<Real> & _intnl0;
86 : ///damage state in compression
87 : MaterialProperty<Real> & _intnl1;
88 : ///element length
89 : MaterialProperty<Real> & _ele_len;
90 : ///fracture energy in tension
91 : MaterialProperty<Real> & _gt;
92 : ///fracture energy in compression
93 : MaterialProperty<Real> & _gc;
94 : ///tensile damage
95 : MaterialProperty<Real> & _tD;
96 : ///compression damage
97 : MaterialProperty<Real> & _cD;
98 : ///damage variable
99 : MaterialProperty<Real> & _D;
100 : ///minimum Eigen value of plastic strain
101 : MaterialProperty<Real> & _min_ep;
102 : ///middle Eigen value of plastic strain
103 : MaterialProperty<Real> & _mid_ep;
104 : ///maximum Eigen value of plastic strain
105 : MaterialProperty<Real> & _max_ep;
106 : ///damaged minimum principal stress
107 : MaterialProperty<Real> & _sigma0;
108 : ///damaged mid value of principal stress
109 : MaterialProperty<Real> & _sigma1;
110 : ///damaged maximum principal stress
111 : MaterialProperty<Real> & _sigma2;
112 : /**
113 : * Obtain the undamaged strength
114 : * @param intnl (Array containing damage states in tension and compression, respectively)
115 : * @return value of ft (tensile strength)
116 : */
117 : Real fbar(const Real & f0, const Real & a, const Real & exponent, const Real & kappa) const;
118 : // Real ftbar(const std::vector<Real> & intnl) const;
119 : /**
120 : * Obtain the partial derivative of the undamaged tensile strength to the damage state
121 : * @param intnl (Array containing damage states in tension and compression, respectively)
122 : * @return value of dft (partial derivative of the tensile strength to the damage state)
123 : */
124 : Real
125 : dfbar_dkappa(const Real & f0, const Real & a, const Real & exponent, const Real & kappa) const;
126 :
127 : // * Obtain the damaged tensile strength
128 : // * @param intnl (Array containing damage states in tension and compression, respectively)
129 : // * @return value of ft (tensile strength)
130 : // */
131 : Real f(const Real & f0, const Real & a, const Real & kappa) const;
132 :
133 : /**
134 : * Obtain the partial derivative of the undamaged strength to the damage state
135 : * @param intnl (Array containing damage states in tension and compression, respectively)
136 : * @return value of dft (partial derivative of the tensile strength to the damage state)
137 : */
138 : Real df_dkappa(const Real & f0, const Real & a, const Real & kappa) const;
139 : /**
140 : * beta is a dimensionless constant, which is a component of the yield function
141 : * It is defined in terms of tensile strength, compressive strength, and another
142 : * dimensionless constant alpha (See Eqn. 37 in Lee (1998))
143 : * @param intnl (Array containing damage states in tension and compression, respectively)
144 : * @return value of beta
145 : */
146 : Real beta(const std::vector<Real> & intnl) const;
147 :
148 : /**
149 : * dbeta0 is a derivative of beta wrt. tensile strength (ft)
150 : * @param intnl (Array containing damage states in tension and compression, respectively)
151 : * @return value of dbeta0
152 : */
153 : Real dbeta0(const std::vector<Real> & intnl) const;
154 :
155 : /**
156 : * dbeta1 is a derivative of beta wrt. compressive strength (fc)
157 : * @param intnl (Array containing damage states in tension and compression, respectively)
158 : * @return value of dbeta1
159 : */
160 : Real dbeta1(const std::vector<Real> & intnl) const;
161 :
162 : /**
163 : * weighfac is the weight factor, defined interms of the ratio of sum of principal stresses
164 : * to the sum of absolute value of the principal stresses
165 : * @param stress_params is the array of principal stresses
166 : * @return wf
167 : */
168 : void weighfac(const std::vector<Real> & stress_params, Real & wf) const;
169 :
170 : /**
171 : * dweighfac is the derivative of the weight factor
172 : * @param stress_params is the array of principal stresses
173 : * @param wf is the weight factor
174 : * @return dwf
175 : */
176 : void dweighfac(const std::vector<Real> & stress_params, Real & wf, std::vector<Real> & dwf) const;
177 :
178 : /**
179 : * damageVar is the degradation damage variable as defined in Eqn. 43 in Lee (1998)
180 : * @param stress_params is the array of principal stresses
181 : * @param intnl (Array containing damage states in tension and compression, respectively)
182 : * @return value of damageVar
183 : */
184 : Real damageVar(const std::vector<Real> & stress_params, const std::vector<Real> & intnl) const;
185 :
186 : void computeStressParams(const RankTwoTensor & stress,
187 : std::vector<Real> & stress_params) const override;
188 :
189 : std::vector<RankTwoTensor> dstress_param_dstress(const RankTwoTensor & stress) const override;
190 :
191 : std::vector<RankFourTensor> d2stress_param_dstress(const RankTwoTensor & stress) const override;
192 :
193 : void setEffectiveElasticity(const RankFourTensor & Eijkl) override;
194 :
195 : virtual void preReturnMapV(const std::vector<Real> & trial_stress_params,
196 : const RankTwoTensor & stress_trial,
197 : const std::vector<Real> & intnl_old,
198 : const std::vector<Real> & yf,
199 : const RankFourTensor & Eijkl) override;
200 :
201 : virtual void setStressAfterReturnV(const RankTwoTensor & stress_trial,
202 : const std::vector<Real> & stress_params,
203 : Real gaE,
204 : const std::vector<Real> & intnl,
205 : const yieldAndFlow & smoothed_q,
206 : const RankFourTensor & Eijkl,
207 : RankTwoTensor & stress) const override;
208 :
209 : void yieldFunctionValuesV(const std::vector<Real> & stress_params,
210 : const std::vector<Real> & intnl,
211 : std::vector<Real> & yf) const override;
212 :
213 : void computeAllQV(const std::vector<Real> & stress_params,
214 : const std::vector<Real> & intnl,
215 : std::vector<yieldAndFlow> & all_q) const override;
216 :
217 : /**
218 : * This function calculates the flow potential
219 : * @param stress_params is the array of principal stresses
220 : * @param intnl (Array containing damage states in tension and compression, respectively)
221 : * @return r (flowpotential)
222 : */
223 : virtual void flowPotential(const std::vector<Real> & stress_params,
224 : const std::vector<Real> & intnl,
225 : std::vector<Real> & r) const;
226 :
227 : /**
228 : * This function calculates the derivative of the flow potential with the stress
229 : * @param stress_params is the array of principal stresses
230 : * @param intnl (Array containing damage states in tension and compression, respectively)
231 : * @return dr_dstress (dflowpotential_dstress)
232 : */
233 : virtual void dflowPotential_dstress(const std::vector<Real> & stress_params,
234 : std::vector<std::vector<Real>> & dr_dstress) const;
235 : /**
236 : * This function calculates the derivative of the flow potential with the damage states
237 : * @param stress_params is the array of principal stresses
238 : * @param intnl (Array containing damage states in tension and compression, respectively)
239 : * @return dr_dintnl (dflowPotential_dintnl)
240 : */
241 : virtual void dflowPotential_dintnl(const std::vector<Real> & stress_params,
242 : const std::vector<Real> & intnl,
243 : std::vector<std::vector<Real>> & dr_dintnl) const;
244 : /**
245 : * This function calculates the hardening potential
246 : * @param stress_params is the array of principal stresses
247 : * @param intnl (Array containing damage states in tension and compression, respectively)
248 : * @return h (hardening Potential)
249 : */
250 : virtual void hardPotential(const std::vector<Real> & stress_params,
251 : const std::vector<Real> & intnl,
252 : std::vector<Real> & h) const;
253 : /**
254 : * This function calculates the derivative of the hardening potential with the stress
255 : * @param stress_params is the array of principal stresses
256 : * @param intnl (Array containing damage states in tension and compression, respectively)
257 : * @return dh_dsig (dhardPotential_dstress)
258 : */
259 : virtual void dhardPotential_dstress(const std::vector<Real> & stress_params,
260 : const std::vector<Real> & intnl,
261 : std::vector<std::vector<Real>> & dh_dsig) const;
262 : /**
263 : * This function calculates the derivative of the hardening potential with the damage states
264 : * @param stress_params is the array of principal stresses
265 : * @param intnl (Array containing damage states in tension and compression, respectively)
266 : * @return dh_dintnl (dhardPotential_dintnl)
267 : */
268 : virtual void dhardPotential_dintnl(const std::vector<Real> & stress_params,
269 : const std::vector<Real> & intnl,
270 : std::vector<std::vector<Real>> & dh_dintnl) const;
271 : /**
272 : * This function updates the damage states
273 : * @param stress_params is the array of principal stresses
274 : * @param trial_stress_params is the trial values of the principal stresses
275 : * @param intnl_old (Array containing previous step's damage states in tension and compression,
276 : * respectively)
277 : * @return no particular return values, updates internal variables
278 : */
279 : void initialiseVarsV(const std::vector<Real> & trial_stress_params,
280 : const std::vector<Real> & intnl_old,
281 : std::vector<Real> & stress_params,
282 : Real & gaE,
283 : std::vector<Real> & intnl) const;
284 :
285 : void setIntnlValuesV(const std::vector<Real> & trial_stress_params,
286 : const std::vector<Real> & current_stress_params,
287 : const std::vector<Real> & intnl_old,
288 : std::vector<Real> & intnl) const override;
289 :
290 : void setIntnlDerivativesV(const std::vector<Real> & trial_stress_params,
291 : const std::vector<Real> & current_stress_params,
292 : const std::vector<Real> & intnl,
293 : std::vector<std::vector<Real>> & dintnl) const override;
294 :
295 : virtual void consistentTangentOperatorV(const RankTwoTensor & stress_trial,
296 : const std::vector<Real> & trial_stress_params,
297 : const RankTwoTensor & stress,
298 : const std::vector<Real> & stress_params,
299 : Real gaE,
300 : const yieldAndFlow & smoothed_q,
301 : const RankFourTensor & Eijkl,
302 : bool compute_full_tangent_operator,
303 : const std::vector<std::vector<Real>> & dvar_dtrial,
304 : RankFourTensor & cto) override;
305 : };
|
