www.mooseframework.org
PhaseFieldApp.C
Go to the documentation of this file.
1 /****************************************************************/
2 /* MOOSE - Multiphysics Object Oriented Simulation Environment */
3 /* */
4 /* All contents are licensed under LGPL V2.1 */
5 /* See LICENSE for full restrictions */
6 /****************************************************************/
7 #include "PhaseFieldApp.h"
8 #include "Moose.h"
9 #include "AppFactory.h"
10 #include "MooseSyntax.h"
11 
12 /*
13  * Kernels
14  */
15 #include "ACGBPoly.h"
17 #include "ACGrGrMulti.h"
18 #include "ACGrGrPoly.h"
19 #include "ACInterface.h"
20 #include "ACMultiInterface.h"
21 #include "ACInterfaceKobayashi1.h"
22 #include "ACInterfaceKobayashi2.h"
23 #include "ACInterfaceStress.h"
24 #include "AllenCahnPFFracture.h"
25 #include "ACSEDGPoly.h"
26 #include "ACSwitching.h"
27 #include "AllenCahn.h"
28 #include "CahnHilliard.h"
29 #include "CahnHilliardAniso.h"
30 #include "CHBulkPFCTrad.h"
31 #include "CHCpldPFCTrad.h"
32 #include "CHInterface.h"
33 #include "CHInterfaceAniso.h"
34 #include "CHMath.h"
35 #include "CHPFCRFF.h"
37 #include "CHSplitConcentration.h"
38 #include "CHSplitFlux.h"
40 #include "CoefReaction.h"
41 #include "ConservedLangevinNoise.h"
42 #include "CoupledAllenCahn.h"
46 #include "GradientComponent.h"
47 #include "HHPFCRFF.h"
48 #include "KKSACBulkC.h"
49 #include "KKSACBulkF.h"
50 #include "KKSCHBulk.h"
51 #include "KKSMultiACBulkC.h"
52 #include "KKSMultiACBulkF.h"
55 #include "KKSPhaseConcentration.h"
56 #include "KKSSplitCHCRes.h"
57 #include "LangevinNoise.h"
58 #include "LaplacianSplit.h"
59 #include "MaskedBodyForce.h"
60 #include "MatAnisoDiffusion.h"
61 #include "MatDiffusion.h"
62 #include "MatReaction.h"
64 #include "PFFracBulkRate.h"
65 #include "PFFracCoupledInterface.h"
66 #include "SimpleACInterface.h"
67 #include "SimpleCHInterface.h"
69 #include "SimpleSplitCHWRes.h"
71 #include "SoretDiffusion.h"
72 #include "SplitCHMath.h"
73 #include "SplitCHParsed.h"
74 #include "SplitCHWRes.h"
75 #include "SplitCHWResAniso.h"
77 #include "PFFractureBulkRate.h"
82 
83 // Remove this once the PFFracIntVar -> Reaction deprecation is expired:
84 #include "Reaction.h"
85 
86 /*
87  * Initial Conditions
88  */
91 #include "ClosePackIC.h"
92 #include "CrossIC.h"
93 #include "LatticeSmoothCircleIC.h"
94 #include "MultiBoundingBoxIC.h"
95 #include "MultiSmoothCircleIC.h"
97 #include "PFCFreezingIC.h"
98 #include "PolycrystalColoringIC.h"
99 #include "PolycrystalRandomIC.h"
101 #include "RampIC.h"
102 #include "ReconPhaseVarIC.h"
103 #include "RndBoundingBoxIC.h"
104 #include "RndSmoothCircleIC.h"
105 #include "SmoothCircleIC.h"
106 #include "SmoothCircleFromFileIC.h"
107 #include "SmoothSuperellipsoidIC.h"
108 #include "SpecifiedSmoothCircleIC.h"
110 #include "ThumbIC.h"
113 
114 /*
115  * Boundary Conditions
116  */
117 #include "CahnHilliardAnisoFluxBC.h"
118 #include "CahnHilliardFluxBC.h"
119 
120 /*
121  * InterfaceKernels
122  */
127 
128 /*
129  * Materials
130  */
132 #include "BarrierFunctionMaterial.h"
133 #include "CompositeMobilityTensor.h"
137 #include "DeformedGrainMaterial.h"
140 #include "DerivativeSumMaterial.h"
142 #include "DiscreteNucleation.h"
143 #include "ElasticEnergyMaterial.h"
145 #include "ForceDensityMaterial.h"
146 #include "GBAnisotropy.h"
148 #include "GBDependentDiffusivity.h"
149 #include "GBEvolution.h"
150 #include "GBWidthAnisotropy.h"
151 #include "GrainAdvectionVelocity.h"
152 #include "IdealGasFreeEnergy.h"
154 #include "KKSXeVacSolidMaterial.h"
155 #include "MathEBFreeEnergy.h"
156 #include "MathFreeEnergy.h"
159 #include "ParsedMaterial.h"
160 #include "PFCRFFMaterial.h"
161 #include "PFCTradMaterial.h"
162 #include "PFFracBulkRateMaterial.h"
163 #include "PFMobility.h"
164 #include "PFParamsPolyFreeEnergy.h"
165 #include "PhaseNormalTensor.h"
166 #include "PolynomialFreeEnergy.h"
173 #include "TimeStepMaterial.h"
174 #include "VanDerWaalsFreeEnergy.h"
176 
177 /*
178  * Postprocessors
179  */
180 #include "AverageGrainVolume.h"
181 #include "FeatureFloodCount.h"
182 #include "GrainBoundaryArea.h"
183 #include "GrainTracker.h"
184 #include "GrainTrackerElasticity.h"
185 #include "FauxGrainTracker.h"
187 
188 /*
189  * AuxKernels
190  */
191 #include "BndsCalcAux.h"
194 #include "FeatureFloodCountAux.h"
195 #include "GrainAdvectionAux.h"
196 #include "KKSGlobalFreeEnergy.h"
197 #include "KKSMultiFreeEnergy.h"
198 #include "PFCEnergyDensity.h"
199 #include "PFCRFFEnergyDensity.h"
200 #include "EBSDReaderAvgDataAux.h"
201 #include "EBSDReaderPointDataAux.h"
202 #include "TotalFreeEnergy.h"
203 #include "OutputEulerAngles.h"
205 
206 /*
207  * Functions
208  */
209 
210 /*
211  * User Objects
212  */
218 #include "ConservedNormalNoise.h"
219 #include "ConservedUniformNoise.h"
222 #include "DiscreteNucleationMap.h"
223 #include "EulerAngleUpdater.h"
224 #include "GrainForceAndTorqueSum.h"
226 #include "PolycrystalCircles.h"
227 #include "PolycrystalHex.h"
228 #include "PolycrystalVoronoi.h"
229 #include "PolycrystalEBSD.h"
231 
232 #include "EBSDReader.h"
233 #include "SolutionRasterizer.h"
234 
235 /*
236  * Meshes
237  */
238 #include "EBSDMesh.h"
239 #include "MortarPeriodicMesh.h"
240 
241 /*
242  * Actions
243  */
248 #include "ConservedAction.h"
250 #include "EulerAngle2RGBAction.h"
251 #include "GrainGrowthAction.h"
257 #include "MortarPeriodicAction.h"
258 #include "MultiAuxVariablesAction.h"
259 #include "NonconservedAction.h"
260 #include "PFCRFFKernelAction.h"
261 #include "PFCRFFVariablesAction.h"
264 #include "PolycrystalKernelAction.h"
271 
272 /*
273  * VectorPostprocessors
274  */
275 #include "EulerAngleUpdaterCheck.h"
276 #include "FeatureVolumeFraction.h"
281 
282 template <>
283 InputParameters
285 {
286  InputParameters params = validParams<MooseApp>();
287  return params;
288 }
289 
290 PhaseFieldApp::PhaseFieldApp(const InputParameters & parameters) : MooseApp(parameters)
291 {
292  Moose::registerObjects(_factory);
294 
295  Moose::associateSyntax(_syntax, _action_factory);
296  PhaseFieldApp::associateSyntax(_syntax, _action_factory);
297 }
298 
300 
301 // External entry point for dynamic application loading
302 extern "C" void
304 {
306 }
307 void
309 {
310  registerApp(PhaseFieldApp);
311 }
312 
313 // External entry point for dynamic object registration
314 extern "C" void
316 {
318 }
319 void
321 {
322  registerKernel(ACGBPoly);
323  registerKernel(ACGrGrElasticDrivingForce);
324  registerKernel(ACGrGrMulti);
325  registerKernel(ACGrGrPoly);
326  registerKernel(ACInterface);
327  registerKernel(ACMultiInterface);
328  registerKernel(ACInterfaceKobayashi1);
329  registerKernel(ACInterfaceKobayashi2);
330  registerKernel(ACInterfaceStress);
331  registerKernel(AllenCahnPFFracture);
332  registerKernel(ACSEDGPoly);
333  registerKernel(ACSwitching);
334  registerKernel(AllenCahn);
335  registerKernel(CahnHilliard);
336  registerKernel(CahnHilliardAniso);
337  registerKernel(CHBulkPFCTrad);
338  registerDeprecatedObject(CHCpldPFCTrad);
339  registerKernel(CHInterface);
340  registerKernel(CHInterfaceAniso);
341  registerKernel(CHMath);
342  registerKernel(CHPFCRFF);
343  registerKernel(CHSplitChemicalPotential);
344  registerKernel(CHSplitConcentration);
345  registerKernel(CHSplitFlux);
346  registerKernel(CoefCoupledTimeDerivative);
347  registerKernel(CoefReaction);
348  registerKernel(ConservedLangevinNoise);
349  registerKernel(CoupledAllenCahn);
350  registerKernel(CoupledSusceptibilityTimeDerivative);
351  registerKernel(CoupledSwitchingTimeDerivative);
352  registerKernel(CoupledMaterialDerivative);
353  registerKernel(GradientComponent);
354  registerKernel(HHPFCRFF);
355  registerKernel(KKSACBulkC);
356  registerKernel(KKSACBulkF);
357  registerKernel(KKSCHBulk);
358  registerKernel(KKSMultiACBulkC);
359  registerKernel(KKSMultiACBulkF);
360  registerKernel(KKSMultiPhaseConcentration);
361  registerKernel(KKSPhaseChemicalPotential);
362  registerKernel(KKSPhaseConcentration);
363  registerKernel(KKSSplitCHCRes);
364  registerKernel(LangevinNoise);
365  registerKernel(LaplacianSplit);
366  registerKernel(MaskedBodyForce);
367  registerKernel(MatAnisoDiffusion);
368  registerKernel(MatDiffusion);
369  registerKernel(MatReaction);
370  registerKernel(MultiGrainRigidBodyMotion);
371  registerDeprecatedObject(PFFracBulkRate);
372  registerKernel(PFFractureBulkRate);
373  registerDeprecatedObject(PFFracCoupledInterface);
374  registerKernel(SimpleACInterface);
375  registerKernel(SimpleCHInterface);
376  registerKernel(SimpleCoupledACInterface);
377  registerKernel(SimpleSplitCHWRes);
378  registerKernel(SingleGrainRigidBodyMotion);
379  registerKernel(SoretDiffusion);
380  registerKernel(SplitCHMath);
381  registerKernel(SplitCHParsed);
382  registerKernel(SplitCHWRes);
383  registerKernel(SplitCHWResAniso);
384  registerKernel(SplitPFFractureBulkRate);
385  registerKernel(SusceptibilityTimeDerivative);
386  registerKernel(SwitchingFunctionConstraintEta);
387  registerKernel(SwitchingFunctionConstraintLagrange);
388  registerKernel(SwitchingFunctionPenalty);
389 
390  registerInitialCondition(BimodalInverseSuperellipsoidsIC);
391  registerInitialCondition(BimodalSuperellipsoidsIC);
392  registerInitialCondition(ClosePackIC);
393  registerInitialCondition(CrossIC);
394  registerInitialCondition(LatticeSmoothCircleIC);
395  registerInitialCondition(MultiBoundingBoxIC);
396  registerInitialCondition(MultiSmoothCircleIC);
397  registerInitialCondition(MultiSmoothSuperellipsoidIC);
398  registerInitialCondition(PFCFreezingIC);
399  registerInitialCondition(PolycrystalColoringIC);
400  registerInitialCondition(PolycrystalRandomIC);
401  registerInitialCondition(PolycrystalVoronoiVoidIC);
402  registerInitialCondition(RampIC);
403  registerInitialCondition(ReconPhaseVarIC);
404  registerInitialCondition(RndBoundingBoxIC);
405  registerInitialCondition(RndSmoothCircleIC);
406  registerInitialCondition(SmoothCircleIC);
407  registerInitialCondition(SmoothCircleFromFileIC);
408  registerInitialCondition(SmoothSuperellipsoidIC);
409  registerInitialCondition(SpecifiedSmoothCircleIC);
410  registerInitialCondition(SpecifiedSmoothSuperellipsoidIC);
411  registerInitialCondition(ThumbIC);
412  registerInitialCondition(Tricrystal2CircleGrainsIC);
413  registerInitialCondition(TricrystalTripleJunctionIC);
414 
415  registerBoundaryCondition(CahnHilliardAnisoFluxBC);
416  registerBoundaryCondition(CahnHilliardFluxBC);
417 
418  registerInterfaceKernel(EqualGradientLagrangeInterface);
419  registerInterfaceKernel(EqualGradientLagrangeMultiplier);
420  registerInterfaceKernel(InterfaceDiffusionBoundaryTerm);
421  registerInterfaceKernel(InterfaceDiffusionFluxMatch);
422 
424  registerMaterial(BarrierFunctionMaterial);
425  registerMaterial(CompositeMobilityTensor);
426  registerMaterial(ComputePolycrystalElasticityTensor);
427  registerMaterial(ConstantAnisotropicMobility);
428  registerMaterial(CrossTermBarrierFunctionMaterial);
429  registerMaterial(DeformedGrainMaterial);
430  registerMaterial(DerivativeMultiPhaseMaterial);
431  registerMaterial(DerivativeParsedMaterial);
432  registerMaterial(DerivativeSumMaterial);
433  registerMaterial(DerivativeTwoPhaseMaterial);
434  registerMaterial(DiscreteNucleation);
435  registerMaterial(ElasticEnergyMaterial);
436  registerMaterial(ExternalForceDensityMaterial);
437  registerMaterial(ForceDensityMaterial);
438  registerMaterial(GBAnisotropy);
439  registerMaterial(GBEvolution);
440  registerMaterial(GBDependentAnisotropicTensor);
441  registerMaterial(GBDependentDiffusivity);
442  registerMaterial(GBWidthAnisotropy);
443  registerMaterial(GrainAdvectionVelocity);
444  registerMaterial(IdealGasFreeEnergy);
445  registerMaterial(InterfaceOrientationMaterial);
446  registerMaterial(KKSXeVacSolidMaterial);
447  registerMaterial(MathEBFreeEnergy);
448  registerMaterial(MathFreeEnergy);
449  registerMaterial(MixedSwitchingFunctionMaterial);
450  registerMaterial(MultiBarrierFunctionMaterial);
451  registerMaterial(ParsedMaterial);
452  registerMaterial(PFCRFFMaterial);
453  registerMaterial(PFCTradMaterial);
454  registerMaterial(PFFracBulkRateMaterial);
455  registerMaterial(PFParamsPolyFreeEnergy);
456  registerMaterial(PhaseNormalTensor);
457  registerMaterial(PolynomialFreeEnergy);
458  registerMaterial(RegularSolutionFreeEnergy);
459  registerMaterial(StrainGradDispDerivatives);
460  registerMaterial(SwitchingFunction3PhaseMaterial);
461  registerMaterial(SwitchingFunctionMaterial);
462  registerMaterial(SwitchingFunctionMultiPhaseMaterial);
463  registerMaterial(ThirdPhaseSuppressionMaterial);
464  registerMaterial(TimeStepMaterial);
465  registerMaterial(VanDerWaalsFreeEnergy);
466  registerMaterial(VariableGradientMaterial);
467 
468  registerPostprocessor(AverageGrainVolume);
469  registerPostprocessor(FauxGrainTracker);
470  registerPostprocessor(FeatureFloodCount);
471  registerPostprocessor(FeatureVolumeFraction);
472  registerPostprocessor(GrainBoundaryArea);
473  registerPostprocessor(GrainTracker);
474  registerPostprocessor(GrainTrackerElasticity);
475  registerPostprocessor(PFCElementEnergyIntegral);
476 
477  registerAux(BndsCalcAux);
478  registerAux(CrossTermGradientFreeEnergy);
479  registerAux(EBSDReaderAvgDataAux);
480  registerAux(EBSDReaderPointDataAux);
481  registerAux(EulerAngleProvider2RGBAux);
482  registerAux(EulerAngleVariables2RGBAux);
483  registerAux(FeatureFloodCountAux);
484  registerAux(GrainAdvectionAux);
485  registerAux(KKSGlobalFreeEnergy);
486  registerAux(KKSMultiFreeEnergy);
487  registerAux(OutputEulerAngles);
488  registerAux(PFCEnergyDensity);
489  registerAux(PFCRFFEnergyDensity);
490  registerAux(TotalFreeEnergy);
491 
492  registerUserObject(ComputeExternalGrainForceAndTorque);
493  registerUserObject(ComputeGrainForceAndTorque);
494  registerUserObject(ConservedMaskedNormalNoise);
495  registerUserObject(ConservedMaskedUniformNoise);
496  registerUserObject(ConservedNormalNoise);
497  registerUserObject(ConservedUniformNoise);
498  registerUserObject(ConstantGrainForceAndTorque);
499  registerUserObject(DiscreteNucleationInserter);
500  registerUserObject(DiscreteNucleationMap);
501  registerUserObject(EBSDReader);
502  registerUserObject(EulerAngleUpdater);
503  registerUserObject(GrainForceAndTorqueSum);
504  registerUserObject(MaskedGrainForceAndTorque);
505  registerUserObject(PolycrystalCircles);
506  registerUserObject(PolycrystalHex);
507  registerUserObject(PolycrystalVoronoi);
508  registerUserObject(PolycrystalEBSD);
509  registerUserObject(RandomEulerAngleProvider);
510  registerUserObject(SolutionRasterizer);
511 
512  registerVectorPostprocessor(EulerAngleUpdaterCheck);
513  registerVectorPostprocessor(FeatureVolumeVectorPostprocessor);
514  registerVectorPostprocessor(GrainForcesPostprocessor);
515  registerVectorPostprocessor(GrainTextureVectorPostprocessor);
516 
517  registerMesh(EBSDMesh);
518  registerMesh(MortarPeriodicMesh);
519 }
520 
521 // External entry point for dynamic syntax association
522 extern "C" void
523 PhaseFieldApp__associateSyntax(Syntax & syntax, ActionFactory & action_factory)
524 {
525  PhaseFieldApp::associateSyntax(syntax, action_factory);
526 }
527 void
528 PhaseFieldApp::associateSyntax(Syntax & syntax, ActionFactory & action_factory)
529 {
530  registerSyntax("BicrystalBoundingBoxICAction", "ICs/PolycrystalICs/BicrystalBoundingBoxIC");
531  registerSyntax("BicrystalCircleGrainICAction", "ICs/PolycrystalICs/BicrystalCircleGrainIC");
532  registerSyntax("CHPFCRFFSplitKernelAction", "Kernels/CHPFCRFFSplitKernel");
533  registerSyntax("CHPFCRFFSplitVariablesAction", "Variables/CHPFCRFFSplitVariables");
534  registerSyntax("ConservedAction", "Modules/PhaseField/Conserved/*");
535  registerSyntax("DisplacementGradientsAction", "Modules/PhaseField/DisplacementGradients");
536  registerSyntax("EmptyAction", "ICs/PolycrystalICs"); // placeholder
537  registerSyntax("EulerAngle2RGBAction", "Modules/PhaseField/EulerAngles2RGB");
538  registerSyntax("GrainGrowthAction", "Modules/PhaseField/GrainGrowth");
539  registerSyntax("HHPFCRFFSplitKernelAction", "Kernels/HHPFCRFFSplitKernel");
540  registerSyntax("HHPFCRFFSplitVariablesAction", "Variables/HHPFCRFFSplitVariables");
541  registerSyntax("MatVecRealGradAuxKernelAction", "AuxKernels/MatVecRealGradAuxKernel");
542  registerSyntax("MaterialVectorAuxKernelAction", "AuxKernels/MaterialVectorAuxKernel");
543  registerSyntax("MaterialVectorGradAuxKernelAction", "AuxKernels/MaterialVectorGradAuxKernel");
544  registerSyntax("MortarPeriodicAction", "Modules/PhaseField/MortarPeriodicity/*");
545  registerSyntax("MultiAuxVariablesAction", "AuxVariables/MultiAuxVariables");
546  registerSyntax("PFCRFFKernelAction", "Kernels/PFCRFFKernel");
547  registerSyntax("PFCRFFVariablesAction", "Variables/PFCRFFVariables");
548  registerSyntax("PolycrystalColoringICAction", "ICs/PolycrystalICs/PolycrystalColoringIC");
549  registerSyntax("PolycrystalElasticDrivingForceAction", "Kernels/PolycrystalElasticDrivingForce");
550  registerSyntax("NonconservedAction", "Modules/PhaseField/Nonconserved/*");
551  registerSyntax("PolycrystalKernelAction", "Kernels/PolycrystalKernel");
552  registerSyntax("PolycrystalRandomICAction", "ICs/PolycrystalICs/PolycrystalRandomIC");
553  registerSyntax("PolycrystalStoredEnergyAction", "Kernels/PolycrystalStoredEnergy");
554  registerSyntax("PolycrystalVariablesAction", "Variables/PolycrystalVariables");
555  registerSyntax("PolycrystalVoronoiVoidICAction", "ICs/PolycrystalICs/PolycrystalVoronoiVoidIC");
556  registerSyntax("RigidBodyMultiKernelAction", "Kernels/RigidBodyMultiKernel");
557  registerSyntax("Tricrystal2CircleGrainsICAction", "ICs/PolycrystalICs/Tricrystal2CircleGrainsIC");
558 
559  registerAction(BicrystalBoundingBoxICAction, "add_ic");
560  registerAction(BicrystalCircleGrainICAction, "add_ic");
561  registerAction(CHPFCRFFSplitKernelAction, "add_kernel");
562  registerAction(CHPFCRFFSplitVariablesAction, "add_variable");
563  registerAction(ConservedAction, "add_variable");
564  registerAction(ConservedAction, "add_kernel");
565  registerAction(DisplacementGradientsAction, "add_kernel");
566  registerAction(DisplacementGradientsAction, "add_material");
567  registerAction(DisplacementGradientsAction, "add_variable");
568  registerAction(EulerAngle2RGBAction, "add_aux_kernel");
569  registerAction(EulerAngle2RGBAction, "add_aux_variable");
570  registerAction(GrainGrowthAction, "add_aux_variable");
571  registerAction(GrainGrowthAction, "add_aux_kernel");
572  registerAction(GrainGrowthAction, "add_variable");
573  registerAction(GrainGrowthAction, "add_kernel");
574  registerAction(HHPFCRFFSplitKernelAction, "add_kernel");
575  registerAction(HHPFCRFFSplitVariablesAction, "add_variable");
576  registerAction(MaterialVectorAuxKernelAction, "add_aux_kernel");
577  registerAction(MaterialVectorGradAuxKernelAction, "add_aux_kernel");
578  registerAction(MatVecRealGradAuxKernelAction, "add_aux_kernel");
579  registerAction(MortarPeriodicAction, "add_constraint");
580  registerAction(MortarPeriodicAction, "add_mortar_interface");
581  registerAction(MortarPeriodicAction, "add_variable");
582  registerAction(MultiAuxVariablesAction, "add_aux_variable");
583  registerAction(NonconservedAction, "add_variable");
584  registerAction(NonconservedAction, "add_kernel");
585  registerAction(PFCRFFKernelAction, "add_kernel");
586  registerAction(PFCRFFVariablesAction, "add_variable");
587  registerAction(PolycrystalElasticDrivingForceAction, "add_kernel");
588  registerAction(PolycrystalColoringICAction, "add_ic");
589  registerAction(PolycrystalKernelAction, "add_kernel");
590  registerAction(PolycrystalRandomICAction, "add_ic");
591  registerAction(PolycrystalStoredEnergyAction, "add_kernel");
592  registerAction(PolycrystalVariablesAction, "add_variable");
593  registerAction(PolycrystalVoronoiVoidICAction, "add_ic");
594  registerAction(RigidBodyMultiKernelAction, "add_kernel");
595  registerAction(Tricrystal2CircleGrainsICAction, "add_ic");
596 }
This is the Cahn-Hilliard equation base class that implements the interfacial or gradient energy term...
Definition: CHInterface.h:16
The couple, SplitCHMath and SplitCHWRes, splits the CH equation by replacing chemical potential with ...
Definition: SplitCHMath.h:19
Material class to compute the elastic free energy and its derivatives.
Derivative free energy material defining polynomial free energies for single component materials...
KKSACBulkBase child class for the free energy difference term in the the Allen-Cahn bulk residual...
Definition: KKSACBulkF.h:25
This Material calculates the force density acting on a particle/grain due to interaction between part...
Material class that provides the free energy of a Van der Waals gas with the expression builder and u...
This kernel calculates the residual for grain growth for a single phase, poly-crystal system...
Definition: ACGrGrPoly.h:23
SmoothcircleIC creates a circle of a given radius centered at a given point in the domain...
SplitCHWRes creates the residual of the Cahn-Hilliard equation with a scalar (isotropic) mobility...
virtual ~PhaseFieldApp()
AllenCahn uses the Free Energy function and derivatives provided by a DerivativeParsedMaterial to com...
Definition: AllenCahn.h:23
Material class to provide the switching function for the KKS system.
This VectorPostprocessor is intended to be used to calculate accurate volumes from the FeatureFloodCo...
This UserObject maintains a per QP map that indicates if a nucleus is present or not.
AsymmetricCrossTermBarrierFunctionMaterial adds a free energy contribution on the interfaces between ...
Phase-field fracture model This class computes the contribution to residual and jacobian of the varia...
SplitCHWResAniso creates the residual for the chemical potential in the split form of the Cahn-Hillia...
Sets up a polycrystal initial condition with voids on grain boundaries for all order parameters...
SplitCHBulk child class that takes all the necessary data from a KKSBaseMaterial. ...
RndBoundingBoxIC allows setting the initial condition of a value inside and outside of a specified bo...
ReconPhaseVarIC initializes a single order parameter to represent a phase obtained form an EBSDReader...
Total free energy (both the bulk and gradient parts), where the bulk free energy has been defined in ...
ConstantAnisotropicMobility provides a simple RealTensorValue type MaterialProperty that can be used ...
void PhaseFieldApp__associateSyntax(Syntax &syntax, ActionFactory &action_factory)
This class is here to get the force and torque acting on a grain.
This kernel makes data from the EBSDReader GeneralUserObject available as AuxVariables.
Tricrystal2CircleGrainsIC creates a 3 grain structure with 2 circle grains and one matrix grain...
SoretDiffusion adds the soret effect in the split form of the Cahn-Hilliard equation.
This class is here to get the force and torque acting on a grain from different userobjects and sum t...
Compute the free energy in the multi-phase KKS Model .
void PhaseFieldApp__registerObjects(Factory &factory)
This kernel makes data from the EBSDReader GeneralUserObject available as AuxVariables.
This kernel adds to the residual a contribution of where is a material property and is a variable ...
Definition: MatReaction.h:24
Set up Mortar based periodicity in an input file with a MortarPeriodicMesh.
Function auxiliary value.
This Material calculates the force density acting on a particle/grain due to interaction between part...
TricrystalTripleJunctionIC creates a 3-grain structure with a triple junction centered at _junction a...
KKSACBulkBase child class for the phase concentration difference term in the the Allen-Cahn bulk res...
Definition: KKSACBulkC.h:25
An InitialCondition for initializing phase variable in close packed circles/spheres pattern...
Definition: ClosePackIC.h:22
This calculates a modified coupled time derivative that multiplies the time derivative of a coupled v...
GrainTextureVectorPostprocessor is a VectorPostprocessor that outputs the the coordinates, grain number, and Euler Angles associated with each element.
Kernel 1 of 2 for interfacial energy anisotropy in the Allen-Cahn equation as implemented in R...
void PhaseFieldApp__registerApps()
SmoothSuperellipsoidIC creates a Superellipsoid of given semiaxes a,b,c and exponent n centered at a ...
Material class that creates the math free energy with the expression builder and uses automatic diffe...
FunctionMaterialBase child class to evaluate a parsed function.
Compute the global free energy in the KKS Model .
PhaseFieldApp(const InputParameters &parameters)
CHSplitFlux computes flux as non-linear variable via residual = flux + mobility * gradient(chemical p...
Definition: CHSplitFlux.h:24
Userobject that generates a uniformly distributed random number in the interval [-1:1] once per times...
This kernel calculates the residual for grain growth for a multi-phase, poly-crystal system...
Definition: ACGrGrMulti.h:23
Phase field based fracture model This kernel computes the residual and jacobian for bulk free energy ...
Automatically generates all variables to model a polycrystal with op_num orderparameters.
This class is here to get the force and torque acting on a grain from different userobjects and sum t...
Add weak form surface terms of the Diffusion equation for two different variables across a subdomain ...
Compute the Allen-Cahn interface term with constant Mobility and Interfacial parameter.
Solves Cahn-Hilliard equation using chemical potential as non-linear variable.
This kernel adds the term (dFdv, test), where v is a coupled variable.
SpecifiedsmoothCircleIC creates multiple SmoothCircles (number = size of x_positions) that are positi...
SpecifiedSmoothSuperellipsoidIC creates multiple SmoothSuperellipsoids (number = size of x_positions)...
InterfaceKernel to enforce a Lagrange-Multiplier based componentwise continuity of a variable gradien...
PolycrystalVoronoiVoidIC initializes either grain or void values for a voronoi tesselation with voids...
PolycrystalColoringIC creates a polycrystal initial condition.
DerivativeFunctionMaterialBase child class to evaluate a parsed function (for example a free energy) ...
SplitCHWRes creates the residual for the chemical potential in the split form of the Cahn-Hilliard eq...
Definition: SplitCHWRes.h:17
Mesh generated from parameters with additional subdomains for mortar interfaces to enforce periodicit...
BimodalSuperellipsoidsIC takes a specified number of superellipsoids, each with given parameters Thes...
Random initial condition for a polycrystalline material.
This calculates the time derivative for a coupled variable multiplied by a scalar coefficient...
Cross term gradient free energy contribution used by ACMultiInterface.
DerivativeMaterial child class to evaluate a parsed function for the free energy and automatically pr...
Automatically generates all the L variables for the RFF phase field crystal model.
TODO: This Kernel needs Documentation!!!
Definition: HHPFCRFF.h:22
Function[kappa, gamma, m, L] = parameters (sigma, mob, w_GB, sigma0) Parameter determination method i...
Cahn-Hilliard Kernel implementing the free energy f = 1/4(1-c^2)^2, such that grad df/dc = (3 c^2 -1)...
Definition: CHMath.h:25
Phase field based fracture model, split form where beta = laplace(c) This kernel computes the residua...
This kernel adds a contribution where are the phases, are the switching functions, is the order parameter that is the nonlinear variable, is time, and are functions for each phase.
This class is here to get the force and torque acting on a grain.
This kernel calculates the main portion of the cahn-hilliard residual for the RFF form of the phase f...
Definition: CHPFCRFF.h:23
Makes initial condition which creates a linear ramp of the given variable on the x-axis with specifie...
Definition: RampIC.h:22
Automatically generates all the L variables for the RFF phase field crystal model.
Action that adds the elastic driving force for each order parameter.
This UserObject manages the insertion and expiration of nuclei in the simulation domain it manages a ...
SwitchingFunctionConstraintLagrange is a constraint kernel that acts on the lambda lagrange multiplie...
Store current time, dt, and time step number in material properties.
Compute an evolving elasticity tensor coupled to a grain growth phase field model.
CrossIC creates a C1 continuous initial condition that looks like a cross in the middle of the domain...
Definition: CrossIC.h:41
Multi phase free energy material that combines an arbitrary number of phase free energies to a global...
Material class that creates the math free energy and its derivatives for use with CHParsed and SplitC...
Compute the Allen-Cahn interface term with the weak form residual .
Definition: ACInterface.h:23
SwitchingFunctionPenalty is a constraint kernel adds a penalty to each order parameter to enforce ...
Kernel 2 of 2 for interfacial energy anisotropy in the Allen-Cahn equation as implemented in R...
Compute the Allen-Cahn interface stress driving force contribution .
static void associateSyntax(Syntax &syntax, ActionFactory &action_factory)
Calculate phase normal tensor based on gradient.
Material class to provide the double well function for the KKS system.
Automatically generates all variables to model a polycrystal with op_num orderparameters.
CrossTermBarrierFunctionMaterial adds free energy contribution on the interfaces between arbitrary pa...
Visualize the location of grain boundaries in a polycrystalline simulation.
Definition: BndsCalcAux.h:21
This object will mark nodes or elements of continuous regions all with a unique number for the purpos...
Enforce sum of phase concentrations to be the real concentration.
Flux boundary condition for variable dependent anisotropic mobilities.
Split with a variable that holds the Laplacian of the phase field.
CoupledAllenCahn uses the Free Energy function and derivatives provided by a DerivativeParsedMaterial...
This is a unit test to check the correctness of the updated euler angles An unit vector is rotated as...
Reads multiple circles from a text file with the columns labeled x y z r.
Userobject that generates a normaly distributed random number once per timestep for every quadrature ...
Manage a list of elasticity tensors for the grains.
A GeneralUserObject that reads an EBSD file and stores the centroid data in a data structure which in...
Definition: EBSDReader.h:34
SwitchingFunctionConstraintEta is a constraint kernel that acts on the lambda lagrange multiplier non...
This class is here to get the force and torque acting on a grain.
Compute the Cahn-Hilliard interface term with constant Mobility and Interfacial parameter.
Enforce gradient continuity between two different variables across a subdomain boundary.
Material class to provide switching functions that prevent formation of a third phase at a two-phase ...
static void registerObjects(Factory &factory)
GB dependent diffusivity Ref.
Calculated properties for a single component phase field model using polynomial free energies...
Random Voronoi tesselation polycrystal action.
SplitCHWRes creates the residual of the Cahn-Hilliard equation with a scalar (isotropic) mobility...
Definition: CahnHilliard.h:16
RndSmoothcircleIC creates a smooth circle with a random distribution of values inside and outside of ...
Phase field based fracture model This kernel computes the residual and jacobian for bulk free energy ...
Anisotropic diffusion kernel that takes a diffusion coefficient of type RealTensorValue.
KKSMultiACBulkBase child class for the free energy term in the the Allen-Cahn bulk residual...
Compute the Allen-Cahn interface term with constant Mobility and Interfacial parameter.
Calculates the advection velocity of grain due to rigid body motion Reports the components of the vel...
Isotropic diffusion kernel that takes a diffusion coefficient of type Real.
Definition: MatDiffusion.h:17
PFCFreezingIC creates an intial density for a PFC model that has one area of a set crystal structure ...
Definition: PFCFreezingIC.h:25
Update Euler angles of each grains after rigid body rotation This class estimates the rotation of pri...
Automatically generates all the L variables for the RFF phase field crystal model.
LatticeSmoothcircleIC creates a lattice of smoothcircles as an initial condition. ...
Free energy penalty contribution to force the nucleation of subresolution particles.
PolycrystalHex creates a hexagonal polycrystal initial condition.
static void registerApps()
Material class that creates regular solution free energy with the expression builder and uses automat...
Assign random Euler angles to each grains.
Double well phase transformation barrier free energy contribution.
Output euler angles from user object to an AuxVariable.
Bicrystal using a bounding box.
GrainForcesPostprocessor is a type of VectorPostprocessor that outputs the force and torque values ca...
OPInterfaceBarrierMaterial is a Free Energy Penalty contribution material that acts on all of the eta...
Material to compute the angular orientation of order parameter interfaces.
CHParsed uses the Free Energy function and derivatives provided by a DerivativeParsedMaterial.
Definition: SplitCHParsed.h:26
Action that sets up ACGrGrPoly, ACInterface, TimeDerivative, and ACGBPoly kernels.
Compute the gradient interface terms for a multiphase system.
Create an encoded RGB triplet from Euler angle data.
Userobject that generates a uniformly distributed random number in the interval [-1:1] once per times...
This Userobject is the base class of Userobjects that generate one random number per timestep and qua...
Userobject that generates a normaly distributed random number once per timestep for every quadrature ...
Phase field based fracture model, non-split form This kernel computes the residual and Jacobian for b...
ThumbIC creates a rectangle with a half circle on top.
Definition: ThumbIC.h:21
InputParameters validParams< PhaseFieldApp >()
CompositeMobilityTensor provides a simple RealTensorValue type MaterialProperty that can be used as a...
Simple case for SplitCHWRes kernel, only with constant Mobility.
SwitchingFunctionMultiPhaseMaterial is a switching function for a multi-phase, multi-order parameter ...
Automatically generates all variables, Kernels, and Materials to ensure the correct derivatives of th...
Function[kappa, gamma, m, L] = parameters (sigma, mob, w_GB, sigma0) Parameter determination method i...
Definition: GBAnisotropy.h:23
BimodalInverseSuperellipsoidsIC takes a specified number of superellipsoids, each with given paramete...
MultiBoundingBoxIC allows setting the initial condition of a value inside and outside of a specified ...
This class is a fake grain tracker object, it will not actually track grains nor remap them but will ...
Material class that provides the free energy of an ideal gas with the expression builder and uses aut...
Calculates the porton of the Allen-Cahn equation that results from the deformation energy...
This calculates the time derivative for a variable multiplied by a generalized susceptibility.
Solves chemical potential in a weak sense (mu-mu_prop=0) Can be coupled to Cahn-Hilliard equation to ...
Automatically generates all variables to model a polycrystal with op_num orderparameters.
Lagrange multiplier "FaceKernel" that is used in conjunction with EqualGradientLagrangeInterface.
MultismoothSuperellipsoidIC creates multiple SmoothSuperellipsoid (number = numbub) that are randomly...
This is the Cahn-Hilliard equation base class that implements the interfacial or gradient energy term...
Automatically generates all auxvariables given vectors telling it the names and how many to create...
Set a material property to the norm of the gradient of a non-linear variable.
Compute a volume integral of the specified variable.
GB dependent anisotropic tensor Ref.
PolycrystalCircles creates a polycrystal made up of circles.
Mesh generated from parameters.
Definition: EBSDMesh.h:22
Compute the average grain area in a polycrystal.
Automatically generates all variables, Kernels, and Materials to ensure the correct derivatives of th...
Bicrystal with a circular grain and an embedding outer grain.
Calculates The Deformation Energy associated with a specific dislocation density. ...
CHBulk child class that takes all the necessary data from a KKSBaseMaterial.
Definition: KKSCHBulk.h:30
Grain boundary energy parameters for isotropic uniform grain boundary energies.
Definition: GBEvolution.h:21
Material class to provide the switching function for the KKS system.
MultismoothCircleIC creates multiple SmoothCircles (number = numbub) that are randomly positioned aro...
Output euler angles from user object to an AuxVariable.
This kernel creates a body force that is modified by a mask defined as a material.
Calculate total grain boundary length in 2D and area in 3D.
This Material calculates the advection velocity, it&#39;s divergence and derivatives acting on a particle...
Enforce the equality of the chemical potentials in the two phases.
Action that sets up ACSEDGPoly Kernels that adds the stored energy contribution to grain growth model...
Enforce sum of phase concentrations to be the real concentration.
KKSACBulkBase child class for the phase concentration term in the the Allen-Cahn bulk residual...
Flux boundary condition for variable dependent mobilities.