Line data Source code
1 :
2 : #include <eigen3/Eigen/Eigenvalues>
3 :
4 : #include <cmath>
5 :
6 : #include <AMReX_SPACE.H>
7 :
8 : #include "PhaseFieldMicrostructure.H"
9 : #include "Integrator/Base/Mechanics.H"
10 : #include "BC/Constant.H"
11 : #include "Set/Set.H"
12 : #include "Util/Util.H"
13 : #include "IC/Random.H"
14 : #include "IC/Trig.H"
15 : #include "IC/Sphere.H"
16 : #include "IC/Expression.H"
17 : #include "Model/Interface/GB/SH.H"
18 : #include "Numeric/Stencil.H"
19 : #include "Solver/Nonlocal/Linear.H"
20 : #include "Solver/Nonlocal/Newton.H"
21 : #include "IC/Trig.H"
22 :
23 : #include "Model/Solid/Affine/Cubic.H"
24 : #include "Model/Solid/Affine/Hexagonal.H"
25 : #include "Model/Solid/Finite/PseudoAffine/Cubic.H"
26 : #include "Model/Defect/Disconnection.H"
27 :
28 : #include "Util/MPI.H"
29 :
30 : namespace Integrator
31 : {
32 : template<class model_type>
33 324 : void PhaseFieldMicrostructure<model_type>::Advance(int lev, Set::Scalar time, Set::Scalar dt)
34 : {
35 : BL_PROFILE("PhaseFieldMicrostructure::Advance");
36 324 : Base::Mechanics<model_type>::Advance(lev, time, dt);
37 324 : const Set::Scalar* DX = this->geom[lev].CellSize();
38 :
39 324 : std::swap(eta_old_mf[lev], eta_mf[lev]);
40 :
41 :
42 324 : Set::Scalar df_max = std::numeric_limits<Set::Scalar>::min();
43 :
44 324 : Model::Interface::GB::SH gbmodel(0.0, 0.0, anisotropy.sigma0, anisotropy.sigma1);
45 :
46 30986 : for (amrex::MFIter mfi(*eta_mf[lev], amrex::TilingIfNotGPU()); mfi.isValid(); ++mfi)
47 : {
48 30662 : amrex::Box bx = mfi.tilebox();
49 30662 : Set::Patch<Set::Scalar> etanew = eta_mf.Patch(lev,mfi);
50 30662 : Set::Patch<const Set::Scalar> eta = eta_old_mf.Patch(lev,mfi);
51 :
52 30662 : Set::Scalar *df_max_handle = &df_max;
53 :
54 30662 : Set::Patch<const Set::Matrix> sigma = stress_mf.Patch(lev,mfi);
55 30662 : Set::Patch<const Set::Vector> disp = this->disp_mf.Patch(lev,mfi);
56 :
57 2029062 : amrex::ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k)
58 : {
59 1998400 : Set::Matrix sig = Set::Matrix::Zero();
60 1998400 : if (pf.elastic_df) sig = Numeric::Interpolate::NodeToCellAverage(sigma, i, j, k, 0);
61 :
62 10005696 : for (int m = 0; m < number_of_grains; m++)
63 : {
64 : //if (shearcouple.on) etaold(i,j,k,m) = eta(i,j,k,m);
65 :
66 8007296 : Set::Scalar driving_force = 0.0;
67 8007296 : Set::Scalar driving_force_threshold = NAN;
68 8007296 : if (pf.threshold.on) driving_force_threshold = 0.0;
69 8007296 : Set::Scalar kappa = NAN, mu = NAN;
70 :
71 : //
72 : // BOUNDARY TERM and SECOND ORDER REGULARIZATION
73 : //
74 :
75 8007296 : Set::Vector Deta = Numeric::Gradient(eta, i, j, k, m, DX);
76 8007296 : Set::Scalar normgrad = Deta.lpNorm<2>();
77 8007296 : if (normgrad < 1E-4)
78 5766615 : continue; // This ought to speed things up.
79 :
80 2240681 : Set::Matrix DDeta = Numeric::Hessian(eta, i, j, k, m, DX);
81 2240681 : Set::Scalar laplacian = DDeta.trace();
82 :
83 2240681 : if (!anisotropy.on || time < anisotropy.tstart)
84 : {
85 877969 : kappa = pf.l_gb * 0.75 * pf.sigma0;
86 877969 : mu = 0.75 * (1.0 / 0.23) * pf.sigma0 / pf.l_gb;
87 877969 : if (pf.threshold.boundary) driving_force_threshold += -kappa * laplacian;
88 877969 : else driving_force += -kappa * laplacian;
89 : }
90 : else
91 : {
92 1362712 : Set::Matrix4<AMREX_SPACEDIM, Set::Sym::Full> DDDDEta = Numeric::DoubleHessian<AMREX_SPACEDIM>(eta, i, j, k, m, DX);
93 1362712 : auto anisotropic_df = boundary->DrivingForce(Deta, DDeta, DDDDEta);
94 1362712 : if (pf.threshold.boundary) driving_force_threshold += pf.l_gb * 0.75 * std::get<0>(anisotropic_df);
95 1362712 : else driving_force += pf.l_gb * 0.75 * std::get<0>(anisotropic_df);
96 1362712 : if (std::isnan(std::get<0>(anisotropic_df))) Util::Abort(INFO);
97 1362712 : if (pf.threshold.boundary) driving_force_threshold += anisotropy.beta * std::get<1>(anisotropic_df);
98 1362712 : else driving_force += anisotropy.beta * std::get<1>(anisotropic_df);
99 1362712 : if (std::isnan(std::get<1>(anisotropic_df))) Util::Abort(INFO);
100 1362712 : mu = 0.75 * (1.0 / 0.23) * boundary->W(Deta) / pf.l_gb;
101 : }
102 :
103 : //
104 : // CHEMICAL POTENTIAL
105 : //
106 :
107 2240681 : Set::Scalar sum_of_squares = 0.;
108 13398019 : for (int n = 0; n < number_of_grains; n++)
109 : {
110 11157338 : if (m == n)
111 2240681 : continue;
112 26749971 : sum_of_squares += eta(i, j, k, n) * eta(i, j, k, n);
113 : }
114 2240681 : if (pf.threshold.chempot)
115 0 : driving_force_threshold += mu * (eta(i, j, k, m) * eta(i, j, k, m) - 1.0 + 2.0 * pf.gamma * sum_of_squares) * eta(i, j, k, m);
116 : else
117 8962724 : driving_force += mu * (eta(i, j, k, m) * eta(i, j, k, m) - 1.0 + 2.0 * pf.gamma * sum_of_squares) * eta(i, j, k, m);
118 :
119 :
120 : //
121 : // LAGRANGE MULTIPLIER
122 : //
123 2240681 : if (lagrange.on && m == 0 && time > lagrange.tstart)
124 : {
125 0 : if (pf.threshold.lagrange)
126 0 : driving_force_threshold += lagrange.lambda * (volume - lagrange.vol0);
127 : else
128 0 : driving_force += lagrange.lambda * (volume - lagrange.vol0);
129 : }
130 :
131 : //
132 : // SYNTHETIC DRIVING FORCE
133 : //
134 2240681 : if (sdf.on && time > sdf.tstart)
135 : {
136 0 : if (pf.threshold.sdf)
137 0 : driving_force_threshold += sdf.val[m](time);
138 : else
139 0 : driving_force += sdf.val[m](time);
140 : }
141 :
142 :
143 : //
144 : // ELASTIC DRIVING FORCE
145 : //
146 2240681 : if (pf.elastic_df)
147 : {
148 0 : Set::Scalar elastic_df_m = 0.0;
149 :
150 0 : if (shearcouple.on)
151 : {
152 0 : for (int n = 0; n < number_of_grains; n++)
153 : {
154 0 : if (n==m) continue;
155 0 : Set::Scalar etam = eta(i,j,k,m);
156 0 : Set::Scalar etan = eta(i,j,k,n);
157 :
158 0 : Set::Scalar sumsq = (etam*etam + etan*etan);
159 0 : sumsq = sumsq * sumsq;
160 :
161 : //Set::Scalar dgm = 2.0*etan*etan*etam / sumsq;
162 0 : Set::Scalar dgn = 2.0*etan*etam*etam / sumsq;
163 :
164 :
165 0 : Set::Matrix Fgbn = shearcouple.Fgb[n*number_of_grains + m];
166 :
167 : if (model_type::kinvar == Model::Solid::KinematicVariable::F)
168 : {
169 0 : Set::Matrix F =
170 : Set::Matrix::Identity() +
171 0 : Numeric::NodeGradientOnCell(disp,i,j,k,DX);
172 0 : Fgbn = F*Fgbn;
173 : }
174 :
175 0 : elastic_df_m += (sig.transpose() * Fgbn).trace() * dgn;
176 : }
177 : }
178 : else
179 : {
180 0 : Set::Matrix F0avg = Set::Matrix::Zero();
181 :
182 0 : for (int n = 0; n < number_of_grains; n++)
183 0 : F0avg += eta(i, j, k, n) * mechanics.model[n].F0;
184 :
185 0 : Set::Matrix dF0deta = Set::Matrix::Zero();
186 :
187 0 : for (int n = 0; n < number_of_grains; n++)
188 : {
189 0 : if (n == m) continue;
190 0 : Set::Scalar normsq = eta(i, j, k, m) * eta(i, j, k, m) + eta(i, j, k, n) * eta(i, j, k, n);
191 0 : dF0deta += (2.0 * eta(i, j, k, m) * eta(i, j, k, n) * eta(i, j, k, n) *
192 0 : (mechanics.model[m].F0 - mechanics.model[n].F0))
193 : / normsq / normsq;
194 : }
195 :
196 0 : elastic_df_m += (dF0deta.transpose() * sig).trace();
197 : }
198 :
199 :
200 0 : if (pf.threshold.mechanics)
201 0 : driving_force_threshold -= pf.elastic_mult * elastic_df_m;
202 : else
203 0 : driving_force -= pf.elastic_mult * elastic_df_m;
204 : }
205 :
206 : //
207 : // Update eta
208 : //
209 : // Final mobility and threshold values:
210 2240681 : Set::Scalar L = NAN, threshold = NAN;
211 : // (if we are NOT using anisotropic kinetics)
212 2240681 : if (!anisotropic_kinetics.on || time < anisotropic_kinetics.tstart)
213 : {
214 2240681 : L = pf.L;
215 2240681 : threshold = pf.threshold.value;
216 : }
217 : // (if we ARE using anisotropic kinetics)
218 : else
219 : {
220 0 : Set::Scalar theta = atan2(Deta(1), Deta(0));
221 0 : L = (4. / 3.) * anisotropic_kinetics.mobility(theta) / pf.l_gb;
222 0 : threshold = anisotropic_kinetics.threshold(theta);
223 : }
224 :
225 2240681 : Set::Scalar totaldf = 0.0;
226 2240681 : if (pf.threshold.on)
227 : {
228 0 : if (driving_force_threshold > threshold)
229 : {
230 0 : if (pf.threshold.type == ThresholdType::Continuous)
231 0 : totaldf -= L * (driving_force_threshold - threshold);
232 0 : else if (pf.threshold.type == ThresholdType::Chop)
233 0 : totaldf -= L * (driving_force_threshold);
234 : }
235 0 : else if (driving_force_threshold < -threshold)
236 : {
237 0 : if (pf.threshold.type == ThresholdType::Continuous)
238 0 : totaldf -= L * (driving_force_threshold + threshold);
239 0 : else if (pf.threshold.type == ThresholdType::Chop)
240 0 : totaldf -= L * (driving_force_threshold);
241 : }
242 : }
243 2240681 : totaldf -= L * driving_force;
244 :
245 : // Final Eta Update
246 4481362 : etanew(i, j, k, m) = eta(i,j,k,m) + dt * totaldf;
247 2240681 : *df_max_handle = std::max(df_max, std::fabs(totaldf));
248 : }
249 : });
250 : }
251 :
252 324 : if (shearcouple.on && time >= mechanics.tstart) UpdateEigenstrain(lev);
253 : //this->DynamicTimestep_SyncDrivingForce(lev,df_max);
254 324 : }
255 :
256 : template <class model_type>
257 0 : void PhaseFieldMicrostructure<model_type>::UpdateEigenstrain(int lev)
258 : {
259 0 : if (this->m_type == Base::Mechanics<model_type>::Disable) return;
260 0 : eta_mf[lev]->FillBoundary();
261 0 : eta_old_mf[lev]->FillBoundary();
262 :
263 0 : amrex::Box domain = this->geom[lev].Domain();
264 0 : domain.convert(amrex::IntVect::TheNodeVector());
265 :
266 0 : for (amrex::MFIter mfi(*this->model_mf[lev], false); mfi.isValid(); ++mfi)
267 : {
268 0 : amrex::Box bx = mfi.grownnodaltilebox() & domain;
269 0 : Set::Patch<const Set::Scalar> etaold = eta_old_mf.Patch(lev,mfi);
270 0 : Set::Patch<const Set::Scalar> etanew = eta_mf.Patch(lev,mfi);
271 0 : Set::Patch<model_type> model = model_mf.Patch(lev,mfi);
272 0 : amrex::ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k)
273 : {
274 0 : for (int m = 0; m < number_of_grains; m++)
275 0 : for (int n = 0; n < number_of_grains; n++)
276 : {
277 0 : if (m==n) continue;
278 0 : Set::Scalar emnew = Numeric::Interpolate::CellToNodeAverage(etanew, i, j, k, m);//, sten);
279 0 : Set::Scalar emold = Numeric::Interpolate::CellToNodeAverage(etaold, i, j, k, m);//, sten);
280 0 : Set::Scalar ennew = Numeric::Interpolate::CellToNodeAverage(etanew, i, j, k, n);//, sten);
281 0 : Set::Scalar enold = Numeric::Interpolate::CellToNodeAverage(etaold, i, j, k, n);//, sten);
282 0 : Set::Scalar gmnew = (emnew * emnew) / (emnew * emnew + ennew * ennew);
283 0 : Set::Scalar gmold = (emold * emold) / (emold * emold + enold * enold);
284 0 : model(i, j, k).F0 -= 0.5 * (gmnew - gmold) * shearcouple.Fgb[m*number_of_grains + n];
285 : }
286 : });
287 : }
288 :
289 0 : Util::RealFillBoundary(*this->model_mf[lev],this->geom[lev]);
290 : }
291 :
292 : template<class model_type>
293 23 : void PhaseFieldMicrostructure<model_type>::Initialize(int lev)
294 : {
295 : BL_PROFILE("PhaseFieldMicrostructure::Initialize");
296 23 : Base::Mechanics<model_type>::Initialize(lev);
297 23 : ic->Initialize(lev, eta_mf);
298 23 : ic->Initialize(lev, eta_old_mf);
299 23 : }
300 :
301 : template<class model_type>
302 50 : void PhaseFieldMicrostructure<model_type>::TagCellsForRefinement(int lev, amrex::TagBoxArray& a_tags, Set::Scalar time, int ngrow)
303 : {
304 : BL_PROFILE("PhaseFieldMicrostructure::TagCellsForRefinement");
305 50 : Base::Mechanics<model_type>::TagCellsForRefinement(lev, a_tags, time, ngrow);
306 50 : const amrex::Real* DX = this->geom[lev].CellSize();
307 50 : const Set::Vector dx(DX);
308 50 : const Set::Scalar dxnorm = dx.lpNorm<2>();
309 :
310 3436 : for (amrex::MFIter mfi(*eta_mf[lev], TilingIfNotGPU()); mfi.isValid(); ++mfi)
311 : {
312 3386 : const amrex::Box& bx = mfi.tilebox();
313 3386 : amrex::Array4<const amrex::Real> const& etanew = (*eta_mf[lev]).array(mfi);
314 3386 : amrex::Array4<char> const& tags = a_tags.array(mfi);
315 :
316 18238 : for (int n = 0; n < number_of_grains; n++)
317 1199940 : amrex::ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k) {
318 1185088 : Set::Vector grad = Numeric::Gradient(etanew, i, j, k, n, DX);
319 :
320 1185088 : if (dxnorm * grad.lpNorm<2>() > ref_threshold)
321 115862 : tags(i, j, k) = amrex::TagBox::SET;
322 : });
323 : }
324 50 : }
325 :
326 : template<class model_type>
327 44 : void PhaseFieldMicrostructure<model_type>::TimeStepComplete(Set::Scalar /*time*/, int /*iter*/)
328 : {
329 44 : this->DynamicTimestep_Update();
330 44 : }
331 :
332 : template<class model_type>
333 0 : void PhaseFieldMicrostructure<model_type>::UpdateModel(int a_step, Set::Scalar /*a_time*/)
334 : {
335 : BL_PROFILE("PhaseFieldMicrostructure::UpdateModel");
336 0 : if (a_step % this->m_interval) return;
337 :
338 0 : for (int lev = 0; lev <= this->finest_level; ++lev)
339 : {
340 0 : amrex::Box domain = this->geom[lev].Domain();
341 0 : domain.convert(amrex::IntVect::TheNodeVector());
342 :
343 0 : eta_mf[lev]->FillBoundary();
344 :
345 0 : for (MFIter mfi(*this->model_mf[lev], false); mfi.isValid(); ++mfi)
346 : {
347 0 : amrex::Box bx = mfi.grownnodaltilebox() & domain;
348 :
349 0 : amrex::Array4<model_type> const& model = this->model_mf[lev]->array(mfi);
350 0 : amrex::Array4<const Set::Scalar> const& eta = eta_mf[lev]->array(mfi);
351 :
352 0 : amrex::ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k)
353 : {
354 0 : std::vector<Set::Scalar> etas(number_of_grains);
355 0 : for (int n = 0; n < number_of_grains; n++)
356 0 : etas[n] = Numeric::Interpolate::CellToNodeAverage(eta, i, j, k, n);
357 0 : model_type mix = model_type::Combine(mechanics.model, etas, mechanics.model_mix_order);
358 0 : if (a_step == 0 || !shearcouple.on) // Do a complete model initialization
359 0 : model(i,j,k) = mix ;
360 : else // Otherwise, we will set the modulus only and leave the eigenstrain alone
361 : {
362 0 : Set::Matrix F0 = model(i,j,k).F0;
363 0 : model(i,j,k) = mix;
364 0 : model(i,j,k).F0 = F0;
365 : }
366 0 : });
367 : }
368 :
369 0 : if (mechanics.model_neumann_boundary)
370 : {
371 0 : Util::AssertException(INFO,TEST(AMREX_SPACEDIM==2),"neumann boundary works in 2d only");
372 0 : for (MFIter mfi(*this->model_mf[lev], false); mfi.isValid(); ++mfi)
373 : {
374 0 : amrex::Box bx = mfi.grownnodaltilebox() & domain;
375 0 : amrex::Array4<model_type> const& model = this->model_mf[lev]->array(mfi);
376 0 : const Dim3 lo = amrex::lbound(domain), hi = amrex::ubound(domain);
377 :
378 0 : amrex::ParallelFor(bx, [=] AMREX_GPU_DEVICE(int i, int j, int k)
379 : {
380 0 : if (i==lo.x && j==lo.y)
381 0 : model(i,j,k) = 0.5*(model(i+1,j,k)+model(i,j+1,k));
382 0 : else if (i==lo.x && j==hi.y)
383 0 : model(i,j,k) = 0.5*(model(i+1,j,k)+model(i,j-1,k));
384 0 : else if (i==hi.x && j==lo.y)
385 0 : model(i,j,k) = 0.5*(model(i-1,j,k)+model(i,j+1,k));
386 0 : else if (i==hi.x && j==hi.y)
387 0 : model(i,j,k) = 0.5*(model(i-1,j,k)+model(i,j-1,k));
388 :
389 0 : else if (i==lo.x)
390 0 : model(i,j,k) = model(i+1,j,k);
391 0 : else if (i==hi.x)
392 0 : model(i,j,k) = model(i-1,j,k);
393 0 : else if (j==lo.y)
394 0 : model(i,j,k) = model(i,j+1,k);
395 0 : else if (j==hi.y)
396 0 : model(i,j,k) = model(i,j-1,k);
397 : });
398 : }
399 : }
400 :
401 0 : Util::RealFillBoundary(*this->model_mf[lev], this->geom[lev]);
402 : }
403 :
404 : }
405 :
406 : template<class model_type>
407 44 : void PhaseFieldMicrostructure<model_type>::TimeStepBegin(Set::Scalar time, int iter)
408 : {
409 : BL_PROFILE("PhaseFieldMicrostructure::TimeStepBegin");
410 44 : for (int lev = 0; lev < totaldf_mf.size(); lev++) totaldf_mf[lev]->setVal(0.0);
411 :
412 : // Insertion of disconnections
413 44 : if (disconnection.on)
414 : {
415 0 : disconnection.model.Nucleate(eta_mf,this->Geom(),this->timestep,time, iter);
416 0 : UpdateEigenstrain();
417 : }
418 :
419 44 : Base::Mechanics<model_type>::TimeStepBegin(time, iter);
420 :
421 44 : if (anisotropy.on && time >= anisotropy.tstart)
422 : {
423 280 : Util::AssertException( INFO,TEST(this->dynamictimestep.on == false),
424 : "Cannot use anisotropy with dynamic timestep yet");
425 40 : this->SetTimestep(anisotropy.timestep);
426 40 : if (anisotropy.elastic_int > 0)
427 0 : if (iter % anisotropy.elastic_int) return;
428 : }
429 : }
430 :
431 : template<class model_type>
432 11898 : void PhaseFieldMicrostructure<model_type>::Integrate(int amrlev, Set::Scalar time, int step,
433 : const amrex::MFIter& mfi, const amrex::Box& box)
434 : {
435 : BL_PROFILE("PhaseFieldMicrostructure::Integrate");
436 11898 : Base::Mechanics<model_type>::Integrate(amrlev, time, step, mfi, box);
437 :
438 11898 : Model::Interface::GB::SH gbmodel(0.0, 0.0, anisotropy.sigma0, anisotropy.sigma1);
439 11898 : const amrex::Real* DX = this->geom[amrlev].CellSize();
440 11898 : Set::Scalar dv = AMREX_D_TERM(DX[0], *DX[1], *DX[2]);
441 :
442 11898 : amrex::Array4<amrex::Real> const& eta = (*eta_mf[amrlev]).array(mfi);
443 574826 : amrex::ParallelFor(box, [=] AMREX_GPU_DEVICE(int i, int j, int k) {
444 : #if AMREX_SPACEDIM == 2
445 562928 : auto sten = Numeric::GetStencil(i, j, k, box);
446 : #endif
447 :
448 562928 : volume += eta(i, j, k, 0) * dv;
449 :
450 562928 : Set::Vector grad = Numeric::Gradient(eta, i, j, k, 0, DX);
451 562928 : Set::Scalar normgrad = grad.lpNorm<2>();
452 :
453 562928 : if (normgrad > 1E-8)
454 : {
455 169596 : Set::Vector normal = grad / normgrad;
456 :
457 169596 : Set::Scalar da = normgrad * dv;
458 169596 : area += da;
459 :
460 169596 : if (!anisotropy.on || time < anisotropy.tstart)
461 : {
462 8556 : gbenergy += pf.sigma0 * da;
463 8556 : Set::Scalar k = 0.75 * pf.sigma0 * pf.l_gb;
464 8556 : realgbenergy += 0.5 * k * normgrad * normgrad * dv;
465 8556 : regenergy = 0.0;
466 8556 : }
467 : else
468 : {
469 : #if AMREX_SPACEDIM == 2
470 161040 : Set::Scalar theta = atan2(grad(1), grad(0));
471 161040 : Set::Scalar sigma = boundary->W(theta);
472 161040 : gbenergy += sigma * da;
473 :
474 161040 : Set::Scalar k = 0.75 * sigma * pf.l_gb;
475 161040 : realgbenergy += 0.5 * k * normgrad * normgrad * dv;
476 :
477 161040 : Set::Matrix DDeta = Numeric::Hessian(eta, i, j, k, 0, DX, sten);
478 161040 : Set::Vector tangent(normal[1], -normal[0]);
479 161040 : Set::Scalar k2 = (DDeta * tangent).dot(tangent);
480 161040 : regenergy += 0.5 * anisotropy.beta * k2 * k2;
481 : #elif AMREX_SPACEDIM == 3
482 0 : gbenergy += gbmodel.W(normal) * da;
483 : #endif
484 : }
485 : }
486 : });
487 11898 : }
488 :
489 : template class PhaseFieldMicrostructure<Model::Solid::Affine::Cubic>;
490 : template class PhaseFieldMicrostructure<Model::Solid::Affine::Hexagonal>;
491 : template class PhaseFieldMicrostructure<Model::Solid::Finite::PseudoAffine::Cubic>;
492 :
493 :
494 : } // namespace Integrator
|
