void
SolidMechanicsApp::registerObjects(Factory & factory)
{
registerAux(ElasticEnergyAux);
registerAux(MaterialSymmElasticityTensorAux);
registerAux(MaterialTensorAux);
registerAux(MaterialVectorAux);
registerAux(AccumulateAux);
registerAux(DomainIntegralQFunction);
registerAux(DomainIntegralTopologicalQFunction);
registerAux(ElementsOnLineAux);
registerBoundaryCondition(DashpotBC);
registerBoundaryCondition(PresetVelocity);
registerBoundaryCondition(InteractionIntegralBenchmarkBC);
registerMaterial(AbaqusCreepMaterial);
registerMaterial(AbaqusUmatMaterial);
registerMaterial(CLSHPlasticMaterial);
registerMaterial(CLSHPlasticModel);
registerMaterial(CombinedCreepPlasticity);
registerMaterial(Elastic);
registerMaterial(ElasticModel);
registerMaterial(InteractionIntegralAuxFields);
registerMaterial(IsotropicPlasticity);
registerMaterial(IsotropicPowerLawHardening);
registerMaterial(LinearAnisotropicMaterial);
registerMaterial(LinearGeneralAnisotropicMaterial);
registerMaterial(LinearIsotropicMaterial);
registerMaterial(LinearStrainHardening);
registerMaterial(MacroElastic);
registerMaterial(PLC_LSH);
registerMaterial(PowerLawCreep);
registerMaterial(PowerLawCreepModel);
registerMaterial(SolidModel);
registerMaterial(RateDepSmearCrackModel);
registerMaterial(RateDepSmearIsoCrackModel);
registerKernel(HomogenizationKernel);
registerKernel(SolidMechImplicitEuler);
registerKernel(StressDivergence);
registerKernel(OutOfPlaneStress);
registerKernel(StressDivergenceRZ);
registerKernel(StressDivergenceRSpherical);
registerPostprocessor(HomogenizedElasticConstants);
registerPostprocessor(JIntegral);
registerPostprocessor(CrackFrontData);
registerPostprocessor(InteractionIntegral);
registerPostprocessor(CavityPressurePostprocessor);
registerPostprocessor(MaterialTensorIntegral);
registerPostprocessor(MixedModeEquivalentK);
registerVectorPostprocessor(CrackDataSampler);
registerVectorPostprocessor(LineMaterialSymmTensorSampler);
registerUserObject(MaterialTensorOnLine);
registerUserObject(CavityPressureUserObject);
registerUserObject(CrackFrontDefinition);
}
void
SolidMechanicsApp::registerObjects(Factory & factory)
{
registerAux(ElasticEnergyAux);
registerAux(MaterialSymmElasticityTensorAux);
registerAux(MaterialTensorAux);
registerAux(MaterialVectorAux);
registerAux(AccumulateAux);
registerAux(NewmarkAccelAux);
registerAux(NewmarkVelAux);
registerAux(qFunctionJIntegral);
registerAux(ElementsOnLineAux);
registerBoundaryCondition(DashpotBC);
registerBoundaryCondition(PresetVelocity);
registerBoundaryCondition(Pressure);
registerExecutioner(AdaptiveTransient);
registerMaterial(AbaqusCreepMaterial);
registerMaterial(AbaqusUmatMaterial);
registerMaterial(CLSHPlasticMaterial);
registerMaterial(CLSHPlasticModel);
registerMaterial(CombinedCreepPlasticity);
registerMaterial(Elastic);
registerMaterial(ElasticModel);
registerMaterial(IsotropicPlasticity);
registerMaterial(LinearAnisotropicMaterial);
registerMaterial(LinearGeneralAnisotropicMaterial);
registerMaterial(LinearIsotropicMaterial);
registerMaterial(LinearStrainHardening);
registerMaterial(MacroElastic);
registerMaterial(PLC_LSH);
registerMaterial(PowerLawCreep);
registerMaterial(PowerLawCreepModel);
registerMaterial(SolidModel);
registerMaterial(TrussMaterial);
registerKernel(Gravity);
registerKernel(HomogenizationKernel);
registerKernel(SolidMechImplicitEuler);
registerKernel(SolidMechInertialForce);
registerKernel(StressDivergence);
registerKernel(StressDivergenceRZ);
registerKernel(StressDivergenceRSpherical);
registerKernel(StressDivergenceTruss);
registerKernel(HomogenizationHeatConduction);
registerPostprocessor(HomogenizedThermalConductivity);
registerPostprocessor(HomogenizedElasticConstants);
registerPostprocessor(Mass);
registerPostprocessor(JIntegral);
registerPostprocessor(CavityPressurePostprocessor);
registerTimeStepper(AdaptiveDT);
registerUserObject(MaterialTensorOnLine);
registerUserObject(CavityPressureUserObject);
registerUserObject(CrackFrontDefinition);
}
void
HeatConductionApp::registerObjects(Factory & factory)
{
#undef registerObject
#define registerObject(name) factory.reg<name>(stringifyName(name))
#undef registerNamedObject
#define registerNamedObject(obj, name) factory.reg<obj>(name)
registerNamedKernel(HeatConductionKernel, "HeatConduction");
registerKernel(AnisoHeatConduction);
registerKernel(HeatConductionTimeDerivative);
registerKernel(HeatSource);
registerBoundaryCondition(HeatConductionBC);
registerBoundaryCondition(ConvectiveFluxFunction);
registerBoundaryCondition(GapHeatTransfer);
registerBoundaryCondition(CoupledConvectiveFlux);
registerMaterial(GapConductance);
registerMaterial(HeatConductionMaterial);
registerMaterial(AnisoHeatConductionMaterial);
registerDiracKernel(GapHeatPointSourceMaster);
registerPostprocessor(ThermalCond);
registerConstraint(GapConductanceConstraint);
#undef registerNamedObject
#define registerNamedObject(obj, name) factory.regLegacy<obj>(name)
#undef registerObject
#define registerObject(name) factory.regLegacy<name>(stringifyName(name))
}
void
AhiApp::registerObjects(Factory & factory)
{
registerBoundaryCondition(RadiationBC);
registerFunction(PostprocessorFunction);
registerBoundaryCondition(ScalarDirichletBC);
}
void
HeatConductionApp::registerObjects(Factory & factory)
{
registerNamedKernel(HeatConductionKernel, "HeatConduction");
registerKernel(AnisoHeatConduction);
registerKernel(HeatConductionTimeDerivative);
registerKernel(HeatSource);
registerKernel(HomogenizedHeatConduction);
registerKernel(HeatCapacityConductionTimeDerivative);
registerKernel(SpecificHeatConductionTimeDerivative);
registerBoundaryCondition(HeatConductionBC);
registerBoundaryCondition(ConvectiveFluxFunction);
registerBoundaryCondition(GapHeatTransfer);
registerBoundaryCondition(CoupledConvectiveFlux);
registerMaterial(GapConductance);
registerMaterial(HeatConductionMaterial);
registerMaterial(AnisoHeatConductionMaterial);
registerDiracKernel(GapHeatPointSourceMaster);
registerPostprocessor(HomogenizedThermalConductivity);
registerPostprocessor(ThermalConductivity);
registerConstraint(GapConductanceConstraint);
}
void
ExampleApp::registerObjects(Factory & factory)
{
registerKernel(Convection);
registerKernel(GaussContForcing); // Extra forcing term
registerBoundaryCondition(CoupledDirichletBC); // Register our Boundary Conditions
registerBoundaryCondition(CoupledNeumannBC);
}
void
RedwingApp::registerObjects(Factory & factory)
{
registerKernel(VectorPotentialA);
registerKernel(VectorPotentialAJ0);
registerBoundaryCondition(VectorPotentialABBC);
registerMaterial(MuMaterial);
registerBoundaryCondition(VectorPotentialABC);
}
/*******************************************************************************
Routine: registerObjects
*******************************************************************************/
void
FalconApp::registerObjects(Factory & factory)
{
/* AuxKernels */
registerAux(PTDarcyFluxAux);
registerAux(PTFluidVelocityAux);
registerAux(VariableGradientAux);
/* BCs */
registerBoundaryCondition(PTEnergyInFlowBC);
registerBoundaryCondition(PTEnergyOutFlowBC);
registerBoundaryCondition(PTMassFluxBC);
registerBoundaryCondition(PTMassFreeBC);
/* DGKernels */
/* DiracKernels */
registerDiracKernel(PTEnergyPointSource);
registerDiracKernel(PTMassPointSource);
/* ICs */
/* Kernel */
// pressure & temperature based single-phase flow and heat
registerKernel(PTEnergyResidual);
registerKernel(PTEnergyTimeDerivative);
registerKernel(PTMassResidual);
registerKernel(PTMassTimeDerivative);
registerKernel(PTMassTimeDerivative_FD);
registerKernel(HeatSource);
// solid mechanics
/* Materials */
registerMaterial(PTGeothermal);
/* PostProcessors */
registerPostprocessor(PTEnergySideProductionIntegral);
registerPostprocessor(PTMassSideFluxAverage);
registerPostprocessor(PTMassSideFluxIntegral);
/* UserObjects */
}
void
PandaApp::registerObjects(Factory & factory)
{
registerInitialCondition(SmoothCirclesIC);
registerBoundaryCondition(WettingNeumannBC);
registerBoundaryCondition(PatternedBC);
registerBoundaryCondition(WettingAngleNeumannBC);
registerAux(CoupledFunctionAux);
registerMaterial(NoEvapFreeEnergy);
registerAux(EnergyCoupledAux);
registerAux(GrowthFunctionAux);
registerPostprocessor(ElementIntegralGradPostprocessor);
registerPostprocessor(ElementMaxTimeDerivative);
}
void
ChemicalReactionsApp::registerObjects(Factory & factory)
{
#undef registerObject
#define registerObject(name) factory.reg<name>(stringifyName(name))
registerKernel(PrimaryTimeDerivative);
registerKernel(PrimaryConvection);
registerKernel(PrimaryDiffusion);
registerKernel(CoupledBEEquilibriumSub);
registerKernel(CoupledConvectionReactionSub);
registerKernel(CoupledDiffusionReactionSub);
registerKernel(CoupledBEKinetic);
registerKernel(DesorptionFromMatrix);
registerKernel(DesorptionToPorespace);
registerAux(AqueousEquilibriumRxnAux);
registerAux(KineticDisPreConcAux);
registerAux(KineticDisPreRateAux);
registerBoundaryCondition(ChemicalOutFlowBC);
registerMaterial(LangmuirMaterial);
registerMaterial(MollifiedLangmuirMaterial);
#undef registerObject
#define registerObject(name) factory.regLegacy<name>(stringifyName(name))
}
void
MiscApp::registerObjects(Factory & factory)
{
registerAux(CoupledDirectionalMeshHeightInterpolation);
registerBoundaryCondition(RobinBC);
registerKernel(BodyForceVoid);
registerKernel(CoefDiffusion);
registerKernel(Convection);
registerKernel(JouleHeating);
registerKernel(CoefTimeDerivative);
registerKernel(GaussContForcing);
registerKernel(ThermoDiffusion);
registerMaterial(Density);
registerUserObject(RigidBodyModesRZ);
registerUserObject(RigidBodyModes3D);
registerPostprocessor(InternalVolume);
registerPostprocessor(SharpInterfaceForcing);
registerPostprocessor(CInterfacePosition);
}
void
XFEMApp::registerObjects(Factory & factory)
{
// AuxKernels
registerAux(XFEMVolFracAux);
registerAux(XFEMCutPlaneAux);
registerAux(XFEMMarkerAux);
// Constraints
registerConstraint(XFEMSingleVariableConstraint);
// UserObjects
registerUserObject(XFEMMarkerUserObject);
registerUserObject(XFEMMaterialTensorMarkerUserObject);
registerUserObject(XFEMRankTwoTensorMarkerUserObject);
// Geometric Cut User Objects
registerUserObject(LineSegmentCutUserObject);
registerUserObject(LineSegmentCutSetUserObject);
registerUserObject(CircleCutUserObject);
registerUserObject(EllipseCutUserObject);
registerUserObject(RectangleCutUserObject);
// DiracKernels
registerDiracKernel(XFEMPressure);
// Kernels
registerKernel(CrackTipEnrichmentStressDivergenceTensors);
// Materials
registerMaterial(ComputeCrackTipEnrichmentSmallStrain);
// BC's
registerBoundaryCondition(CrackTipEnrichmentCutOffBC);
}
void
ExampleApp::registerObjects(Factory & factory)
{
registerBoundaryCondition(ScalarDirichletBC);
registerScalarKernel(ImplicitODEx);
registerScalarKernel(ImplicitODEy);
}
void
DarcyThermoMechApp::registerObjects(Factory & factory)
{
registerKernel(DarcyPressure);
registerMaterial(PackedColumn);
registerAux(DarcyVelocity);
registerBoundaryCondition(HeatConductionOutflow);
}
void
TurkeyApp::registerObjects(Factory & factory)
{
registerKernel(TemperatureTimeDerivative);
registerKernel(HeatConductionKernel);
registerKernel(DensitySourceKernel);
registerKernel(PyrolysisSourceKernel);
registerKernel(DarcyPressure);
registerKernel(GasConvection);
registerKernel(CoordMoveConvection);
registerKernel(DisplaceTimeDerivative);
registerKernel(DisplayDiffusion);
registerKernel(QuickRhoChange);
registerMaterial(PyrolysisMaterial);
registerMaterial(IntegratedBCMaterial);
registerMaterial(HeatFluxMaterial);
registerMaterial(GiveHeatFluxMaterial);
registerBoundaryCondition(IsoThermalBC);
registerBoundaryCondition(HeatFluxBC);
registerBoundaryCondition(HeatTransferBC);
registerBoundaryCondition(PostprocessorFluxBC);
registerBoundaryCondition(SurfaceRecessionBC);
registerBoundaryCondition(HeatRadiationBC);
registerBoundaryCondition(NormalRecessionBC);
registerAux(PyrolysisGasVelocity);
registerAux(PyrolysisRate);
registerAux(GridMovement);
registerAux(HeatFluxAuxKernel);
registerAux(ShowK);
}
void
TensorMechanicsApp::registerObjects(Factory & factory)
{
registerKernel(StressDivergenceTensors);
registerKernel(CosseratStressDivergenceTensors);
registerKernel(MomentBalancing);
registerKernel(StressDivergencePFFracTensors);
registerKernel(GravityTM);
registerMaterial(LinearElasticMaterial);
registerMaterial(FiniteStrainElasticMaterial);
registerMaterial(FiniteStrainPlasticMaterial);
registerMaterial(FiniteStrainMohrCoulomb);
registerMaterial(FiniteStrainRatePlasticMaterial);
registerMaterial(FiniteStrainCrystalPlasticity);
registerMaterial(ComputeMultiPlasticityStress);
registerMaterial(CosseratLinearElasticMaterial);
registerMaterial(ElementPropertyReadFileTest);
registerMaterial(TwoPhaseStressMaterial);
registerMaterial(MultiPhaseStressMaterial);
registerMaterial(SimpleEigenStrainMaterial);
registerMaterial(ComputeElasticityTensor);
registerMaterial(ComputeIsotropicElasticityTensor);
registerMaterial(ComputeSmallStrain);
registerMaterial(ComputeIncrementalSmallStrain);
registerMaterial(ComputeFiniteStrain);
registerMaterial(ComputeLinearElasticStress);
registerMaterial(ComputeFiniteStrainElasticStress);
registerMaterial(Compute1PhaseEigenStrain);
registerUserObject(TensorMechanicsPlasticSimpleTester);
registerUserObject(TensorMechanicsPlasticTensile);
registerUserObject(TensorMechanicsPlasticTensileMulti);
registerUserObject(TensorMechanicsPlasticMohrCoulomb);
registerUserObject(TensorMechanicsPlasticMohrCoulombMulti);
registerUserObject(TensorMechanicsPlasticWeakPlaneTensile);
registerUserObject(TensorMechanicsPlasticWeakPlaneTensileN);
registerUserObject(TensorMechanicsPlasticWeakPlaneShear);
registerUserObject(TensorMechanicsPlasticJ2);
registerUserObject(TensorMechanicsHardeningConstant);
registerUserObject(TensorMechanicsHardeningGaussian);
registerUserObject(TensorMechanicsHardeningExponential);
registerUserObject(TensorMechanicsHardeningCutExponential);
registerUserObject(TensorMechanicsHardeningCubic);
registerUserObject(ElementPropertyReadFile);
registerAux(RankTwoAux);
registerAux(RealTensorValueAux);
registerAux(RankFourAux);
registerAux(TensorElasticEnergyAux);
registerAux(FiniteStrainPlasticAux);
registerAux(CrystalPlasticitySlipSysAux);
registerAux(CrystalPlasticityRotationOutAux);
registerAux(RankTwoScalarAux);
registerBoundaryCondition(PressureTM);
}
void
DgospreyApp::registerObjects(Factory & factory)
{
registerKernel(LinearDrivingForce);
registerMaterial(BedProperties);
registerMaterial(AdsorbentProperties);
registerMaterial(FlowProperties);
registerMaterial(AdsorbateProperties);
registerKernel(RetardedTimeDerivative);
registerKernel(Dispersion);
registerKernel(BedWallHeatTransfer);
registerKernel(WallAmbientHeatTransfer);
registerKernel(WallHeatAccumulation);
registerKernel(FluidHeatTransfer);
registerKernel(HeatConductivity);
registerKernel(BedHeatAccumulation);
registerAux(TotalColumnPressure);
registerAux(MAGPIE_Adsorption);
registerInitialCondition(TotalPressureIC);
registerInitialCondition(ColumnTemperatureIC);
registerInitialCondition(ConcentrationIC);
registerInitialCondition(DGConcentrationIC);
registerDGKernel(DGAdvection);
registerBoundaryCondition(DGFluxBC);
registerKernel(GAdvection);
registerDGKernel(DGAnisotropicDiffusion);
registerKernel(GAnisotropicDiffusion);
registerBoundaryCondition(DGFluxLimitedBC);
registerDGKernel(DGColumnMassAdvection);
registerDGKernel(DGColumnMassDispersion);
registerBoundaryCondition(DGMassFluxBC);
registerBoundaryCondition(DGMassFluxLimitedBC);
registerKernel(GColumnMassAdvection);
registerKernel(GColumnMassDispersion);
registerDGKernel(DGColumnHeatAdvection);
registerKernel(GColumnHeatAdvection);
registerDGKernel(DGColumnHeatDispersion);
registerKernel(GColumnHeatDispersion);
registerBoundaryCondition(DGHeatFluxBC);
registerBoundaryCondition(DGHeatFluxLimitedBC);
registerBoundaryCondition(DGColumnWallHeatFluxBC);
registerBoundaryCondition(DGColumnWallHeatFluxLimitedBC);
}
void
MambaApp::registerObjects(Factory & factory)
{
// First come the kernels
// Our new advection-diffusion kernel that accepts an auxKernel's aqueous species diffusivity,
// the permeability material property, and the coupled pressure variable (of which the grad is taken)
registerKernel(AdvectionForConcentration);
registerKernel(DiffusionForConcentration);
registerKernel(BoricAcidSinks);
// registerAux(WaterSaturationTemperature);
// Our new Darcy flow kernel that accepts the permeability material property
registerKernel(PressureDarcy);
// Our new thermal diffusion kernel that accepts the k_cond (thermal conductivity) material property
registerKernel(ThermalDiffusion);
registerKernel(AdvectionForHeat);
// Next come the auxilliary kernels
registerAux(TortuosityAux);
registerAux(PorosityAux);
registerAux(WaterSaturationTemperatureAux);
registerAux(SuperheatTempAux);
registerAux(PecletAux);
registerAux(Precipitation_HBO2Aux);
registerAux(BO3_SolubilityAux);
// Next come the materials
// Register our new CRUD material class so we can use it.
registerMaterial(CRUDMaterial);
// Next come the boundary conditions
registerBoundaryCondition(CRUDCladNeumannBC);
registerBoundaryCondition(CRUDCladNeumannBCMultiApp);
registerBoundaryCondition(CRUDCoolantNeumannBC);
registerBoundaryCondition(CoupledTsatDirichletBC);
registerBoundaryCondition(ChimneyEvaporationNeumannBC);
registerBoundaryCondition(CRUDChimneyConcentrationMixedBC);
//userobjects
registerUserObject(WaterSteamEOS);
// Finally come the postprocessors
registerPostprocessor(NodalMaxValueFileIO);
registerPostprocessor(AreaAverageBoron);
}
void
NavierStokesApp::registerObjects(Factory & factory)
{
registerKernel(NSMassInviscidFlux);
registerKernel(NSMomentumInviscidFlux);
registerKernel(NSEnergyInviscidFlux);
registerKernel(NSGravityPower);
registerKernel(NSGravityForce);
registerKernel(NSTemperatureL2);
registerBoundaryCondition(NSThermalBC);
registerAux(NSVelocityAux);
registerBoundaryCondition(NSImposedVelocityBC);
registerAux(NSTemperatureAux);
registerAux(NSPressureAux);
registerAux(NSEnthalpyAux);
registerKernel(NSEnergyThermalFlux);
registerKernel(NSMomentumViscousFlux);
registerKernel(NSEnergyViscousFlux);
registerKernel(NSMomentumInviscidFluxWithGradP);
registerKernel(NSSUPGMomentum);
registerKernel(NSSUPGMass);
registerKernel(NSSUPGEnergy);
registerBoundaryCondition(NSMassSpecifiedNormalFlowBC);
registerBoundaryCondition(NSMassUnspecifiedNormalFlowBC);
registerBoundaryCondition(NSInflowThermalBC);
registerBoundaryCondition(NSMomentumInviscidSpecifiedPressureBC);
registerBoundaryCondition(NSMomentumInviscidSpecifiedNormalFlowBC);
registerBoundaryCondition(NSMomentumViscousBC);
registerBoundaryCondition(NSEnergyInviscidSpecifiedPressureBC);
registerBoundaryCondition(NSEnergyInviscidSpecifiedNormalFlowBC);
registerBoundaryCondition(NSEnergyInviscidUnspecifiedBC);
registerBoundaryCondition(NSEnergyInviscidSpecifiedBC);
registerBoundaryCondition(NSEnergyInviscidSpecifiedDensityAndVelocityBC);
registerBoundaryCondition(NSEnergyViscousBC);
registerBoundaryCondition(NSStagnationPressureBC);
registerBoundaryCondition(NSStagnationTemperatureBC);
registerBoundaryCondition(NSImposedVelocityDirectionBC);
registerBoundaryCondition(NSMassWeakStagnationBC);
registerBoundaryCondition(NSMomentumConvectiveWeakStagnationBC);
registerBoundaryCondition(NSMomentumPressureWeakStagnationBC);
registerBoundaryCondition(NSEnergyWeakStagnationBC);
registerBoundaryCondition(NSPenalizedNormalFlowBC);
registerBoundaryCondition(NSMomentumInviscidNoPressureImplicitFlowBC);
//
// Incompressible
//
// Kernels
registerKernel(INSMass);
registerKernel(INSMomentumTimeDerivative);
registerKernel(INSMomentum);
registerKernel(INSTemperatureTimeDerivative);
registerKernel(INSTemperature);
registerKernel(INSSplitMomentum);
registerKernel(INSProjection);
registerKernel(INSPressurePoisson);
registerKernel(INSChorinPredictor);
registerKernel(INSChorinCorrector);
registerKernel(INSChorinPressurePoisson);
// BCs
registerBoundaryCondition(INSMomentumNoBCBC);
registerBoundaryCondition(INSTemperatureNoBCBC);
registerBoundaryCondition(ImplicitNeumannBC);
// AuxKernels
registerAux(INSCourant);
registerAux(INSDivergenceAux);
// Postprocessors
registerPostprocessor(INSExplicitTimestepSelector);
}
void
registerObjects(Factory & factory)
{
// mesh
registerMesh(FileMesh);
registerMesh(GeneratedMesh);
registerMesh(TiledMesh);
// mesh modifiers
registerMeshModifier(MeshExtruder);
registerMeshModifier(SideSetsFromPoints);
registerMeshModifier(SideSetsFromNormals);
registerMeshModifier(AddExtraNodeset);
registerMeshModifier(BoundingBoxNodeSet);
registerMeshModifier(Transform);
registerMeshModifier(SideSetsAroundSubdomain);
registerMeshModifier(SideSetsBetweenSubdomains);
registerMeshModifier(AddAllSideSetsByNormals);
registerMeshModifier(SubdomainBoundingBox);
registerMeshModifier(OrientedSubdomainBoundingBox);
registerMeshModifier(RenameBlock);
// problems
registerProblem(FEProblem);
registerProblem(DisplacedProblem);
// kernels
registerKernel(TimeDerivative);
registerKernel(CoupledTimeDerivative);
registerKernel(MassLumpedTimeDerivative);
registerKernel(Diffusion);
registerKernel(AnisotropicDiffusion);
registerKernel(CoupledForce);
registerKernel(UserForcingFunction);
registerKernel(BodyForce);
registerKernel(Reaction);
registerKernel(MassEigenKernel);
// bcs
registerBoundaryCondition(ConvectiveFluxBC);
registerBoundaryCondition(DirichletBC);
registerBoundaryCondition(PenaltyDirichletBC);
registerBoundaryCondition(PresetBC);
registerBoundaryCondition(NeumannBC);
registerBoundaryCondition(FunctionDirichletBC);
registerBoundaryCondition(FunctionPenaltyDirichletBC);
registerBoundaryCondition(FunctionPresetBC);
registerBoundaryCondition(FunctionNeumannBC);
registerBoundaryCondition(MatchedValueBC);
registerBoundaryCondition(VacuumBC);
registerBoundaryCondition(SinDirichletBC);
registerBoundaryCondition(SinNeumannBC);
registerBoundaryCondition(VectorNeumannBC);
registerBoundaryCondition(WeakGradientBC);
registerBoundaryCondition(DiffusionFluxBC);
registerBoundaryCondition(PostprocessorDirichletBC);
registerBoundaryCondition(OneDEqualValueConstraintBC);
// dirac kernels
registerDiracKernel(ConstantPointSource);
// aux kernels
registerAux(ConstantAux);
registerAux(FunctionAux);
registerAux(NearestNodeDistanceAux);
registerAux(NearestNodeValueAux);
registerAux(PenetrationAux);
registerAux(ProcessorIDAux);
registerAux(SelfAux);
registerAux(GapValueAux);
registerAux(MaterialRealAux);
registerAux(MaterialRealVectorValueAux);
registerAux(MaterialRealTensorValueAux);
registerAux(MaterialStdVectorAux);
registerAux(MaterialRealDenseMatrixAux);
registerAux(MaterialStdVectorRealGradientAux);
registerAux(DebugResidualAux);
registerAux(BoundsAux);
registerAux(SpatialUserObjectAux);
registerAux(SolutionAux);
registerAux(VectorMagnitudeAux);
registerAux(ConstantScalarAux);
registerAux(QuotientAux);
registerAux(NormalizationAux);
registerAux(FunctionScalarAux);
registerAux(VariableGradientComponent);
registerAux(ParsedAux);
// Initial Conditions
registerInitialCondition(ConstantIC);
registerInitialCondition(BoundingBoxIC);
registerInitialCondition(FunctionIC);
registerInitialCondition(RandomIC);
registerInitialCondition(ScalarConstantIC);
registerInitialCondition(ScalarComponentIC);
// executioners
registerExecutioner(Steady);
registerExecutioner(Transient);
registerExecutioner(InversePowerMethod);
registerExecutioner(NonlinearEigen);
#if defined(LIBMESH_HAVE_PETSC) && !PETSC_VERSION_LESS_THAN(3,4,0)
#if 0 // This seems to be broken right now -- doesn't work wiith petsc >= 3.4 either
registerExecutioner(PetscTSExecutioner);
#endif
#endif
// functions
registerFunction(Axisymmetric2D3DSolutionFunction);
registerFunction(ConstantFunction);
registerFunction(CompositeFunction);
registerNamedFunction(MooseParsedFunction, "ParsedFunction");
registerNamedFunction(MooseParsedGradFunction, "ParsedGradFunction");
registerNamedFunction(MooseParsedVectorFunction, "ParsedVectorFunction");
registerFunction(PiecewiseConstant);
registerFunction(PiecewiseLinear);
registerFunction(SolutionFunction);
registerFunction(PiecewiseBilinear);
registerFunction(SplineFunction);
registerFunction(PiecewiseMultilinear);
registerFunction(LinearCombinationFunction);
// materials
registerMaterial(GenericConstantMaterial);
registerMaterial(GenericFunctionMaterial);
// PPS
registerPostprocessor(AverageElementSize);
registerPostprocessor(AverageNodalVariableValue);
registerPostprocessor(NodalSum);
registerPostprocessor(ElementAverageValue);
registerPostprocessor(ElementAverageTimeDerivative);
registerPostprocessor(ElementW1pError);
registerPostprocessor(ElementH1Error);
registerPostprocessor(ElementH1SemiError);
registerPostprocessor(ElementIntegralVariablePostprocessor);
registerPostprocessor(ElementIntegralMaterialProperty);
registerPostprocessor(ElementL2Error);
registerPostprocessor(ElementVectorL2Error);
registerPostprocessor(ScalarL2Error);
registerPostprocessor(EmptyPostprocessor);
registerPostprocessor(NodalVariableValue);
registerPostprocessor(NumDOFs);
registerPostprocessor(TimestepSize);
registerPostprocessor(RunTime);
registerPostprocessor(PerformanceData);
registerPostprocessor(NumElems);
registerPostprocessor(NumNodes);
registerPostprocessor(NumNonlinearIterations);
registerPostprocessor(NumLinearIterations);
registerPostprocessor(Residual);
registerPostprocessor(ScalarVariable);
registerPostprocessor(NumVars);
registerPostprocessor(NumResidualEvaluations);
registerDeprecatedObjectName(FunctionValuePostprocessor, "PlotFunction", "09/18/2015 12:00");
registerPostprocessor(Receiver);
registerPostprocessor(SideAverageValue);
registerPostprocessor(SideFluxIntegral);
registerPostprocessor(SideFluxAverage);
registerPostprocessor(SideIntegralVariablePostprocessor);
registerPostprocessor(NodalMaxValue);
registerPostprocessor(NodalProxyMaxValue);
registerPostprocessor(ElementalVariableValue);
registerPostprocessor(ElementL2Norm);
registerPostprocessor(NodalL2Norm);
registerPostprocessor(NodalL2Error);
registerPostprocessor(TotalVariableValue);
registerPostprocessor(VolumePostprocessor);
registerPostprocessor(AreaPostprocessor);
registerPostprocessor(PointValue);
registerPostprocessor(NodalExtremeValue);
registerPostprocessor(ElementExtremeValue);
registerPostprocessor(DifferencePostprocessor);
registerPostprocessor(FunctionValuePostprocessor);
registerPostprocessor(NumPicardIterations);
registerPostprocessor(FunctionSideIntegral);
registerPostprocessor(ExecutionerAttributeReporter);
registerPostprocessor(PercentChangePostprocessor);
registerPostprocessor(RealParameterReporter);
// vector PPS
registerVectorPostprocessor(ConstantVectorPostprocessor);
registerVectorPostprocessor(NodalValueSampler);
registerVectorPostprocessor(SideValueSampler);
registerVectorPostprocessor(PointValueSampler);
registerVectorPostprocessor(LineValueSampler);
registerVectorPostprocessor(VectorOfPostprocessors);
registerVectorPostprocessor(LeastSquaresFit);
registerVectorPostprocessor(ElementsAlongLine);
registerVectorPostprocessor(LineMaterialRealSampler);
// user objects
registerUserObject(LayeredIntegral);
registerUserObject(LayeredAverage);
registerUserObject(LayeredSideIntegral);
registerUserObject(LayeredSideAverage);
registerUserObject(LayeredSideFluxAverage);
registerUserObject(NearestPointLayeredAverage);
registerUserObject(ElementIntegralVariableUserObject);
registerUserObject(NodalNormalsPreprocessor);
registerUserObject(NodalNormalsCorner);
registerUserObject(NodalNormalsEvaluator);
registerUserObject(SolutionUserObject);
#ifdef LIBMESH_HAVE_FPARSER
registerUserObject(Terminator);
#endif
// preconditioners
registerNamedPreconditioner(PhysicsBasedPreconditioner, "PBP");
registerNamedPreconditioner(FiniteDifferencePreconditioner, "FDP");
registerNamedPreconditioner(SingleMatrixPreconditioner, "SMP");
#if defined(LIBMESH_HAVE_PETSC) && !PETSC_VERSION_LESS_THAN(3,3,0)
registerNamedPreconditioner(SplitBasedPreconditioner, "SBP");
#endif
// dampers
registerDamper(ConstantDamper);
registerDamper(MaxIncrement);
// DG
registerDGKernel(DGDiffusion);
registerBoundaryCondition(DGFunctionDiffusionDirichletBC);
// Constraints
registerConstraint(TiedValueConstraint);
registerConstraint(CoupledTiedValueConstraint);
registerConstraint(EqualValueConstraint);
registerConstraint(EqualValueBoundaryConstraint);
// Scalar kernels
registerScalarKernel(ODETimeDerivative);
registerScalarKernel(NodalEqualValueConstraint);
registerScalarKernel(ParsedODEKernel);
registerScalarKernel(QuotientScalarAux);
// indicators
registerIndicator(AnalyticalIndicator);
registerIndicator(LaplacianJumpIndicator);
registerIndicator(GradientJumpIndicator);
// markers
registerMarker(ErrorToleranceMarker);
registerMarker(ErrorFractionMarker);
registerMarker(UniformMarker);
registerMarker(BoxMarker);
registerMarker(OrientedBoxMarker);
registerMarker(ComboMarker);
registerMarker(ValueThresholdMarker);
registerMarker(ValueRangeMarker);
// splits
registerSplit(Split);
registerSplit(ContactSplit);
// MultiApps
registerMultiApp(TransientMultiApp);
registerMultiApp(FullSolveMultiApp);
registerMultiApp(AutoPositionsMultiApp);
// time steppers
registerTimeStepper(ConstantDT);
registerTimeStepper(FunctionDT);
registerTimeStepper(IterationAdaptiveDT);
registerTimeStepper(SolutionTimeAdaptiveDT);
registerTimeStepper(DT2);
registerTimeStepper(PostprocessorDT);
registerTimeStepper(AB2PredictorCorrector);
// time integrators
registerTimeIntegrator(SteadyState);
registerTimeIntegrator(ImplicitEuler);
registerTimeIntegrator(BDF2);
registerTimeIntegrator(CrankNicolson);
registerTimeIntegrator(ExplicitEuler);
registerTimeIntegrator(RungeKutta2);
registerDeprecatedObjectName(Dirk, "Dirk", "09/22/2015 12:00");
registerTimeIntegrator(LStableDirk2);
// predictors
registerPredictor(SimplePredictor);
registerPredictor(AdamsPredictor);
// Transfers
#ifdef LIBMESH_HAVE_DTK
registerTransfer(MultiAppDTKUserObjectTransfer);
registerTransfer(MultiAppDTKInterpolationTransfer);
registerTransfer(MoabTransfer);
#endif
registerTransfer(MultiAppPostprocessorInterpolationTransfer);
registerTransfer(MultiAppVariableValueSampleTransfer);
registerTransfer(MultiAppVariableValueSamplePostprocessorTransfer);
registerTransfer(MultiAppMeshFunctionTransfer);
registerTransfer(MultiAppUserObjectTransfer);
registerTransfer(MultiAppNearestNodeTransfer);
registerTransfer(MultiAppCopyTransfer);
registerTransfer(MultiAppInterpolationTransfer);
registerTransfer(MultiAppPostprocessorTransfer);
registerTransfer(MultiAppProjectionTransfer);
registerTransfer(MultiAppPostprocessorToAuxScalarTransfer);
// Outputs
#ifdef LIBMESH_HAVE_EXODUS_API
registerOutput(Exodus);
#endif
#ifdef LIBMESH_HAVE_NEMESIS_API
registerOutput(Nemesis);
#endif
registerOutput(Console);
registerOutput(CSV);
#ifdef LIBMESH_HAVE_VTK
registerNamedOutput(VTKOutput, "VTK");
#endif
registerOutput(Checkpoint);
registerNamedOutput(XDA, "XDR");
registerOutput(XDA);
registerNamedOutput(GMVOutput, "GMV");
registerOutput(Tecplot);
registerOutput(Gnuplot);
registerOutput(SolutionHistory);
registerOutput(MaterialPropertyDebugOutput);
registerOutput(VariableResidualNormsDebugOutput);
registerOutput(TopResidualDebugOutput);
registerNamedOutput(DOFMapOutput, "DOFMap");
// Controls
registerControl(RealFunctionControl);
registered = true;
}
void
MooseTestApp::registerObjects(Factory & factory)
{
// Kernels
registerKernel(ConservativeAdvection);
registerKernel(CoeffParamDiffusion);
registerKernel(CoupledConvection);
registerKernel(ForcingFn);
registerKernel(MatDiffusion);
registerKernel(DiffMKernel);
registerKernel(GaussContForcing);
registerKernel(CoefDiffusion);
registerKernel(RestartDiffusion);
registerKernel(MatCoefDiffusion);
registerKernel(FuncCoefDiffusion);
registerKernel(CoefReaction);
registerKernel(Convection);
registerKernel(PolyDiffusion);
registerKernel(PolyConvection);
registerKernel(PolyForcing);
registerKernel(PolyReaction);
registerKernel(MMSImplicitEuler);
registerKernel(MMSDiffusion);
registerKernel(MMSConvection);
registerKernel(MMSForcing);
registerKernel(MMSReaction);
registerKernel(Diffusion0);
registerKernel(GenericDiffusion);
registerKernel(Advection0);
registerKernel(AdvDiffReaction1);
registerKernel(ForcingFunctionXYZ0);
registerKernel(TEJumpFFN);
registerKernel(NanKernel);
registerKernel(NanAtCountKernel);
registerKernel(ExceptionKernel);
registerKernel(MatConvection);
registerKernel(PPSDiffusion);
registerKernel(DefaultPostprocessorDiffusion);
registerKernel(DotCouplingKernel);
registerKernel(UserObjectKernel);
registerKernel(DiffusionPrecompute);
registerKernel(ConvectionPrecompute);
registerKernel(CoupledKernelGradTest);
registerKernel(CoupledKernelValueTest);
registerKernel(SplineFFn);
registerKernel(BlkResTestDiffusion);
registerKernel(DiffTensorKernel);
registerKernel(ScalarLagrangeMultiplier);
registerKernel(OptionallyCoupledForce);
registerKernel(FDDiffusion);
registerKernel(FDAdvection);
registerKernel(MaterialEigenKernel);
registerKernel(PHarmonic);
registerKernel(PMassEigenKernel);
registerKernel(CoupledEigenKernel);
registerKernel(ConsoleMessageKernel);
registerKernel(WrongJacobianDiffusion);
registerKernel(DefaultMatPropConsumerKernel);
registerKernel(DoNotCopyParametersKernel);
// Aux kernels
registerAux(CoupledAux);
registerAux(CoupledScalarAux);
registerAux(CoupledGradAux);
registerAux(PolyConstantAux);
registerAux(MMSConstantAux);
registerAux(MultipleUpdateAux);
registerAux(MultipleUpdateElemAux);
registerAux(PeriodicDistanceAux);
registerAux(MatPropUserObjectAux);
registerAux(SumNodalValuesAux);
registerAux(UniqueIDAux);
registerAux(RandomAux);
registerAux(PostprocessorAux);
registerAux(FluxAverageAux);
registerAux(OldMaterialAux);
registerAux(DotCouplingAux);
// DG kernels
registerDGKernel(DGMatDiffusion);
registerDGKernel(DGAdvection);
// Interface kernels
registerInterfaceKernel(InterfaceDiffusion);
// Boundary Conditions
registerBoundaryCondition(RobinBC);
registerBoundaryCondition(InflowBC);
registerBoundaryCondition(OutflowBC);
registerBoundaryCondition(MTBC);
registerBoundaryCondition(PolyCoupledDirichletBC);
registerBoundaryCondition(MMSCoupledDirichletBC);
registerBoundaryCondition(DirichletBCfuncXYZ0);
registerBoundaryCondition(TEJumpBC);
registerBoundaryCondition(OnOffDirichletBC);
registerBoundaryCondition(OnOffNeumannBC);
registerBoundaryCondition(ScalarVarBC);
registerBoundaryCondition(BndTestDirichletBC);
registerBoundaryCondition(MatTestNeumannBC);
registerBoundaryCondition(DGMDDBC);
registerBoundaryCondition(DGFunctionConvectionDirichletBC);
registerBoundaryCondition(CoupledKernelGradBC);
registerBoundaryCondition(DivergenceBC);
registerBoundaryCondition(MatDivergenceBC);
registerBoundaryCondition(CoupledDirichletBC);
registerBoundaryCondition(TestLapBC);
// Initial conditions
registerInitialCondition(TEIC);
registerInitialCondition(MTICSum);
registerInitialCondition(MTICMult);
registerInitialCondition(DataStructIC);
// Materials
registerMaterial(MTMaterial);
registerMaterial(TypesMaterial);
registerMaterial(StatefulMaterial);
registerMaterial(SpatialStatefulMaterial);
registerMaterial(ComputingInitialTest);
registerMaterial(StatefulTest);
registerMaterial(StatefulSpatialTest);
registerMaterial(CoupledMaterial);
registerMaterial(CoupledMaterial2);
registerMaterial(LinearInterpolationMaterial);
registerMaterial(VarCouplingMaterial);
registerMaterial(VarCouplingMaterialEigen);
registerMaterial(BadStatefulMaterial);
registerMaterial(OutputTestMaterial);
registerMaterial(SumMaterial);
registerMaterial(VecRangeCheckMaterial);
registerMaterial(DerivativeMaterialInterfaceTestProvider);
registerMaterial(DerivativeMaterialInterfaceTestClient);
registerMaterial(DefaultMatPropConsumerMaterial);
registerMaterial(RandomMaterial);
registerMaterial(RecomputeMaterial);
registerMaterial(NewtonMaterial);
registerScalarKernel(ExplicitODE);
registerScalarKernel(ImplicitODEx);
registerScalarKernel(ImplicitODEy);
registerScalarKernel(AlphaCED);
registerScalarKernel(PostprocessorCED);
// Functions
registerFunction(TimestepSetupFunction);
registerFunction(PostprocessorFunction);
registerFunction(MTPiecewiseConst1D);
registerFunction(MTPiecewiseConst2D);
registerFunction(MTPiecewiseConst3D);
registerFunction(TestSetupPostprocessorDataActionFunction);
// DiracKernels
registerDiracKernel(ReportingConstantSource);
registerDiracKernel(FrontSource);
registerDiracKernel(MaterialPointSource);
registerDiracKernel(MaterialMultiPointSource);
registerDiracKernel(StatefulPointSource);
registerDiracKernel(CachingPointSource);
registerDiracKernel(BadCachingPointSource);
registerDiracKernel(NonlinearSource);
// meshes
registerObject(StripeMesh);
registerConstraint(EqualValueNodalConstraint);
// UserObjects
registerUserObject(MTUserObject);
registerUserObject(RandomHitUserObject);
registerUserObject(RandomHitSolutionModifier);
registerUserObject(MaterialPropertyUserObject);
registerUserObject(MaterialCopyUserObject);
registerUserObject(InsideUserObject);
registerUserObject(RestartableTypes);
registerUserObject(RestartableTypesChecker);
registerUserObject(PointerStoreError);
registerUserObject(PointerLoadError);
registerUserObject(VerifyElementUniqueID);
registerUserObject(VerifyNodalUniqueID);
registerUserObject(RandomElementalUserObject);
registerUserObject(TrackDiracFront);
registerUserObject(BoundaryUserObject);
registerUserObject(TestBoundaryRestrictableAssert);
registerUserObject(GetMaterialPropertyBoundaryBlockNamesTest);
registerUserObject(GeneralSetupInterfaceCount);
registerUserObject(ElementSetupInterfaceCount);
registerUserObject(SideSetupInterfaceCount);
registerUserObject(InternalSideSetupInterfaceCount);
registerUserObject(NodalSetupInterfaceCount);
registerUserObject(ReadDoubleIndex);
registerPostprocessor(InsideValuePPS);
registerPostprocessor(TestCopyInitialSolution);
registerPostprocessor(TestSerializedSolution);
registerPostprocessor(BoundaryValuePPS);
registerPostprocessor(NumInternalSides);
registerPostprocessor(NumElemQPs);
registerPostprocessor(NumSideQPs);
registerPostprocessor(ElementL2Diff);
registerPostprocessor(TestPostprocessor);
registerPostprocessor(ElementSidePP);
registerPostprocessor(RealControlParameterReporter);
registerMarker(RandomHitMarker);
registerMarker(QPointMarker);
registerMarker(CircleMarker);
registerExecutioner(TestSteady);
registerExecutioner(AdaptAndModify);
registerProblem(MooseTestProblem);
registerProblem(FailingProblem);
// Outputs
registerOutput(OutputObjectTest);
// Controls
registerControl(TestControl);
}
void
NavierStokesApp::registerObjects(Factory & factory)
{
registerKernel(NSMassInviscidFlux);
registerKernel(NSMomentumInviscidFlux);
registerKernel(NSEnergyInviscidFlux);
registerKernel(NSGravityPower);
registerKernel(NSGravityForce);
registerKernel(NSTemperatureL2);
registerBoundaryCondition(NSThermalBC);
registerAux(NSVelocityAux);
registerAux(NSMachAux);
registerAux(NSInternalEnergyAux);
registerAux(NSSpecificVolumeAux);
registerBoundaryCondition(NSImposedVelocityBC);
registerAux(NSTemperatureAux);
registerAux(NSPressureAux);
registerAux(NSEnthalpyAux);
registerKernel(NSEnergyThermalFlux);
registerKernel(NSMomentumViscousFlux);
registerKernel(NSEnergyViscousFlux);
registerKernel(NSMomentumInviscidFluxWithGradP);
registerKernel(NSSUPGMomentum);
registerKernel(NSSUPGMass);
registerKernel(NSSUPGEnergy);
registerBoundaryCondition(NSMassSpecifiedNormalFlowBC);
registerBoundaryCondition(NSMassUnspecifiedNormalFlowBC);
registerBoundaryCondition(NSInflowThermalBC);
registerBoundaryCondition(NSMomentumInviscidSpecifiedPressureBC);
registerBoundaryCondition(NSMomentumInviscidSpecifiedNormalFlowBC);
registerBoundaryCondition(NSMomentumViscousBC);
registerBoundaryCondition(NSEnergyInviscidSpecifiedPressureBC);
registerBoundaryCondition(NSEnergyInviscidSpecifiedNormalFlowBC);
registerBoundaryCondition(NSEnergyInviscidUnspecifiedBC);
registerBoundaryCondition(NSEnergyInviscidSpecifiedBC);
registerBoundaryCondition(NSEnergyInviscidSpecifiedDensityAndVelocityBC);
registerBoundaryCondition(NSEnergyViscousBC);
registerBoundaryCondition(NSStagnationPressureBC);
registerBoundaryCondition(NSStagnationTemperatureBC);
registerBoundaryCondition(NSImposedVelocityDirectionBC);
registerBoundaryCondition(NSMassWeakStagnationBC);
registerBoundaryCondition(NSMomentumConvectiveWeakStagnationBC);
registerBoundaryCondition(NSMomentumPressureWeakStagnationBC);
registerBoundaryCondition(NSEnergyWeakStagnationBC);
registerBoundaryCondition(NSPenalizedNormalFlowBC);
registerBoundaryCondition(NSMomentumInviscidNoPressureImplicitFlowBC);
registerBoundaryCondition(NSPressureNeumannBC);
registerPostprocessor(NSEntropyError);
registerInitialCondition(NSInitialCondition);
// Boundary condition meta-objects
registerObject(NSWeakStagnationInletBC);
registerObject(NSNoPenetrationBC);
registerObject(NSStaticPressureOutletBC);
//
// Incompressible
//
// Kernels
registerKernel(INSMass);
registerKernel(INSMassRZ);
registerKernel(INSMomentumTimeDerivative);
registerKernel(INSMomentumTractionForm);
registerKernel(INSMomentumTractionFormRZ);
registerKernel(INSMomentumLaplaceForm);
registerKernel(INSMomentumLaplaceFormRZ);
registerKernel(INSTemperatureTimeDerivative);
registerKernel(INSTemperature);
registerKernel(INSSplitMomentum);
registerKernel(INSProjection);
registerKernel(INSPressurePoisson);
registerKernel(INSChorinPredictor);
registerKernel(INSChorinCorrector);
registerKernel(INSChorinPressurePoisson);
registerKernel(INSCompressibilityPenalty);
// BCs
registerBoundaryCondition(INSMomentumNoBCBCTractionForm);
registerBoundaryCondition(INSMomentumNoBCBCLaplaceForm);
registerBoundaryCondition(INSTemperatureNoBCBC);
registerBoundaryCondition(ImplicitNeumannBC);
// AuxKernels
registerAux(INSCourant);
registerAux(INSDivergenceAux);
// Postprocessors
registerPostprocessor(INSExplicitTimestepSelector);
// Materials
registerMaterial(Air);
// Functions
registerFunction(WedgeFunction);
// CNSFV
registerInitialCondition(CNSFVMachIC);
registerInitialCondition(CNSFVPressureIC);
registerUserObject(CNSFVNoSlopeReconstruction);
registerUserObject(CNSFVGreenGaussSlopeReconstruction);
registerUserObject(CNSFVLeastSquaresSlopeReconstruction);
registerUserObject(CNSFVSlopeReconstructionOneD);
registerUserObject(CNSFVNoSlopeLimiting);
registerUserObject(CNSFVMinmaxSlopeLimiting);
registerUserObject(CNSFVWENOSlopeLimiting);
registerUserObject(CNSFVSlopeLimitingOneD);
registerUserObject(CNSFVHLLCInternalSideFlux);
registerUserObject(CNSFVFreeInflowBoundaryFlux);
registerUserObject(CNSFVFreeOutflowBoundaryFlux);
registerUserObject(CNSFVRiemannInvariantBoundaryFlux);
registerUserObject(CNSFVHLLCInflowOutflowBoundaryFlux);
registerUserObject(CNSFVHLLCSlipBoundaryFlux);
registerUserObject(CNSFVFreeInflowBCUserObject);
registerUserObject(CNSFVFreeOutflowBCUserObject);
registerUserObject(CNSFVCharacteristicBCUserObject);
registerUserObject(CNSFVRiemannInvariantBCUserObject);
registerUserObject(CNSFVSlipBCUserObject);
registerBoundaryCondition(CNSFVBC);
registerKernel(CNSFVKernel);
registerMaterial(CNSFVMaterial);
registerAux(CNSFVEntropyProductionAux);
registerAux(CNSFVMachAux);
registerAux(CNSFVPressureAux);
registerAux(CNSFVSpecificTotalEnthalpyAux);
registerPostprocessor(CNSFVIdealGasEntropyL2Error);
registerPostprocessor(CNSFVIdealGasTotalEnthalpyL2Error);
registerPostprocessor(CNSFVTimeStepLimit);
}
void
TensorMechanicsApp::registerObjects(Factory & factory)
{
registerKernel(StressDivergenceTensors);
registerKernel(StressDivergenceTensorsTruss);
registerKernel(CosseratStressDivergenceTensors);
registerKernel(StressDivergenceRZTensors);
registerKernel(StressDivergenceRSphericalTensors);
registerKernel(MomentBalancing);
registerKernel(StressDivergencePFFracTensors);
registerKernel(PoroMechanicsCoupling);
registerKernel(InertialForce);
registerKernel(Gravity);
registerKernel(DynamicStressDivergenceTensors);
registerKernel(OutOfPlanePressure);
registerMaterial(LinearElasticMaterial);
registerMaterial(LinearElasticTruss);
registerMaterial(FiniteStrainPlasticMaterial);
registerMaterial(FiniteStrainRatePlasticMaterial);
registerMaterial(FiniteStrainCrystalPlasticity);
registerMaterial(FiniteStrainCPSlipRateRes);
registerMaterial(FiniteStrainUObasedCP);
registerMaterial(ComputeMultiPlasticityStress);
registerMaterial(ComputeCosseratLinearElasticStress);
registerMaterial(ComputeCosseratSmallStrain);
registerMaterial(ComputeCosseratElasticityTensor);
registerMaterial(ComputeLayeredCosseratElasticityTensor);
registerMaterial(TwoPhaseStressMaterial);
registerMaterial(MultiPhaseStressMaterial);
registerMaterial(SimpleEigenStrainMaterial);
registerMaterial(CompositeEigenstrain);
registerMaterial(CompositeElasticityTensor);
registerMaterial(ComputeElasticityTensor);
registerMaterial(ComputeElasticityTensorCP);
registerMaterial(ComputeIsotropicElasticityTensor);
registerMaterial(ComputeSmallStrain);
registerMaterial(ComputePlaneSmallStrain);
registerMaterial(ComputePlaneFiniteStrain);
registerMaterial(ComputeAxisymmetricRZSmallStrain);
registerMaterial(ComputeRSphericalSmallStrain);
registerMaterial(ComputeIncrementalSmallStrain);
registerMaterial(ComputeAxisymmetricRZIncrementalStrain);
registerMaterial(ComputeRSphericalIncrementalStrain);
registerMaterial(ComputeFiniteStrain);
registerMaterial(ComputeAxisymmetricRZFiniteStrain);
registerMaterial(ComputeRSphericalFiniteStrain);
registerMaterial(ComputeLinearElasticStress);
registerMaterial(ComputeFiniteStrainElasticStress);
registerMaterial(ComputeEigenstrain);
registerMaterial(ComputeVariableBaseEigenStrain);
registerMaterial(ComputeVariableEigenstrain);
registerMaterial(ComputeThermalExpansionEigenStrain);
registerMaterial(ComputeConcentrationDependentElasticityTensor);
registerMaterial(FiniteStrainHyperElasticViscoPlastic);
registerMaterial(LinearIsoElasticPFDamage);
registerMaterial(HyperElasticPhaseFieldIsoDamage);
registerMaterial(ComputeVolumetricDeformGrad);
registerMaterial(ComputeDeformGradBasedStress);
registerMaterial(VolumeDeformGradCorrectedStress);
registerMaterial(ComputeReturnMappingStress);
registerMaterial(RecomputeRadialReturn);
registerMaterial(RecomputeRadialReturnIsotropicPlasticity);
registerMaterial(RecomputeRadialReturnPowerLawCreep);
registerMaterial(RecomputeRadialReturnTempDepHardening);
registerMaterial(StressBasedChemicalPotential);
registerMaterial(FluxBasedStrainIncrement);
registerMaterial(GBRelaxationStrainIncrement);
registerMaterial(SumTensorIncrements);
registerMaterial(ComputeStrainIncrementBasedStress);
registerMaterial(ComputeElasticSmearedCrackingStress);
registerUserObject(TensorMechanicsPlasticSimpleTester);
registerUserObject(TensorMechanicsPlasticTensile);
registerUserObject(TensorMechanicsPlasticTensileMulti);
registerUserObject(TensorMechanicsPlasticMohrCoulomb);
registerUserObject(TensorMechanicsPlasticMohrCoulombMulti);
registerUserObject(TensorMechanicsPlasticWeakPlaneTensile);
registerUserObject(TensorMechanicsPlasticWeakPlaneTensileN);
registerUserObject(TensorMechanicsPlasticWeakPlaneShear);
registerUserObject(TensorMechanicsPlasticJ2);
registerUserObject(TensorMechanicsPlasticMeanCap);
registerUserObject(TensorMechanicsPlasticDruckerPragerHyperbolic);
registerUserObject(TensorMechanicsHardeningConstant);
registerUserObject(TensorMechanicsHardeningGaussian);
registerUserObject(TensorMechanicsHardeningExponential);
registerUserObject(TensorMechanicsHardeningCutExponential);
registerUserObject(TensorMechanicsHardeningCubic);
registerUserObject(ElementPropertyReadFile);
registerUserObject(EulerAngleFileReader);
registerUserObject(HEVPLinearHardening);
registerUserObject(HEVPRambergOsgoodHardening);
registerUserObject(HEVPEqvPlasticStrain);
registerUserObject(HEVPEqvPlasticStrainRate);
registerUserObject(HEVPFlowRatePowerLawJ2);
registerUserObject(CavityPressureUserObject);
registerUserObject(CrystalPlasticitySlipRateGSS);
registerUserObject(CrystalPlasticitySlipResistanceGSS);
registerUserObject(CrystalPlasticityStateVariable);
registerUserObject(CrystalPlasticityStateVarRateComponentGSS);
registerAux(CylindricalRankTwoAux);
registerAux(RankTwoAux);
registerAux(RankFourAux);
registerAux(ElasticEnergyAux);
registerAux(AccumulateAux);
registerAux(CrystalPlasticityRotationOutAux);
registerAux(RankTwoScalarAux);
registerAux(NewmarkAccelAux);
registerAux(NewmarkVelAux);
registerBoundaryCondition(DashpotBC);
registerBoundaryCondition(PresetVelocity);
registerBoundaryCondition(Pressure);
registerBoundaryCondition(DisplacementAboutAxis);
registerPostprocessor(CavityPressurePostprocessor);
registerPostprocessor(Mass);
registerPostprocessor(TorqueReaction);
registerPostprocessor(MaterialTensorIntegral);
registerVectorPostprocessor(LineMaterialRankTwoSampler);
registerVectorPostprocessor(LineMaterialRankTwoScalarSampler);
}
void
MooseTestApp::registerObjects(Factory & factory)
{
// Kernels
registerKernel(CoupledConvection);
registerKernel(ForcingFn);
registerKernel(MatDiffusion);
registerKernel(DiffMKernel);
registerKernel(GaussContForcing);
registerKernel(CoefDiffusion);
registerKernel(RestartDiffusion);
registerKernel(MatCoefDiffusion);
registerKernel(FuncCoefDiffusion);
registerKernel(CoefReaction);
registerKernel(Convection);
registerKernel(PolyDiffusion);
registerKernel(PolyConvection);
registerKernel(PolyForcing);
registerKernel(PolyReaction);
registerKernel(MMSImplicitEuler);
registerKernel(MMSDiffusion);
registerKernel(MMSConvection);
registerKernel(MMSForcing);
registerKernel(MMSReaction);
registerKernel(Diffusion0);
registerKernel(GenericDiffusion);
registerKernel(Advection0);
registerKernel(AdvDiffReaction1);
registerKernel(ForcingFunctionXYZ0);
registerKernel(TEJumpFFN);
registerKernel(NanKernel);
registerKernel(ExceptionKernel);
registerKernel(MatConvection);
registerKernel(PPSDiffusion);
registerKernel(DefaultPostprocessorDiffusion);
registerKernel(DotCouplingKernel);
registerKernel(UserObjectKernel);
registerKernel(DiffusionPrecompute);
registerKernel(ConvectionPrecompute);
registerKernel(CoupledKernelGradTest);
registerKernel(CoupledKernelValueTest);
registerKernel(SplineFFn);
registerKernel(BlkResTestDiffusion);
registerKernel(DiffTensorKernel);
registerKernel(ScalarLagrangeMultiplier);
registerKernel(OptionallyCoupledForce);
registerKernel(FDDiffusion);
registerKernel(FDAdvection);
registerKernel(MaterialEigenKernel);
registerKernel(PHarmonic);
registerKernel(PMassEigenKernel);
registerKernel(CoupledEigenKernel);
// Aux kernels
registerAux(CoupledAux);
registerAux(CoupledGradAux);
registerAux(PolyConstantAux);
registerAux(MMSConstantAux);
registerAux(MultipleUpdateAux);
registerAux(MultipleUpdateElemAux);
registerAux(PeriodicDistanceAux);
registerAux(MatPropUserObjectAux);
registerAux(SumNodalValuesAux);
registerAux(UniqueIDAux);
registerAux(RandomAux);
registerAux(PostprocessorAux);
// DG kernels
registerDGKernel(DGMatDiffusion);
// Boundary Conditions
registerBoundaryCondition(MTBC);
registerBoundaryCondition(PolyCoupledDirichletBC);
registerBoundaryCondition(MMSCoupledDirichletBC);
registerBoundaryCondition(DirichletBCfuncXYZ0);
registerBoundaryCondition(DirichletBCfuncXYZ1);
registerBoundaryCondition(TEJumpBC);
registerBoundaryCondition(OnOffDirichletBC);
registerBoundaryCondition(OnOffNeumannBC);
registerBoundaryCondition(ScalarVarBC);
registerBoundaryCondition(BndTestDirichletBC);
registerBoundaryCondition(MatTestNeumannBC);
registerBoundaryCondition(DGMDDBC);
registerBoundaryCondition(DGFunctionConvectionDirichletBC);
registerBoundaryCondition(PenaltyDirichletBC);
registerBoundaryCondition(FunctionPenaltyDirichletBC);
registerBoundaryCondition(CoupledKernelGradBC);
registerBoundaryCondition(DivergenceBC);
// Initial conditions
registerInitialCondition(TEIC);
registerInitialCondition(MTICSum);
registerInitialCondition(MTICMult);
// Materials
registerMaterial(MTMaterial);
registerMaterial(Diff1Material);
registerMaterial(Diff2Material);
registerMaterial(StatefulMaterial);
registerMaterial(SpatialStatefulMaterial);
registerMaterial(ComputingInitialTest);
registerMaterial(StatefulTest);
registerMaterial(StatefulSpatialTest);
registerMaterial(CoupledMaterial);
registerMaterial(CoupledMaterial2);
registerMaterial(LinearInterpolationMaterial);
registerMaterial(VarCouplingMaterial);
registerMaterial(VarCouplingMaterialEigen);
registerMaterial(BadStatefulMaterial);
registerMaterial(OutputTestMaterial);
registerScalarKernel(ExplicitODE);
registerScalarKernel(ImplicitODEx);
registerScalarKernel(ImplicitODEy);
registerScalarKernel(AlphaCED);
registerScalarKernel(PostprocessorCED);
// Functions
registerFunction(TimestepSetupFunction);
registerFunction(PostprocessorFunction);
registerFunction(MTPiecewiseConst1D);
registerFunction(MTPiecewiseConst2D);
registerFunction(MTPiecewiseConst3D);
registerFunction(TestSetupPostprocessorDataActionFunction);
// DiracKernels
registerDiracKernel(ReportingConstantSource);
registerDiracKernel(FrontSource);
registerDiracKernel(MaterialPointSource);
registerDiracKernel(StatefulPointSource);
// meshes
registerObject(StripeMesh);
registerConstraint(EqualValueNodalConstraint);
// UserObjects
registerUserObject(MTUserObject);
registerUserObject(RandomHitUserObject);
registerUserObject(RandomHitSolutionModifier);
registerUserObject(MaterialPropertyUserObject);
registerUserObject(InsideUserObject);
registerUserObject(RestartableTypes);
registerUserObject(RestartableTypesChecker);
registerUserObject(PointerStoreError);
registerUserObject(PointerLoadError);
registerUserObject(VerifyElementUniqueID);
registerUserObject(VerifyNodalUniqueID);
registerUserObject(RandomElementalUserObject);
registerUserObject(TrackDiracFront);
registerUserObject(BoundaryUserObject);
registerUserObject(TestBoundaryRestrictableAssert);
registerPostprocessor(InsideValuePPS);
registerPostprocessor(TestCopyInitialSolution);
registerPostprocessor(BoundaryValuePPS);
registerPostprocessor(NumInternalSides);
registerPostprocessor(ElementL2Diff);
registerMarker(RandomHitMarker);
registerExecutioner(ExceptionSteady);
registerExecutioner(SteadyTransientExecutioner);
registerExecutioner(AdaptAndModify);
registerProblem(MooseTestProblem);
registerProblem(FailingProblem);
// Outputs
registerOutput(OutputObjectTest);
}
void
PhaseFieldApp::registerObjects(Factory & factory)
{
registerKernel(ACGBPoly);
registerKernel(ACGrGrElasticDrivingForce);
registerKernel(ACGrGrPoly);
registerKernel(ACInterface);
registerKernel(ACMultiInterface);
registerKernel(ACInterfaceKobayashi1);
registerKernel(ACInterfaceKobayashi2);
registerKernel(AllenCahn);
registerKernel(CahnHilliard);
registerKernel(CahnHilliardAniso);
registerKernel(CHBulkPFCTrad);
registerKernel(CHCpldPFCTrad);
registerKernel(CHInterface);
registerKernel(CHInterfaceAniso);
registerKernel(CHMath);
registerKernel(CHPFCRFF);
registerKernel(CHSplitChemicalPotential);
registerKernel(CHSplitConcentration);
registerKernel(CHSplitFlux);
registerKernel(CHSplitVar);
registerKernel(CoefCoupledTimeDerivative);
registerKernel(ConservedLangevinNoise);
registerKernel(CoupledAllenCahn);
registerKernel(CoupledSusceptibilityTimeDerivative);
registerKernel(GradientComponent);
registerKernel(HHPFCRFF);
registerKernel(KKSACBulkC);
registerKernel(KKSACBulkF);
registerKernel(KKSCHBulk);
registerKernel(KKSPhaseChemicalPotential);
registerKernel(KKSPhaseConcentration);
registerKernel(KKSSplitCHCRes);
registerKernel(LangevinNoise);
registerKernel(MaskedBodyForce);
registerKernel(MatAnisoDiffusion);
registerKernel(MatDiffusion);
registerKernel(MatReaction);
registerKernel(MultiGrainRigidBodyMotion);
registerKernel(PFFracBulkRate);
registerKernel(PFFracCoupledInterface);
registerKernel(PFFracIntVar);
registerKernel(SingleGrainRigidBodyMotion);
registerKernel(SoretDiffusion);
registerKernel(SplitCHMath);
registerKernel(SplitCHParsed);
registerKernel(SplitCHWRes);
registerKernel(SplitCHWResAniso);
registerKernel(SusceptibilityTimeDerivative);
registerKernel(SwitchingFunctionConstraintEta);
registerKernel(SwitchingFunctionConstraintLagrange);
registerKernel(SwitchingFunctionPenalty);
registerDeprecatedObjectName(AllenCahn, "ACParsed", "15/04/2016 00:00");
registerDeprecatedObjectName(CahnHilliard, "CHParsed", "11/01/2015 00:00");
registerInitialCondition(BimodalSuperellipsoidsIC);
registerInitialCondition(ClosePackIC);
registerInitialCondition(CrossIC);
registerInitialCondition(HexPolycrystalIC);
registerInitialCondition(LatticeSmoothCircleIC);
registerInitialCondition(MultiBoundingBoxIC);
registerInitialCondition(MultiSmoothCircleIC);
registerInitialCondition(PFCFreezingIC);
registerInitialCondition(PolycrystalRandomIC);
registerInitialCondition(PolycrystalReducedIC);
registerInitialCondition(RampIC);
registerInitialCondition(ReconPhaseVarIC);
registerInitialCondition(ReconVarIC);
registerInitialCondition(RndBoundingBoxIC);
registerInitialCondition(RndSmoothCircleIC);
registerInitialCondition(SmoothCircleIC);
registerInitialCondition(SmoothSuperellipsoidIC);
registerInitialCondition(SpecifiedSmoothCircleIC);
registerInitialCondition(SpecifiedSmoothSuperellipsoidIC);
registerInitialCondition(ThumbIC);
registerInitialCondition(Tricrystal2CircleGrainsIC);
registerBoundaryCondition(CahnHilliardAnisoFluxBC);
registerBoundaryCondition(CahnHilliardFluxBC);
registerMaterial(AsymmetricCrossTermBarrierFunctionMaterial);
registerMaterial(BarrierFunctionMaterial);
registerMaterial(CompositeMobilityTensor);
registerMaterial(ComputePolycrystalElasticityTensor);
registerMaterial(ConstantAnisotropicMobility);
registerMaterial(CrossTermBarrierFunctionMaterial);
registerMaterial(DerivativeMultiPhaseMaterial);
registerMaterial(DerivativeParsedMaterial);
registerMaterial(DerivativeSumMaterial);
registerMaterial(DerivativeTwoPhaseMaterial);
registerMaterial(DiscreteNucleation);
registerMaterial(ElasticEnergyMaterial);
registerMaterial(ExternalForceDensityMaterial);
registerMaterial(ForceDensityMaterial);
registerMaterial(GBAnisotropy);
registerMaterial(GBEvolution);
registerMaterial(GBDependentAnisotropicTensor);
registerMaterial(GBDependentDiffusivity);
registerMaterial(GrainAdvectionVelocity);
registerMaterial(InterfaceOrientationMaterial);
registerMaterial(KKSXeVacSolidMaterial);
registerMaterial(MathEBFreeEnergy);
registerMaterial(MathFreeEnergy);
registerMaterial(MultiBarrierFunctionMaterial);
registerMaterial(ParsedMaterial);
registerMaterial(PFCRFFMaterial);
registerMaterial(PFCTradMaterial);
registerMaterial(PFFracBulkRateMaterial);
registerMaterial(PFParamsPolyFreeEnergy);
registerMaterial(PhaseNormalTensor);
registerMaterial(PolynomialFreeEnergy);
registerMaterial(RegularSolutionFreeEnergy);
registerMaterial(StrainGradDispDerivatives);
registerMaterial(SwitchingFunction3PhaseMaterial);
registerMaterial(SwitchingFunctionMaterial);
registerMaterial(ThirdPhaseSuppressionMaterial);
registerPostprocessor(FeatureFloodCount);
registerPostprocessor(GrainTracker);
registerPostprocessor(FauxGrainTracker);
registerPostprocessor(NodalVolumeFraction);
registerPostprocessor(PFCElementEnergyIntegral);
registerAux(BndsCalcAux);
registerAux(CrossTermGradientFreeEnergy);
registerAux(Euler2RGBAux);
registerAux(FeatureFloodCountAux);
registerAux(KKSGlobalFreeEnergy);
registerAux(PFCEnergyDensity);
registerAux(PFCRFFEnergyDensity);
registerAux(EBSDReaderAvgDataAux);
registerAux(EBSDReaderPointDataAux);
registerAux(TotalFreeEnergy);
registerAux(OutputEulerAngles);
registerUserObject(ComputeGrainCenterUserObject);
registerUserObject(ComputeGrainForceAndTorque);
registerUserObject(ConservedMaskedNormalNoise);
registerUserObject(ConservedMaskedUniformNoise);
registerUserObject(ConservedNormalNoise);
registerUserObject(ConservedUniformNoise);
registerUserObject(ConstantGrainForceAndTorque);
registerUserObject(DiscreteNucleationInserter);
registerUserObject(DiscreteNucleationMap);
registerUserObject(GrainForceAndTorqueSum);
registerUserObject(MaskedGrainForceAndTorque);
registerUserObject(EBSDReader);
registerUserObject(SolutionRasterizer);
registerVectorPostprocessor(GrainCentersPostprocessor);
registerVectorPostprocessor(GrainForcesPostprocessor);
registerVectorPostprocessor(GrainTextureVectorPostprocessor);
registerMesh(EBSDMesh);
registerMesh(MortarPeriodicMesh);
}
void
RichardsApp::registerObjects(Factory & factory)
{
// UserObjects
registerUserObject(RichardsPorepressureNames);
registerUserObject(RichardsDensityConstBulk);
registerUserObject(RichardsDensityIdeal);
registerUserObject(RichardsDensityMethane20degC);
registerUserObject(RichardsRelPermMonomial);
registerUserObject(RichardsRelPermPower);
registerUserObject(RichardsRelPermVG);
registerUserObject(RichardsRelPermVG1);
registerUserObject(RichardsRelPermBW);
registerUserObject(RichardsRelPermPowerGas);
registerUserObject(RichardsSeff1VG);
registerUserObject(RichardsSeff1VGcut);
registerUserObject(RichardsSeff1BWsmall);
registerUserObject(RichardsSeff1RSC);
registerUserObject(RichardsSeff2waterVG);
registerUserObject(RichardsSeff2gasVG);
registerUserObject(RichardsSeff2waterRSC);
registerUserObject(RichardsSeff2gasRSC);
registerUserObject(RichardsSat);
registerUserObject(RichardsSUPGnone);
registerUserObject(RichardsSUPGstandard);
registerUserObject(RichardsSumQuantity);
// AuxKernels
registerAux(RichardsSeffAux);
registerAux(RichardsSeffPrimeAux);
registerAux(RichardsSeffPrimePrimeAux);
registerAux(RichardsDensityAux);
registerAux(RichardsDensityPrimeAux);
registerAux(RichardsDensityPrimePrimeAux);
registerAux(RichardsRelPermAux);
registerAux(RichardsRelPermPrimeAux);
registerAux(RichardsRelPermPrimePrimeAux);
registerAux(FunctionOfVariableAux);
// Materials
registerMaterial(RichardsMaterial);
// DiracKernels
registerDiracKernel(RichardsPolyLineSink);
registerDiracKernel(RichardsBorehole);
// Functions
registerFunction(RichardsExcavGeom);
registerFunction(GradParsedFunction);
registerFunction(Grad2ParsedFunction);
// Indicators
registerIndicator(RichardsFluxJumpIndicator);
// Markers
registerMarker(OrientedBoxMarkerDepr);
// Postprocessors
registerPostprocessor(RichardsMass);
registerPostprocessor(RichardsPiecewiseLinearSinkFlux);
registerPostprocessor(RichardsHalfGaussianSinkFlux);
registerPostprocessor(NodalMaxVarChange);
registerPostprocessor(RichardsExcavFlow);
registerPostprocessor(RichardsPlotQuantity);
// TimeSteppers
registerTimeStepper(FunctionControlledDT);
// Kernels
registerKernel(RichardsMassChange);
registerKernel(RichardsFlux);
registerKernel(RichardsPPenalty);
// BoundaryConditions
registerBoundaryCondition(RichardsExcav);
registerBoundaryCondition(RichardsPiecewiseLinearSink);
registerBoundaryCondition(RichardsHalfGaussianSink);
}
void
RichardsApp::registerObjects(Factory & factory)
{
// UserObjects
registerUserObject(RichardsVarNames);
registerUserObject(RichardsDensityConstBulk);
registerUserObject(RichardsDensityConstBulkCut);
registerUserObject(RichardsDensityIdeal);
registerUserObject(RichardsDensityMethane20degC);
registerUserObject(RichardsDensityVDW);
registerUserObject(RichardsRelPermMonomial);
registerUserObject(RichardsRelPermPower);
registerUserObject(RichardsRelPermVG);
registerUserObject(RichardsRelPermVG1);
registerUserObject(RichardsRelPermBW);
registerUserObject(RichardsRelPermPowerGas);
registerUserObject(Q2PRelPermPowerGas);
registerUserObject(RichardsSeff1VG);
registerUserObject(RichardsSeff1VGcut);
registerUserObject(RichardsSeff1BWsmall);
registerUserObject(RichardsSeff1RSC);
registerUserObject(RichardsSeff2waterVG);
registerUserObject(RichardsSeff2gasVG);
registerUserObject(RichardsSeff2waterVGshifted);
registerUserObject(RichardsSeff2gasVGshifted);
registerUserObject(RichardsSeff2waterRSC);
registerUserObject(RichardsSeff2gasRSC);
registerUserObject(RichardsSat);
registerUserObject(RichardsSUPGnone);
registerUserObject(RichardsSUPGstandard);
registerUserObject(RichardsSumQuantity);
// AuxKernels
registerAux(RichardsSatAux);
registerAux(RichardsSatPrimeAux);
registerAux(RichardsSeffAux);
registerAux(RichardsSeffPrimeAux);
registerAux(RichardsSeffPrimePrimeAux);
registerAux(RichardsDensityAux);
registerAux(RichardsDensityPrimeAux);
registerAux(RichardsDensityPrimePrimeAux);
registerAux(RichardsRelPermAux);
registerAux(RichardsRelPermPrimeAux);
registerAux(RichardsRelPermPrimePrimeAux);
registerAux(DarcyFluxComponent);
// Materials
registerMaterial(RichardsMaterial);
registerMaterial(PoroFullSatMaterial); // Used for mechanical coupling
registerMaterial(DarcyMaterial);
registerMaterial(Q2PMaterial);
// DiracKernels
registerDiracKernel(RichardsPolyLineSink);
registerDiracKernel(RichardsBorehole);
registerDiracKernel(Q2PBorehole);
// Functions
registerFunction(RichardsExcavGeom);
registerFunction(GradParsedFunction);
registerFunction(Grad2ParsedFunction);
// Postprocessors
registerPostprocessor(RichardsMass);
registerPostprocessor(RichardsPiecewiseLinearSinkFlux);
registerPostprocessor(RichardsHalfGaussianSinkFlux);
registerPostprocessor(NodalMaxVarChange);
registerPostprocessor(RichardsExcavFlow);
registerPostprocessor(RichardsPlotQuantity);
registerPostprocessor(Q2PPiecewiseLinearSinkFlux);
// Kernels
registerKernel(RichardsMassChange);
registerKernel(RichardsLumpedMassChange);
registerKernel(RichardsFlux);
registerKernel(RichardsFullyUpwindFlux);
registerKernel(RichardsPPenalty);
registerKernel(PoroFullSatTimeDerivative); // Used for mechanical coupling
registerKernel(DarcyFlux);
registerKernel(Q2PPorepressureFlux);
registerKernel(Q2PSaturationFlux);
registerKernel(Q2PSaturationDiffusion);
registerKernel(Q2PNodalMass);
registerKernel(Q2PNegativeNodalMassOld);
// BoundaryConditions
registerBoundaryCondition(RichardsExcav);
registerBoundaryCondition(RichardsPiecewiseLinearSink);
registerBoundaryCondition(RichardsHalfGaussianSink);
registerBoundaryCondition(Q2PPiecewiseLinearSink);
// Problems
registerProblem(RichardsMultiphaseProblem);
}
void
TensorMechanicsApp::registerObjects(Factory & factory)
{
registerKernel(StressDivergenceTensors);
registerKernel(CosseratStressDivergenceTensors);
registerKernel(StressDivergenceRZTensors);
registerKernel(MomentBalancing);
registerKernel(StressDivergencePFFracTensors);
registerKernel(PoroMechanicsCoupling);
registerKernel(InertialForce);
registerKernel(Gravity);
registerMaterial(LinearElasticMaterial);
registerMaterial(FiniteStrainElasticMaterial);
registerMaterial(FiniteStrainPlasticMaterial);
registerMaterial(FiniteStrainMohrCoulomb);
registerMaterial(FiniteStrainRatePlasticMaterial);
registerMaterial(FiniteStrainCrystalPlasticity);
registerMaterial(ComputeMultiPlasticityStress);
registerMaterial(CosseratLinearElasticMaterial);
registerMaterial(ElementPropertyReadFileTest);
registerMaterial(TwoPhaseStressMaterial);
registerMaterial(MultiPhaseStressMaterial);
registerMaterial(SimpleEigenStrainMaterial);
registerMaterial(ComputeElasticityTensor);
registerMaterial(ComputeIsotropicElasticityTensor);
registerMaterial(ComputeSmallStrain);
registerMaterial(ComputePlaneSmallStrain);
registerMaterial(ComputePlaneFiniteStrain);
registerMaterial(ComputeAxisymmetricRZSmallStrain);
registerMaterial(ComputeIncrementalSmallStrain);
registerMaterial(ComputeFiniteStrain);
registerMaterial(ComputeAxisymmetricRZFiniteStrain);
registerMaterial(ComputeLinearElasticStress);
registerMaterial(ComputeFiniteStrainElasticStress);
registerMaterial(ComputeEigenstrain);
registerMaterial(ComputeVariableEigenstrain);
registerMaterial(ComputeConcentrationDependentElasticityTensor);
registerMaterial(FiniteStrainHyperElasticViscoPlastic);
registerMaterial(LinearIsoElasticPFDamage);
registerUserObject(TensorMechanicsPlasticSimpleTester);
registerUserObject(TensorMechanicsPlasticTensile);
registerUserObject(TensorMechanicsPlasticTensileMulti);
registerUserObject(TensorMechanicsPlasticMohrCoulomb);
registerUserObject(TensorMechanicsPlasticMohrCoulombMulti);
registerUserObject(TensorMechanicsPlasticWeakPlaneTensile);
registerUserObject(TensorMechanicsPlasticWeakPlaneTensileN);
registerUserObject(TensorMechanicsPlasticWeakPlaneShear);
registerUserObject(TensorMechanicsPlasticJ2);
registerUserObject(TensorMechanicsHardeningConstant);
registerUserObject(TensorMechanicsHardeningGaussian);
registerUserObject(TensorMechanicsHardeningExponential);
registerUserObject(TensorMechanicsHardeningCutExponential);
registerUserObject(TensorMechanicsHardeningCubic);
registerUserObject(ElementPropertyReadFile);
registerUserObject(HyperElasticStress);
registerUserObject(FlowRateModel);
registerUserObject(RambergOsgoodHardening);
registerUserObject(EulerAngleFileReader);
registerAux(RankTwoAux);
registerAux(RankFourAux);
registerAux(TensorElasticEnergyAux);
registerAux(CrystalPlasticityRotationOutAux);
registerAux(RankTwoScalarAux);
registerAux(NewmarkAccelAux);
registerAux(NewmarkVelAux);
registerBoundaryCondition(Pressure);
}
void
TensorMechanicsApp::registerObjects(Factory & factory)
{
registerKernel(StressDivergenceTensors);
registerKernel(CosseratStressDivergenceTensors);
registerKernel(StressDivergenceRZTensors);
registerKernel(StressDivergenceRSphericalTensors);
registerKernel(MomentBalancing);
registerKernel(StressDivergencePFFracTensors);
registerKernel(PoroMechanicsCoupling);
registerKernel(InertialForce);
registerKernel(Gravity);
registerKernel(DynamicStressDivergenceTensors);
registerMaterial(LinearElasticMaterial);
registerMaterial(FiniteStrainElasticMaterial);
registerMaterial(FiniteStrainPlasticMaterial);
registerMaterial(FiniteStrainMohrCoulomb);
registerMaterial(FiniteStrainRatePlasticMaterial);
registerMaterial(FiniteStrainCrystalPlasticity);
registerMaterial(FiniteStrainCPSlipRateRes);
registerMaterial(FiniteStrainUObasedCP);
registerMaterial(ComputeMultiPlasticityStress);
registerMaterial(CosseratLinearElasticMaterial);
registerMaterial(ElementPropertyReadFileTest);
registerMaterial(TwoPhaseStressMaterial);
registerMaterial(MultiPhaseStressMaterial);
registerMaterial(SimpleEigenStrainMaterial);
registerMaterial(CompositeElasticityTensor);
registerMaterial(ComputeElasticityTensor);
registerMaterial(ComputeElasticityTensorCP);
registerMaterial(ComputeIsotropicElasticityTensor);
registerMaterial(ComputeSmallStrain);
registerMaterial(ComputePlaneSmallStrain);
registerMaterial(ComputePlaneFiniteStrain);
registerMaterial(ComputeAxisymmetricRZSmallStrain);
registerMaterial(ComputeRSphericalSmallStrain);
registerMaterial(ComputeIncrementalSmallStrain);
registerMaterial(ComputeFiniteStrain);
registerMaterial(ComputeAxisymmetricRZFiniteStrain);
registerMaterial(ComputeRSphericalFiniteStrain);
registerMaterial(ComputeLinearElasticStress);
registerMaterial(ComputeFiniteStrainElasticStress);
registerMaterial(ComputeEigenstrain);
registerMaterial(ComputeVariableEigenstrain);
registerMaterial(ComputeConcentrationDependentElasticityTensor);
registerMaterial(FiniteStrainHyperElasticViscoPlastic);
registerMaterial(LinearIsoElasticPFDamage);
registerMaterial(HyperElasticPhaseFieldIsoDamage);
registerMaterial(ComputeVolumetricDeformGrad);
registerMaterial(ComputeDeformGradBasedStress);
registerMaterial(VolumeDeformGradCorrectedStress);
registerMaterial(ComputeReturnMappingStress);
registerMaterial(RecomputeRadialReturnStressIncrement);
registerMaterial(RecomputeRadialReturnIsotropicPlasticity);
registerUserObject(TensorMechanicsPlasticSimpleTester);
registerUserObject(TensorMechanicsPlasticTensile);
registerUserObject(TensorMechanicsPlasticTensileMulti);
registerUserObject(TensorMechanicsPlasticMohrCoulomb);
registerUserObject(TensorMechanicsPlasticMohrCoulombMulti);
registerUserObject(TensorMechanicsPlasticWeakPlaneTensile);
registerUserObject(TensorMechanicsPlasticWeakPlaneTensileN);
registerUserObject(TensorMechanicsPlasticWeakPlaneShear);
registerUserObject(TensorMechanicsPlasticJ2);
registerUserObject(TensorMechanicsPlasticMeanCap);
registerUserObject(TensorMechanicsHardeningConstant);
registerUserObject(TensorMechanicsHardeningGaussian);
registerUserObject(TensorMechanicsHardeningExponential);
registerUserObject(TensorMechanicsHardeningCutExponential);
registerUserObject(TensorMechanicsHardeningCubic);
registerUserObject(ElementPropertyReadFile);
registerUserObject(EulerAngleFileReader);
registerUserObject(HEVPLinearHardening);
registerUserObject(HEVPRambergOsgoodHardening);
registerUserObject(HEVPEqvPlasticStrain);
registerUserObject(HEVPEqvPlasticStrainRate);
registerUserObject(HEVPFlowRatePowerLawJ2);
registerUserObject(CrystalPlasticitySlipRateGSS);
registerUserObject(CrystalPlasticitySlipResistanceGSS);
registerUserObject(CrystalPlasticityStateVariableGSS);
registerUserObject(CrystalPlasticityStateVarRateComponentGSS);
registerAux(CylindricalRankTwoAux);
registerAux(RankTwoAux);
registerAux(RankFourAux);
registerAux(TensorElasticEnergyAux);
registerAux(CrystalPlasticityRotationOutAux);
registerAux(RankTwoScalarAux);
registerAux(NewmarkAccelAux);
registerAux(NewmarkVelAux);
registerBoundaryCondition(Pressure);
}
void
registerObjects(Factory & factory)
{
// mesh
registerMesh(FileMesh);
registerMesh(GeneratedMesh);
registerMesh(TiledMesh);
registerMesh(ImageMesh);
registerMesh(PatternedMesh);
registerMesh(StitchedMesh);
registerMesh(AnnularMesh);
// mesh modifiers
registerMeshModifier(MeshExtruder);
registerMeshModifier(SideSetsFromPoints);
registerMeshModifier(SideSetsFromNormals);
registerMeshModifier(AddExtraNodeset);
registerMeshModifier(BoundingBoxNodeSet);
registerMeshModifier(Transform);
registerMeshModifier(SideSetsAroundSubdomain);
registerMeshModifier(SideSetsBetweenSubdomains);
registerMeshModifier(AddAllSideSetsByNormals);
registerMeshModifier(SubdomainBoundingBox);
registerMeshModifier(OrientedSubdomainBoundingBox);
registerMeshModifier(RenameBlock);
registerMeshModifier(AssignElementSubdomainID);
registerMeshModifier(ImageSubdomain);
registerMeshModifier(BlockDeleter);
registerMeshModifier(ParsedSubdomainMeshModifier);
registerMeshModifier(BreakBoundaryOnSubdomain);
registerMeshModifier(ParsedAddSideset);
registerMeshModifier(AssignSubdomainID);
registerMeshModifier(MeshSideSet);
registerMeshModifier(AddSideSetsFromBoundingBox);
// problems
registerProblem(DisplacedProblem);
registerProblem(FEProblem);
registerProblem(EigenProblem);
// kernels
registerKernel(TimeDerivative);
registerKernel(ConservativeAdvection);
registerKernel(CoupledTimeDerivative);
registerKernel(MassLumpedTimeDerivative);
registerKernel(Diffusion);
registerKernel(AnisotropicDiffusion);
registerKernel(CoupledForce);
registerRenamedObject("UserForcingFunction", BodyForce, "04/01/2018 00:00");
registerKernel(Reaction);
registerKernel(MassEigenKernel);
registerKernel(NullKernel);
registerKernel(MaterialDerivativeTestKernel);
registerKernel(MaterialDerivativeRankTwoTestKernel);
registerKernel(MaterialDerivativeRankFourTestKernel);
// bcs
registerBoundaryCondition(ConvectiveFluxBC);
registerBoundaryCondition(DirichletBC);
registerBoundaryCondition(PenaltyDirichletBC);
registerBoundaryCondition(PresetBC);
registerBoundaryCondition(NeumannBC);
registerBoundaryCondition(PostprocessorNeumannBC);
registerBoundaryCondition(FunctionDirichletBC);
registerBoundaryCondition(FunctionPenaltyDirichletBC);
registerBoundaryCondition(FunctionPresetBC);
registerBoundaryCondition(FunctionNeumannBC);
registerBoundaryCondition(MatchedValueBC);
registerBoundaryCondition(VacuumBC);
registerBoundaryCondition(SinDirichletBC);
registerBoundaryCondition(SinNeumannBC);
registerBoundaryCondition(VectorNeumannBC);
registerBoundaryCondition(WeakGradientBC);
registerBoundaryCondition(DiffusionFluxBC);
registerBoundaryCondition(PostprocessorDirichletBC);
registerBoundaryCondition(OneDEqualValueConstraintBC);
// dirac kernels
registerDiracKernel(ConstantPointSource);
registerDiracKernel(FunctionDiracSource);
// aux kernels
registerAux(ConstantAux);
registerAux(FunctionAux);
registerAux(NearestNodeDistanceAux);
registerAux(NearestNodeValueAux);
registerAux(PenetrationAux);
registerAux(ProcessorIDAux);
registerAux(SelfAux);
registerAux(GapValueAux);
registerAux(MaterialRealAux);
registerAux(MaterialRealVectorValueAux);
registerAux(MaterialRealTensorValueAux);
registerAux(MaterialStdVectorAux);
registerAux(MaterialRealDenseMatrixAux);
registerAux(MaterialStdVectorRealGradientAux);
registerAux(DebugResidualAux);
registerAux(BoundsAux);
registerAux(SpatialUserObjectAux);
registerAux(SolutionAux);
registerAux(VectorMagnitudeAux);
registerAux(ConstantScalarAux);
registerAux(QuotientAux);
registerAux(NormalizationAux);
registerAux(FunctionScalarAux);
registerAux(VariableGradientComponent);
registerAux(ParsedAux);
registerAux(VariableTimeIntegrationAux);
registerAux(ElementLengthAux);
registerAux(ElementLpNormAux);
registerAux(ElementL2ErrorFunctionAux);
registerAux(ElementH1ErrorFunctionAux);
registerAux(DiffusionFluxAux);
// Initial Conditions
registerInitialCondition(ConstantIC);
registerInitialCondition(BoundingBoxIC);
registerInitialCondition(FunctionIC);
registerInitialCondition(RandomIC);
registerInitialCondition(ScalarConstantIC);
registerInitialCondition(ScalarComponentIC);
registerInitialCondition(FunctionScalarIC);
// executioners
registerExecutioner(Steady);
registerExecutioner(Transient);
registerExecutioner(InversePowerMethod);
registerExecutioner(NonlinearEigen);
registerExecutioner(Eigenvalue);
// functions
registerFunction(Axisymmetric2D3DSolutionFunction);
registerFunction(ConstantFunction);
registerFunction(CompositeFunction);
registerNamedFunction(MooseParsedFunction, "ParsedFunction");
registerNamedFunction(MooseParsedGradFunction, "ParsedGradFunction");
registerNamedFunction(MooseParsedVectorFunction, "ParsedVectorFunction");
registerFunction(PiecewiseConstant);
registerFunction(PiecewiseLinear);
registerFunction(SolutionFunction);
registerFunction(PiecewiseBilinear);
registerFunction(SplineFunction);
registerFunction(BicubicSplineFunction);
registerFunction(PiecewiseMultilinear);
registerFunction(LinearCombinationFunction);
registerFunction(ImageFunction);
registerFunction(VectorPostprocessorFunction);
// materials
registerMaterial(DerivativeParsedMaterial);
registerMaterial(DerivativeSumMaterial);
registerMaterial(GenericConstantMaterial);
registerMaterial(GenericConstantRankTwoTensor);
registerMaterial(GenericFunctionMaterial);
registerMaterial(ParsedMaterial);
registerMaterial(PiecewiseLinearInterpolationMaterial);
// PPS
registerPostprocessor(AverageElementSize);
registerPostprocessor(AverageNodalVariableValue);
registerPostprocessor(CumulativeValuePostprocessor);
registerPostprocessor(ChangeOverTimePostprocessor);
registerPostprocessor(ChangeOverTimestepPostprocessor);
registerPostprocessor(NodalSum);
registerPostprocessor(ElementAverageValue);
registerPostprocessor(ElementAverageTimeDerivative);
registerPostprocessor(ElementW1pError);
registerPostprocessor(ElementH1Error);
registerPostprocessor(ElementH1SemiError);
registerPostprocessor(ElementIntegralVariablePostprocessor);
registerPostprocessor(ElementIntegralMaterialProperty);
registerPostprocessor(ElementL2Error);
registerPostprocessor(ElementVectorL2Error);
registerPostprocessor(ScalarL2Error);
registerPostprocessor(EmptyPostprocessor);
registerPostprocessor(FindValueOnLine);
registerPostprocessor(NodalVariableValue);
registerPostprocessor(NumDOFs);
registerPostprocessor(TimestepSize);
registerPostprocessor(PerformanceData);
registerPostprocessor(MemoryUsage);
registerPostprocessor(NumElems);
registerPostprocessor(NumNodes);
registerPostprocessor(NumNonlinearIterations);
registerPostprocessor(NumLinearIterations);
registerPostprocessor(Residual);
registerPostprocessor(ScalarVariable);
registerPostprocessor(NumVars);
registerPostprocessor(NumResidualEvaluations);
registerPostprocessor(Receiver);
registerPostprocessor(SideAverageValue);
registerPostprocessor(SideFluxIntegral);
registerPostprocessor(SideFluxAverage);
registerPostprocessor(SideIntegralVariablePostprocessor);
registerPostprocessor(NodalMaxValue);
registerPostprocessor(NodalProxyMaxValue);
registerPostprocessor(ElementalVariableValue);
registerPostprocessor(ElementL2Norm);
registerPostprocessor(NodalL2Norm);
registerPostprocessor(NodalL2Error);
registerPostprocessor(TotalVariableValue);
registerPostprocessor(VolumePostprocessor);
registerPostprocessor(AreaPostprocessor);
registerPostprocessor(PointValue);
registerPostprocessor(NodalExtremeValue);
registerPostprocessor(ElementExtremeValue);
registerPostprocessor(DifferencePostprocessor);
registerPostprocessor(RelativeDifferencePostprocessor);
registerPostprocessor(ScalePostprocessor);
registerPostprocessor(LinearCombinationPostprocessor);
registerPostprocessor(FunctionValuePostprocessor);
registerPostprocessor(NumPicardIterations);
registerPostprocessor(FunctionSideIntegral);
registerPostprocessor(ExecutionerAttributeReporter);
registerPostprocessor(PercentChangePostprocessor);
registerPostprocessor(ElementL2Difference);
registerPostprocessor(TimeExtremeValue);
registerPostprocessor(RelativeSolutionDifferenceNorm);
registerPostprocessor(AxisymmetricCenterlineAverageValue);
registerPostprocessor(VariableInnerProduct);
registerPostprocessor(VariableResidual);
// vector PPS
registerVectorPostprocessor(CSVReader);
registerVectorPostprocessor(ConstantVectorPostprocessor);
registerVectorPostprocessor(Eigenvalues);
registerVectorPostprocessor(ElementVariablesDifferenceMax);
registerVectorPostprocessor(ElementsAlongLine);
registerVectorPostprocessor(ElementsAlongPlane);
registerVectorPostprocessor(IntersectionPointsAlongLine);
registerVectorPostprocessor(LeastSquaresFit);
registerVectorPostprocessor(LineFunctionSampler);
registerVectorPostprocessor(LineMaterialRealSampler);
registerVectorPostprocessor(LineValueSampler);
registerVectorPostprocessor(MaterialVectorPostprocessor);
registerVectorPostprocessor(NodalValueSampler);
registerVectorPostprocessor(PointValueSampler);
registerVectorPostprocessor(SideValueSampler);
registerVectorPostprocessor(SphericalAverage);
registerVectorPostprocessor(VectorOfPostprocessors);
registerVectorPostprocessor(VolumeHistogram);
// user objects
registerUserObject(GeometrySphere);
registerUserObject(LayeredIntegral);
registerUserObject(LayeredAverage);
registerUserObject(LayeredSideIntegral);
registerUserObject(LayeredSideAverage);
registerUserObject(LayeredSideFluxAverage);
registerUserObject(NearestPointLayeredAverage);
registerUserObject(ElementIntegralVariableUserObject);
registerUserObject(NodalNormalsPreprocessor);
registerUserObject(NodalNormalsCorner);
registerUserObject(NodalNormalsEvaluator);
registerUserObject(SolutionUserObject);
registerUserObject(PerflogDumper);
registerUserObject(ElementQualityChecker);
#ifdef LIBMESH_HAVE_FPARSER
registerUserObject(Terminator);
#endif
// preconditioners
registerNamedPreconditioner(PhysicsBasedPreconditioner, "PBP");
registerNamedPreconditioner(FiniteDifferencePreconditioner, "FDP");
registerNamedPreconditioner(SingleMatrixPreconditioner, "SMP");
#if defined(LIBMESH_HAVE_PETSC) && !PETSC_VERSION_LESS_THAN(3, 3, 0)
registerNamedPreconditioner(FieldSplitPreconditioner, "FSP");
#endif
// dampers
registerDamper(ConstantDamper);
registerDamper(MaxIncrement);
registerDamper(BoundingValueNodalDamper);
registerDamper(BoundingValueElementDamper);
// DG
registerDGKernel(DGDiffusion);
registerBoundaryCondition(DGFunctionDiffusionDirichletBC);
registerDGKernel(DGConvection);
// Constraints
registerConstraint(TiedValueConstraint);
registerConstraint(CoupledTiedValueConstraint);
registerConstraint(EqualGradientConstraint);
registerConstraint(EqualValueConstraint);
registerConstraint(EqualValueBoundaryConstraint);
registerConstraint(LinearNodalConstraint);
// Scalar kernels
registerScalarKernel(ODETimeDerivative);
registerScalarKernel(CoupledODETimeDerivative);
registerScalarKernel(NodalEqualValueConstraint);
registerScalarKernel(ParsedODEKernel);
registerScalarKernel(QuotientScalarAux);
// indicators
registerIndicator(AnalyticalIndicator);
registerIndicator(LaplacianJumpIndicator);
registerIndicator(GradientJumpIndicator);
registerIndicator(ValueJumpIndicator);
// markers
registerMarker(ErrorToleranceMarker);
registerMarker(ErrorFractionMarker);
registerMarker(UniformMarker);
registerMarker(BoxMarker);
registerMarker(OrientedBoxMarker);
registerMarker(ComboMarker);
registerMarker(ValueThresholdMarker);
registerMarker(ValueRangeMarker);
// splits
registerSplit(Split);
// MultiApps
registerMultiApp(TransientMultiApp);
registerMultiApp(FullSolveMultiApp);
registerMultiApp(AutoPositionsMultiApp);
registerMultiApp(CentroidMultiApp);
// time steppers
registerTimeStepper(ConstantDT);
registerTimeStepper(LogConstantDT);
registerTimeStepper(FunctionDT);
registerTimeStepper(TimeSequenceStepper);
registerTimeStepper(ExodusTimeSequenceStepper);
registerTimeStepper(CSVTimeSequenceStepper);
registerTimeStepper(IterationAdaptiveDT);
registerTimeStepper(SolutionTimeAdaptiveDT);
registerTimeStepper(DT2);
registerTimeStepper(PostprocessorDT);
registerTimeStepper(AB2PredictorCorrector);
// time integrators
registerTimeIntegrator(ImplicitEuler);
registerTimeIntegrator(BDF2);
registerTimeIntegrator(CrankNicolson);
registerTimeIntegrator(ExplicitEuler);
registerTimeIntegrator(ExplicitMidpoint);
registerTimeIntegrator(ExplicitTVDRK2);
registerTimeIntegrator(LStableDirk2);
registerTimeIntegrator(LStableDirk3);
registerTimeIntegrator(AStableDirk4);
registerTimeIntegrator(LStableDirk4);
registerTimeIntegrator(ImplicitMidpoint);
registerTimeIntegrator(Heun);
registerTimeIntegrator(Ralston);
// predictors
registerPredictor(SimplePredictor);
registerPredictor(AdamsPredictor);
// Transfers
#ifdef LIBMESH_TRILINOS_HAVE_DTK
registerTransfer(MultiAppDTKUserObjectTransfer);
registerTransfer(MultiAppDTKInterpolationTransfer);
#endif
registerTransfer(MultiAppPostprocessorInterpolationTransfer);
registerTransfer(MultiAppVariableValueSampleTransfer);
registerTransfer(MultiAppVariableValueSamplePostprocessorTransfer);
registerTransfer(MultiAppMeshFunctionTransfer);
registerTransfer(MultiAppUserObjectTransfer);
registerTransfer(MultiAppNearestNodeTransfer);
registerTransfer(MultiAppCopyTransfer);
registerTransfer(MultiAppInterpolationTransfer);
registerTransfer(MultiAppPostprocessorTransfer);
registerTransfer(MultiAppProjectionTransfer);
registerTransfer(MultiAppPostprocessorToAuxScalarTransfer);
registerTransfer(MultiAppScalarToAuxScalarTransfer);
registerTransfer(MultiAppVectorPostprocessorTransfer);
// Outputs
#ifdef LIBMESH_HAVE_EXODUS_API
registerOutput(Exodus);
#endif
#ifdef LIBMESH_HAVE_NEMESIS_API
registerOutput(Nemesis);
#endif
registerOutput(Console);
registerOutput(CSV);
#ifdef LIBMESH_HAVE_VTK
registerNamedOutput(VTKOutput, "VTK");
#endif
registerOutput(Checkpoint);
registerNamedOutput(XDA, "XDR");
registerOutput(XDA);
registerNamedOutput(GMVOutput, "GMV");
registerOutput(Tecplot);
registerOutput(Gnuplot);
registerOutput(SolutionHistory);
registerOutput(MaterialPropertyDebugOutput);
registerOutput(VariableResidualNormsDebugOutput);
registerOutput(TopResidualDebugOutput);
registerNamedOutput(DOFMapOutput, "DOFMap");
registerOutput(ControlOutput);
// Controls
registerControl(RealFunctionControl);
registerControl(TimePeriod);
// Partitioner
registerPartitioner(LibmeshPartitioner);
// NodalKernels
registerNodalKernel(TimeDerivativeNodalKernel);
registerNodalKernel(ConstantRate);
registerNodalKernel(UserForcingFunctionNodalKernel);
// RelationshipManagers
registerRelationshipManager(ElementSideNeighborLayers);
registerRelationshipManager(ElementPointNeighbors);
}
