www.mooseframework.org
Moose.C
Go to the documentation of this file.
1 /****************************************************************/
2 /* DO NOT MODIFY THIS HEADER */
3 /* MOOSE - Multiphysics Object Oriented Simulation Environment */
4 /* */
5 /* (c) 2010 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 #include "libmesh/petsc_macro.h"
16 #include "libmesh/libmesh_config.h"
17 
18 #include "Moose.h"
19 
20 #include "ActionWarehouse.h"
21 #include "ActionFactory.h"
22 #include "AuxiliarySystem.h"
23 #include "Factory.h"
24 #include "PetscSupport.h"
25 #include "Syntax.h"
26 
27 // objects that can be created by MOOSE
28 // Mesh
29 #include "FileMesh.h"
30 #include "GeneratedMesh.h"
31 #include "TiledMesh.h"
32 #include "ImageMesh.h"
33 #include "PatternedMesh.h"
34 #include "StitchedMesh.h"
35 #include "AnnularMesh.h"
36 
37 // MeshModifiers
38 #include "MeshExtruder.h"
39 #include "SideSetsFromPoints.h"
40 #include "SideSetsFromNormals.h"
41 #include "AddExtraNodeset.h"
42 #include "BoundingBoxNodeSet.h"
43 #include "Transform.h"
47 #include "SubdomainBoundingBox.h"
49 #include "RenameBlock.h"
51 #include "ImageSubdomain.h"
52 #include "BlockDeleter.h"
55 #include "ParsedAddSideset.h"
56 #include "AssignSubdomainID.h"
57 #include "MeshSideSet.h"
59 
60 // problems
61 #include "DisplacedProblem.h"
62 #include "FEProblem.h"
63 #include "EigenProblem.h"
64 
65 // kernels
66 #include "ConservativeAdvection.h"
67 #include "TimeDerivative.h"
68 #include "CoupledTimeDerivative.h"
70 #include "Diffusion.h"
71 #include "AnisotropicDiffusion.h"
72 #include "CoupledForce.h"
73 #include "BodyForce.h"
74 #include "Reaction.h"
75 #include "MassEigenKernel.h"
76 #include "NullKernel.h"
80 
81 // bcs
82 #include "ConvectiveFluxBC.h"
83 #include "DirichletBC.h"
84 #include "PenaltyDirichletBC.h"
85 #include "PresetBC.h"
86 #include "NeumannBC.h"
87 #include "PostprocessorNeumannBC.h"
88 #include "FunctionDirichletBC.h"
90 #include "FunctionPresetBC.h"
91 #include "FunctionNeumannBC.h"
92 #include "MatchedValueBC.h"
93 #include "VacuumBC.h"
94 #include "SinDirichletBC.h"
95 #include "SinNeumannBC.h"
96 #include "VectorNeumannBC.h"
97 #include "WeakGradientBC.h"
98 #include "DiffusionFluxBC.h"
101 
102 // auxkernels
103 #include "ConstantAux.h"
104 #include "FunctionAux.h"
105 #include "NearestNodeDistanceAux.h"
106 #include "NearestNodeValueAux.h"
107 #include "PenetrationAux.h"
108 #include "ProcessorIDAux.h"
109 #include "SelfAux.h"
110 #include "GapValueAux.h"
111 #include "MaterialRealAux.h"
114 #include "MaterialStdVectorAux.h"
117 #include "DebugResidualAux.h"
118 #include "BoundsAux.h"
119 #include "SpatialUserObjectAux.h"
120 #include "SolutionAux.h"
121 #include "VectorMagnitudeAux.h"
122 #include "ConstantScalarAux.h"
123 #include "QuotientAux.h"
124 #include "NormalizationAux.h"
126 #include "ParsedAux.h"
128 #include "ElementLengthAux.h"
129 #include "ElementLpNormAux.h"
132 #include "DiffusionFluxAux.h"
133 
134 // dirac kernels
135 #include "ConstantPointSource.h"
136 #include "FunctionDiracSource.h"
137 
138 // DG
139 #include "DGDiffusion.h"
141 #include "DGConvection.h"
142 
143 // ics
144 #include "ConstantIC.h"
145 #include "BoundingBoxIC.h"
146 #include "FunctionIC.h"
147 #include "RandomIC.h"
148 #include "ScalarConstantIC.h"
149 #include "ScalarComponentIC.h"
150 #include "FunctionScalarIC.h"
151 
152 // executioners
153 #include "Steady.h"
154 #include "Transient.h"
155 #include "InversePowerMethod.h"
156 #include "NonlinearEigen.h"
157 #include "Eigenvalue.h"
158 
159 // functions
161 #include "ConstantFunction.h"
162 #include "CompositeFunction.h"
163 #include "MooseParsedFunction.h"
165 #include "MooseParsedGradFunction.h"
166 #include "PiecewiseConstant.h"
167 #include "PiecewiseLinear.h"
168 #include "SolutionFunction.h"
169 #include "PiecewiseBilinear.h"
170 #include "SplineFunction.h"
171 #include "BicubicSplineFunction.h"
172 #include "PiecewiseMultilinear.h"
174 #include "ImageFunction.h"
176 
177 // materials
178 #include "GenericConstantMaterial.h"
180 #include "GenericFunctionMaterial.h"
182 
183 // PPS
184 #include "AverageElementSize.h"
188 #include "NodalSum.h"
189 #include "ElementAverageValue.h"
191 #include "ElementW1pError.h"
192 #include "ElementH1Error.h"
193 #include "ElementH1SemiError.h"
196 #include "ElementL2Error.h"
197 #include "ElementVectorL2Error.h"
198 #include "EmptyPostprocessor.h"
199 #include "FindValueOnLine.h"
201 #include "NodalVariableValue.h"
202 #include "NumDOFs.h"
203 #include "TimestepSize.h"
204 #include "PerformanceData.h"
205 #include "MemoryUsage.h"
206 #include "NumElems.h"
207 #include "NumNodes.h"
208 #include "NumNonlinearIterations.h"
209 #include "NumLinearIterations.h"
210 #include "Residual.h"
211 #include "ScalarVariable.h"
212 #include "NumVars.h"
213 #include "NumResidualEvaluations.h"
214 #include "Receiver.h"
215 #include "SideAverageValue.h"
216 #include "SideFluxIntegral.h"
217 #include "SideFluxAverage.h"
219 #include "NodalMaxValue.h"
220 #include "NodalProxyMaxValue.h"
221 #include "ScalarL2Error.h"
222 #include "ElementalVariableValue.h"
223 #include "ElementL2Norm.h"
224 #include "NodalL2Norm.h"
225 #include "NodalL2Error.h"
226 #include "TotalVariableValue.h"
227 #include "VolumePostprocessor.h"
228 #include "AreaPostprocessor.h"
229 #include "PointValue.h"
230 #include "NodalExtremeValue.h"
231 #include "ElementExtremeValue.h"
232 #include "DifferencePostprocessor.h"
234 #include "ScalePostprocessor.h"
236 #include "NumPicardIterations.h"
237 #include "FunctionSideIntegral.h"
240 #include "ElementL2Difference.h"
241 #include "TimeExtremeValue.h"
244 #include "VariableInnerProduct.h"
245 #include "VariableResidual.h"
246 
247 // vector PPS
248 #include "CSVReader.h"
250 #include "Eigenvalues.h"
252 #include "ElementsAlongLine.h"
253 #include "ElementsAlongPlane.h"
255 #include "LeastSquaresFit.h"
256 #include "LineFunctionSampler.h"
257 #include "LineMaterialRealSampler.h"
258 #include "LineValueSampler.h"
260 #include "NodalValueSampler.h"
261 #include "PointValueSampler.h"
262 #include "SideValueSampler.h"
263 #include "SphericalAverage.h"
264 #include "VectorOfPostprocessors.h"
265 #include "VolumeHistogram.h"
266 
267 // user objects
268 #include "GeometrySphere.h"
269 #include "LayeredIntegral.h"
270 #include "LayeredAverage.h"
271 #include "LayeredSideIntegral.h"
272 #include "LayeredSideAverage.h"
273 #include "LayeredSideFluxAverage.h"
276 #include "NodalNormalsEvaluator.h"
277 #include "NodalNormalsCorner.h"
279 #include "SolutionUserObject.h"
280 #include "PerflogDumper.h"
281 #ifdef LIBMESH_HAVE_FPARSER
282 #include "Terminator.h"
283 #endif
284 
285 // preconditioners
289 
291 #include "Split.h"
292 #include "AddFieldSplitAction.h"
293 
294 // dampers
295 #include "ConstantDamper.h"
296 #include "MaxIncrement.h"
299 
300 // Constraints
301 #include "TiedValueConstraint.h"
303 #include "AddBoundsVectorsAction.h"
304 #include "EqualGradientConstraint.h"
305 #include "EqualValueConstraint.h"
307 #include "LinearNodalConstraint.h"
308 
309 // ScalarKernels
310 #include "ODETimeDerivative.h"
312 #include "FunctionScalarAux.h"
314 #include "ParsedODEKernel.h"
315 #include "QuotientScalarAux.h"
316 
317 // indicators
318 #include "AnalyticalIndicator.h"
319 #include "LaplacianJumpIndicator.h"
320 #include "GradientJumpIndicator.h"
321 
322 // markers
323 #include "ErrorToleranceMarker.h"
324 #include "ErrorFractionMarker.h"
325 #include "UniformMarker.h"
326 #include "BoxMarker.h"
327 #include "ComboMarker.h"
328 #include "ValueThresholdMarker.h"
329 #include "ValueRangeMarker.h"
330 #include "OrientedBoxMarker.h"
331 
332 // time steppers
333 #include "ConstantDT.h"
334 #include "LogConstantDT.h"
335 #include "FunctionDT.h"
336 #include "TimeSequenceStepper.h"
338 #include "CSVTimeSequenceStepper.h"
339 #include "IterationAdaptiveDT.h"
340 #include "SolutionTimeAdaptiveDT.h"
341 #include "DT2.h"
342 #include "PostprocessorDT.h"
343 #include "AB2PredictorCorrector.h"
344 
345 // time integrators
346 #include "ImplicitEuler.h"
347 #include "BDF2.h"
348 #include "CrankNicolson.h"
349 #include "ExplicitEuler.h"
350 #include "ExplicitMidpoint.h"
351 #include "ExplicitTVDRK2.h"
352 #include "LStableDirk2.h"
353 #include "LStableDirk3.h"
354 #include "AStableDirk4.h"
355 #include "LStableDirk4.h"
356 #include "ImplicitMidpoint.h"
357 #include "Heun.h"
358 #include "Ralston.h"
359 #include "SimplePredictor.h"
360 #include "AdamsPredictor.h"
361 
362 // MultiApps
363 #include "TransientMultiApp.h"
364 #include "FullSolveMultiApp.h"
365 #include "AutoPositionsMultiApp.h"
366 
367 // Transfers
368 #ifdef LIBMESH_TRILINOS_HAVE_DTK
371 #endif
378 #include "MultiAppCopyTransfer.h"
384 
385 // Actions
386 #include "AddBCAction.h"
387 #include "AddDiracKernelAction.h"
388 #include "AddICAction.h"
390 #include "AddKernelAction.h"
391 #include "AddScalarKernelAction.h"
392 #include "AddDGKernelAction.h"
394 #include "AddPeriodicBCAction.h"
395 #include "AddVariableAction.h"
396 #include "AddAuxVariableAction.h"
397 #include "AddPostprocessorAction.h"
399 #include "AddDamperAction.h"
400 #include "AddFunctionAction.h"
401 #include "AddDistributionAction.h"
402 #include "AddSamplerAction.h"
403 #include "CreateExecutionerAction.h"
404 #include "DetermineSystemType.h"
405 #include "EmptyAction.h"
406 #include "InitProblemAction.h"
407 #include "CopyNodalVarsAction.h"
408 #include "SetupMeshAction.h"
409 #include "AddMeshModifierAction.h"
410 #include "SetupMeshCompleteAction.h"
411 #include "AddOutputAction.h"
412 #include "CommonOutputAction.h"
413 #include "AddMaterialAction.h"
414 #include "GlobalParamsAction.h"
415 #include "AdaptivityAction.h"
416 #include "PartitionerAction.h"
417 #include "SetupDampersAction.h"
418 #include "CheckIntegrityAction.h"
419 #include "SetupQuadratureAction.h"
421 #include "SetupDebugAction.h"
423 #include "DeprecatedBlockAction.h"
424 #include "AddConstraintAction.h"
426 #include "CreateProblemAction.h"
428 #include "AddUserObjectAction.h"
429 #include "AddControlAction.h"
430 #include "AddElementalFieldAction.h"
431 #include "AddIndicatorAction.h"
432 #include "AddMarkerAction.h"
434 #include "AddMultiAppAction.h"
435 #include "AddTransferAction.h"
436 #include "AddNodalNormalsAction.h"
437 #include "SetupTimeStepperAction.h"
439 #include "SetupPredictorAction.h"
442 #include "MaterialOutputAction.h"
443 #include "CheckOutputAction.h"
445 #include "AddNodalKernelAction.h"
447 
448 // Outputs
449 #ifdef LIBMESH_HAVE_EXODUS_API
450 #include "Exodus.h"
451 #endif
452 #include "Nemesis.h"
453 #include "Console.h"
454 #include "CSV.h"
455 #include "VTKOutput.h"
456 #include "Checkpoint.h"
457 #include "XDA.h"
458 #include "GMVOutput.h"
459 #include "Tecplot.h"
460 #include "Gnuplot.h"
461 #include "SolutionHistory.h"
464 #include "TopResidualDebugOutput.h"
465 #include "DOFMapOutput.h"
466 #include "ControlOutput.h"
467 
468 // Controls
469 #include "RealFunctionControl.h"
470 #include "TimePeriod.h"
471 
472 // Partitioner
473 #include "LibmeshPartitioner.h"
474 
475 // NodalKernels
476 #include "ConstantRate.h"
479 
480 #include <unistd.h>
481 
482 namespace Moose
483 {
484 
485 static bool registered = false;
486 
487 void
489 {
490  // mesh
491  registerMesh(FileMesh);
492  registerMesh(GeneratedMesh);
493  registerMesh(TiledMesh);
494  registerMesh(ImageMesh);
495  registerMesh(PatternedMesh);
496  registerMesh(StitchedMesh);
497  registerMesh(AnnularMesh);
498 
499  // mesh modifiers
500  registerMeshModifier(MeshExtruder);
501  registerMeshModifier(SideSetsFromPoints);
502  registerMeshModifier(SideSetsFromNormals);
503  registerMeshModifier(AddExtraNodeset);
504  registerMeshModifier(BoundingBoxNodeSet);
505  registerMeshModifier(Transform);
506  registerMeshModifier(SideSetsAroundSubdomain);
507  registerMeshModifier(SideSetsBetweenSubdomains);
508  registerMeshModifier(AddAllSideSetsByNormals);
509  registerMeshModifier(SubdomainBoundingBox);
510  registerMeshModifier(OrientedSubdomainBoundingBox);
511  registerMeshModifier(RenameBlock);
512  registerMeshModifier(AssignElementSubdomainID);
513  registerMeshModifier(ImageSubdomain);
514  registerMeshModifier(BlockDeleter);
515  registerMeshModifier(ParsedSubdomainMeshModifier);
516  registerMeshModifier(BreakBoundaryOnSubdomain);
517  registerMeshModifier(ParsedAddSideset);
518  registerMeshModifier(AssignSubdomainID);
519  registerMeshModifier(MeshSideSet);
520  registerMeshModifier(AddSideSetsFromBoundingBox);
521 
522  // problems
523  registerProblem(DisplacedProblem);
524  registerProblem(FEProblem);
525  registerProblem(EigenProblem);
526 
527  // kernels
528  registerKernel(TimeDerivative);
529  registerKernel(ConservativeAdvection);
530  registerKernel(CoupledTimeDerivative);
531  registerKernel(MassLumpedTimeDerivative);
532  registerKernel(Diffusion);
533  registerKernel(AnisotropicDiffusion);
534  registerKernel(CoupledForce);
535  registerNamedObject(BodyForce, "UserForcingFunction");
536  factory.deprecateObject("UserForcingFunction", "BodyForce");
537  registerKernel(BodyForce);
538  registerKernel(Reaction);
539  registerKernel(MassEigenKernel);
540  registerKernel(NullKernel);
541  registerKernel(MaterialDerivativeTestKernel);
542  registerKernel(MaterialDerivativeRankTwoTestKernel);
543  registerKernel(MaterialDerivativeRankFourTestKernel);
544 
545  // bcs
546  registerBoundaryCondition(ConvectiveFluxBC);
547  registerBoundaryCondition(DirichletBC);
548  registerBoundaryCondition(PenaltyDirichletBC);
549  registerBoundaryCondition(PresetBC);
550  registerBoundaryCondition(NeumannBC);
551  registerBoundaryCondition(PostprocessorNeumannBC);
552  registerBoundaryCondition(FunctionDirichletBC);
553  registerBoundaryCondition(FunctionPenaltyDirichletBC);
554  registerBoundaryCondition(FunctionPresetBC);
555  registerBoundaryCondition(FunctionNeumannBC);
556  registerBoundaryCondition(MatchedValueBC);
557  registerBoundaryCondition(VacuumBC);
558 
559  registerBoundaryCondition(SinDirichletBC);
560  registerBoundaryCondition(SinNeumannBC);
561  registerBoundaryCondition(VectorNeumannBC);
562  registerBoundaryCondition(WeakGradientBC);
563  registerBoundaryCondition(DiffusionFluxBC);
564  registerBoundaryCondition(PostprocessorDirichletBC);
565  registerBoundaryCondition(OneDEqualValueConstraintBC);
566 
567  // dirac kernels
568  registerDiracKernel(ConstantPointSource);
569  registerDiracKernel(FunctionDiracSource);
570 
571  // aux kernels
572  registerAux(ConstantAux);
573  registerAux(FunctionAux);
574  registerAux(NearestNodeDistanceAux);
575  registerAux(NearestNodeValueAux);
576  registerAux(PenetrationAux);
577  registerAux(ProcessorIDAux);
578  registerAux(SelfAux);
579  registerAux(GapValueAux);
580  registerAux(MaterialRealAux);
581  registerAux(MaterialRealVectorValueAux);
582  registerAux(MaterialRealTensorValueAux);
583  registerAux(MaterialStdVectorAux);
584  registerAux(MaterialRealDenseMatrixAux);
586  registerAux(DebugResidualAux);
587  registerAux(BoundsAux);
588  registerAux(SpatialUserObjectAux);
589  registerAux(SolutionAux);
590  registerAux(VectorMagnitudeAux);
591  registerAux(ConstantScalarAux);
592  registerAux(QuotientAux);
593  registerAux(NormalizationAux);
594  registerAux(FunctionScalarAux);
595  registerAux(VariableGradientComponent);
596  registerAux(ParsedAux);
597  registerAux(VariableTimeIntegrationAux);
598  registerAux(ElementLengthAux);
599  registerAux(ElementLpNormAux);
600  registerAux(ElementL2ErrorFunctionAux);
601  registerAux(ElementH1ErrorFunctionAux);
602  registerAux(DiffusionFluxAux);
603 
604  // Initial Conditions
605  registerInitialCondition(ConstantIC);
606  registerInitialCondition(BoundingBoxIC);
607  registerInitialCondition(FunctionIC);
608  registerInitialCondition(RandomIC);
609  registerInitialCondition(ScalarConstantIC);
610  registerInitialCondition(ScalarComponentIC);
611  registerInitialCondition(FunctionScalarIC);
612 
613  // executioners
614  registerExecutioner(Steady);
615  registerExecutioner(Transient);
616  registerExecutioner(InversePowerMethod);
617  registerExecutioner(NonlinearEigen);
618  registerExecutioner(Eigenvalue);
619 
620  // functions
621  registerFunction(Axisymmetric2D3DSolutionFunction);
622  registerFunction(ConstantFunction);
623  registerFunction(CompositeFunction);
624  registerNamedFunction(MooseParsedFunction, "ParsedFunction");
625  registerNamedFunction(MooseParsedGradFunction, "ParsedGradFunction");
626  registerNamedFunction(MooseParsedVectorFunction, "ParsedVectorFunction");
627  registerFunction(PiecewiseConstant);
628  registerFunction(PiecewiseLinear);
629  registerFunction(SolutionFunction);
630  registerFunction(PiecewiseBilinear);
631  registerFunction(SplineFunction);
632  registerFunction(BicubicSplineFunction);
633  registerFunction(PiecewiseMultilinear);
634  registerFunction(LinearCombinationFunction);
635  registerFunction(ImageFunction);
636  registerFunction(VectorPostprocessorFunction);
637 
638  // materials
639  registerMaterial(GenericConstantMaterial);
640  registerMaterial(GenericConstantRankTwoTensor);
641  registerMaterial(GenericFunctionMaterial);
642  registerMaterial(PiecewiseLinearInterpolationMaterial);
643 
644  // PPS
645  registerPostprocessor(AverageElementSize);
646  registerPostprocessor(AverageNodalVariableValue);
647  registerPostprocessor(CumulativeValuePostprocessor);
648  registerPostprocessor(ChangeOverTimestepPostprocessor);
649  registerPostprocessor(NodalSum);
650  registerPostprocessor(ElementAverageValue);
651  registerPostprocessor(ElementAverageTimeDerivative);
652  registerPostprocessor(ElementW1pError);
653  registerPostprocessor(ElementH1Error);
654  registerPostprocessor(ElementH1SemiError);
655  registerPostprocessor(ElementIntegralVariablePostprocessor);
656  registerPostprocessor(ElementIntegralMaterialProperty);
657  registerPostprocessor(ElementL2Error);
658  registerPostprocessor(ElementVectorL2Error);
659  registerPostprocessor(ScalarL2Error);
660  registerPostprocessor(EmptyPostprocessor);
661  registerPostprocessor(FindValueOnLine);
662  registerPostprocessor(NodalVariableValue);
663  registerPostprocessor(NumDOFs);
664  registerPostprocessor(TimestepSize);
665  registerPostprocessor(PerformanceData);
666  registerPostprocessor(MemoryUsage);
667  registerPostprocessor(NumElems);
668  registerPostprocessor(NumNodes);
669  registerPostprocessor(NumNonlinearIterations);
670  registerPostprocessor(NumLinearIterations);
671  registerPostprocessor(Residual);
672  registerPostprocessor(ScalarVariable);
673  registerPostprocessor(NumVars);
674  registerPostprocessor(NumResidualEvaluations);
675  registerPostprocessor(Receiver);
676  registerPostprocessor(SideAverageValue);
677  registerPostprocessor(SideFluxIntegral);
678  registerPostprocessor(SideFluxAverage);
679  registerPostprocessor(SideIntegralVariablePostprocessor);
680  registerPostprocessor(NodalMaxValue);
681  registerPostprocessor(NodalProxyMaxValue);
682  registerPostprocessor(ElementalVariableValue);
683  registerPostprocessor(ElementL2Norm);
684  registerPostprocessor(NodalL2Norm);
685  registerPostprocessor(NodalL2Error);
686  registerPostprocessor(TotalVariableValue);
687  registerPostprocessor(VolumePostprocessor);
688  registerPostprocessor(AreaPostprocessor);
689  registerPostprocessor(PointValue);
690  registerPostprocessor(NodalExtremeValue);
691  registerPostprocessor(ElementExtremeValue);
692  registerPostprocessor(DifferencePostprocessor);
693  registerPostprocessor(RelativeDifferencePostprocessor);
694  registerPostprocessor(ScalePostprocessor);
695  registerPostprocessor(LinearCombinationPostprocessor);
696  registerPostprocessor(FunctionValuePostprocessor);
697  registerPostprocessor(NumPicardIterations);
698  registerPostprocessor(FunctionSideIntegral);
699  registerPostprocessor(ExecutionerAttributeReporter);
700  registerPostprocessor(PercentChangePostprocessor);
701  registerPostprocessor(ElementL2Difference);
702  registerPostprocessor(TimeExtremeValue);
703  registerPostprocessor(RelativeSolutionDifferenceNorm);
704  registerPostprocessor(AxisymmetricCenterlineAverageValue);
705  registerPostprocessor(VariableInnerProduct);
706  registerPostprocessor(VariableResidual);
707 
708  // vector PPS
709  registerVectorPostprocessor(CSVReader);
710  registerVectorPostprocessor(ConstantVectorPostprocessor);
711  registerVectorPostprocessor(Eigenvalues);
712  registerVectorPostprocessor(ElementVariablesDifferenceMax);
713  registerVectorPostprocessor(ElementsAlongLine);
714  registerVectorPostprocessor(ElementsAlongPlane);
715  registerVectorPostprocessor(IntersectionPointsAlongLine);
716  registerVectorPostprocessor(LeastSquaresFit);
717  registerVectorPostprocessor(LineFunctionSampler);
718  registerVectorPostprocessor(LineMaterialRealSampler);
719  registerVectorPostprocessor(LineValueSampler);
720  registerVectorPostprocessor(MaterialVectorPostprocessor);
721  registerVectorPostprocessor(NodalValueSampler);
722  registerVectorPostprocessor(PointValueSampler);
723  registerVectorPostprocessor(SideValueSampler);
724  registerVectorPostprocessor(SphericalAverage);
725  registerVectorPostprocessor(VectorOfPostprocessors);
726  registerVectorPostprocessor(VolumeHistogram);
727 
728  // user objects
729  registerUserObject(GeometrySphere);
730  registerUserObject(LayeredIntegral);
731  registerUserObject(LayeredAverage);
732  registerUserObject(LayeredSideIntegral);
733  registerUserObject(LayeredSideAverage);
734  registerUserObject(LayeredSideFluxAverage);
735  registerUserObject(NearestPointLayeredAverage);
736  registerUserObject(ElementIntegralVariableUserObject);
737  registerUserObject(NodalNormalsPreprocessor);
738  registerUserObject(NodalNormalsCorner);
739  registerUserObject(NodalNormalsEvaluator);
740  registerUserObject(SolutionUserObject);
741  registerUserObject(PerflogDumper);
742 #ifdef LIBMESH_HAVE_FPARSER
743  registerUserObject(Terminator);
744 #endif
745 
746  // preconditioners
747  registerNamedPreconditioner(PhysicsBasedPreconditioner, "PBP");
748  registerNamedPreconditioner(FiniteDifferencePreconditioner, "FDP");
749  registerNamedPreconditioner(SingleMatrixPreconditioner, "SMP");
750 #if defined(LIBMESH_HAVE_PETSC) && !PETSC_VERSION_LESS_THAN(3, 3, 0)
751  registerNamedPreconditioner(FieldSplitPreconditioner, "FSP");
752 #endif
753  // dampers
754  registerDamper(ConstantDamper);
755  registerDamper(MaxIncrement);
756  registerDamper(BoundingValueNodalDamper);
757  registerDamper(BoundingValueElementDamper);
758  // DG
759  registerDGKernel(DGDiffusion);
760  registerBoundaryCondition(DGFunctionDiffusionDirichletBC);
761  registerDGKernel(DGConvection);
762 
763  // Constraints
764  registerConstraint(TiedValueConstraint);
765  registerConstraint(CoupledTiedValueConstraint);
766  registerConstraint(EqualGradientConstraint);
767  registerConstraint(EqualValueConstraint);
768  registerConstraint(EqualValueBoundaryConstraint);
769  registerConstraint(LinearNodalConstraint);
770 
771  // Scalar kernels
772  registerScalarKernel(ODETimeDerivative);
773  registerScalarKernel(CoupledODETimeDerivative);
774  registerScalarKernel(NodalEqualValueConstraint);
775  registerScalarKernel(ParsedODEKernel);
776  registerScalarKernel(QuotientScalarAux);
777 
778  // indicators
779  registerIndicator(AnalyticalIndicator);
780  registerIndicator(LaplacianJumpIndicator);
781  registerIndicator(GradientJumpIndicator);
782 
783  // markers
784  registerMarker(ErrorToleranceMarker);
785  registerMarker(ErrorFractionMarker);
786  registerMarker(UniformMarker);
787  registerMarker(BoxMarker);
788  registerMarker(OrientedBoxMarker);
789  registerMarker(ComboMarker);
790  registerMarker(ValueThresholdMarker);
791  registerMarker(ValueRangeMarker);
792 
793  // splits
794  registerSplit(Split);
795 
796  // MultiApps
797  registerMultiApp(TransientMultiApp);
798  registerMultiApp(FullSolveMultiApp);
799  registerMultiApp(AutoPositionsMultiApp);
800 
801  // time steppers
802  registerTimeStepper(ConstantDT);
803  registerTimeStepper(LogConstantDT);
804  registerTimeStepper(FunctionDT);
805  registerTimeStepper(TimeSequenceStepper);
806  registerTimeStepper(ExodusTimeSequenceStepper);
807  registerTimeStepper(CSVTimeSequenceStepper);
808  registerTimeStepper(IterationAdaptiveDT);
809  registerTimeStepper(SolutionTimeAdaptiveDT);
810  registerTimeStepper(DT2);
811  registerTimeStepper(PostprocessorDT);
812  registerTimeStepper(AB2PredictorCorrector);
813  // time integrators
814  registerTimeIntegrator(ImplicitEuler);
815  registerTimeIntegrator(BDF2);
816  registerTimeIntegrator(CrankNicolson);
817  registerTimeIntegrator(ExplicitEuler);
818  registerTimeIntegrator(ExplicitMidpoint);
819  registerTimeIntegrator(ExplicitTVDRK2);
820  registerTimeIntegrator(LStableDirk2);
821  registerTimeIntegrator(LStableDirk3);
822  registerTimeIntegrator(AStableDirk4);
823  registerTimeIntegrator(LStableDirk4);
824  registerTimeIntegrator(ImplicitMidpoint);
825  registerTimeIntegrator(Heun);
826  registerTimeIntegrator(Ralston);
827  // predictors
828  registerPredictor(SimplePredictor);
829  registerPredictor(AdamsPredictor);
830 
831 // Transfers
832 #ifdef LIBMESH_TRILINOS_HAVE_DTK
833  registerTransfer(MultiAppDTKUserObjectTransfer);
834  registerTransfer(MultiAppDTKInterpolationTransfer);
835 #endif
837  registerTransfer(MultiAppVariableValueSampleTransfer);
839  registerTransfer(MultiAppMeshFunctionTransfer);
840  registerTransfer(MultiAppUserObjectTransfer);
841  registerTransfer(MultiAppNearestNodeTransfer);
842  registerTransfer(MultiAppCopyTransfer);
843  registerTransfer(MultiAppInterpolationTransfer);
844  registerTransfer(MultiAppPostprocessorTransfer);
845  registerTransfer(MultiAppProjectionTransfer);
847  registerTransfer(MultiAppScalarToAuxScalarTransfer);
848 
849 // Outputs
850 #ifdef LIBMESH_HAVE_EXODUS_API
851  registerOutput(Exodus);
852 #endif
853 #ifdef LIBMESH_HAVE_NEMESIS_API
854  registerOutput(Nemesis);
855 #endif
856  registerOutput(Console);
857  registerOutput(CSV);
858 #ifdef LIBMESH_HAVE_VTK
859  registerNamedOutput(VTKOutput, "VTK");
860 #endif
861  registerOutput(Checkpoint);
862  registerNamedOutput(XDA, "XDR");
863  registerOutput(XDA);
864  registerNamedOutput(GMVOutput, "GMV");
865  registerOutput(Tecplot);
866  registerOutput(Gnuplot);
867  registerOutput(SolutionHistory);
868  registerOutput(MaterialPropertyDebugOutput);
869  registerOutput(VariableResidualNormsDebugOutput);
870  registerOutput(TopResidualDebugOutput);
871  registerNamedOutput(DOFMapOutput, "DOFMap");
872  registerOutput(ControlOutput);
873 
874  // Controls
875  registerControl(RealFunctionControl);
876  registerControl(TimePeriod);
877 
878  // Partitioner
879  registerPartitioner(LibmeshPartitioner);
880 
881  // NodalKernels
882  registerNodalKernel(TimeDerivativeNodalKernel);
883  registerNodalKernel(ConstantRate);
884  registerNodalKernel(UserForcingFunctionNodalKernel);
885 
886  registered = true;
887 }
888 
889 void
891 {
905  // clang-format off
906  /**************************/
907  /**** Register Actions ****/
908  /**************************/
909  registerMooseObjectTask("create_problem", Problem, false);
910  registerMooseObjectTask("setup_executioner", Executioner, true);
911 
912  // This task does not construct an object, but it needs all of the parameters that
913  // would normally be used to construct an object.
914  registerMooseObjectTask("determine_system_type", Executioner, true);
915 
916  registerMooseObjectTask("setup_mesh", MooseMesh, false);
917  registerMooseObjectTask("init_mesh", MooseMesh, false);
918  registerMooseObjectTask("add_mesh_modifier", MeshModifier, false);
919 
920  registerMooseObjectTask("add_kernel", Kernel, false);
921  appendMooseObjectTask ("add_kernel", EigenKernel);
922 
923  registerMooseObjectTask("add_nodal_kernel", NodalKernel, false);
924 
925  registerMooseObjectTask("add_material", Material, false);
926  registerMooseObjectTask("add_bc", BoundaryCondition, false);
927  registerMooseObjectTask("add_function", Function, false);
928  registerMooseObjectTask("add_distribution", Distribution, false);
929  registerMooseObjectTask("add_sampler", Sampler, false);
930 
931  registerMooseObjectTask("add_aux_kernel", AuxKernel, false);
932  registerMooseObjectTask("add_elemental_field_variable", AuxKernel, false);
933 
934  registerMooseObjectTask("add_scalar_kernel", ScalarKernel, false);
935  registerMooseObjectTask("add_aux_scalar_kernel", AuxScalarKernel, false);
936  registerMooseObjectTask("add_dirac_kernel", DiracKernel, false);
937  registerMooseObjectTask("add_dg_kernel", DGKernel, false);
938  registerMooseObjectTask("add_interface_kernel", InterfaceKernel, false);
939  registerMooseObjectTask("add_constraint", Constraint, false);
940 
941  registerMooseObjectTask("add_ic", InitialCondition, false);
942  appendMooseObjectTask ("add_ic", ScalarInitialCondition);
943 
944  registerMooseObjectTask("add_damper", Damper, false);
945  registerMooseObjectTask("setup_predictor", Predictor, false);
946  registerMooseObjectTask("setup_time_stepper", TimeStepper, false);
947  registerMooseObjectTask("setup_time_integrator", TimeIntegrator, false);
948 
949  registerMooseObjectTask("add_preconditioning", MoosePreconditioner, false);
950  registerMooseObjectTask("add_field_split", Split, false);
951 
952  registerMooseObjectTask("add_user_object", UserObject, false);
953  appendMooseObjectTask ("add_user_object", Postprocessor);
954 
955  registerMooseObjectTask("add_postprocessor", Postprocessor, false);
956  registerMooseObjectTask("add_vector_postprocessor", VectorPostprocessor, false);
957 
958  registerMooseObjectTask("add_indicator", Indicator, false);
959  registerMooseObjectTask("add_marker", Marker, false);
960 
961  registerMooseObjectTask("add_multi_app", MultiApp, false);
962  registerMooseObjectTask("add_transfer", Transfer, false);
963 
964  registerMooseObjectTask("add_output", Output, false);
965 
966  registerMooseObjectTask("add_control", Control, false);
967  registerMooseObjectTask("add_partitioner", MoosePartitioner, false);
968 
969  // clang-format on
970 
971  registerTask("dynamic_object_registration", false);
972  registerTask("common_output", true);
973  registerTask("setup_recover_file_base", true);
974 
975  registerTask("add_bounds_vectors", false);
976  registerTask("add_periodic_bc", false);
977  registerTask("add_aux_variable", false);
978  registerTask("add_variable", false);
979 
980  registerTask("execute_mesh_modifiers", false);
981  registerTask("uniform_refine_mesh", false);
982  registerTask("prepare_mesh", false);
983  registerTask("setup_mesh_complete", false); // calls prepare
984 
985  registerTask("init_displaced_problem", false);
986 
987  registerTask("init_problem", true);
988  registerTask("check_copy_nodal_vars", true);
989  registerTask("copy_nodal_vars", true);
990  registerTask("copy_nodal_aux_vars", true);
991  registerTask("setup_postprocessor_data", false);
992 
993  registerTask("setup_dampers", true);
994  registerTask("check_integrity", true);
995  registerTask("setup_quadrature", true);
996 
998  registerTask("no_action", false); // Used for Empty Action placeholders
999  registerTask("set_global_params", false);
1000  registerTask("setup_adaptivity", false);
1001  registerTask("meta_action", false);
1002  registerTask("setup_debug", false);
1003  registerTask("setup_residual_debug", false);
1004  registerTask("setup_oversampling", false);
1005  registerTask("deprecated_block", false);
1006  registerTask("set_adaptivity_options", false);
1007  registerTask("add_mortar_interface", false);
1008 
1009  // Dummy Actions (useful for sync points in the dependencies)
1010  registerTask("setup_function_complete", false);
1011  registerTask("setup_variable_complete", false);
1012  registerTask("ready_to_init", true);
1013 
1014  // Output related actions
1015  registerTask("setup_material_output", true);
1016  registerTask("check_output", true);
1017 
1018  /**************************/
1019  /****** Dependencies ******/
1020  /**************************/
1031  syntax.addDependencySets("(meta_action)"
1032  "(dynamic_object_registration)"
1033  "(common_output)"
1034  "(set_global_params)"
1035  "(setup_recover_file_base)"
1036  "(check_copy_nodal_vars)"
1037  "(setup_mesh)"
1038  "(add_partitioner)"
1039  "(init_mesh)"
1040  "(prepare_mesh)"
1041  "(add_mesh_modifier)"
1042  "(execute_mesh_modifiers)"
1043  "(add_mortar_interface)"
1044  "(uniform_refine_mesh)"
1045  "(setup_mesh_complete)"
1046  "(determine_system_type)"
1047  "(create_problem)"
1048  "(setup_time_integrator)"
1049  "(setup_executioner)"
1050  "(setup_time_stepper)"
1051  "(setup_predictor)"
1052  "(setup_postprocessor_data)"
1053  "(init_displaced_problem)"
1054  "(add_aux_variable, add_variable, add_elemental_field_variable)"
1055  "(setup_variable_complete)"
1056  "(setup_quadrature)"
1057  "(add_function)"
1058  "(add_distribution)"
1059  "(add_sampler)"
1060  "(add_periodic_bc)"
1061  "(add_user_object)"
1062  "(setup_function_complete)"
1063  "(setup_adaptivity)"
1064  "(set_adaptivity_options)"
1065  "(add_ic)"
1066  "(add_constraint, add_field_split)"
1067  "(add_preconditioning)"
1068  "(ready_to_init)"
1069  "(setup_dampers)"
1070  "(setup_residual_debug)"
1071  "(add_bounds_vectors)"
1072  "(add_multi_app)"
1073  "(add_transfer)"
1074  "(copy_nodal_vars, copy_nodal_aux_vars)"
1075  "(add_material)"
1076  "(setup_material_output)"
1077  "(init_problem)"
1078  "(setup_debug)"
1079  "(add_output)"
1080  "(add_postprocessor)"
1081  "(add_vector_postprocessor)" // MaterialVectorPostprocessor requires this
1082  // to be after material objects are created.
1083  "(add_aux_kernel, add_bc, add_damper, add_dirac_kernel, add_kernel, "
1084  "add_nodal_kernel, add_dg_kernel, add_interface_kernel, "
1085  "add_scalar_kernel, add_aux_scalar_kernel, add_indicator, add_marker)"
1086  "(add_control)"
1087  "(check_output)"
1088  "(check_integrity)");
1089 }
1090 
1121 void
1122 registerActions(Syntax & syntax, ActionFactory & action_factory)
1123 {
1124 
1125 #undef registerAction
1126 #define registerAction(tplt, action) \
1127  action_factory.reg<tplt>(stringifyName(tplt), action, __FILE__, __LINE__)
1128 
1129  registerAction(SetupPostprocessorDataAction, "setup_postprocessor_data");
1130 
1131  registerAction(SetupMeshAction, "setup_mesh");
1132  registerAction(SetupMeshAction, "init_mesh");
1133  registerAction(SetupMeshCompleteAction, "prepare_mesh");
1134  registerAction(AddMeshModifierAction, "add_mesh_modifier");
1135  registerAction(AddMortarInterfaceAction, "add_mortar_interface");
1136  registerAction(SetupMeshCompleteAction, "execute_mesh_modifiers");
1137  registerAction(SetupMeshCompleteAction, "uniform_refine_mesh");
1138  registerAction(SetupMeshCompleteAction, "setup_mesh_complete");
1139 
1140  registerAction(AddFunctionAction, "add_function");
1141  registerAction(AddDistributionAction, "add_distribution");
1142  registerAction(AddSamplerAction, "add_sampler");
1143  registerAction(CreateExecutionerAction, "setup_executioner");
1144  registerAction(SetupTimeStepperAction, "setup_time_stepper");
1145  registerAction(SetupTimeIntegratorAction, "setup_time_integrator");
1146  registerAction(CreateDisplacedProblemAction, "init_displaced_problem");
1147  registerAction(DetermineSystemType, "determine_system_type");
1148  registerAction(CreateProblemAction, "create_problem");
1149  registerAction(DynamicObjectRegistrationAction, "dynamic_object_registration");
1150  registerAction(AddOutputAction, "add_output");
1151  registerAction(CommonOutputAction, "common_output");
1152  registerAction(SetupRecoverFileBaseAction, "setup_recover_file_base");
1153  registerAction(GlobalParamsAction, "set_global_params");
1154  registerAction(SetupPredictorAction, "setup_predictor");
1155  registerAction(MaterialOutputAction, "setup_material_output");
1156  registerAction(CheckOutputAction, "check_output");
1157 
1159  registerAction(AddVariableAction, "add_variable");
1160  registerAction(AddAuxVariableAction, "add_aux_variable");
1161 
1162  registerAction(CopyNodalVarsAction, "check_copy_nodal_vars");
1163  registerAction(CopyNodalVarsAction, "copy_nodal_vars");
1164  registerAction(CopyNodalVarsAction, "copy_nodal_aux_vars");
1165 
1166  // Initial Condition Actions
1167  registerAction(AddICAction, "add_ic");
1168  registerAction(AddInitialConditionAction, "add_ic");
1169 
1170  registerAction(AddKernelAction, "add_kernel");
1171  registerAction(AddNodalKernelAction, "add_nodal_kernel");
1172  registerAction(AddKernelAction, "add_aux_kernel");
1173  registerAction(AddScalarKernelAction, "add_scalar_kernel");
1174  registerAction(AddScalarKernelAction, "add_aux_scalar_kernel");
1175  registerAction(AddDGKernelAction, "add_dg_kernel");
1176  registerAction(AddInterfaceKernelAction, "add_interface_kernel");
1177  registerAction(AddBCAction, "add_bc");
1178  registerAction(EmptyAction, "no_action"); // placeholder
1179  registerAction(AddPeriodicBCAction, "add_periodic_bc");
1180  registerAction(AddMaterialAction, "add_material");
1181  registerAction(AddPostprocessorAction, "add_postprocessor");
1182  registerAction(AddVectorPostprocessorAction, "add_vector_postprocessor");
1183  registerAction(AddDamperAction, "add_damper");
1184  registerAction(AddFieldSplitAction, "add_field_split");
1185  registerAction(SetupPreconditionerAction, "add_preconditioning");
1186  registerAction(SetupQuadratureAction, "setup_quadrature");
1187  registerAction(DeprecatedBlockAction, "deprecated_block");
1188  registerAction(AddConstraintAction, "add_constraint");
1189  registerAction(AddUserObjectAction, "add_user_object");
1190  registerAction(AddControlAction, "add_control");
1191  registerAction(AddElementalFieldAction, "add_elemental_field_variable");
1192  registerAction(AddIndicatorAction, "add_indicator");
1193  registerAction(AddMarkerAction, "add_marker");
1194  registerAction(SetAdaptivityOptionsAction, "set_adaptivity_options");
1195 
1196  registerAction(AddNodalNormalsAction, "add_aux_variable");
1197  registerAction(AddNodalNormalsAction, "add_postprocessor");
1198  registerAction(AddNodalNormalsAction, "add_user_object");
1199 
1200 #ifdef LIBMESH_ENABLE_AMR
1201  registerAction(AdaptivityAction, "setup_adaptivity");
1202 #endif
1203 
1204  registerAction(PartitionerAction, "add_partitioner");
1205  registerAction(AddDiracKernelAction, "add_dirac_kernel");
1206  registerAction(SetupDebugAction, "setup_debug");
1207  registerAction(SetupResidualDebugAction, "setup_residual_debug");
1208 
1209  registerAction(AddBoundsVectorsAction, "add_bounds_vectors");
1210 
1211  // NonParsedActions
1212  registerAction(SetupDampersAction, "setup_dampers");
1213  registerAction(EmptyAction, "ready_to_init");
1214  registerAction(InitProblemAction, "init_problem");
1215  registerAction(CheckIntegrityAction, "check_integrity");
1216 
1217  registerAction(AddMultiAppAction, "add_multi_app");
1218  registerAction(AddTransferAction, "add_transfer");
1219 
1220  // TODO: Why is this here?
1221  registerTask("finish_input_file_output", false);
1222  registerAction(EmptyAction, "finish_input_file_output");
1223 
1224  registerAction(MaterialDerivativeTestAction, "add_variable");
1225  registerAction(MaterialDerivativeTestAction, "add_kernel");
1226  registerAction(MaterialDerivativeTestAction, "add_preconditioning");
1227 
1228 #undef registerAction
1229 #define registerAction(tplt, action) action_factory.regLegacy<tplt>(stringifyName(tplt), action)
1230 }
1231 
1232 void
1234 {
1235 #ifdef LIBMESH_HAVE_PETSC
1236  // May be a touch expensive to create a new DM every time, but probably safer to do it this way
1238 #endif // LIBMESH_HAVE_PETSC
1239 }
1240 
1241 MPI_Comm
1242 swapLibMeshComm(MPI_Comm new_comm)
1243 {
1244 #ifdef LIBMESH_HAVE_PETSC
1245  MPI_Comm old_comm = PETSC_COMM_WORLD;
1246  PETSC_COMM_WORLD = new_comm;
1247  return old_comm;
1248 #endif // LIBMESH_HAVE_PETSC
1249 }
1250 
1251 void
1252 enableFPE(bool on)
1253 {
1254  if (_trap_fpe)
1255  libMesh::enableFPE(on);
1256 }
1257 
1261 #ifdef DEBUG
1262 bool _trap_fpe = true;
1263 #else
1264 bool _trap_fpe = false;
1265 #endif
1266 
1267 static bool _color_console = isatty(fileno(stdout));
1268 
1269 bool
1271 {
1272  return _color_console;
1273 }
1274 
1275 bool
1276 setColorConsole(bool use_color, bool force)
1277 {
1278  _color_console = (isatty(fileno(stdout)) || force) && use_color;
1279  return _color_console;
1280 }
1281 
1283 
1285 
1286 bool _throw_on_error = false;
1287 
1288 } // namespace Moose
DG kernel for diffusion.
Definition: DGDiffusion.h:36
Sum_over_i (w_i * functions_i)
Transfers from spatially varying Interpolations in a MultiApp to the "master" system.
Sets the quadrature.
Integrate a post-processor value over time using trapezoidal rule.
This kernel implements a generic functional body force term: $ - c f $.
Definition: BodyForce.h:35
Defines a boundary condition that forces the value to be a user specified function at the boundary...
Definition: FunctionIC.h:37
Fourth-order diagonally implicit Runge Kutta method (Dirk) with five stages.
Definition: LStableDirk4.h:62
Computes a linear combination between an arbitrary number of post-processors.
Function which provides a piecewise continuous linear interpolation of a data set provided as two col...
Simple time-stepper which imposes a time step constant in the logarithmic space.
Definition: LogConstantDT.h:27
Class that represents constant function.
This UserObject computes volume integrals of a variable storing partial sums for the specified number...
Automatically generates Sub-App positions from positions in the master app&#39;s mesh.
Transient executioners usually loop through a number of timesteps...
Definition: Transient.h:36
Base class for function objects.
Definition: Function.h:46
Solves the PDEs at a sequence of time points given as a column in a text table file (such as a *...
Computes the magnitude of a vector whose components are given by up to three coupled variables...
The explicit midpoint time integration method.
This class samples Real material properties for the integration points in all elements that are inter...
Initial condition to set different values on each component of scalar variable.
bool colorConsole()
Returns whether Console coloring is turned on (default: true).
Definition: Moose.C:1270
Compute an elemental field variable (single value per element) equal to the Lp-norm of a coupled Vari...
This Action adds a periodic boundary to the problem.
Implements a preconditioner designed to map onto PETSc&#39;s PCFieldSplit.
Base class for split-based preconditioners.
Definition: Split.h:30
Second-order Runge-Kutta (implicit midpoint) time integration.
MeshModifier for re-numbering or re-naming blocks.
Definition: RenameBlock.h:30
A class for computing the element-wise H1 error (actually W^{1,p} error, if you set the value of p to...
Compute a histogram of volume fractions binned according to variable values.
MPI_Comm swapLibMeshComm(MPI_Comm new_comm)
Swap the libMesh MPI communicator out for ours.
Definition: Moose.C:1242
This postprocessor computes a volume integral of the specified variable.
Adds nonlinear variable.
A basic control for changing an input parameter using a Function.
AuxKernel for outputting a std::vector material-property component to an AuxVariable.
Generic factory class for build all sorts of objects.
Definition: Factory.h:152
void setSolverDefaults(FEProblemBase &problem)
Definition: Moose.C:1233
A spatially-constant, time-varying NodalBC whose imposed value g(t) varies sinusoidally with time acc...
A function for extracting data from an image or stack of images.
Definition: ImageFunction.h:31
Computes the difference between two postprocessors.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Definition: FEProblem.h:30
Computes the distance from a block or boundary to another boundary.
A CoupledTiedValueConstraint forces the value of a variable to be the same on both sides of an interf...
A class for computing the element-wise L^2 error (actually L^p error, if you set the value of p to so...
This is the base class for Samplers.
Definition: Sampler.h:46
Base class for predictors.
Definition: Predictor.h:39
This kernel implements the Laplacian operator multiplied by a 2nd order tensor giving anisotropic (di...
This UserObject computes side averages of a flux storing partial sums for the specified number of int...
void petscSetDefaults(FEProblemBase &problem)
Sets the default options for PETSc.
Definition: PetscSupport.C:560
This postprocessor computes the volume of a specified block.
bool _warnings_are_errors
Variable to toggle any warning into an error (includes deprecated code warnings)
Definition: Moose.C:1282
Sets up variables and Kernels to test the derivatives of material properties via the Jacobian checker...
ScalarConstantIC just returns a constant value.
Computes the max value at a node and broadcasts it to all processors.
Implements a simple Vacuum BC for neutron diffusion on the boundary.
Definition: VacuumBC.h:32
An output object for writing to the console (screen)
Definition: Console.h:30
This postprocessor will print out the h1 seminorm between the computed solution and the passed functi...
Creates a box of specified width, length and height, with its center at specified position...
void registerActions(Syntax &syntax, ActionFactory &action_factory)
Multiple Action class can be associated with a single input file section, in which case all associate...
Definition: Moose.C:1122
AuxKernel for outputting a DenseMatrix<Real> material property component to an AuxVariable.
Compute the value of a variable at a specified location.
Definition: PointValue.h:32
This class implements a damper that limits the value of a variable to be within user-specified bounds...
This postprocessor computes an average element size (h) for the whole domain.
Base class for all Constraint types.
Definition: Constraint.h:42
MeshModifier for defining a Subdomain inside or outside of a bounding box with arbitrary orientation...
An ElementUserObject that prepares MOOSE for computing nodal normals.
A TiedValueConstraint forces the value of a variable to be the same on both sides of an interface...
Constant auxiliary value.
Definition: ConstantAux.h:29
This postprocessor computes a volume integral of the specified variable.
NumNonlinearIterations is a postprocessor that reports the number of nonlinear iterations.
Class that hold the whole problem being solved.
Definition: Problem.h:29
This kernel is used for testing derivatives of a material property.
Auxiliary kernel for debugging convergence.
Function auxiliary value.
Definition: Marker.h:42
Fills in the "bounds vectors" to provide an upper and lower bound for the variable that is coupled in...
Definition: BoundsAux.h:34
MeshModifiers are objects that can modify or add to an existing mesh.
Definition: MeshModifier.h:31
Third order diagonally implicit Runge Kutta method (Dirk) with three stages.
Definition: LStableDirk3.h:51
Adjust the timestep based on the number of iterations.
Steady executioners usually only call "solve()" on the NonlinearSystem once.
Definition: Steady.h:37
Base class for time stepping.
Definition: TimeStepper.h:31
Sets the predictor.
Function which provides a piecewise continuous constant interpolation of a provided (x...
Constrain a specified component of the gradient of a variable to be the same on both sides of an inte...
Computes the change in a post-processor value, or the magnitude of its relative change, over a time step.
Copy the value to the target domain from the nearest node in the source domain.
Function which provides a piecewise continuous linear interpolation of a provided (x...
MultiApp Implementation for Transient Apps.
A class for producing various debug related outputs.
AuxKernel for outputting a RealTensorValue material property component to an AuxVariable.
A class to report class attributes value from Executioners.
This is the term from the mortar method.
All Distributions should inherit from this class.
Definition: Distribution.h:28
static bool registered
Definition: Moose.C:485
This class is used to evaluate symbolic equations passed in to Moose through the input file...
Class for output data to the XDAII format.
Definition: XDA.h:30
This calculates the time derivative for a coupled variable.
Copies the value of a SCALAR variable from one App to another.
Transfers from spatially varying UserObjects in a MultiApp to the "master" system.
Based class for adding basic filename support to output base class.
Definition: Gnuplot.h:32
Action for creating Control objects.
Action to setup computation of nodal normals.
A FluxBC which is consistent with the boundary terms arising from the Diffusion Kernel.
Boundary condition of a Neumann style whose value is computed by a user-defined function.
This class adds a distribution object.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
MeshModifier for assigning a subdomain ID to all elements.
Simple class to demonstrate off diagonal Jacobian contributions.
Definition: CoupledForce.h:29
void registerObjects(Factory &factory)
Register objects that are in MOOSE.
Definition: Moose.C:488
This kernel implements the Laplacian operator: $ u $.
Definition: Diffusion.h:29
Copy the value to the target domain from the nearest node in the source domain.
Implements an explicit Adams predictor based on two old solution vectors.
Transfers from spatially varying PostprocessorInterpolations in a MultiApp to the "master" system...
This kernel is used for testing derivatives of a material property.
This class will add sidesets to the entire mesh based on unique normals.
A SimplePredictor uses an algorithm that will predict the next solution based on previous solutions...
Reads an arbitrary set of meshes and attempts to "stitch" (join) them along boundaries.
Definition: StitchedMesh.h:35
Base class for function objects.
InitialConditions are objects that set the initial value of variables.
Base class for MOOSE preconditioners.
This UserObject computes side averages of a variable storing partial sums for the specified number of...
BDF2 time integrator.
Definition: BDF2.h:28
This postprocessor computes the area of a specified block.
This auxiliary kernel computes its value by dividing "numerator" by "denominator. ...
Constrain the value of a variable to be the same on both sides of an interface.
MeshModifier for defining a Sideset by a parsed expression and optionally by looking at the subdomain...
Samples a variable&#39;s value in the Master domain at the point where the MultiApp is.
Creates AuxVariables and AuxKernels for automatic output of material properties.
Defines a boundary condition that forces the value to be a user specified function at the boundary...
AuxKernel that evaluates a parsed function expression.
Definition: ParsedAux.h:30
BoundingBoxIC allows setting the initial condition of a value inside and outside of a specified box...
Definition: BoundingBoxIC.h:51
Solves the PDEs at a sequence of time points given as a vector in the input file. ...
An adaptive timestepper that compares the solution obtained from a single step of size dt with two st...
Definition: DT2.h:38
Implements a flux boundary condition grad(u).n = V.n, where the vector V is specifed by the user...
Do nothing action.
Definition: EmptyAction.h:28
This postprocessor displays a single value which is supplied by a MooseFunction.
Scale a postprocessor.
Based class for output objects.
Definition: Output.h:45
A class for producing various debug related outputs.
This UserObject computes averages of a variable storing partial sums for the specified number of inte...
Set the preconditioner up.
Simple constant damper.
Action for checking that "outputs" is properly populated for Materials.
Action for creating output objects.
This UserObject computes averages of a variable storing partial sums for the specified number of inte...
Gets the relative solution norm from the transient executioner.
Computes the absolute value of the relative difference between 2 post-processor values.
This material automatically declares as material properties whatever is passed to it through the para...
This postprocessor computes a side integral of the mass flux.
A basic control for disabling objects for a portion of the simulation.
Definition: TimePeriod.h:31
Adds the faces on the boundary of given block to the sidesets specified by "boundary" Optionally...
VectorOfPostprocessors is a type of VectorPostprocessor that outputs the values of an arbitrary user-...
Mesh generated from parameters.
Definition: GeneratedMesh.h:28
This class parses functions in the [Functions] block and creates them.
Reads one or more 2D mesh files and stitches them together based on a provided two-dimensional patter...
Definition: PatternedMesh.h:41
Find a specific target value along a sampling line.
The DGKernel class is responsible for calculating the residuals for various physics on internal sides...
Definition: DGKernel.h:47
bool _deprecated_is_error
Variable to toggle only deprecated warnings as errors.
Definition: Moose.C:1284
Heun&#39;s (aka improved Euler) time integration method.
Definition: Heun.h:36
Copy the value to the target domain from the nearest node in the source domain.
static bool _color_console
Definition: Moose.C:1267
Base class for making kernels that work on auxiliary scalar variables.
Sums a nodal value across all processors and multiplies the result by a scale factor.
This class implements a damper that limits the value of a variable to be within user-specified bounds...
Based class for adding basic filename support to output base class.
Definition: CSV.h:32
Project values from one domain to another.
Boundary condition of a Dirichlet type.
void deprecateObject(const std::string &name)
Allow objects to be deprecated via function call.
Definition: Factory.C:158
Class for output data to the ExodusII format.
Definition: Exodus.h:36
Specialized factory for generic Action System objects.
Definition: ActionFactory.h:70
Boundary condition of a Dirichlet type.
Definition: DirichletBC.h:30
MeshModifier for defining a Subdomains based on Image data.
MooseMesh wraps a libMesh::Mesh object and enhances its capabilities by caching additional data and s...
Definition: MooseMesh.h:74
A postprocessor for collecting the nodal min or max value.
Implements a constant Neumann BC where grad(u) is a equal to a postprocessor on the boundary...
Implements a segregated solve preconditioner.
LeastSquaresFit is a VectorPostprocessor that performs a least squares fit on data calculated in anot...
Defines a boundary condition that forces the value to be a user specified function at the boundary...
Function auxiliary value.
Definition: FunctionAux.h:30
Copies the value of a Postprocessor from one app to a scalar AuxVariable in another.
Action for creating Auxiliary variables.
This material automatically declares as material properties whatever is passed to it through the para...
Executioners are objects that do the actual work of solving your problem.
Definition: Executioner.h:41
TODO:
Definition: PresetBC.h:28
The slave node variable is programmed as a linear combination of the master node variables (i...
Function for reading a 2D axisymmetric solution from file and mapping it to a 3D Cartesian system...
RandomIC just returns a Random value.
Definition: RandomIC.h:40
An output object for writing the DOF map of the system in a machine parsable format.
Definition: DOFMapOutput.h:31
Base class for all Postprocessors.
Definition: Postprocessor.h:35
The behavior of this kernel is controlled by one problem-wise global parameter eigen_on_current - boo...
Definition: EigenKernel.h:34
Samples a variable&#39;s value in the Master domain at the point where the MultiApp is.
MeshModifier for defining a Subdomain inside or outside of a bounding box.
Base class for creating new auxiliary kernels and auxiliary boundary conditions.
Definition: AuxKernel.h:51
Weakly enforce a Dirichlet BC using a penalty term.
Computes the value of dt based on a postprocessor value.
This kernel is used for testing derivatives of a material property.
Transfers a vector of variables.
This class computes a maximum (over all the nodal values) of the coupled variable.
Definition: NodalMaxValue.h:30
This Userobject requests termination of the current solve based on the values of Postprocessors (and ...
Definition: Terminator.h:45
This auxiliary kernel normalizes a variable based on a postprocessor.
Mesh generated from parameters.
Definition: AnnularMesh.h:28
Represents the rate in a simple ODE of du/dt = f.
Get all of the elements that are intersected by a plane.
Class for output data to the TecplotII format.
Definition: Tecplot.h:30
Function for reading a solution from file Creates a function that extracts values from a solution rea...
Get the intersection points for all of the elements that are intersected by a line.
InterfaceKernel is responsible for interfacing physics across subdomains.
InitialConditions are objects that set the initial value of variables.
This postprocessor computes the integral of a function over a specified boundary. ...
Fourth-order diagonally implicit Runge Kutta method (Dirk) with three stages plus an update...
Definition: AStableDirk4.h:62
Solves the PDEs at a sequence of time points given as a vector in the input file. ...
void addDependencySets(const std::string &action_sets)
Definition: Syntax.C:60
Finds the closest node on a paired boundary to the current node or element and stores a corresponding...
Output maximum, average, or total process memory usage.
Definition: MemoryUsage.h:28
Ralston&#39;s time integration method.
Definition: Ralston.h:36
Materials compute MaterialProperties.
Definition: Material.h:53
Implements a simple constant Neumann BC where grad(u)=value on the boundary.
Definition: NeumannBC.h:29
Base class for creating new types of boundary conditions.
This class is similar to ParsedFunction except it also supports returning the gradient of the functio...
A postprocessor for collecting the nodal min or max value.
Auxiliary kernel responsible for computing the components of the flux vector in diffusion problems...
Computes a sum of the nodal values of the coupled variable.
Definition: NodalSum.h:29
bool _trap_fpe
Variable indicating whether we will enable FPE trapping for this run.
Definition: Moose.C:1262
Finite difference preconditioner.
Samples a variable&#39;s value in the Master domain at the point where the MultiApp is.
Sets a constant value on a scalar variable.
This material uses a LinearInterpolation object to define the dependence of the material&#39;s value on a...
A different approach to applying Dirichlet BCs.
Explicit Euler time integrator.
Definition: ExplicitEuler.h:28
Function that uses spline interpolation.
Snaps the selected nodes to the surface of a sphere (or circular disk in 2D)
Constraint to enforce equal values (in 1D)
Base class for time integrators.
Extract a component from the gradient of a variable.
Base class for Control objects.
Definition: Control.h:43
Just returns the total number of Residual Evaluations performed.
Creates a cumulative sum of a post-processor value over a transient.
Object for passing a scalar, REAL material property to an AuxVariable.
This postprocessor will print out the H^1-norm of the difference between the computed solution and th...
PiecewiseBilinear reads from a file the information necessary to build the vectors x and y and the Co...
This postprocessor computes a volume integral of the time derivative of a given variable.
Self auxiliary value.
Definition: SelfAux.h:29
Base class for MOOSE partitioner.
bool setColorConsole(bool use_color, bool force=false)
Turns color escape sequences on/off for info written to stdout.
Definition: Moose.C:1276
AuxKernel for outputting a std::vector material-property component to an AuxVariable.
This postprocessor computes a volume integral of the specified variable.
Base class for deriving dampers.
Definition: Damper.h:35
Works on top of NodalNormalsPreprocessor.
MeshModifier for defining a Subdomain inside or outside of combinatorial geometry.
Selects a set of nodes and assigns a nodeset name to them based on the bounding box specified...
Records all post processor data in a CSV file.
Definition: PerflogDumper.h:26
Holding syntax for parsing input files.
Definition: Syntax.h:26
A class for producing various debug related outputs.
Returns the number of Picard iterations taken by the underlying Transient Executioner as a Postproces...
Definition: Kernel.h:25
AuxKernel for reading a solution from file.
Definition: SolutionAux.h:33
MeshModifier for defining a Subdomain inside or outside of a bounding box.
This UserObject computes volume integrals of a variable storing partial sums for the specified number...
Implements a spatially-constant, time-varying flux boundary condition grad(u).n = g(t)...
Definition: SinNeumannBC.h:38
A class for storing data, it allows the user to change the value of the postprocessor by altering the...
Definition: Receiver.h:30
This postprocessor computes a line integral of the specified variable along the centerline of an axis...
Represents the rate in a simple ODE of du/dt = rate.
Definition: ConstantRate.h:29
Single matrix preconditioner.
Add lower dimensional elements along the faces contained in a side set.
Definition: MeshSideSet.h:28
ConstantIC just returns a constant value.
Definition: ConstantIC.h:41
This postprocessor computes a volume integral of the specified variable.
Finds the largest difference between two variable fields.
Definition: Moose.h:84
Declares a constant material property of type RankTwoTensor.
This class adds a Sampler object.
Second order diagonally implicit Runge Kutta method (Dirk) with two stages.
Definition: LStableDirk2.h:49
Sets a value of a scalar variable based on the function.
Specialization of SubProblem for solving nonlinear equations plus auxiliary equations.
Definition: EigenProblem.h:32
Computes the L2-Norm difference between two solution fields.
Get all of the elements that are intersected by a line.
Explicit TVD (total-variation-diminishing) second-order Runge-Kutta time integration methods: ...
Class for output information regarding Controls to the screen.
Definition: ControlOutput.h:30
Computes the min or max of element length.
User object that reads an existing solution from an input file and uses it in the current simulation...
AuxKernel for outputting a RealVectorValue material property component to an AuxVariable.
Base class for creating new types of boundary conditions.
Definition: NodalKernel.h:50
A MultiApp represents one or more MOOSE applications that are running simultaneously.
Definition: MultiApp.h:59
Class for output data to the GMVOutputII format.
Definition: GMVOutput.h:30
Base class for Postprocessors that produce a vector of values.
Used for marking that some block are deprecated and not be used.
Copies the value of a Postprocessor from the Master to a MultiApp.
A TimeStepper based on the AB2 method.
bool _throw_on_error
Variable to turn on exceptions during mooseError() and mooseWarning(), should only be used with MOOSE...
Definition: Moose.C:1286
This class is similar to ParsedFunction except it returns a vector function.
This postprocessor records all scalar material properties of the specified material object on specifi...
Compute a spherical average of a variableas a function of radius throughout the simulation domain...
Function that uses spline interpolation.
The PostprocessorInterface::hasPostprocessor method utilizes the PostprocessorData to determine if a ...
MeshModifier for assigning subdomain IDs of all elements.
Crank-Nicolson time integrator.
Definition: CrankNicolson.h:33
A DiracKernel is used when you need to add contributions to the residual by means of multiplying some...
Definition: DiracKernel.h:50
void enableFPE(bool on=true)
Definition: Moose.C:1252
Base class for user-specific data.
Definition: UserObject.h:42
This postprocessor computes a volume integral of the specified variable.
void addActionTypes(Syntax &syntax)
Definition: Moose.C:890
A 2D GeneratedMesh where xmin, xmax, etc.
Definition: ImageMesh.h:29
Meta-action for creating common output object parameters This action serves two purpose, first it adds common output object parameters.
This type of MultiApp will completely solve itself the first time it is asked to take a step...
An AuxKernel that can be used to integrate a field variable in time using a variety of different inte...
Implicit Euler&#39;s method.
Definition: ImplicitEuler.h:28
A postprocessor for reporting the max/min value of another postprocessor over time.
This auxiliary kernel computes its value by dividing "numerator" by "denominator. ...
Definition: QuotientAux.h:32
Based class for adding basic filename support to output base class.
Computes the "nodal" L2-norm of the coupled variable, which is defined by summing the square of its v...
Definition: NodalL2Norm.h:31
Postprocessor for computing the error in a scalar value relative to a known Function&#39;s value...
Definition: ScalarL2Error.h:33
This postprocessor displays the change in the postprocessor between adjacent timesteps.
Class for output data to the Nemesis format.
Definition: Nemesis.h:36
This postprocessor computes the Sobolev norm W^{1,p} of the difference between the computed solution ...
Base class for all Transfer objects.
Definition: Transfer.h:46
Implements a simple coupled boundary condition where u=v on the boundary.
A FluxBC which is consistent with the boundary terms arising from the Diffusion Kernel.