Class for output data to the XDAII format. More...

#include <XDA.h>

Inheritance diagram for XDA:

Public Types
using	DataFileParameterType = DataFileName
	The parameter type this interface expects for a data file name.

Public Member Functions
	XDA (const InputParameters &parameters)
	Class consturctor.

bool	supportsMaterialPropertyOutput () const override
	A virtual function that stores whether output type supports material output.

virtual void	initialSetup () override
	Call init() method on setup.

virtual void	meshChanged () override
	Called on this object when the mesh changes.

virtual void	outputStep (const ExecFlagType &type) override
	A single call to this function should output all the necessary data for a single timestep.

virtual bool	hasOutput ()
	Returns true if any of the other has methods return true.

bool	hasOutput (const ExecFlagType &type)
	Tests that any output exist for the given output type.

bool	hasNodalVariableOutput ()
	Returns true if there exists nodal nonlinear variables for output.

const std::set< std::string > &	getNodalVariableOutput ()
	The list of nodal nonlinear variables names that are set for output.

bool	hasElementalVariableOutput ()
	Returns true if there exists elemental nonlinear variables for output.

const std::set< std::string > &	getElementalVariableOutput ()
	The list of elemental nonlinear variables names that are set for output.

bool	hasScalarOutput ()
	Returns true if there exists scalar variables for output.

const std::set< std::string > &	getScalarOutput ()
	The list of scalar variables names that are set for output.

bool	hasPostprocessorOutput ()
	Returns true if there exists postprocessors for output.

const std::set< std::string > &	getPostprocessorOutput ()
	The list of postprocessor names that are set for output.

bool	hasVectorPostprocessorOutput ()
	Returns true if there exists VectorPostprocessors for output.

const std::set< std::string > &	getVectorPostprocessorOutput ()
	The list of VectorPostprocessor names that are set for output.

bool	hasReporterOutput ()
	Returns true if there exists Reporter for output.

const std::set< std::string > &	getReporterOutput ()
	The list of Reporter names that are set for output.

const OutputOnWarehouse &	advancedExecuteOn () const
	Get the current advanced 'execute_on' selections for display.

void	setFileBase (const std::string &file_base)
	Sets the file base string if the 'file_base' parameter is not set.

void	setFileNumber (unsigned int num)
	Sets the file number manually.

unsigned int	getFileNumber ()
	Return the current file number for this outputter.

virtual Real	time () override
	Get the output time.

virtual Real	timeOld ()
	Get the old output time.

virtual Real	dt ()
	Get the current time step size.

virtual Real	dtOld ()
	Get old time step size.

virtual int	timeStep ()
	Get the current time step.

const unsigned int &	interval () const
	Get the output interval.

const MultiMooseEnum &	executeOn () const
	Get the current 'execute_on' selections for display.

bool	isAdvanced ()
	Returns true if this object is an AdvancedOutput object.

void	allowOutput (bool state)
	Method for controlling the allow output state.

const std::set< Real > &	getSyncTimes ()

virtual bool	enabled () const
	Return the enabled status of the object.

std::shared_ptr< MooseObject >	getSharedPtr ()
	Get another shared pointer to this object that has the same ownership group.

std::shared_ptr< const MooseObject >	getSharedPtr () const

bool	isKokkosObject () const
	Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

MooseApp &	getMooseApp () const
	Get the MooseApp this class is associated with.

const std::string &	type () const
	Get the type of this class.

const std::string &	name () const
	Get the name of the class.

std::string	typeAndName () const
	Get the class's combined type and name; useful in error handling.

MooseObjectParameterName	uniqueParameterName (const std::string &parameter_name) const

MooseObjectName	uniqueName () const

const InputParameters &	parameters () const
	Get the parameters of the object.

const hit::Node *	getHitNode () const

bool	hasBase () const

const std::string &	getBase () const

template<typename T >
const T &	getParam (const std::string &name) const
	Retrieve a parameter for the object.

template<typename T1 , typename T2 >
std::vector< std::pair< T1, T2 > >	getParam (const std::string &param1, const std::string &param2) const
	Retrieve two parameters and provide pair of parameters for the object.

template<typename T >
const T *	queryParam (const std::string &name) const
	Query a parameter for the object.

template<typename T >
const T &	getRenamedParam (const std::string &old_name, const std::string &new_name) const
	Retrieve a renamed parameter for the object.

template<typename T >
T	getCheckedPointerParam (const std::string &name, const std::string &error_string="") const
	Verifies that the requested parameter exists and is not NULL and returns it to the caller.

bool	isParamValid (const std::string &name) const
	Test if the supplied parameter is valid.

bool	isParamSetByUser (const std::string &name) const
	Test if the supplied parameter is set by a user, as opposed to not set or set to default.

void	connectControllableParams (const std::string &parameter, const std::string &object_type, const std::string &object_name, const std::string &object_parameter) const
	Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

template<typename... Args>
void	paramError (const std::string &param, Args... args) const
	Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const
	Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

template<typename... Args>
void	paramWarning (const std::string &param, Args... args) const

template<typename... Args>
void	paramInfo (const std::string &param, Args... args) const
	Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

std::string	messagePrefix (const bool hit_prefix=true) const

std::string	errorPrefix (const std::string &) const
	Deprecated message prefix; the error type is no longer used.

template<typename... Args>
void	mooseError (Args &&... args) const
	Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

template<typename... Args>
void	mooseDocumentedError (const std::string &repo_name, const unsigned int issue_num, Args &&... args) const

template<typename... Args>
void	mooseErrorNonPrefixed (Args &&... args) const
	Emits an error without the prefixing included in mooseError().

template<typename... Args>
void	mooseWarning (Args &&... args) const
	Emits a warning prefixed with object name and type.

template<typename... Args>
void	mooseWarning (Args &&... args) const

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const
	Emits a warning without the prefixing included in mooseWarning().

template<typename... Args>
void	mooseWarningNonPrefixed (Args &&... args) const

template<typename... Args>
void	mooseDeprecated (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and a stack trace.

template<typename... Args>
void	mooseDeprecated (Args &&... args) const

template<typename... Args>
void	mooseDeprecatedNoTrace (Args &&... args) const
	Emits a deprecation warning prefixed with the object name and type, and no stack trace.

template<typename... Args>
void	mooseInfo (Args &&... args) const

void	callMooseError (std::string msg, const bool with_prefix, const hit::Node *node=nullptr, const bool show_trace=true) const
	External method for calling moose error with added object context.

const Parallel::Communicator &	comm () const

processor_id_type	n_processors () const

processor_id_type	processor_id () const

std::string	getDataFileName (const std::string &param) const
	Deprecated method.

std::string	getDataFileNameByName (const std::string &relative_path) const
	Deprecated method.

std::string	getDataFilePath (const std::string &relative_path) const
	Returns the path of a data file for a given relative file path.

virtual void	timestepSetup ()
	Gets called at the beginning of the timestep before this object is asked to do its job.

virtual void	jacobianSetup ()
	Gets called just before the Jacobian is computed and before this object is asked to do its job.

virtual void	residualSetup ()
	Gets called just before the residual is computed and before this object is asked to do its job.

virtual void	subdomainSetup ()
	Gets called when the subdomain changes (i.e.

virtual void	customSetup (const ExecFlagType &)
	Gets called in FEProblemBase::execute() for execute flags other than initial, timestep_begin, nonlinear, linear and subdomain.

const ExecFlagEnum &	getExecuteOnEnum () const
	Return the execute on MultiMooseEnum for this object.

const Function &	getFunction (const std::string &name) const
	Get a function with a given name.

const Function &	getFunctionByName (const FunctionName &name) const
	Get a function with a given name.

bool	hasFunction (const std::string &param_name) const
	Determine if the function exists.

bool	hasFunctionByName (const FunctionName &name) const
	Determine if the function exists.

Moose::Kokkos::Function	getKokkosFunction (const std::string &name) const
	Get a Kokkos function of an abstract type with a given name Calling this function will error out currently if Kokkos was configured with GPU.

template<typename T >
const T &	getKokkosFunction (const std::string &name) const
	Get a Kokkos function of a concrete type with a given name.

Moose::Kokkos::Function	getKokkosFunctionByName (const FunctionName &name) const
	Get a Kokkos function of an abstract type with a given name Calling this function will error out currently if Kokkos was configured with GPU.

template<typename T >
const T &	getKokkosFunctionByName (const FunctionName &name) const
	Get a Kokkos function of a concrete type with a given name.

bool	hasKokkosFunction (const std::string &param_name) const
	Determine if the Kokkos function exists.

bool	hasKokkosFunctionByName (const FunctionName &name) const
	Determine if the Kokkos function exists.

bool	isDefaultPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
	Determine whether or not the Postprocessor is a default value.

bool	hasPostprocessor (const std::string &param_name, const unsigned int index=0) const
	Determine if the Postprocessor data exists.

bool	hasPostprocessorByName (const PostprocessorName &name) const
	Determine if the Postprocessor data exists.

std::size_t	coupledPostprocessors (const std::string &param_name) const
	Returns number of Postprocessors coupled under parameter name.

const PostprocessorName &	getPostprocessorName (const std::string &param_name, const unsigned int index=0) const
	Get the name of a postprocessor.

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const
	DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast.

const VectorPostprocessorValue &	getVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const
	Retrieve the value of a VectorPostprocessor.

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const
	DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast.

const VectorPostprocessorValue &	getVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const
	Retrieve the value of the VectorPostprocessor.

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const
	DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast.

const VectorPostprocessorValue &	getVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name, bool needs_broadcast) const
	Retrieve the old value of a VectorPostprocessor.

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const
	DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast.

const VectorPostprocessorValue &	getVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name, bool needs_broadcast) const
	Retrieve the old value of a VectorPostprocessor.

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValue (const std::string &param_name, const std::string &vector_name) const
	Return the scatter value for the post processor.

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueByName (const VectorPostprocessorName &name, const std::string &vector_name) const
	Return the scatter value for the post processor.

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOld (const std::string &param_name, const std::string &vector_name) const
	Return the old scatter value for the post processor.

const ScatterVectorPostprocessorValue &	getScatterVectorPostprocessorValueOldByName (const VectorPostprocessorName &name, const std::string &vector_name) const
	Return the old scatter value for the post processor.

bool	hasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const
	Determine if the VectorPostprocessor data exists by parameter.

bool	hasVectorPostprocessor (const std::string &param_name) const
	Determine if the VectorPostprocessor exists by parameter.

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const
	Determine if the VectorPostprocessor data exists by name.

bool	hasVectorPostprocessorByName (const VectorPostprocessorName &name) const
	Determine if the VectorPostprocessor exists by name.

const VectorPostprocessorName &	getVectorPostprocessorName (const std::string &param_name) const
	Get the name of a VectorPostprocessor associated with a parameter.

PerfGraph &	perfGraph ()
	Get the PerfGraph.


const PostprocessorValue &	getPostprocessorValue (const std::string &param_name, const unsigned int index=0) const
	doco-normal-methods-begin Retrieve the value of a Postprocessor or one of it's old or older values

const PostprocessorValue &	getPostprocessorValueOld (const std::string &param_name, const unsigned int index=0) const

const PostprocessorValue &	getPostprocessorValueOlder (const std::string &param_name, const unsigned int index=0) const


virtual const PostprocessorValue &	getPostprocessorValueByName (const PostprocessorName &name) const
	Retrieve the value of the Postprocessor.

const PostprocessorValue &	getPostprocessorValueOldByName (const PostprocessorName &name) const

const PostprocessorValue &	getPostprocessorValueOlderByName (const PostprocessorName &name) const


bool	isVectorPostprocessorDistributed (const std::string &param_name) const
	Return true if the VectorPostprocessor is marked with parallel_type as DISTRIBUTED.

bool	isVectorPostprocessorDistributedByName (const VectorPostprocessorName &name) const

Static Public Member Functions
static InputParameters	validParams ()

static InputParameters	enableOutputTypes (const std::string &names=std::string())
	A method for enabling individual output type control.

static ExecFlagEnum	getDefaultExecFlagEnum ()
	Return an ExecFlagEnum object with the available execution flags for Output objects.

static void	addDeprecatedInputParameters (InputParameters &params)
	A static helper for injecting deprecated parameters.

static void	callMooseError (MooseApp const app, const InputParameters &params, std::string msg, const bool with_prefix, const hit::Node node, const bool show_trace=true)
	External method for calling moose error with added object context.

Public Attributes
	usingCombinedWarningSolutionWarnings

const ConsoleStream	_console
	An instance of helper class to write streams to the Console objects.

Static Public Attributes
static const std::string	type_param = "_type"
	The name of the parameter that contains the object type.

static const std::string	name_param = "_object_name"
	The name of the parameter that contains the object name.

static const std::string	unique_name_param = "_unique_name"
	The name of the parameter that contains the unique object name.

static const std::string	app_param = "_moose_app"
	The name of the parameter that contains the MooseApp.

static const std::string	moose_base_param = "_moose_base"
	The name of the parameter that contains the moose system base.

static const std::string	kokkos_object_param = "_kokkos_object"
	The name of the parameter that indicates an object is a Kokkos functor.

Protected Member Functions
virtual void	output () override
	Overload the Output::output method, this is required for XDA output due to the method utlized for outputting single/global parameters.

virtual std::string	filename () override
	Returns the current filename, this method handles adding the timestep suffix.

virtual void	updateSample ()
	Performs the update of the solution vector for the sample/re-positioned mesh.

virtual void	setFileBaseInternal (const std::string &file_base) override
	Appends the base class's file base string.

virtual void	init ()
	Populates the various data structures needed to control the output.

void	hideAdditionalVariable (const std::string &category, const std::string &var_name)
	Add an additional variable to the hide list.

virtual bool	shouldOutput ()
	Handles logic for determining if a step should be output.

virtual void	outputNodalVariables ()
	Performs output of nodal nonlinear variables The child class must define this method to output the nonlinear variables as desired.

virtual void	outputElementalVariables ()
	Performs output of elemental nonlinear variables The child class must define this method to output the nonlinear variables as desired.

virtual void	outputScalarVariables ()
	Performs output of scalar variables The child class must define this method to output the scalar variables as desired.

virtual void	outputPostprocessors ()
	Performs output of postprocessors The child class must define this method to output the postprocessors as desired.

virtual void	outputVectorPostprocessors ()
	Performs output of VectorPostprocessors The child class must define this method to output the VectorPostprocessors as desired.

virtual void	outputInput ()
	Performs the output of the input file By default this method does nothing and is not called, the individual Output objects are responsible for calling it.

virtual void	outputSystemInformation ()

virtual void	outputReporters ()
	Output Reporter values.

void	clearLastExecuteTime ()
	Clears bookkeeping used to suppress duplicate EXEC_FINAL output at the same time.

bool	checkFilename ()
	Checks the filename for output Checks the output against the 'output_if_base_contians' list.

bool	inNonlinearTimeWindow ()

bool	inLinearTimeWindow ()

virtual Real	getOutputTime ()
	Get the time that will be used for stream/file outputting.

virtual bool	onInterval ()
	Returns true if the output interval is satisfied.

void	setWallTimeIntervalFromCommandLineParam ()
	Function to set the wall time interval based on value of command line parameter (used for testing only).

template<bool warning>
void	flagInvalidSolutionInternal (const InvalidSolutionID invalid_solution_id) const
	Set solution invalid mark for the given solution ID.

InvalidSolutionID	registerInvalidSolutionInternal (const std::string &message, const bool warning) const

template<typename T , typename... Args>
T &	declareRestartableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "restartable" and initialize it.

template<typename T , typename... Args>
ManagedValue< T >	declareManagedRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declares a piece of "managed" restartable data and initialize it.

template<typename T , typename... Args>
const T &	getRestartableData (const std::string &data_name) const
	Declare a piece of data as "restartable" and initialize it Similar to `declareRestartableData` but returns a const reference to the object.

template<typename T , typename... Args>
T &	declareRestartableDataWithContext (const std::string &data_name, void *context, Args &&... args)
	Declare a piece of data as "restartable" and initialize it.

template<typename T , typename... Args>
T &	declareRecoverableData (const std::string &data_name, Args &&... args)
	Declare a piece of data as "recoverable" and initialize it.

template<typename T , typename... Args>
T &	declareRestartableDataWithObjectName (const std::string &data_name, const std::string &object_name, Args &&... args)
	Declare a piece of data as "restartable".

template<typename T , typename... Args>
T &	declareRestartableDataWithObjectNameWithContext (const std::string &data_name, const std::string &object_name, void *context, Args &&... args)
	Declare a piece of data as "restartable".

std::string	restartableName (const std::string &data_name) const
	Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

virtual void	addPostprocessorDependencyHelper (const PostprocessorName &) const
	Helper for deriving classes to override to add dependencies when a Postprocessor is requested.

virtual void	addVectorPostprocessorDependencyHelper (const VectorPostprocessorName &) const
	Helper for deriving classes to override to add dependencies when a VectorPostprocessor is requested.

const ReporterContextBase &	getReporterContextBaseByName (const ReporterName &reporter_name) const
	Get the reporter context to allow non-typed operations with the data.

const ReporterName &	getReporterName (const std::string &param_name) const

virtual void	addReporterDependencyHelper (const ReporterName &)
	A method that can be overridden to update the UO dependencies.

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level) const
	Call to register a named section for timing.

PerfID	registerTimedSection (const std::string &section_name, const unsigned int level, const std::string &live_message, const bool print_dots=true) const
	Call to register a named section for timing.

std::string	timedSectionName (const std::string &section_name) const


template<typename T >
const T &	getReporterValue (const std::string &param_name, const std::size_t time_index=0)
	doco-normal-methods-begin Returns read-only reference to a Reporter value that is provided by an input parameter.

template<typename T >
const T &	getReporterValue (const std::string &param_name, ReporterMode mode, const std::size_t time_index=0)


template<typename T >
const T &	getReporterValueByName (const ReporterName &reporter_name, const std::size_t time_index=0)
	Returns read-only reference to a Reporter value that is provided by name directly.

template<typename T >
const T &	getReporterValueByName (const ReporterName &reporter_name, ReporterMode mode, const std::size_t time_index=0)


bool	hasReporterValue (const std::string &param_name) const
	Return True if the Reporter value exists.

template<typename T >
bool	hasReporterValue (const std::string &param_name) const

bool	hasReporterValueByName (const ReporterName &reporter_name) const

template<typename T >
bool	hasReporterValueByName (const ReporterName &reporter_name) const

Static Protected Member Functions
static PetscErrorCode	petscNonlinearOutput (SNES, PetscInt its, PetscReal fnorm, void *void_ptr)
	Performs the output on non-linear iterations This is the monitor method that PETSc will call on non-linear iterations.

static PetscErrorCode	petscLinearOutput (KSP, PetscInt its, PetscReal fnorm, void *void_ptr)
	Performs the output onlinear iterations This is the monitor method that PETSc will call on linear iterations.

Protected Attributes
const unsigned int	_refinements
	The number of oversampling refinements.

const bool	_using_external_sampling_file
	Flag indicating another file is being used for the sampling.

const bool	_change_position
	Flag for re-positioning.

bool	_use_sampled_output
	Flag indicating that the sampled output should be used to re-sample the underlying EquationSystem of the output.

bool	_elemental_as_nodal
	Flags to control nodal output.

bool	_scalar_as_nodal

const ReporterData &	_reporter_data
	Storage for Reporter values.

unsigned int &	_file_num
	A file number counter, initialized to 0 (this must be controlled by the child class, see Exodus)

unsigned int	_padding
	Number of digits to pad the extensions.

std::vector< std::string >	_output_if_base_contains
	Storage for 'output_if_base_contains'.

std::string	_file_base
	The base filename from the input paramaters.

Real	_norm
	Current norm returned from PETSc.

PetscInt	_nonlinear_iter
	Current non-linear iteration returned from PETSc.

PetscInt	_linear_iter
	Current linear iteration returned from PETSc.

bool	_on_linear_residual
	True if current output calls is on the linear residual (used by time())

bool	_on_nonlinear_residual
	True if current output call is on the non-linear residual (used by time())

FEProblemBase *	_problem_ptr
	Pointer the the FEProblemBase object for output object (use this)

bool	_transient
	Transient flag (true = transient)

bool	_use_displaced
	Flag for using displaced mesh.

libMesh::EquationSystems *	_es_ptr
	Reference the the libMesh::EquationSystems object that contains the data.

MooseMesh *	_mesh_ptr
	A convenience pointer to the current mesh (reference or displaced depending on "use_displaced")

bool	_sequence
	Flag for forcing call to outputSetup() with every call to output() (restartable)

ExecFlagEnum	_execute_on
	The common Execution types; this is used as the default execution type for everything except system information and input.

ExecFlagType	_current_execute_flag
	Current execute on flag.

Real &	_time
	The current time for output purposes.

Real &	_time_old
	The old time.

int &	_t_step
	The current time step.

Real &	_dt
	Time step delta.

Real &	_dt_old
	Old time step delta.

unsigned int	_num
	The number of outputs written.

const bool	_time_step_interval_set_by_addparam
	Whether time step interval is set by AddParam.

unsigned int	_time_step_interval
	The output time step interval.

const Real	_min_simulation_time_interval
	Minimum simulation time between outputs.

Real	_wall_time_interval
	Target wall time between outputs in seconds.

std::set< Real >	_sync_times
	Sync times for this outputter.

const Times *const	_sync_times_object
	Sync times object for this outputter.

Real	_start_time
	Start outputting time.

Real	_end_time
	End outputting time.

int	_start_step
	Start outputting at this time step.

int	_end_step
	End outputting at this time step.

Real	_t_tol
	Time checking tolerance.

bool	_sync_only
	Flag for only executing at sync times.

bool	_allow_output
	Flag for disabling output.

bool	_is_advanced
	Flag for advanced output testing.

OutputOnWarehouse	_advanced_execute_on
	Storage for the individual component execute flags.

Real &	_last_output_simulation_time
	last simulation time an output has occured

std::chrono::time_point< std::chrono::steady_clock >	_last_output_wall_time
	last wall time an output has occured

Real	_wall_time_since_last_output
	time in seconds since last output

const bool &	_enabled
	Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

MooseApp &	_app
	The MOOSE application this is associated with.

Factory &	_factory
	The Factory associated with the MooseApp.

ActionFactory &	_action_factory
	Builds Actions.

const std::string &	_type
	The type of this class.

const std::string &	_name
	The name of this class.

const InputParameters &	_pars
	The object's parameters.

const Parallel::Communicator &	_communicator

MooseApp &	_restartable_app
	Reference to the application.

const std::string	_restartable_system_name
	The system name this object is in.

const THREAD_ID	_restartable_tid
	The thread ID for this object.

const bool	_restartable_read_only
	Flag for toggling read only status (see ReporterData)

FEProblemBase &	_mci_feproblem
	Reference to FEProblemBase instance.

const ExecFlagEnum &	_execute_enum
	Execute settings for this object.

MooseApp &	_pg_moose_app
	The MooseApp that owns the PerfGraph.

const std::string	_prefix
	A prefix to use for all sections.

PetscOutput *	_petsc_output

Private Member Functions
void	initSample ()
	Setups the output object to produce re-positioned and/or sampled results.

void	cloneMesh ()
	Clone mesh in preperation for re-positioning or oversampling.

bool	isSampledAtNodes (const FEType &fe_type) const
	Used to decide which variable is sampled at nodes, then output as a nodal variable for (over)sampling purposes If not sampled at nodes, it is sampled at centroids and output as a constant monomial.

void	initAvailableLists ()
	Initializes the available lists for each of the output types.

void	initExecutionTypes (const std::string &name, ExecFlagEnum &input)
	Initialize the possible execution types.

void	initShowHideLists (const std::vector< VariableName > &show, const std::vector< VariableName > &hide)
	Parses the user-supplied input for hiding and showing variables and postprocessors into a list for each type of output.

template<typename postprocessor_type >
void	initPostprocessorOrVectorPostprocessorLists (const std::string &execute_data_name)
	Helper function for initAvailableLists, templated on warehouse type and postprocessor_type.

void	initOutputList (OutputData &data)
	Initializes the list of items to be output using the available, show, and hide lists.

bool	wantOutput (const std::string &name, const ExecFlagType &type)
	Handles logic for determining if a step should be output.

bool	hasOutputHelper (const std::string &name)
	Helper method for checking if output types exists.

void	solveSetup () override
	Internal setup function that executes at the beginning of the time step.

RestartableDataValue &	registerRestartableDataOnApp (std::unique_ptr< RestartableDataValue > data, THREAD_ID tid) const
	Helper function for actually registering the restartable data.

void	registerRestartableNameWithFilterOnApp (const std::string &name, Moose::RESTARTABLE_FILTER filter)
	Helper function for actually registering the restartable data.

template<typename T , typename... Args>
RestartableData< T > &	declareRestartableDataHelper (const std::string &data_name, void *context, Args &&... args) const
	Helper function for declaring restartable data.

const Moose::FunctionBase *	getKokkosFunctionByNameHelper (const FunctionName &name) const
	Helper function to retrieve a Kokkos function.

const PostprocessorName &	getPostprocessorNameInternal (const std::string &param_name, const unsigned int index, const bool allow_default_value=true) const
	Internal method for getting the PostprocessorName associated with a paremeter.

bool	isDefaultPostprocessorValueByName (const PostprocessorName &name) const

PostprocessorValue	getDefaultPostprocessorValueByName (const PostprocessorName &name) const

void	checkParam (const std::string &param_name, const unsigned int index=std::numeric_limits< unsigned int >::max()) const
	Checks the parameters relating to a Postprocessor.

bool	postprocessorsAdded () const

const VectorPostprocessorValue &	getVectorPostprocessorByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name, bool broadcast, std::size_t t_index) const
	Helper function for extracting VPP data from ReporterData object.

const VectorPostprocessorContext< VectorPostprocessorValue > &	getVectorPostprocessorContextByNameHelper (const VectorPostprocessorName &name, const std::string &vector_name) const
	Helper for getting the VPP context that handles scatter values.

bool	vectorPostprocessorsAdded () const

bool	reportersAdded () const

template<typename T >
void	possiblyCheckHasReporter (const ReporterName &reporter_name, const std::string &param_name="") const
	Helpers for "possibly" checking if a Reporter value exists.


const PostprocessorValue &	getPostprocessorValueInternal (const std::string &param_name, unsigned int index, std::size_t t_index) const
	Internal methods for getting Postprocessor values.

const PostprocessorValue &	getPostprocessorValueByNameInternal (const PostprocessorName &name, std::size_t t_index) const


void	possiblyCheckHasVectorPostprocessor (const std::string &param_name, const std::string &vector_name) const
	Helpers for "possibly" checking if a vpp exists.

void	possiblyCheckHasVectorPostprocessorByName (const VectorPostprocessorName &name, const std::string &vector_name) const

Static Private Member Functions
static void	addValidParams (InputParameters &params, const MultiMooseEnum &types)
	Method for defining the available parameters based on the types of outputs.

static MultiMooseEnum	getOutputTypes ()
	Get the supported types of output (e.g., postprocessors, etc.)

static const hit::Node *	getHitNode (const InputParameters &params)
	Internal method for getting a hit node (if available) given a set of parameters.

static std::string	messagePrefix (const InputParameters &params, const bool hit_prefix)
	Internal method for getting the message prefix for an object (object type, name, etc).

Private Attributes
bool	_binary
	Flag for binary output.

std::vector< std::vector< std::unique_ptr< libMesh::MeshFunction > > >	_mesh_functions
	A vector of pointers to the mesh functions on the sampled mesh This is only populated when the initSample() function is called, it must be cleaned up by the destructor.

std::vector< std::vector< unsigned int > >	_variable_numbers_in_system
	A vector of vectors that keeps track of the variable numbers in each system for each mesh function.

Point	_position
	When oversampling, the output is shift by this amount.

bool	_sampling_mesh_changed
	A flag indicating that the mesh has changed and the sampled mesh needs to be re-initialized.

bool	_mesh_subdomains_match
	A flag tracking whether the sampling and source meshes match in terms of subdomains.

bool	_serialize
	Flag indicating whether we are outputting in serial or parallel.

std::unique_ptr< EquationSystems >	_sampling_es
	Equation system holding the solution vectors for the sampled variables.

std::unique_ptr< MooseMesh >	_sampling_mesh_ptr
	Mesh used for sampling. The Output class' _mesh_ptr will refer to this mesh if sampling is being used.

std::unique_ptr< NumericVector< Number > >	_serialized_solution
	Sample solution vector.

OutputDataWarehouse	_execute_data
	Storage structures for the various output types.

std::map< std::string, Real > &	_last_execute_time
	Storage for the last output time for the various output types, this is used to avoid duplicate output when using OUTPUT_FINAL flag.

const bool	_postprocessors_as_reporters
	Flags for outputting PP/VPP data as a reporter.

const bool	_vectorpostprocessors_as_reporters

Real	_nonlinear_time
	The psuedo non-linear time.

Real	_nonlinear_dt
	The pseuedo non-linear time step.

Real	_linear_time
	Psuedo linear time.

Real	_linear_dt
	Psuedo linear time step.

Real	_nonlinear_dt_divisor
	Pseudo non-linear timestep divisor.

Real	_linear_dt_divisor
	Pseudo linear timestep divisor.

Real	_nonlinear_start_time
	Non-linear residual output start time.

Real	_linear_start_time
	Linear residual output start time.

Real	_nonlinear_end_time
	Non-linear residual output end time.

Real	_linear_end_time
	Linear residual output end time.

const ParallelParamObject &	_parent

const MooseBase &	_si_moose_base
	The MooseBase that owns this interface.

const FEProblemBase *	_si_problem
	A pointer to FEProblem base.

const RestartableDataMapName	_metaname
	Restartable metadata name.

std::string	_restartable_name
	The name of the object.

ExecFlagEnum	_empty_execute_enum
	Empty ExecFlagEnum for the case when the "execute_on" parameter is not included.

const MooseObject &	_fni_object
	Reference to the object.

const InputParameters &	_fni_params
	Parameters of the object with this interface.

FEProblemBase &	_fni_feproblem
	Reference to FEProblemBase instance.

const THREAD_ID	_fni_tid
	Thread ID.

const MooseObject &	_ppi_moose_object
	The MooseObject that uses this interface.

const InputParameters &	_ppi_params
	PostprocessorInterface Parameters.

const FEProblemBase &	_ppi_feproblem
	Reference the the FEProblemBase class.

std::map< PostprocessorName, std::unique_ptr< PostprocessorValue > >	_default_values
	Holds the default postprocessor values that are requested (key is PostprocessorName)

const bool	_broadcast_by_default
	Whether or not to force broadcasting by default.

const MooseObject &	_vpi_moose_object
	The MooseObject that uses this interface.

const FEProblemBase &	_vpi_feproblem
	Reference the FEProblemBase class.

const THREAD_ID	_vpi_tid
	Thread ID.

const InputParameters &	_ri_params
	Parameters for the MooseObject inherting from this interface.

FEProblemBase &	_ri_fe_problem_base
	Provides access to FEProblemBase::getReporterData.

const ReporterData &	_ri_reporter_data
	The ReporterData.

const MooseObject &	_ri_moose_object
	The MooseObject needing this interface.

Detailed Description

Class for output data to the XDAII format.

Definition at line 18 of file XDA.h.

Member Typedef Documentation

◆ DataFileParameterType

using DataFileInterface::DataFileParameterType = DataFileName

inherited

The parameter type this interface expects for a data file name.

Definition at line 27 of file DataFileInterface.h.

Constructor & Destructor Documentation

◆ XDA()

XDA::XDA ( const InputParameters & parameters )

Class consturctor.

Definition at line 41 of file XDA.C.

  : SampledOutput(parameters), _binary(getParam<bool>("_binary"))
{
}

Member Function Documentation

◆ addDeprecatedInputParameters()

static void Output::addDeprecatedInputParameters ( InputParameters & params )

staticinherited

A static helper for injecting deprecated parameters.

◆ addPostprocessorDependencyHelper()

virtual void PostprocessorInterface::addPostprocessorDependencyHelper ( const PostprocessorName & ) const

inlineprotectedvirtualinherited

Helper for deriving classes to override to add dependencies when a Postprocessor is requested.

Reimplemented in UserObjectBase, AuxKernelBase, and InitialConditionBase.

Definition at line 149 of file PostprocessorInterface.h.

149{}

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal().

◆ addReporterDependencyHelper()

virtual void ReporterInterface::addReporterDependencyHelper ( const ReporterName & )

inlineprotectedvirtualinherited

A method that can be overridden to update the UO dependencies.

This is needed because the get methods for this interface cannot be virtual because of the template parameter. See GeneralUserObject for how it is utilized.

Reimplemented in UserObjectBase.

Definition at line 112 of file ReporterInterface.h.

112{}

Referenced by ReporterInterface::getReporterValueByName().

◆ addValidParams()

void AdvancedOutput::addValidParams	(	InputParameters &	params,
		const MultiMooseEnum &	types
	)

staticprivateinherited

Method for defining the available parameters based on the types of outputs.

Parameters

params	The InputParamters object to add parameters to
types	The types of output this object should support (see Output::enableOutputTypes)

Each output object may have a varying set of supported output types (e.g., elemental variables may not be supported). This private, static method populates the InputParameters object with the correct parameters based on the items contained in the ExecFlagEnum.

This method is private, users should utilize the Output::enableOutputTypes method

See also: Output::enableOutputTypes

Definition at line 712 of file AdvancedOutput.C.

{
  ExecFlagEnum empty_execute_on = MooseUtils::getDefaultExecFlagEnum();
  empty_execute_on.addAvailableFlags(EXEC_FAILED);
 
  // Nodal output
  if (types.isValueSet("nodal"))
  {
    params.addParam<ExecFlagEnum>(
        "execute_nodal_on", empty_execute_on, "Control the output of nodal variables");
    params.addParamNamesToGroup("execute_nodal_on", "Selection/restriction of output");
  }
 
  // Elemental output
  if (types.isValueSet("elemental"))
  {
    params.addParam<ExecFlagEnum>(
        "execute_elemental_on", empty_execute_on, "Control the output of elemental variables");
    params.addParamNamesToGroup("execute_elemental_on", "Selection/restriction of output");
 
    // Add material output control, which are output via elemental variables
    params.addParam<bool>("output_material_properties",
                          false,
                          "Flag indicating if material properties should be output");
    params.addParam<std::vector<std::string>>(
        "show_material_properties",
        "List of material properties that should be written to the output");
    params.addParamNamesToGroup("output_material_properties show_material_properties", "Materials");
 
    // Add mesh extra element id control, which are output via elemental variables
    params.addParam<bool>(
        "output_extra_element_ids",
        false,
        "Flag indicating if extra element ids defined on the mesh should be outputted");
    params.addParam<std::vector<std::string>>(
        "extra_element_ids_to_output",
        "List of extra element ids defined on the mesh that should be written to the output.");
    params.addParamNamesToGroup("output_extra_element_ids extra_element_ids_to_output", "Mesh");
  }
 
  // Scalar variable output
  if (types.isValueSet("scalar"))
  {
    params.addParam<ExecFlagEnum>(
        "execute_scalars_on", empty_execute_on, "Control the output of scalar variables");
    params.addParamNamesToGroup("execute_scalars_on", "Selection/restriction of output");
  }
 
  // Nodal and scalar output
  if (types.isValueSet("nodal") && types.isValueSet("scalar"))
  {
    params.addParam<bool>("scalar_as_nodal", false, "Output scalar variables as nodal");
    params.addParamNamesToGroup("scalar_as_nodal", "Conversions before output");
  }
 
  // Elemental and nodal
  if (types.isValueSet("elemental") && types.isValueSet("nodal"))
  {
    params.addParam<bool>(
        "elemental_as_nodal", false, "Output elemental nonlinear variables as nodal");
    params.addParamNamesToGroup("elemental_as_nodal", "Conversions before output");
  }
 
  // Postprocessors
  if (types.isValueSet("postprocessor"))
  {
    params.addParam<ExecFlagEnum>(
        "execute_postprocessors_on", empty_execute_on, "Control of when postprocessors are output");
    params.addParamNamesToGroup("execute_postprocessors_on", "Selection/restriction of output");
  }
 
  // Vector Postprocessors
  if (types.isValueSet("vector_postprocessor"))
  {
    params.addParam<ExecFlagEnum>("execute_vector_postprocessors_on",
                                  empty_execute_on,
                                  "Enable/disable the output of VectorPostprocessors");
    params.addParamNamesToGroup("execute_vector_postprocessors_on",
                                "Selection/restriction of output");
  }
 
  // Reporters
  if (types.isValueSet("reporter"))
  {
    params.addParam<ExecFlagEnum>(
        "execute_reporters_on", empty_execute_on, "Control of when Reporter values are output");
    params.addParamNamesToGroup("execute_reporters_on", "Selection/restriction of output");
  }
 
  // Input file
  if (types.isValueSet("input"))
  {
    params.addParam<ExecFlagEnum>(
        "execute_input_on", empty_execute_on, "Enable/disable the output of the input file");
    params.addParamNamesToGroup("execute_input_on", "Selection/restriction of output");
  }
 
  // System Information
  if (types.isValueSet("system_information"))
  {
    params.addParam<ExecFlagEnum>("execute_system_information_on",
                                  empty_execute_on,
                                  "Control when the output of the simulation information occurs");
    params.addParamNamesToGroup("execute_system_information_on", "Selection/restriction of output");
  }
}

Referenced by AdvancedOutput::enableOutputTypes().

◆ addVectorPostprocessorDependencyHelper()

virtual void VectorPostprocessorInterface::addVectorPostprocessorDependencyHelper ( const VectorPostprocessorName & ) const

inlineprotectedvirtualinherited

Helper for deriving classes to override to add dependencies when a VectorPostprocessor is requested.

Reimplemented in UserObjectBase, and AuxKernelBase.

Definition at line 319 of file VectorPostprocessorInterface.h.

320 {

321 }

Referenced by VectorPostprocessorInterface::getVectorPostprocessorByNameHelper(), and VectorPostprocessorInterface::getVectorPostprocessorContextByNameHelper().

◆ advancedExecuteOn()

const OutputOnWarehouse & AdvancedOutput::advancedExecuteOn ( ) const

virtualinherited

Get the current advanced 'execute_on' selections for display.

Reimplemented from Output.

Definition at line 899 of file AdvancedOutput.C.

{
  return _advanced_execute_on;
}

Referenced by CSV::initialSetup().

◆ allowOutput()

void Output::allowOutput ( bool state )

inlineinherited

Method for controlling the allow output state.

Parameters

state The state to set the allow flag to

Definition at line 129 of file Output.h.

129{ _allow_output = state; }

Output::_allow_output

bool _allow_output

Flag for disabling output.

Definition Output.h:268

◆ callMooseError() [1/2]

void MooseBase::callMooseError	(	MooseApp *const	app,
		const InputParameters &	params,
		std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node,
		const bool	show_trace = `true`
	)

staticinherited

External method for calling moose error with added object context.

Needed so that objects without the MooseBase context (InputParameters) can call errors with context

Parameters

app	The app pointer (if available); adds multiapp context and clears the console
params	The parameters, needed to obtain object information
msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 114 of file MooseBase.C.

{
  if (!node)
    node = MooseBase::getHitNode(params);
 
  std::string multiapp_prefix = "";
  if (app)
  {
    if (!app->isUltimateMaster())
      multiapp_prefix = app->name();
    app->getOutputWarehouse().mooseConsole();
  }
 
  if (with_prefix)
    // False here because the hit context will get processed by the node
    msg = messagePrefix(params, false) + msg;
 
  moose::internal::mooseErrorRaw(msg, multiapp_prefix, node, show_trace);
}

◆ callMooseError() [2/2]

void MooseBase::callMooseError	(	std::string	msg,
		const bool	with_prefix,
		const hit::Node *	node = `nullptr`,
		const bool	show_trace = `true`
	)		const

inherited

External method for calling moose error with added object context.

Parameters

msg	The message
with_prefix	If true, add the prefix from messagePrefix(), which is the object information (type, name, etc)
node	Optional hit node to add file path context as a prefix
show_trace	Whether or not to show a stack trace, defaults to true

Definition at line 105 of file MooseBase.C.

{
  callMooseError(&_app, _pars, msg, with_prefix, node, show_trace);
}

Referenced by MooseBase::callMooseError(), InputParameters::callMooseError(), MooseBase::mooseDocumentedError(), MooseBase::mooseError(), and MooseBase::mooseErrorNonPrefixed().

◆ checkFilename()

bool FileOutput::checkFilename ( )

protectedinherited

Checks the filename for output Checks the output against the 'output_if_base_contians' list.

Returns: Returns true if the filename is valid for output

Definition at line 88 of file FileOutput.C.

{
  // Return true if 'output_if_base_contains' is not utilized
  if (_output_if_base_contains.empty())
    return true;
 
  // Assumed output is false
  bool output = false;
 
  // Loop through each string in the list
  for (const auto & search_string : _output_if_base_contains)
  {
    // Search for the string in the file base, if found set the output to true and break the loop
    if (_file_base.find(search_string) != std::string::npos)
    {
      output = true;
      break;
    }
  }
 
  // Return the value
  return output;
}

Referenced by AdvancedOutput::shouldOutput(), and FileOutput::shouldOutput().

◆ checkParam()

void PostprocessorInterface::checkParam	(	const std::string &	param_name,
		const unsigned int	index = `std::numeric_limits<unsigned int>::max()`
	)		const

privateinherited

Checks the parameters relating to a Postprocessor.

If index is not set, index checking is not performed.

Definition at line 149 of file PostprocessorInterface.C.

{
  const bool check_index = index != std::numeric_limits<unsigned int>::max();
 
  if (!_ppi_params.isParamValid(param_name))
    _ppi_moose_object.mooseError(
        "When getting a Postprocessor, failed to get a parameter with the name \"",
        param_name,
        "\".",
        "\n\nKnown parameters:\n",
        _ppi_moose_object.parameters());
 
  if (_ppi_params.isType<PostprocessorName>(param_name))
  {
    if (check_index && index > 0)
      _ppi_moose_object.paramError(param_name,
                                   "A Postprocessor was requested with index ",
                                   index,
                                   " but a single Postprocessor is coupled.");
  }
  else if (_ppi_params.isType<std::vector<PostprocessorName>>(param_name))
  {
    const auto & names = _ppi_params.get<std::vector<PostprocessorName>>(param_name);
    if (check_index && names.size() <= index)
      _ppi_moose_object.paramError(param_name,
                                   "A Postprocessor was requested with index ",
                                   index,
                                   " but only ",
                                   names.size(),
                                   " Postprocessors are coupled.");
  }
  else
  {
    _ppi_moose_object.mooseError(
        "Supplied parameter with name \"",
        param_name,
        "\" of type \"",
        _ppi_params.type(param_name),
        "\" is not an expected type for getting a Postprocessor.\n\n",
        "Allowed types are \"PostprocessorName\" and \"std::vector<PostprocessorName>\".");
  }
}

Referenced by PostprocessorInterface::coupledPostprocessors(), and PostprocessorInterface::getPostprocessorNameInternal().

◆ clearLastExecuteTime()

void AdvancedOutput::clearLastExecuteTime ( )

protectedinherited

Clears bookkeeping used to suppress duplicate EXEC_FINAL output at the same time.

Definition at line 337 of file AdvancedOutput.C.

{
  _last_execute_time.clear();
}

Referenced by Exodus::clear(), and TableOutput::clear().

◆ cloneMesh()

void SampledOutput::cloneMesh ( )

privateinherited

Clone mesh in preperation for re-positioning or oversampling.

This changes the pointer, _mesh_ptr, with a clone of the current mesh so that it may be modified to perform the necessary sample/positioning/block-restriction actions

Definition at line 446 of file SampledOutput.C.

{
  // Create the new mesh from a file
  if (isParamValid("file"))
  {
    InputParameters mesh_params = _app.getFactory().getValidParams("FileMesh");
    mesh_params.applyParameters(parameters(), {}, true);
    mesh_params.set<bool>("nemesis") = false;
    _sampling_mesh_ptr =
        _app.getFactory().createUnique<MooseMesh>("FileMesh", "output_problem_mesh", mesh_params);
    _sampling_mesh_ptr->allowRecovery(false); // We actually want to reread the initial mesh
    _sampling_mesh_ptr->init();
  }
  // Clone the existing mesh
  else
  {
    if (_app.isRecovering())
      mooseWarning("Recovering or Restarting with oversampling may not work (especially with "
                   "adapted meshes)!!  Refs #2295");
    _sampling_mesh_ptr = _mesh_ptr->safeClone();
  }
 
  // Remove unspecified blocks
  if (isParamValid("sampling_blocks"))
  {
    // Remove all elements not in the blocks
    const auto & blocks_to_keep_names = getParam<std::vector<SubdomainName>>("sampling_blocks");
    const auto & blocks_to_keep = _sampling_mesh_ptr->getSubdomainIDs(blocks_to_keep_names);
    for (const auto & elem_ptr : _sampling_mesh_ptr->getMesh().element_ptr_range())
      if (std::find(blocks_to_keep.begin(), blocks_to_keep.end(), elem_ptr->subdomain_id()) ==
          blocks_to_keep.end())
        _sampling_mesh_ptr->getMesh().delete_elem(elem_ptr);
 
    // Deleting elements and isolated nodes would cause renumbering. Not renumbering might help
    // user examining the sampling mesh and the regular mesh. Also if we end up partitioning the
    // elements, the node partitioning is unlikely to match if the element numbering is different.
    // Still not enough of a guarantee, because of deleted elements the node partitioning could be
    // different. We will rely on ghosting to make it work
    _sampling_mesh_ptr->getMesh().allow_renumbering(false);
  }
 
  // Set a partitioner
  if (!_serialize)
  {
    _sampling_mesh_ptr->setIsCustomPartitionerRequested(true);
    InputParameters partition_params = _app.getFactory().getValidParams("CopyMeshPartitioner");
    partition_params.set<MooseMesh *>("mesh") = _sampling_mesh_ptr.get();
    partition_params.set<MooseMesh *>("source_mesh") = _mesh_ptr;
    std::shared_ptr<MoosePartitioner> mp = _factory.create<MoosePartitioner>(
        "CopyMeshPartitioner", "sampled_output_part", partition_params);
    _sampling_mesh_ptr->setCustomPartitioner(mp.get());
 
    _sampling_mesh_ptr->getMesh().prepare_for_use();
    // this should be called by prepare_for_use, but is not.
    // it also requires a prior call to prepare_for_use()
    mp->partition(_sampling_mesh_ptr->getMesh(), comm().size());
  }
 
  // Prepare mesh, needed for the mesh functions
  if (_using_external_sampling_file)
    _sampling_mesh_ptr->prepare(/*mesh to clone*/ nullptr);
  else if (_serialize && isParamValid("sampling_blocks"))
    // TODO: constraints have not been initialized?
    _sampling_mesh_ptr->getMesh().prepare_for_use();
 
  if (_serialize)
    // we want to avoid re-partitioning, as we will serialize anyway
    _sampling_mesh_ptr->getMesh().skip_partitioning(true);
 
  // Make sure that the mesh pointer points to the newly cloned mesh
  _mesh_ptr = _sampling_mesh_ptr.get();
 
  // Check the source and target mesh in case their subdomains match
  const std::vector<SubdomainID> mesh_subdomain_ids_vec(_mesh_ptr->meshSubdomains().begin(),
                                                        _mesh_ptr->meshSubdomains().end());
  const std::vector<SubdomainID> initial_mesh_subdomain_ids_vec(
      _problem_ptr->mesh().meshSubdomains().begin(), _problem_ptr->mesh().meshSubdomains().end());
  _mesh_subdomains_match =
      (_mesh_ptr->meshSubdomains() == _problem_ptr->mesh().meshSubdomains() &&
       _mesh_ptr->getSubdomainNames(mesh_subdomain_ids_vec) ==
           _problem_ptr->mesh().getSubdomainNames(initial_mesh_subdomain_ids_vec));
  if (_using_external_sampling_file && !_mesh_subdomains_match)
    mooseInfoRepeated("Variable block restriction disabled in sampled output due to non-matching "
                      "subdomain names and ids");
}

Referenced by SampledOutput::initSample().

◆ connectControllableParams()

void MooseBase::connectControllableParams	(	const std::string &	parameter,
		const std::string &	object_type,
		const std::string &	object_name,
		const std::string &	object_parameter
	)		const

inherited

Connect controllable parameter of this action with the controllable parameters of the objects added by this action.

Parameters

parameter	Name of the controllable parameter of this action
object_type	Type of the object added by this action.
object_name	Name of the object added by this action.
object_parameter	Name of the parameter of the object.

Definition at line 77 of file MooseBase.C.

{
  auto & factory = _app.getFactory();
  auto & ip_warehouse = _app.getInputParameterWarehouse();
 
  MooseObjectParameterName primary_name(uniqueName(), parameter);
  const auto base_type = factory.getValidParams(object_type).getBase();
  MooseObjectParameterName secondary_name(base_type, object_name, object_parameter);
  ip_warehouse.addControllableParameterConnection(primary_name, secondary_name);
 
  const auto & tags = _pars.get<std::vector<std::string>>("control_tags");
  for (const auto & tag : tags)
  {
    if (!tag.empty())
    {
      // Only adds the parameter with the different control tags if the derived class
      // properly registers the parameter to its own syntax
      MooseObjectParameterName tagged_name(tag, name(), parameter);
      ip_warehouse.addControllableParameterConnection(
          tagged_name, secondary_name, /*error_on_empty=*/false);
    }
  }
}

◆ coupledPostprocessors()

std::size_t PostprocessorInterface::coupledPostprocessors ( const std::string & param_name ) const

inherited

Returns number of Postprocessors coupled under parameter name.

Parameters

param_name The name of the Postprocessor parameter

Returns: Number of coupled post-processors, 1 if it's a single

Definition at line 139 of file PostprocessorInterface.C.

{
  checkParam(param_name);
 
  if (_ppi_params.isType<PostprocessorName>(param_name))
    return 1;
  return _ppi_params.get<std::vector<PostprocessorName>>(param_name).size();
}

Referenced by FunctionValuePostprocessor::FunctionValuePostprocessor().

◆ customSetup()

virtual void SetupInterface::customSetup ( const ExecFlagType & )

inlinevirtualinherited

Gets called in FEProblemBase::execute() for execute flags other than initial, timestep_begin, nonlinear, linear and subdomain.

Reimplemented in Function.

Definition at line 69 of file SetupInterface.h.

69{}

◆ declareManagedRestartableDataWithContext()

template<typename T , typename... Args>

Restartable::ManagedValue< T > Restartable::declareManagedRestartableDataWithContext	(	const std::string &	data_name,
		void *	context,
		Args &&...	args
	)

protectedinherited

Declares a piece of "managed" restartable data and initialize it.

Here, "managed" restartable data means that the caller can destruct this data upon destruction of the return value of this method. Therefore, this ManagedValue<T> wrapper should survive after the final calls to dataStore() for it. That is... at the very end.

This is needed for objects whose destruction ordering is important, and enables natural c++ destruction in reverse construction order of the object that declares it.

See delcareRestartableData and declareRestartableDataWithContext for more information.

Definition at line 283 of file Restartable.h.

{
  auto & data_ptr =
      declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...);
  return Restartable::ManagedValue<T>(data_ptr);
}

◆ declareRecoverableData()

template<typename T , typename... Args>

T & Restartable::declareRecoverableData	(	const std::string &	data_name,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "recoverable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

Note - this data will NOT be restored on Restart!

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 358 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  registerRestartableNameWithFilterOnApp(full_name, Moose::RESTARTABLE_FILTER::RECOVERABLE);
 
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

◆ declareRestartableData()

template<typename T , typename... Args>

T & Restartable::declareRestartableData	(	const std::string &	data_name,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
args	Arguments to forward to the constructor of the data

Definition at line 276 of file Restartable.h.

{
  return declareRestartableDataWithContext<T>(data_name, nullptr, std::forward<Args>(args)...);
}

◆ declareRestartableDataHelper()

template<typename T , typename... Args>

RestartableData< T > & Restartable::declareRestartableDataHelper	(	const std::string &	data_name,
		void *	context,
		Args &&...	args
	)		const

privateinherited

Helper function for declaring restartable data.

We use this function to reduce code duplication when returning const/nonconst references to the data.

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 310 of file Restartable.h.

{
  const auto full_name = restartableName(data_name);
 
  // Here we will create the RestartableData even though we may not use this instance.
  // If it's already in use, the App will return a reference to the existing instance and we'll
  // return that one instead. We might refactor this to have the app create the RestartableData
  // at a later date.
  auto data_ptr =
      std::make_unique<RestartableData<T>>(full_name, context, std::forward<Args>(args)...);
  auto & restartable_data_ref = static_cast<RestartableData<T> &>(
      registerRestartableDataOnApp(std::move(data_ptr), _restartable_tid));
 
  return restartable_data_ref;
}

◆ declareRestartableDataWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithContext	(	const std::string &	data_name,
		void *	context,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "restartable" and initialize it.

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 301 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, context, std::forward<Args>(args)...).set();
}

◆ declareRestartableDataWithObjectName()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectName	(	const std::string &	data_name,
		const std::string &	object_name,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
args	Arguments to forward to the constructor of the data

Definition at line 330 of file Restartable.h.

{
  return declareRestartableDataWithObjectNameWithContext<T>(
      data_name, object_name, nullptr, std::forward<Args>(args)...);
}

◆ declareRestartableDataWithObjectNameWithContext()

template<typename T , typename... Args>

T & Restartable::declareRestartableDataWithObjectNameWithContext	(	const std::string &	data_name,
		const std::string &	object_name,
		void *	context,
		Args &&...	args
	)

protectedinherited

Declare a piece of data as "restartable".

This means that in the event of a restart this piece of data will be restored back to its previous value.

NOTE: This returns a reference! Make sure you store it in a reference!

Parameters

data_name	The name of the data (usually just use the same name as the member variable)
object_name	A supplied name for the object that is declaring this data.
context	Context pointer that will be passed to the load and store functions
args	Arguments to forward to the constructor of the data

Definition at line 340 of file Restartable.h.

{
  std::string old_name = _restartable_name;
 
  _restartable_name = object_name;
 
  T & value = declareRestartableDataWithContext<T>(data_name, context, std::forward<Args>(args)...);
 
  _restartable_name = old_name;
 
  return value;
}

◆ dt()

Real Output::dt ( )

virtualinherited

Get the current time step size.

Definition at line 369 of file Output.C.

{
  if (_transient)
    return _dt;
  else
    return 1;
}

Referenced by Console::writeTimestepInformation().

◆ dtOld()

Real Output::dtOld ( )

virtualinherited

Get old time step size.

Definition at line 378 of file Output.C.

{
  if (_transient)
    return _dt_old;
  else
    return 1;
}

◆ enabled()

virtual bool MooseObject::enabled ( ) const

inlinevirtualinherited

Return the enabled status of the object.

Reimplemented in EigenKernel.

Definition at line 49 of file MooseObject.h.

49{ return _enabled; }

MooseObject::_enabled

const bool & _enabled

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition MooseObject.h:71

Referenced by EigenKernel::enabled(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), and NodeFaceConstraint::validParams().

◆ enableOutputTypes()

InputParameters AdvancedOutput::enableOutputTypes ( const std::string & names = std::string() )

staticinherited

A method for enabling individual output type control.

Parameters

names (optional) Space separated of output type names that are supported by this Output object, if this is omitted all outputs types will be supported. The list of available output types is given below.

Output objects vary widely in what type of outputs they support (e.g., elemental variables, or postprocessor data). This method provides the user a means for controlling the types of outputs that are supported for the object being created. This is a static method that MUST be used to append parameters inside the objects validParams function.

List of Output Types and Method Names The output system is designed around overloading virtual method calls to output the various output types, the following list gives the name of the output type and the associated virtual method that should be overloaded to perform the output in the object being created.

Type virtual Method Name

nodal outputNodalVariables() elemental outputElementalVariables() scalar outputScalarVariables() postprocessor outputPostprocessors() vector_postprocessor outputVectorPostprocessors() input outputInput() system_information outputSystemInformation()

See also: CSV Exodus

Definition at line 117 of file AdvancedOutput.C.

{
  // The parameters object that will be returned
  InputParameters params = emptyInputParameters();
 
  // Get the MultiEnum of output types
  MultiMooseEnum output_types = getOutputTypes();
 
  // Update the enum of output types to append
  if (names.empty())
    output_types = output_types.getRawNames();
  else
    output_types = names;
 
  // Add the parameters and return them
  addValidParams(params, output_types);
  return params;
}

Referenced by Console::validParams(), Exodus::validParams(), JSONOutput::validParams(), Nemesis::validParams(), TableOutput::validParams(), and XMLOutput::validParams().

◆ errorPrefix()

std::string MooseBase::errorPrefix ( const std::string & ) const

inlineinherited

Deprecated message prefix; the error type is no longer used.

Definition at line 264 of file MooseBase.h.

264{ return messagePrefix(); }

◆ executeOn()

const MultiMooseEnum & Output::executeOn ( ) const

inherited

Get the current 'execute_on' selections for display.

Definition at line 393 of file Output.C.

{
  return _execute_on;
}

◆ filename()

std::string XDA::filename ( )

overrideprotectedvirtual

Returns the current filename, this method handles adding the timestep suffix.

Returns: A string containg the current filename to be written

Reimplemented from FileOutput.

Definition at line 71 of file XDA.C.

{
  // Append the padded time step to the file base
  std::ostringstream output;
  output << _file_base << "_" << std::setw(_padding) << std::setprecision(0) << std::setfill('0')
         << std::right << _file_num;
 
  if (_binary)
    output << ".xdr";
  else
    output << ".xda";
  return output.str();
}

Referenced by output().

◆ flagInvalidSolutionInternal()

template<bool warning>

template void SolutionInvalidInterface::flagInvalidSolutionInternal< false > ( const InvalidSolutionID invalid_solution_id ) const

protectedinherited

Set solution invalid mark for the given solution ID.

Definition at line 41 of file SolutionInvalidInterface.C.

{
  mooseAssert(
      warning == moose::internal::getSolutionInvalidityRegistry().item(invalid_solution_id).warning,
      "Inconsistent warning flag");
  auto & solution_invalidity = _si_moose_base.getMooseApp().solutionInvalidity();
  if constexpr (!warning)
    if (!_si_problem || _si_problem->immediatelyPrintInvalidSolution())
      solution_invalidity.printDebug(invalid_solution_id);
  return solution_invalidity.flagInvalidSolutionInternal(invalid_solution_id);
}

◆ getBase()

const std::string & MooseBase::getBase ( ) const

inlineinherited

Returns: The registered base for this object (set via InputParameters::registerBase())

Definition at line 147 of file MooseBase.h.

147{ return _pars.getBase(); }

InputParameters::getBase

const std::string & getBase() const

Definition InputParameters.C:505

Referenced by Factory::copyConstruct(), and MooseBase::uniqueParameterName().

◆ getCheckedPointerParam()

template<typename T >

T MooseBase::getCheckedPointerParam	(	const std::string &	name,
		const std::string &	error_string = `""`
	)		const

inherited

Verifies that the requested parameter exists and is not NULL and returns it to the caller.

The template parameter must be a pointer or an error will be thrown.

Definition at line 450 of file MooseBase.h.

{
  return _pars.getCheckedPointerParam<T>(name, error_string);
}

◆ getDataFileName()

std::string DataFileInterface::getDataFileName ( const std::string & param ) const

inherited

Deprecated method.

The data file paths are now automatically set within the InputParameters object, so using getParam<DataFileName>("param_name") is now sufficient.

Definition at line 21 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileName() is deprecated. The file path is now directly set "
                          "within the InputParameters.\nUse getParam<DataFileName>(\"",
                          param,
                          "\") instead.");
  return _parent.getParam<DataFileName>(param);
}

◆ getDataFileNameByName()

std::string DataFileInterface::getDataFileNameByName ( const std::string & relative_path ) const

inherited

Deprecated method.

Use getDataFilePath() instead.

Definition at line 31 of file DataFileInterface.C.

{
  _parent.mooseDeprecated("getDataFileNameByName() is deprecated. Use getDataFilePath(\"",
                          relative_path,
                          "\") instead.");
  return getDataFilePath(relative_path);
}

◆ getDataFilePath()

std::string DataFileInterface::getDataFilePath ( const std::string & relative_path ) const

inherited

Returns the path of a data file for a given relative file path.

This can be used for hardcoded datafile names and will search the same locations as getDataFileName

Definition at line 40 of file DataFileInterface.C.

{
  // This should only ever be used with relative paths. There is no point to
  // use this search path with an absolute path.
  if (std::filesystem::path(relative_path).is_absolute())
    _parent.mooseWarning("While using getDataFilePath(\"",
                         relative_path,
                         "\"): This API should not be used for absolute paths.");
 
  // This will search the data paths for this relative path
  std::optional<std::string> error;
  Moose::DataFileUtils::Path found_path;
  {
    // Throw on error so that if getPath() fails, we can throw an error
    // with the context of _parent.mooseError()
    Moose::ScopedThrowOnError scoped_throw_on_error;
 
    try
    {
      found_path = Moose::DataFileUtils::getPath(relative_path);
    }
    catch (std::exception & e)
    {
      error = e.what();
    }
  }
 
  if (error)
    _parent.mooseError(*error);
 
  mooseAssert(found_path.context == Moose::DataFileUtils::Context::DATA,
              "Should only ever obtain data");
  mooseAssert(found_path.data_name, "Should be set");
 
  const std::string msg =
      "Using data file '" + found_path.path + "' from " + *found_path.data_name + " data";
  _parent.mooseInfo(msg);
 
  return found_path.path;
}

Referenced by DataFileInterface::getDataFileNameByName().

◆ getDefaultExecFlagEnum()

ExecFlagEnum Output::getDefaultExecFlagEnum ( )

staticinherited

Return an ExecFlagEnum object with the available execution flags for Output objects.

Definition at line 104 of file Output.C.

{
  ExecFlagEnum exec_enum = MooseUtils::getDefaultExecFlagEnum();
  exec_enum.addAvailableFlags(EXEC_FAILED);
  return exec_enum;
}

Referenced by CommonOutputAction::validParams(), and Output::validParams().

◆ getDefaultPostprocessorValueByName()

PostprocessorValue PostprocessorInterface::getDefaultPostprocessorValueByName ( const PostprocessorName & name ) const

privateinherited

Returns: The default value stored in the PostprocessorName name.

Definition at line 106 of file PostprocessorInterface.C.

{
  mooseAssert(isDefaultPostprocessorValueByName(name), "Not a default value");
 
  Real real_value = -std::numeric_limits<Real>::max();
  std::istringstream ss(name);
  ss >> real_value;
  return real_value;
}

Referenced by PostprocessorInterface::getPostprocessorValueInternal().

◆ getElementalVariableOutput()

const std::set< std::string > & AdvancedOutput::getElementalVariableOutput ( )

inherited

The list of elemental nonlinear variables names that are set for output.

Returns: A vector of strings containing the names of the nonlinear variables for output

See also: hasElementalVariableOutput

Definition at line 845 of file AdvancedOutput.C.

{
  return _execute_data["elemental"].output;
}

Referenced by SampledOutput::initSample(), Nemesis::output(), and Exodus::outputElementalVariables().

◆ getExecuteOnEnum()

const ExecFlagEnum & SetupInterface::getExecuteOnEnum ( ) const

inherited

Return the execute on MultiMooseEnum for this object.

Definition at line 73 of file SetupInterface.C.

{
  return _execute_enum;
}

Referenced by ChangeOverFixedPointPostprocessor::ChangeOverFixedPointPostprocessor(), ChangeOverTimePostprocessor::ChangeOverTimePostprocessor(), MultiAppTransfer::checkMultiAppExecuteOn(), Control::Control(), IntegralPreservingFunctionIC::initialSetup(), MultiAppConservativeTransfer::initialSetup(), Terminator::initialSetup(), Exodus::outputSetup(), ElementReporter::shouldStore(), GeneralReporter::shouldStore(), NodalReporter::shouldStore(), and PIDTransientControl::timestepSetup().

◆ getFileNumber()

unsigned int FileOutput::getFileNumber ( )

inherited

Return the current file number for this outputter.

This method was implemented for the MultiApp system, particularly when reseting an application and a new output file is desired after the reset.

Definition at line 180 of file FileOutput.C.

{
  return _file_num;
}

Referenced by OutputWarehouse::getFileNumbers(), and MFEMDataCollection::output().

◆ getFunction()

const Function & FunctionInterface::getFunction ( const std::string & name ) const

inherited

Get a function with a given name.

Parameters

name	The name of the parameter key of the function to retrieve

Returns: The function with name associated with the parameter 'name'

Definition at line 34 of file FunctionInterface.C.

{
  return getFunctionByName(_fni_params.get<FunctionName>(name));
}

Referenced by FunctionDT::FunctionDT(), and Output::Output().

◆ getFunctionByName()

const Function & FunctionInterface::getFunctionByName ( const FunctionName & name ) const

inherited

Get a function with a given name.

Parameters

name	The name of the function to retrieve

Returns: The function with name 'name'

Definition at line 40 of file FunctionInterface.C.

{
  return _fni_feproblem.getFunction(name, _fni_tid);
}

Referenced by ArrayBodyForce::ArrayBodyForce(), ArrayFunctionIC::ArrayFunctionIC(), CompositeFunction::CompositeFunction(), FunctionArrayAux::FunctionArrayAux(), FunctionScalarAux::FunctionScalarAux(), FunctionScalarIC::FunctionScalarIC(), GenericFunctionMaterialTempl< is_ad >::GenericFunctionMaterialTempl(), GenericFunctionRankTwoTensorTempl< is_ad >::GenericFunctionRankTwoTensorTempl(), GenericFunctionVectorMaterialTempl< is_ad >::GenericFunctionVectorMaterialTempl(), FunctionInterface::getFunction(), LinearCombinationFunction::LinearCombinationFunction(), LineFunctionSampler::LineFunctionSampler(), and PiecewiseFunction::PiecewiseFunction().

◆ getHitNode() [1/2]

const hit::Node * MooseBase::getHitNode ( ) const

inlineinherited

Returns: The block-level hit node for this object, if any

Definition at line 136 of file MooseBase.h.

136{ return getHitNode(_pars); }

Referenced by MooseBase::callMooseError(), MooseBase::getHitNode(), and MooseBase::messagePrefix().

◆ getHitNode() [2/2]

const hit::Node * MooseBase::getHitNode ( const InputParameters & params )

staticprivateinherited

Internal method for getting a hit node (if available) given a set of parameters.

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 167 of file MooseBase.C.

{
  if (const auto hit_node = params.getHitNode())
    if (!hit_node->isRoot())
      return hit_node;
  return nullptr;
}

◆ getKokkosFunction() [1/2]

Moose::Kokkos::Function FunctionInterface::getKokkosFunction ( const std::string & name ) const

inherited

Get a Kokkos function of an abstract type with a given name Calling this function will error out currently if Kokkos was configured with GPU.

Parameters

name	The name of the parameter key of the Kokkos function to retrieve

Returns: The copy of the Kokkos function of the abstract type with name associated with the parameter 'name'

◆ getKokkosFunction() [2/2]

template<typename T >

const T & FunctionInterface::getKokkosFunction ( const std::string & name ) const

inherited

Get a Kokkos function of a concrete type with a given name.

Template Parameters

T	The Kokkos function type

Parameters

name	The name of the parameter key of the Kokkos function to retrieve

Returns: The reference of the Kokkos function of the concrete type with name associated with the parameter 'name'. Always store it in a reference wrapper if to be used on GPU.

Definition at line 165 of file FunctionInterface.h.

{
  return getKokkosFunctionByName<T>(_fni_params.get<FunctionName>(name));
}

◆ getKokkosFunctionByName() [1/2]

Moose::Kokkos::Function FunctionInterface::getKokkosFunctionByName ( const FunctionName & name ) const

inherited

Get a Kokkos function of an abstract type with a given name Calling this function will error out currently if Kokkos was configured with GPU.

Parameters

name	The name of the Kokkos function to retrieve

Returns: The copy of the Kokkos function of the abstract type with name 'name'

◆ getKokkosFunctionByName() [2/2]

template<typename T >

const T & FunctionInterface::getKokkosFunctionByName ( const FunctionName & name ) const

inherited

Get a Kokkos function of a concrete type with a given name.

Template Parameters

T	The Kokkos function type

Parameters

name	The name of the Kokkos function to retrieve

Returns: The reference of the Kokkos function of the concrete type with name 'name'. Always store it in a reference wrapper if to be used on GPU.

Definition at line 172 of file FunctionInterface.h.

{
  auto function = dynamic_cast<const T *>(getKokkosFunctionByNameHelper(name));
 
  if (!function)
    _fni_object.mooseError(
        "Kokkos function '", name, "' is not of type '", MooseUtils::prettyCppType<T>(), "'");
 
  return *function;
}

◆ getKokkosFunctionByNameHelper()

const Moose::FunctionBase * FunctionInterface::getKokkosFunctionByNameHelper ( const FunctionName & name ) const

privateinherited

Helper function to retrieve a Kokkos function.

Referenced by FunctionInterface::getKokkosFunctionByName().

◆ getMooseApp()

MooseApp & MooseBase::getMooseApp ( ) const

inlineinherited

Get the MooseApp this class is associated with.

Definition at line 87 of file MooseBase.h.

87{ return _app; }

Referenced by ChainControlSetupAction::act(), AddDefaultConvergenceAction::addDefaultMultiAppFixedPointConvergence(), AddDefaultConvergenceAction::addDefaultNonlinearConvergence(), AddDefaultConvergenceAction::addDefaultSteadyStateConvergence(), FEProblemBase::advanceState(), ParsedChainControl::buildFunction(), ReporterTransferInterface::checkHasReporterValue(), AddDefaultConvergenceAction::checkUnusedMultiAppFixedPointConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedNonlinearConvergenceParameters(), AddDefaultConvergenceAction::checkUnusedSteadyStateConvergenceParameters(), Coupleable::checkWritableVar(), ComponentPhysicsInterface::ComponentPhysicsInterface(), Coupleable::Coupleable(), MortarInterfaceWarehouse::createMortarInterface(), EigenProblem::doFreeNonlinearPowerIterations(), Terminator::execute(), FEProblemSolve::FEProblemSolve(), SolutionInvalidInterface::flagInvalidSolutionInternal(), ChainControl::getChainControlDataSystem(), FEProblemBase::getDistribution(), FEProblemBase::getFunction(), FEProblemBase::getFVInterpolationMethod(), FEProblemBase::getMultiApp(), FEProblemBase::getSampler(), DefaultConvergenceBase::getSharedExecutionerParam(), FEProblemBase::getUserObjectBase(), FEProblemBase::getVectorPostprocessorObjectByName(), ChainControlDataPostprocessor::initialSetup(), MaterialPropertyInterface::MaterialPropertyInterface(), MooseVariableDataFV< OutputType >::MooseVariableDataFV(), ProgressOutput::output(), PetscOutputInterface::petscLinearOutput(), PetscOutputInterface::petscNonlinearOutput(), Moose::PetscSupport::PetscOptionsScope::PetscOptionsScope(), PetscOutputInterface::PetscOutputInterface(), PostprocessorInterface::postprocessorsAdded(), MultiApp::preTransfer(), Reporter::Reporter(), ReporterInterface::reportersAdded(), MultiApp::restore(), and VectorPostprocessorInterface::vectorPostprocessorsAdded().

◆ getNodalVariableOutput()

const std::set< std::string > & AdvancedOutput::getNodalVariableOutput ( )

inherited

The list of nodal nonlinear variables names that are set for output.

Returns: A vector of strings containing the names of the nodal nonlinear variables for output

Note: The list returned by this will contain the names of both elemental and nodal variable names if 'elemental_as_nodal = true' in the input file. The libMesh output system (EquationSystems::build_solution_vector) performs the correct action within the solution vector by setting the nodal values as the average of the values for each of the element that the node shares.

See also: hasNodalVariableOutput

Definition at line 833 of file AdvancedOutput.C.

{
  return _execute_data["nodal"].output;
}

Referenced by SampledOutput::initSample(), Nemesis::output(), and Exodus::outputNodalVariables().

◆ getOutputTime()

Real PetscOutput::getOutputTime ( )

protectedvirtualinherited

Get the time that will be used for stream/file outputting.

This method is intended to override the output given by time() for cases that do not conform to the linear, nonlinear, time step pattern. For example, this can be used for optimization or fixed point iteration solves. If you override this method for your application, replace time() calls with getOutputTime() calls and ensure output consistency.

Definition at line 273 of file PetscOutput.C.

{
  return time();
}

Referenced by Nemesis::output(), Tecplot::output(), Exodus::outputEmptyTimestep(), Exodus::outputNodalVariables(), TableOutput::outputPostprocessorsRow(), TableOutput::outputReporter(), TableOutput::outputScalarVariables(), TableOutput::shouldOutputPostprocessorsRow(), and Console::writeTimestepInformation().

◆ getOutputTypes()

MultiMooseEnum AdvancedOutput::getOutputTypes ( )

staticprivateinherited

Get the supported types of output (e.g., postprocessors, etc.)

Definition at line 109 of file AdvancedOutput.C.

{
  return MultiMooseEnum("nodal=0 elemental=1 scalar=2 postprocessor=3 vector_postprocessor=4 "
                        "input=5 system_information=6 reporter=7");
}

Referenced by AdvancedOutput::enableOutputTypes().

◆ getParam() [1/2]

template<typename T >

const T & MooseBase::getParam ( const std::string & name ) const

inherited

Retrieve a parameter for the object.

Parameters

name	The name of the parameter

Returns: The value of the parameter

Definition at line 406 of file MooseBase.h.

{
  return InputParameters::getParamHelper<T>(name, _pars);
}

◆ getParam() [2/2]

template<typename T1 , typename T2 >

std::vector< std::pair< T1, T2 > > MooseBase::getParam	(	const std::string &	param1,
		const std::string &	param2
	)		const

inherited

Retrieve two parameters and provide pair of parameters for the object.

Parameters

param1	The name of first parameter
param2	The name of second parameter

Returns: Vector of pairs of first and second parameters

Definition at line 443 of file MooseBase.h.

{
  return _pars.get<T1, T2>(param1, param2);
}

◆ getPostprocessorName()

const PostprocessorName & PostprocessorInterface::getPostprocessorName	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Get the name of a postprocessor.

This can only be used if the postprocessor parameter does not have a default value set (see isDefaultPostprocessorValue()), in which case the "name" is actually the default value.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the Postprocessor

Returns: The name of the given Postprocessor

Definition at line 195 of file PostprocessorInterface.C.

{
  return getPostprocessorNameInternal(param_name, index, /* allow_default_value = */ false);
}

Referenced by EigenKernel::EigenKernel().

◆ getPostprocessorNameInternal()

const PostprocessorName & PostprocessorInterface::getPostprocessorNameInternal	(	const std::string &	param_name,
		const unsigned int	index,
		const bool	allow_default_value = `true`
	)		const

privateinherited

Internal method for getting the PostprocessorName associated with a paremeter.

Needed in order to allow the return of a name that is a default value.

Definition at line 202 of file PostprocessorInterface.C.

{
  checkParam(param_name, index);
 
  const auto & name = _ppi_params.isType<PostprocessorName>(param_name)
                          ? _ppi_params.get<PostprocessorName>(param_name)
                          : _ppi_params.get<std::vector<PostprocessorName>>(param_name)[index];
 
  if (!allow_default_value && isDefaultPostprocessorValueByName(name))
  {
    std::stringstream oss;
    oss << "Cannot get the name associated with PostprocessorName parameter \"" << param_name
        << "\"";
    if (index)
      oss << " at index " << index;
    oss << ",\nbecause said parameter is a default Postprocessor value.";
    _ppi_moose_object.paramError(param_name, oss.str());
  }
 
  return name;
}

Referenced by PostprocessorInterface::getPostprocessorName(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::hasPostprocessor(), and PostprocessorInterface::isDefaultPostprocessorValue().

◆ getPostprocessorOutput()

const std::set< std::string > & AdvancedOutput::getPostprocessorOutput ( )

inherited

The list of postprocessor names that are set for output.

Returns: A vector of strings containing the names of the postprocessor variables for output

See also: hasPostprocessorOutput

Definition at line 869 of file AdvancedOutput.C.

{
  return _execute_data["postprocessors"].output;
}

Referenced by CSV::initialSetup(), Exodus::outputPostprocessors(), Nemesis::outputPostprocessors(), TableOutput::outputPostprocessorsRow(), and TableOutput::shouldOutputPostprocessorsRow().

◆ getPostprocessorValue()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValue	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

doco-normal-methods-begin Retrieve the value of a Postprocessor or one of it's old or older values

Parameters

param_name	The name of the Postprocessor parameter (see below)
index	The index of the Postprocessor

Returns: A reference to the desired value

The name required by this method is the name that is hard-coded into your source code. For example, if you have a Kernel that requires a Postprocessor you may have an input file with "pp = my_pp", this function requires the "pp" name as input (see .../moose_test/functions/PostprocessorFunction.C)

see getPostprocessorValueByName getPostprocessorValueOldByName getPostprocessorValueOlderByName

Definition at line 46 of file PostprocessorInterface.C.

{
  return getPostprocessorValueInternal(param_name, index, /* t_index = */ 0);
}

Referenced by EigenKernel::EigenKernel(), FunctionValuePostprocessor::FunctionValuePostprocessor(), LinearCombinationPostprocessor::LinearCombinationPostprocessor(), and ParsedPostprocessor::ParsedPostprocessor().

◆ getPostprocessorValueByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueByName ( const PostprocessorName & name ) const

virtualinherited

Retrieve the value of the Postprocessor.

Parameters

name	Postprocessor name (see below)

Returns: A reference to the desired value

The name required by this method is the name defined in the input file. For example, if you have a Kernel that requires a Postprocessor you may have an input file with "pp = my_pp", this method requires the "my_pp" name as input (see .../moose_test/functions/PostprocessorFunction.C)

see getPostprocessorValue getPostprocessorValueOld getPostprocessorValueOlder

Definition at line 67 of file PostprocessorInterface.C.

{
  return getPostprocessorValueByNameInternal(name, /* t_index = */ 0);
}

Referenced by EigenKernel::EigenKernel(), PIDTransientControl::execute(), IterationAdaptiveDT::IterationAdaptiveDT(), LibtorchNeuralNetControl::LibtorchNeuralNetControl(), MultiPostprocessorConvergence::MultiPostprocessorConvergence(), ParsedODEKernel::ParsedODEKernel(), PicardSolve::savePostprocessorValues(), SecantSolve::savePostprocessorValues(), SteffensenSolve::savePostprocessorValues(), SumPostprocessor::SumPostprocessor(), Terminator::Terminator(), PicardSolve::transformPostprocessors(), SecantSolve::transformPostprocessors(), SteffensenSolve::transformPostprocessors(), and VectorOfPostprocessors::VectorOfPostprocessors().

◆ getPostprocessorValueByNameInternal()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueByNameInternal	(	const PostprocessorName &	name,
		std::size_t	t_index
	)		const

privateinherited

Definition at line 256 of file PostprocessorInterface.C.

{
  mooseAssert(t_index < 3, "Invalid time index");
  mooseAssert(!isDefaultPostprocessorValueByName(name), "Should not be default");
 
  // If all pps have been added, we can check for existance
  if (postprocessorsAdded() && !hasPostprocessorByName(name))
    _ppi_moose_object.mooseError("A Postprocessor with the name \"", name, "\" was not found.");
 
  if (t_index == 0)
    addPostprocessorDependencyHelper(name);
 
  return _ppi_feproblem.getReporterData().getReporterValue<PostprocessorValue>(
      PostprocessorReporterName(name), _ppi_moose_object, REPORTER_MODE_ROOT, t_index);
}

Referenced by PostprocessorInterface::getPostprocessorValueByName(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::getPostprocessorValueOldByName(), and PostprocessorInterface::getPostprocessorValueOlderByName().

◆ getPostprocessorValueInternal()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueInternal	(	const std::string &	param_name,
		unsigned int	index,
		std::size_t	t_index
	)		const

privateinherited

Internal methods for getting Postprocessor values.

Definition at line 228 of file PostprocessorInterface.C.

{
  const auto & name = getPostprocessorNameInternal(param_name, index);
 
  // If the Postprocessor is a default value (either set by addParam or set to a constant
  // value by the user in input/an action), we covert the name to a value, store said
  // value locally, and return it so that it fits in with the rest of the interface
  // (needing a reference to a value)
  if (isDefaultPostprocessorValueByName(name))
  {
    const auto value = getDefaultPostprocessorValueByName(name);
    const auto & value_ref =
        *_default_values.emplace(name, std::make_unique<PostprocessorValue>(value))
             .first->second; // first is inserted pair, second is value in pair
    mooseAssert(value == value_ref, "Inconsistent default value");
    return value_ref;
  }
  // If not a default and all pps have been added, we check check for existance
  else if (postprocessorsAdded() && !hasPostprocessorByName(name))
    _ppi_moose_object.paramError(
        param_name, "A Postprocessor with the name \"", name, "\" was not found.");
 
  return getPostprocessorValueByNameInternal(name, t_index);
}

Referenced by PostprocessorInterface::getPostprocessorValue(), PostprocessorInterface::getPostprocessorValueOld(), and PostprocessorInterface::getPostprocessorValueOlder().

◆ getPostprocessorValueOld()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOld	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Definition at line 53 of file PostprocessorInterface.C.

{
  return getPostprocessorValueInternal(param_name, index, /* t_index = */ 1);
}

◆ getPostprocessorValueOldByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOldByName ( const PostprocessorName & name ) const

inherited

Definition at line 73 of file PostprocessorInterface.C.

{
  return getPostprocessorValueByNameInternal(name, /* t_index = */ 1);
}

Referenced by EigenKernel::EigenKernel().

◆ getPostprocessorValueOlder()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOlder	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Definition at line 60 of file PostprocessorInterface.C.

{
  return getPostprocessorValueInternal(param_name, index, /* t_index = */ 2);
}

◆ getPostprocessorValueOlderByName()

const PostprocessorValue & PostprocessorInterface::getPostprocessorValueOlderByName ( const PostprocessorName & name ) const

inherited

Definition at line 79 of file PostprocessorInterface.C.

{
  return getPostprocessorValueByNameInternal(name, /* t_index = */ 2);
}

◆ getRenamedParam()

template<typename T >

const T & MooseBase::getRenamedParam	(	const std::string &	old_name,
		const std::string &	new_name
	)		const

inherited

Retrieve a renamed parameter for the object.

This helper makes sure we check both names before erroring, and that only one parameter is passed to avoid silent errors

Parameters

old_name	the old name for the parameter
new_name	the new name for the parameter

Definition at line 420 of file MooseBase.h.

{
  // Most important: accept new parameter
  if (isParamSetByUser(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Second most: accept old parameter
  if (isParamValid(old_name) && !isParamSetByUser(new_name))
    return getParam<T>(old_name);
  // Third most: accept default for new parameter
  if (isParamValid(new_name) && !isParamValid(old_name))
    return getParam<T>(new_name);
  // Refuse: no default, no value passed
  if (!isParamValid(old_name) && !isParamValid(new_name))
    mooseError("parameter '" + new_name +
               "' is being retrieved without being set.\nDid you misspell it?");
  // Refuse: both old and new parameters set by user
  else
    mooseError("Parameter '" + new_name + "' may not be provided alongside former parameter '" +
               old_name + "'");
}

◆ getReporterContextBaseByName()

const ReporterContextBase & ReporterInterface::getReporterContextBaseByName ( const ReporterName & reporter_name ) const

protectedinherited

Get the reporter context to allow non-typed operations with the data.

Parameters

reporter_name A ReporterName object that for the desired Reporter context.

Returns: ReporterContextBase of the reporter value

Definition at line 60 of file ReporterInterface.C.

{
  if (!reportersAdded())
    _ri_moose_object.mooseError(
        "Cannot call getReporterContextBaseByName() until all Reporters have been constructed.");
 
  return _ri_reporter_data.getReporterContextBase(reporter_name);
}

◆ getReporterName()

const ReporterName & ReporterInterface::getReporterName ( const std::string & param_name ) const

protectedinherited

Returns: The ReporterName associated with the parametre param_name.

Performs error checking to mak sure that the parameter is valid.

Definition at line 70 of file ReporterInterface.C.

{
  if (!_ri_params.isParamValid(param_name))
    _ri_moose_object.mooseError(
        "When getting a Reporter, failed to get a parameter with the name \"",
        param_name,
        "\".",
        "\n\nKnown parameters:\n",
        _ri_moose_object.parameters());
 
  if (_ri_params.isType<ReporterName>(param_name))
    return _ri_params.get<ReporterName>(param_name);
 
  _ri_moose_object.mooseError("Supplied parameter with name \"",
                              param_name,
                              "\" of type \"",
                              _ri_params.type(param_name),
                              "\" is not an expected type for getting a Reporter.\n\n",
                              "The expected type is \"ReporterName\".");
}

Referenced by ReporterInterface::getReporterValue(), and ReporterInterface::hasReporterValue().

◆ getReporterOutput()

const std::set< std::string > & AdvancedOutput::getReporterOutput ( )

inherited

The list of Reporter names that are set for output.

Returns: A vector containing the names of the Reporter names for output

See also: hasReporterOutput

Definition at line 893 of file AdvancedOutput.C.

{
  return _execute_data["reporters"].output;
}

Referenced by CSV::initialSetup(), Exodus::outputReporters(), JSONOutput::outputReporters(), and TableOutput::outputReporters().

◆ getReporterValue() [1/2]

template<typename T >

const T & ReporterInterface::getReporterValue	(	const std::string &	param_name,
		const std::size_t	time_index = `0`
	)

protectedinherited

doco-normal-methods-begin Returns read-only reference to a Reporter value that is provided by an input parameter.

Template Parameters

T	The C++ type of the Reporter value being consumed

Parameters

param_name	The name of the parameter that gives the name of the Reporter, which must be a ReporterName parameter (i.e., getParam<ReporterName>(param_name)).
mode	The mode that the object will consume the Reporter value @pararm time_index (optional) If zero is provided the current value is returned. Use a positive index to return previous values (1 = older, 2 = older, etc.). The maximum number of old values is dictated by the ReporterData object.

Definition at line 148 of file ReporterInterface.h.

{
  return getReporterValue<T>(param_name, REPORTER_MODE_UNSET, time_index);
}

◆ getReporterValue() [2/2]

template<typename T >

const T & ReporterInterface::getReporterValue	(	const std::string &	param_name,
		ReporterMode	mode,
		const std::size_t	time_index = `0`
	)

protectedinherited

Definition at line 155 of file ReporterInterface.h.

{
  const auto & reporter_name = getReporterName(param_name);
 
  possiblyCheckHasReporter<T>(reporter_name, param_name);
 
  return getReporterValueByName<T>(reporter_name, mode, time_index);
}

◆ getReporterValueByName() [1/2]

template<typename T >

const T & ReporterInterface::getReporterValueByName	(	const ReporterName &	reporter_name,
		const std::size_t	time_index = `0`
	)

protectedinherited

Returns read-only reference to a Reporter value that is provided by name directly.

Template Parameters

T	The C++ type of the Reporter value being consumed

Parameters

reporter_name	A ReporterName object that for the desired Reporter value.
mode	The mode that the object will consume the Reporter value @pararm time_index (optional) If zero is provided the current value is returned. Use a positive index to return previous values (1 = older, 2 = older, etc.). The maximum number of old values is dictated by the ReporterData object.

Definition at line 168 of file ReporterInterface.h.

{
  return getReporterValueByName<T>(reporter_name, REPORTER_MODE_UNSET, time_index);
}

Referenced by ParsedVectorReporter::ParsedVectorReporter().

◆ getReporterValueByName() [2/2]

template<typename T >

const T & ReporterInterface::getReporterValueByName	(	const ReporterName &	reporter_name,
		ReporterMode	mode,
		const std::size_t	time_index = `0`
	)

protectedinherited

Definition at line 176 of file ReporterInterface.h.

{
  possiblyCheckHasReporter<T>(reporter_name);
 
  addReporterDependencyHelper(reporter_name);
 
  return _ri_reporter_data.getReporterValue<T>(reporter_name, _ri_moose_object, mode, time_index);
}

◆ getRestartableData()

template<typename T , typename... Args>

const T & Restartable::getRestartableData ( const std::string & data_name ) const

protectedinherited

Declare a piece of data as "restartable" and initialize it Similar to declareRestartableData but returns a const reference to the object.

Forwarded arguments are not allowed in this case because we assume that the object is restarted and we won't need different constructors to initialize it.

NOTE: This returns a const reference! Make sure you store it in a const reference!

Parameters

data_name The name of the data (usually just use the same name as the member variable)

Definition at line 294 of file Restartable.h.

{
  return declareRestartableDataHelper<T>(data_name, nullptr).get();
}

◆ getScalarOutput()

const std::set< std::string > & AdvancedOutput::getScalarOutput ( )

inherited

The list of scalar variables names that are set for output.

Returns: A vector of strings containing the names of the scalar variables for output

See also: hasScalarVariableOutput

Definition at line 857 of file AdvancedOutput.C.

{
  return _execute_data["scalars"].output;
}

Referenced by CSV::initialSetup(), Exodus::outputScalarVariables(), Nemesis::outputScalarVariables(), and TableOutput::outputScalarVariables().

◆ getScatterVectorPostprocessorValue()

const ScatterVectorPostprocessorValue & VectorPostprocessorInterface::getScatterVectorPostprocessorValue	(	const std::string &	param_name,
		const std::string &	vector_name
	)		const

inherited

Return the scatter value for the post processor.

This is only valid when you expec the vector to be of lenghth "num_procs" In that case - this will return a reference to a value that will be this processor's value from that vector

Parameters

param_name	The name of the parameter holding the vpp name
vector_name	The name of the vector

Returns: The reference to the current scatter value

Definition at line 119 of file VectorPostprocessorInterface.C.

{
  possiblyCheckHasVectorPostprocessor(param_name, vector_name);
  return getScatterVectorPostprocessorValueByName(getVectorPostprocessorName(param_name),
                                                  vector_name);
}

◆ getScatterVectorPostprocessorValueByName()

const ScatterVectorPostprocessorValue & VectorPostprocessorInterface::getScatterVectorPostprocessorValueByName	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name
	)		const

inherited

Return the scatter value for the post processor.

This is only valid when you expec the vector to be of lenghth "num_procs" In that case - this will return a reference to a value that will be this processor's value from that vector

Parameters

name	The name of the VectorPostprocessor
vector_name	The name of the vector

Returns: The reference to the current scatter value

Definition at line 128 of file VectorPostprocessorInterface.C.

{
  return getVectorPostprocessorContextByNameHelper(name, vector_name).getScatterValue();
}

Referenced by VectorPostprocessorInterface::getScatterVectorPostprocessorValue().

◆ getScatterVectorPostprocessorValueOld()

const ScatterVectorPostprocessorValue & VectorPostprocessorInterface::getScatterVectorPostprocessorValueOld	(	const std::string &	param_name,
		const std::string &	vector_name
	)		const

inherited

Return the old scatter value for the post processor.

This is only valid when you expec the vector to be of lenghth "num_procs" In that case - this will return a reference to a value that will be this processor's value from that vector

Parameters

param_name	The name of the parameter holding the vpp name
vector_name	The name of the vector

Returns: The reference to the old scatter value

Definition at line 135 of file VectorPostprocessorInterface.C.

{
  possiblyCheckHasVectorPostprocessor(param_name, vector_name);
  return getScatterVectorPostprocessorValueOldByName(getVectorPostprocessorName(param_name),
                                                     vector_name);
}

◆ getScatterVectorPostprocessorValueOldByName()

const ScatterVectorPostprocessorValue & VectorPostprocessorInterface::getScatterVectorPostprocessorValueOldByName	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name
	)		const

inherited

Return the old scatter value for the post processor.

This is only valid when you expect the vector to be of length "num_procs" In that case - this will return a reference to a value that will be this processor's value from that vector

Parameters

name	The name of the VectorPostprocessor
vector_name	The name of the vector

Returns: The reference to the old scatter value

Definition at line 144 of file VectorPostprocessorInterface.C.

{
  return getVectorPostprocessorContextByNameHelper(name, vector_name).getScatterValueOld();
}

Referenced by VectorPostprocessorInterface::getScatterVectorPostprocessorValueOld().

◆ getSharedPtr() [1/2]

std::shared_ptr< MooseObject > MooseObject::getSharedPtr ( )

inherited

Get another shared pointer to this object that has the same ownership group.

Wrapper around shared_from_this().

Definition at line 70 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

Referenced by MFEMProblem::addImagComponentToBC(), MFEMProblem::addImagComponentToKernel(), MFEMProblem::addRealComponentToBC(), MFEMProblem::addRealComponentToKernel(), and WebServerControl::addServerAction().

◆ getSharedPtr() [2/2]

std::shared_ptr< const MooseObject > MooseObject::getSharedPtr ( ) const

inherited

Definition at line 83 of file MooseObject.C.

{
  try
  {
    return shared_from_this();
  }
  catch (std::bad_weak_ptr &)
  {
    mooseError(not_shared_error);
  }
}

◆ getSyncTimes()

const std::set< Real > & Output::getSyncTimes ( )

inlineinherited

Definition at line 144 of file Output.h.

144{ return _sync_times; }

Output::_sync_times

std::set< Real > _sync_times

Sync times for this outputter.

Definition Output.h:244

Referenced by OutputWarehouse::addOutput().

◆ getVectorPostprocessorByNameHelper()

const VectorPostprocessorValue & VectorPostprocessorInterface::getVectorPostprocessorByNameHelper	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name,
		bool	broadcast,
		std::size_t	t_index
	)		const

privateinherited

Helper function for extracting VPP data from ReporterData object.

Definition at line 282 of file VectorPostprocessorInterface.C.

{
  possiblyCheckHasVectorPostprocessorByName(name, vector_name);
  addVectorPostprocessorDependencyHelper(name);
 
  const ReporterMode mode = broadcast ? REPORTER_MODE_REPLICATED : REPORTER_MODE_ROOT;
  return _vpi_feproblem.getReporterData().getReporterValue<VectorPostprocessorValue>(
      VectorPostprocessorReporterName(name, vector_name), _vpi_moose_object, mode, t_index);
}

Referenced by VectorPostprocessorInterface::getVectorPostprocessorValueByName(), VectorPostprocessorInterface::getVectorPostprocessorValueByName(), VectorPostprocessorInterface::getVectorPostprocessorValueOldByName(), and VectorPostprocessorInterface::getVectorPostprocessorValueOldByName().

◆ getVectorPostprocessorContextByNameHelper()

const VectorPostprocessorContext< VectorPostprocessorValue > & VectorPostprocessorInterface::getVectorPostprocessorContextByNameHelper	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name
	)		const

privateinherited

Helper for getting the VPP context that handles scatter values.

Definition at line 297 of file VectorPostprocessorInterface.C.

{
  possiblyCheckHasVectorPostprocessorByName(name, vector_name);
  addVectorPostprocessorDependencyHelper(name);
 
  // The complete name of the store Reporter value
  const VectorPostprocessorReporterName r_name(name, vector_name);
 
  // Indicate the scatter value is desired, so the the VectorPostprocessorContext will do scatter
  _vpi_feproblem.getReporterData().getReporterValue<VectorPostprocessorValue>(
      r_name, _vpi_moose_object, REPORTER_MODE_VPP_SCATTER, 0);
 
  // Retrieve the VectorPostprocessorContext which contains the scattered value to be referenced
  const auto & context = _vpi_feproblem.getReporterData().getReporterContextBase(r_name);
  auto vpp_context_ptr =
      dynamic_cast<const VectorPostprocessorContext<VectorPostprocessorValue> *>(&context);
  mooseAssert(vpp_context_ptr, "Failed to get the VectorPostprocessorContext");
  return *vpp_context_ptr;
}

Referenced by VectorPostprocessorInterface::getScatterVectorPostprocessorValueByName(), and VectorPostprocessorInterface::getScatterVectorPostprocessorValueOldByName().

◆ getVectorPostprocessorName()

const VectorPostprocessorName & VectorPostprocessorInterface::getVectorPostprocessorName ( const std::string & param_name ) const

inherited

Get the name of a VectorPostprocessor associated with a parameter.

Parameters

param_name The name of the VectorPostprocessor parameter

Returns: The name of the given VectorPostprocessor

Definition at line 216 of file VectorPostprocessorInterface.C.

{
  const auto & params = _vpi_moose_object.parameters();
 
  if (!params.isParamValid(param_name))
    _vpi_moose_object.mooseError(
        "When getting a VectorPostprocessor, failed to get a parameter with the name \"",
        param_name,
        "\".",
        "\n\nKnown parameters:\n",
        _vpi_moose_object.parameters());
 
  if (!params.isType<VectorPostprocessorName>(param_name))
    _vpi_moose_object.mooseError(
        "Supplied parameter with name \"",
        param_name,
        "\" of type \"",
        params.type(param_name),
        "\" is not an expected type for getting a VectorPostprocessor.\n\n",
        "The allowed type is \"VectorPostprocessorName\".");
 
  return params.get<VectorPostprocessorName>(param_name);
}

◆ getVectorPostprocessorOutput()

const std::set< std::string > & AdvancedOutput::getVectorPostprocessorOutput ( )

inherited

The list of VectorPostprocessor names that are set for output.

Returns: A vector of strings containing the names of the VectorPostprocessor variables for output

See also: hasVectorPostprocessorOutput

Definition at line 881 of file AdvancedOutput.C.

{
  return _execute_data["vector_postprocessors"].output;
}

Referenced by CSV::initialSetup(), TableOutput::outputReporters(), TableOutput::outputVectorPostprocessors(), and XMLOutput::outputVectorPostprocessors().

◆ getVectorPostprocessorValue() [1/2]

const VectorPostprocessorValue & VectorPostprocessorInterface::getVectorPostprocessorValue	(	const std::string &	param_name,
		const std::string &	vector_name
	)		const

inherited

DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast.

Retrieve the value of a VectorPostprocessor

Parameters

param_name	The name of the VectorPostprocessor parameter (see below)
vector_name	The name of the particular vector you want.

Returns: A reference to the desired value

The name required by this method is the name that is hard-coded into your source code. For example, if you have a Kernel that requires a VectorPostprocessor you may have an input file with "pp = my_pp", this function requires the "pp" name as input (see .../moose_test/functions/VectorPostprocessorFunction.C)

see getVectorPostprocessorValueOld getVectorPostprocessorValueByName getVectorPostprocessorValueOldByName

Definition at line 49 of file VectorPostprocessorInterface.C.

{
  possiblyCheckHasVectorPostprocessor(param_name, vector_name);
  return getVectorPostprocessorValueByName(getVectorPostprocessorName(param_name), vector_name);
}

◆ getVectorPostprocessorValue() [2/2]

const VectorPostprocessorValue & VectorPostprocessorInterface::getVectorPostprocessorValue	(	const std::string &	param_name,
		const std::string &	vector_name,
		bool	needs_broadcast
	)		const

inherited

Retrieve the value of a VectorPostprocessor.

Parameters

param_name	The name of the VectorPostprocessor parameter (see below)
vector_name	The name of the particular vector you want.
need_broadcast	Whether or not this object requires the vector to be replicated in parallel

Returns: A reference to the desired value

The name required by this method is the name that is hard-coded into your source code. For example, if you have a Kernel that requires a VectorPostprocessor you may have an input file with "pp = my_pp", this function requires the "pp" name as input (see .../moose_test/functions/VectorPostprocessorFunction.C)

see getVectorPostprocessorValueOld getVectorPostprocessorValueByName getVectorPostprocessorValueOldByName

Definition at line 79 of file VectorPostprocessorInterface.C.

{
  possiblyCheckHasVectorPostprocessor(param_name, vector_name);
  return getVectorPostprocessorValueByName(
      getVectorPostprocessorName(param_name), vector_name, needs_broadcast);
}

◆ getVectorPostprocessorValueByName() [1/2]

const VectorPostprocessorValue & VectorPostprocessorInterface::getVectorPostprocessorValueByName	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name
	)		const

inherited

DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast.

Retrieve the value of the VectorPostprocessor

Parameters

name	VectorPostprocessor name (see below)
vector_name	The name of the particular vector you want.

Returns: A reference to the desired value

The name required by this method is the name defined in the input file. For example, if you have a Kernel that requires a VectorPostprocessor you may have an input file with "pp = my_pp", this method requires the "my_pp" name as input (see .../moose_test/functions/VectorPostprocessorFunction.C)

see getVectorPostprocessorValue getVectorPostprocessorValueOldByName getVectorPostprocessorValueByName

Definition at line 57 of file VectorPostprocessorInterface.C.

{
  return getVectorPostprocessorByNameHelper(name, vector_name, _broadcast_by_default, 0);
}

Referenced by CombinedVectorPostprocessor::CombinedVectorPostprocessor(), VectorPostprocessorInterface::getVectorPostprocessorValue(), and VectorPostprocessorInterface::getVectorPostprocessorValue().

◆ getVectorPostprocessorValueByName() [2/2]

const VectorPostprocessorValue & VectorPostprocessorInterface::getVectorPostprocessorValueByName	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name,
		bool	needs_broadcast
	)		const

inherited

Retrieve the value of the VectorPostprocessor.

Parameters

name	VectorPostprocessor name (see below)
vector_name	The name of the particular vector you want.
need_broadcast	Whether or not this object requires the vector to be replicated in parallel

Returns: A reference to the desired value

The name required by this method is the name defined in the input file. For example, if you have a Kernel that requires a VectorPostprocessor you may have an input file with "pp = my_pp", this method requires the "my_pp" name as input (see .../moose_test/functions/VectorPostprocessorFunction.C)

see getVectorPostprocessorValue getVectorPostprocessorValueOldByName getVectorPostprocessorValueByName

Definition at line 89 of file VectorPostprocessorInterface.C.

{
  return getVectorPostprocessorByNameHelper(
      name, vector_name, needs_broadcast || _broadcast_by_default, 0);
}

◆ getVectorPostprocessorValueOld() [1/2]

const VectorPostprocessorValue & VectorPostprocessorInterface::getVectorPostprocessorValueOld	(	const std::string &	param_name,
		const std::string &	vector_name
	)		const

inherited

DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast.

Retrieve the old value of a VectorPostprocessor

Parameters

param_name	The name of the VectorPostprocessor parameter
vector_name	The name of the particular vector you want.

Returns: The value of the VectorPostprocessor

see getVectorPostprocessorValue

Definition at line 64 of file VectorPostprocessorInterface.C.

{
  possiblyCheckHasVectorPostprocessor(param_name, vector_name);
  return getVectorPostprocessorValueOldByName(getVectorPostprocessorName(param_name), vector_name);
}

◆ getVectorPostprocessorValueOld() [2/2]

const VectorPostprocessorValue & VectorPostprocessorInterface::getVectorPostprocessorValueOld	(	const std::string &	param_name,
		const std::string &	vector_name,
		bool	needs_broadcast
	)		const

inherited

Retrieve the old value of a VectorPostprocessor.

Parameters

param_name	The name of the VectorPostprocessor parameter
vector_name	The name of the particular vector you want.
need_broadcast	Whether or not this object requires the vector to be replicated in parallel

Returns: The value of the VectorPostprocessor

see getVectorPostprocessorValue

Definition at line 99 of file VectorPostprocessorInterface.C.

{
  possiblyCheckHasVectorPostprocessor(param_name, vector_name);
  return getVectorPostprocessorValueOldByName(
      getVectorPostprocessorName(param_name), vector_name, needs_broadcast);
}

◆ getVectorPostprocessorValueOldByName() [1/2]

const VectorPostprocessorValue & VectorPostprocessorInterface::getVectorPostprocessorValueOldByName	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name
	)		const

inherited

DEPRECATED: Use the new version where you need to specify whether or not the vector must be broadcast.

Retrieve the old value of a VectorPostprocessor

Parameters

name	The name of the VectorPostprocessor
vector_name	The name of the particular vector you want.

Returns: The value of the VectorPostprocessor

If within the validParams for the object the addVectorPostprocessorParam was called this method will retun a reference to the default value specified in the call to the addVectorPostprocessorParam function if the postVectorPostprocessor does not exist.

see getVectorPostprocessorValueByName

Definition at line 72 of file VectorPostprocessorInterface.C.

{
  return getVectorPostprocessorByNameHelper(name, vector_name, _broadcast_by_default, 1);
}

Referenced by VectorPostprocessorInterface::getVectorPostprocessorValueOld(), and VectorPostprocessorInterface::getVectorPostprocessorValueOld().

◆ getVectorPostprocessorValueOldByName() [2/2]

const VectorPostprocessorValue & VectorPostprocessorInterface::getVectorPostprocessorValueOldByName	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name,
		bool	needs_broadcast
	)		const

inherited

Retrieve the old value of a VectorPostprocessor.

Parameters

name	The name of the VectorPostprocessor
vector_name	The name of the particular vector you want.
need_broadcast	Whether or not this object requires the vector to be replicated in parallel

Returns: The value of the VectorPostprocessor

If within the validParams for the object the addVectorPostprocessorParam was called this method will retun a reference to the default value specified in the call to the addVectorPostprocessorParam function if the postVectorPostprocessor does not exist.

see getVectorPostprocessorValueByName

Definition at line 109 of file VectorPostprocessorInterface.C.

{
  return getVectorPostprocessorByNameHelper(
      name, vector_name, needs_broadcast || _broadcast_by_default, 1);
}

◆ hasBase()

bool MooseBase::hasBase ( ) const

inlineinherited

Returns: Whether or not this object has a registered base (set via InputParameters::registerBase())

Definition at line 142 of file MooseBase.h.

142{ return _pars.hasBase(); }

InputParameters::hasBase

bool hasBase() const

Definition InputParameters.C:499

◆ hasElementalVariableOutput()

bool AdvancedOutput::hasElementalVariableOutput ( )

inherited

Returns true if there exists elemental nonlinear variables for output.

Returns: True if nonlinear variable output exists

See also: getElementalVariableOutput

Definition at line 839 of file AdvancedOutput.C.

{
  return hasOutputHelper("elemental");
}

Referenced by Exodus::initialSetup().

◆ hasFunction()

bool FunctionInterface::hasFunction ( const std::string & param_name ) const

inherited

Determine if the function exists.

Parameters

param_name	The name of the function parameter
index	The index of the function

Returns: True if the function exists

Definition at line 46 of file FunctionInterface.C.

{
  return hasFunctionByName(_fni_params.get<FunctionName>(param_name));
}

◆ hasFunctionByName()

bool FunctionInterface::hasFunctionByName ( const FunctionName & name ) const

inherited

Determine if the function exists.

Parameters

name	The name of the function

Returns: True if the function exists

Definition at line 52 of file FunctionInterface.C.

{
  return _fni_feproblem.hasFunction(name, _fni_tid);
}

Referenced by FunctionInterface::hasFunction().

◆ hasKokkosFunction()

bool FunctionInterface::hasKokkosFunction ( const std::string & param_name ) const

inherited

Determine if the Kokkos function exists.

Parameters

param_name	The name of the Kokkos function parameter
index	The index of the Kokkos function

Returns: True if the Kokkos function exists

◆ hasKokkosFunctionByName()

bool FunctionInterface::hasKokkosFunctionByName ( const FunctionName & name ) const

inherited

Determine if the Kokkos function exists.

Parameters

name	The name of the Kokkos function

Returns: True if the Kokkos function exists

◆ hasNodalVariableOutput()

bool AdvancedOutput::hasNodalVariableOutput ( )

inherited

Returns true if there exists nodal nonlinear variables for output.

Returns: True if nonlinear variable output exists

See also: getNodalVariableOutput

Definition at line 827 of file AdvancedOutput.C.

{
  return hasOutputHelper("nodal");
}

Referenced by Exodus::initialSetup(), and Exodus::outputElementalVariables().

◆ hasOutput() [1/2]

bool AdvancedOutput::hasOutput ( )

virtualinherited

Returns true if any of the other has methods return true.

Definition at line 394 of file AdvancedOutput.C.

{
  // Test that variables exist for output AND that output execution flags are valid
  for (const auto & it : _execute_data)
    if (!(it.second).output.empty() && _advanced_execute_on.contains(it.first) &&
        _advanced_execute_on[it.first].isValid())
      return true;
 
  // Test execution flags for non-variable output
  if (_advanced_execute_on.contains("system_information") &&
      _advanced_execute_on["system_information"].isValid())
    return true;
  if (_advanced_execute_on.contains("input") && _advanced_execute_on["input"].isValid())
    return true;
 
  return false;
}

Referenced by Exodus::initialSetup(), and AdvancedOutput::shouldOutput().

◆ hasOutput() [2/2]

bool AdvancedOutput::hasOutput ( const ExecFlagType & type )

inherited

Tests that any output exist for the given output type.

See also: Exodus

Definition at line 382 of file AdvancedOutput.C.

{
  // If any of the component outputs are true, then there is some output to perform
  for (const auto & it : _advanced_execute_on)
    if (wantOutput(it.first, type))
      return true;
 
  // There is nothing to output
  return false;
}

◆ hasOutputHelper()

bool AdvancedOutput::hasOutputHelper ( const std::string & name )

privateinherited

Helper method for checking if output types exists.

Parameters

name	The name of the output type to test (e.g., postprocessors)

Definition at line 820 of file AdvancedOutput.C.

{
  return !_execute_data[name].output.empty() && _advanced_execute_on.contains(name) &&
         _advanced_execute_on[name].isValid() && !_advanced_execute_on[name].isValueSet("none");
}

Referenced by AdvancedOutput::hasElementalVariableOutput(), AdvancedOutput::hasNodalVariableOutput(), AdvancedOutput::hasPostprocessorOutput(), AdvancedOutput::hasReporterOutput(), AdvancedOutput::hasScalarOutput(), and AdvancedOutput::hasVectorPostprocessorOutput().

◆ hasPostprocessor()

bool PostprocessorInterface::hasPostprocessor	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Determine if the Postprocessor data exists.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the Postprocessor

Returns: True if the Postprocessor exists

See also: hasPostprocessorByName getPostprocessorValue

Definition at line 117 of file PostprocessorInterface.C.

{
  if (!postprocessorsAdded())
    _ppi_moose_object.mooseError(
        "Cannot call hasPostprocessor() until all Postprocessors have been constructed.");
 
  return hasPostprocessorByName(getPostprocessorNameInternal(param_name, index));
}

◆ hasPostprocessorByName()

bool PostprocessorInterface::hasPostprocessorByName ( const PostprocessorName & name ) const

inherited

Determine if the Postprocessor data exists.

Parameters

name	The name of the Postprocessor

Returns: True if the Postprocessor exists

See also: hasPostprocessor getPostprocessorValueByName

Definition at line 128 of file PostprocessorInterface.C.

{
  if (!postprocessorsAdded())
    _ppi_moose_object.mooseError(
        "Cannot call hasPostprocessorByName() until all Postprocessors have been constructed.");
 
  return _ppi_feproblem.getReporterData().hasReporterValue<PostprocessorValue>(
      PostprocessorReporterName(name));
}

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::hasPostprocessor(), AdvancedOutput::initShowHideLists(), Exodus::outputReporters(), and TableOutput::outputReporters().

◆ hasPostprocessorOutput()

bool AdvancedOutput::hasPostprocessorOutput ( )

inherited

Returns true if there exists postprocessors for output.

Returns: True if postprocessor output exists

See also: getPostprocessorOutput

Definition at line 863 of file AdvancedOutput.C.

{
  return hasOutputHelper("postprocessors");
}

Referenced by Exodus::initialSetup().

◆ hasReporterOutput()

bool AdvancedOutput::hasReporterOutput ( )

inherited

Returns true if there exists Reporter for output.

Returns: True if Reporter output exists

See also: getReporterOutput

Definition at line 887 of file AdvancedOutput.C.

{
  return hasOutputHelper("reporters");
}

◆ hasReporterValue() [1/2]

bool ReporterInterface::hasReporterValue ( const std::string & param_name ) const

protectedinherited

Return True if the Reporter value exists.

Template Parameters

T	The C++ type of the Reporter value being consumed

Parameters

reporter_name A ReporterName object that for the desired Reporter value.

Definition at line 40 of file ReporterInterface.C.

{
  if (!reportersAdded())
    _ri_moose_object.mooseError(
        "Cannot call hasReporterValue() until all Reporters have been constructed.");
 
  return hasReporterValueByName(getReporterName(param_name));
}

◆ hasReporterValue() [2/2]

template<typename T >

bool ReporterInterface::hasReporterValue ( const std::string & param_name ) const

protectedinherited

Definition at line 189 of file ReporterInterface.h.

{
  if (!reportersAdded())
    _ri_moose_object.mooseError(
        "Cannot call hasReporterValue() until all Reporters have been constructed.");
 
  return hasReporterValueByName<T>(getReporterName(param_name));
}

◆ hasReporterValueByName() [1/2]

bool ReporterInterface::hasReporterValueByName ( const ReporterName & reporter_name ) const

protectedinherited

Definition at line 50 of file ReporterInterface.C.

{
  if (!reportersAdded())
    _ri_moose_object.mooseError(
        "Cannot call hasReporterValueByName() until all Reporters have been constructed.");
 
  return _ri_reporter_data.hasReporterValue(reporter_name);
}

Referenced by ReporterInterface::hasReporterValue(), and AdvancedOutput::initShowHideLists().

◆ hasReporterValueByName() [2/2]

template<typename T >

bool ReporterInterface::hasReporterValueByName ( const ReporterName & reporter_name ) const

protectedinherited

Definition at line 200 of file ReporterInterface.h.

{
  if (!reportersAdded())
    _ri_moose_object.mooseError(
        "Cannot call hasReporterValueByName() until all Reporters have been constructed.");
 
  return _ri_reporter_data.hasReporterValue<T>(reporter_name);
}

◆ hasScalarOutput()

bool AdvancedOutput::hasScalarOutput ( )

inherited

Returns true if there exists scalar variables for output.

Returns: True if scalar variable output exists

See also: getScalarVariableOutput

Definition at line 851 of file AdvancedOutput.C.

{
  return hasOutputHelper("scalars");
}

Referenced by Exodus::initialSetup().

◆ hasVectorPostprocessor() [1/2]

bool VectorPostprocessorInterface::hasVectorPostprocessor ( const std::string & param_name ) const

inherited

Determine if the VectorPostprocessor exists by parameter.

Parameters

name	The name of the VectorPostprocessor parameter

Returns: True if the VectorPostprocessor exists

Definition at line 175 of file VectorPostprocessorInterface.C.

{
  if (!vectorPostprocessorsAdded())
    _vpi_feproblem.mooseError("Cannot call hasVectorPostprocessor() until all "
                              "VectorPostprocessors have been constructed.");
 
  return hasVectorPostprocessorByName(getVectorPostprocessorName(param_name));
}

◆ hasVectorPostprocessor() [2/2]

bool VectorPostprocessorInterface::hasVectorPostprocessor	(	const std::string &	param_name,
		const std::string &	vector_name
	)		const

inherited

Determine if the VectorPostprocessor data exists by parameter.

Parameters

param_name	The name of the VectorPostprocessor parameter
vector_name	The vector name within the VectorPostprocessor

Returns: True if the VectorPostprocessor data exists

See also: hasVectorPostprocessorByName getVectorPostprocessorValue

Definition at line 151 of file VectorPostprocessorInterface.C.

{
  if (!vectorPostprocessorsAdded())
    _vpi_feproblem.mooseError("Cannot call hasVectorPostprocessor() until all VectorPostprocessors "
                              "have been constructed.");
 
  return hasVectorPostprocessorByName(getVectorPostprocessorName(param_name), vector_name);
}

Referenced by VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor().

◆ hasVectorPostprocessorByName() [1/2]

bool VectorPostprocessorInterface::hasVectorPostprocessorByName ( const VectorPostprocessorName & name ) const

inherited

Determine if the VectorPostprocessor exists by name.

Parameters

name	The name of the VectorPostprocessor

Returns: True if the VectorPostprocessor exists

Definition at line 185 of file VectorPostprocessorInterface.C.

{
  if (!vectorPostprocessorsAdded())
    _vpi_feproblem.mooseError("Cannot call hasVectorPostprocessorByName() until all "
                              "VectorPostprocessors have been constructed.");
 
  std::vector<VectorPostprocessor *> objs;
  _vpi_feproblem.theWarehouse()
      .query()
      .condition<AttribInterfaces>(Interfaces::VectorPostprocessor)
      .condition<AttribThread>(0)
      .condition<AttribName>(name)
      .queryInto(objs);
  return !objs.empty();
}

◆ hasVectorPostprocessorByName() [2/2]

bool VectorPostprocessorInterface::hasVectorPostprocessorByName	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name
	)		const

inherited

Determine if the VectorPostprocessor data exists by name.

Parameters

name	The name of the VectorPostprocessor
vector_name	The vector name within the VectorPostprocessor

Returns: True if the VectorPostprocessor data exists

See also: hasVectorPostprocessor getVectorPostprocessorValueByName

Definition at line 162 of file VectorPostprocessorInterface.C.

{
  if (!vectorPostprocessorsAdded())
    _vpi_feproblem.mooseError("Cannot call hasVectorPostprocessorByName() until all "
                              "VectorPostprocessors have been constructed.");
 
  return _vpi_feproblem.getReporterData().hasReporterValue<VectorPostprocessorValue>(
             VectorPostprocessorReporterName(name, vector_name)) &&
         hasVectorPostprocessorByName(name);
}

Referenced by VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), AdvancedOutput::initShowHideLists(), CSV::output(), and VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName().

◆ hasVectorPostprocessorOutput()

bool AdvancedOutput::hasVectorPostprocessorOutput ( )

inherited

Returns true if there exists VectorPostprocessors for output.

Returns: True if VectorPostprocessor output exists

See also: getVectorPostprocessorOutput

Definition at line 875 of file AdvancedOutput.C.

{
  return hasOutputHelper("vector_postprocessors");
}

◆ hideAdditionalVariable()

void AdvancedOutput::hideAdditionalVariable	(	const std::string &	category,
		const std::string &	var_name
	)

inlineprotectedinherited

Add an additional variable to the hide list.

Definition at line 204 of file AdvancedOutput.h.

  {
    _execute_data[category].hide.insert(var_name);
    _execute_data[category].output.erase(var_name);
  }

Referenced by SampledOutput::initSample().

◆ init()

void AdvancedOutput::init ( )

protectedvirtualinherited

Populates the various data structures needed to control the output.

Definition at line 158 of file AdvancedOutput.C.

{
  // Initialize the execution flags
  for (auto & [name, input] : _advanced_execute_on)
    initExecutionTypes(name, input);
 
  // Clear existing execute information lists
  _execute_data.reset();
 
  // Initialize the available output
  initAvailableLists();
 
  // Separate the hide/show list into components
  initShowHideLists(getParam<std::vector<VariableName>>("show"),
                    getParam<std::vector<VariableName>>("hide"));
 
  // If 'elemental_as_nodal = true' the elemental variable names must be appended to the
  // nodal variable names. Thus, when libMesh::EquationSystem::build_solution_vector is called
  // it will create the correct nodal variable from the elemental
  if (_elemental_as_nodal)
  {
    OutputData & nodal = _execute_data["nodal"];
    OutputData & elemental = _execute_data["elemental"];
    nodal.show.insert(elemental.show.begin(), elemental.show.end());
    nodal.hide.insert(elemental.hide.begin(), elemental.hide.end());
    nodal.available.insert(elemental.available.begin(), elemental.available.end());
  }
 
  // Similarly as above, if 'scalar_as_nodal = true' append the elemental variable lists
  if (_scalar_as_nodal)
  {
    OutputData & nodal = _execute_data["nodal"];
    OutputData & scalar = _execute_data["scalars"];
    nodal.show.insert(scalar.show.begin(), scalar.show.end());
    nodal.hide.insert(scalar.hide.begin(), scalar.hide.end());
    nodal.available.insert(scalar.available.begin(), scalar.available.end());
  }
 
  // Initialize the show/hide/output lists for each of the types of output
  for (auto & it : _execute_data)
    initOutputList(it.second);
}

Referenced by AdvancedOutput::initialSetup(), and AdvancedOutput::output().

◆ initAvailableLists()

void AdvancedOutput::initAvailableLists ( )

privateinherited

Initializes the available lists for each of the output types.

Definition at line 413 of file AdvancedOutput.C.

{
  // Initialize Postprocessor list
  // This flag is set to true if any postprocessor has the 'outputs' parameter set, it is then used
  // to produce an warning if postprocessor output is disabled
  if (!_postprocessors_as_reporters)
    initPostprocessorOrVectorPostprocessorLists<Postprocessor>("postprocessors");
 
  // Initialize vector postprocessor list
  // This flag is set to true if any vector postprocessor has the 'outputs' parameter set, it is
  // then used
  // to produce an warning if vector postprocessor output is disabled
  if (!_vectorpostprocessors_as_reporters)
    initPostprocessorOrVectorPostprocessorLists<VectorPostprocessor>("vector_postprocessors");
 
  // Get a list of the available variables
  std::vector<VariableName> variables = _problem_ptr->getVariableNames();
 
  // Loop through the variables and store the names in the correct available lists
  for (const auto & var_name : variables)
  {
    if (_problem_ptr->hasVariable(var_name))
    {
      MooseVariableFEBase & var = _problem_ptr->getVariable(
          0, var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
 
      // Skip if the 'outputs' parameter has been set to exclude this output
      if (var.isParamValid("outputs"))
      {
        const auto & outputs = var.getParam<std::vector<OutputName>>("outputs");
        if (outputs.size() && std::find(outputs.begin(), outputs.end(), name()) == outputs.end() &&
            outputs[0] != "all")
          continue;
      }
 
      const FEType type = var.feType();
      for (unsigned int i = 0; i < var.count(); ++i)
      {
        VariableName vname = var_name;
        if (var.isArray())
          vname = var.arrayVariableComponent(i);
 
        // A note that if we have p-refinement we assume "worst-case" scenario that our constant
        // monomial/monomial-vec families have been refined and we can no longer write them as
        // elemental
        if (type.order == CONSTANT && !_problem_ptr->havePRefinement() &&
            type.family != MONOMIAL_VEC)
          _execute_data["elemental"].available.insert(vname);
        else if (FEInterface::field_type(type) == TYPE_VECTOR)
        {
          const auto geom_type = ((type.family == MONOMIAL_VEC) && (type.order == CONSTANT) &&
                                  !_problem_ptr->havePRefinement())
                                     ? "elemental"
                                     : "nodal";
          switch (_es_ptr->get_mesh().spatial_dimension())
          {
            case 0:
            case 1:
              _execute_data[geom_type].available.insert(vname);
              break;
            case 2:
              _execute_data[geom_type].available.insert(vname + "_x");
              _execute_data[geom_type].available.insert(vname + "_y");
              break;
            case 3:
              _execute_data[geom_type].available.insert(vname + "_x");
              _execute_data[geom_type].available.insert(vname + "_y");
              _execute_data[geom_type].available.insert(vname + "_z");
              break;
          }
        }
        else
          _execute_data["nodal"].available.insert(vname);
      }
    }
 
    else if (_problem_ptr->hasScalarVariable(var_name))
      _execute_data["scalars"].available.insert(var_name);
  }
 
  // Initialize Reporter name list
  for (auto && r_name : _reporter_data.getReporterNames())
    if ((_postprocessors_as_reporters || !r_name.isPostprocessor()) &&
        (_vectorpostprocessors_as_reporters || !r_name.isVectorPostprocessor()))
      _execute_data["reporters"].available.insert(r_name);
}

Referenced by AdvancedOutput::init().

◆ initExecutionTypes()

void AdvancedOutput::initExecutionTypes	(	const std::string &	name,
		ExecFlagEnum &	input
	)

privateinherited

Initialize the possible execution types.

Parameters

name	The name of the supplied MultiMoose enum from the _execute_on std::map (e.g., scalars)
input	The ExecFlagEnum for output type flags to initialize

Definition at line 501 of file AdvancedOutput.C.

{
  // Build the input parameter name
  std::string param_name = "execute_";
  param_name += name + "_on";
 
  // The parameters exists and has been set by the user
  if (_pars.have_parameter<ExecFlagEnum>(param_name) && isParamValid(param_name))
    input = getParam<ExecFlagEnum>(param_name);
 
  // If the parameter does not exists; set it to a state where no valid entries exists so nothing
  // gets executed
  else if (!_pars.have_parameter<ExecFlagEnum>(param_name))
  {
    input = _execute_on;
    input.clearSetValues();
  }
}

Referenced by AdvancedOutput::init().

◆ initialSetup()

void SampledOutput::initialSetup ( )

overridevirtualinherited

Call init() method on setup.

Reimplemented from AdvancedOutput.

Reimplemented in Exodus.

Definition at line 76 of file SampledOutput.C.

{
  AdvancedOutput::initialSetup();
 
  // Creates and initializes the sampling mesh
  initSample();
}

Referenced by Exodus::initialSetup().

◆ initOutputList()

void AdvancedOutput::initOutputList ( OutputData & data )

privateinherited

Initializes the list of items to be output using the available, show, and hide lists.

Parameters

data	The OutputData to operate on

Definition at line 652 of file AdvancedOutput.C.

{
  // References to the vectors of variable names
  std::set<std::string> & hide = data.hide;
  std::set<std::string> & show = data.show;
  std::set<std::string> & avail = data.available;
  std::set<std::string> & output = data.output;
 
  // Get the hide list from OutputInterface objects
  std::set<std::string> interface_hide_all_types;
  _app.getOutputWarehouse().buildInterfaceHideVariables(name(), interface_hide_all_types);
 
  // OutputInterface hide list includes all types; only include those that are available
  std::set<std::string> interface_hide;
  std::set_intersection(interface_hide_all_types.begin(),
                        interface_hide_all_types.end(),
                        avail.begin(),
                        avail.end(),
                        std::inserter(interface_hide, interface_hide.begin()));
 
  // Append to the hide list from OutputInterface objects
  hide.insert(interface_hide.begin(), interface_hide.end());
 
  // Both show and hide are empty and no show/hide settings were provided (show all available)
  if (!_execute_data.hasShowList() && hide.empty())
    output = avail;
 
  // Only hide is empty (show all the variables listed)
  else if (_execute_data.hasShowList() && hide.empty())
    output = show;
 
  // Only show is empty (show all except those hidden)
  else if (!_execute_data.hasShowList() && !hide.empty())
    std::set_difference(avail.begin(),
                        avail.end(),
                        hide.begin(),
                        hide.end(),
                        std::inserter(output, output.begin()));
 
  // Both hide and show are present (show all those listed)
  else // (_execute_data.hasShowList() && !hide.empty())
  {
    // Check if variables are in both, which is invalid
    std::vector<std::string> tmp;
    std::set_intersection(
        hide.begin(), hide.end(), show.begin(), show.end(), std::inserter(tmp, tmp.begin()));
    if (!tmp.empty())
    {
      std::ostringstream oss;
      oss << "Output(s) specified to be both shown and hidden: ";
      std::copy(tmp.begin(), tmp.end(), infix_ostream_iterator<std::string>(oss, " "));
      mooseError(oss.str());
    }
 
    // Define the output variable list
    output = show;
  }
}

Referenced by AdvancedOutput::init().

◆ initPostprocessorOrVectorPostprocessorLists()

template<typename postprocessor_type >

void AdvancedOutput::initPostprocessorOrVectorPostprocessorLists ( const std::string & execute_data_name )

privateinherited

Helper function for initAvailableLists, templated on warehouse type and postprocessor_type.

Parameters

execute_data_name	Name of the OutputData struct to initialize
warehouse	Reference to the postprocessor or vector postprocessor warehouse

Definition at line 383 of file AdvancedOutput.h.

{
  // Convenience reference to the OutputData being operated on (should used "postprocessors" or
  // "vector_postprocessors")
  OutputData & execute_data = _execute_data[execute_data_name];
 
  // Build the input file parameter name (i.e. "output_postprocessors_on" or
  // "output_vector_postprocessors_on")
  std::ostringstream oss;
  oss << "execute_" << execute_data_name << "_on";
  std::string execute_on_name = oss.str();
 
  std::vector<postprocessor_type *> objs;
  if constexpr (std::is_same_v<postprocessor_type, Postprocessor>)
    _problem_ptr->theWarehouse()
        .query()
        .condition<AttribInterfaces>(Interfaces::Postprocessor)
        .condition<AttribThread>(0)
        .queryIntoUnsorted(objs);
  else if constexpr (std::is_same_v<postprocessor_type, VectorPostprocessor>)
    _problem_ptr->theWarehouse()
        .query()
        .condition<AttribInterfaces>(Interfaces::VectorPostprocessor)
        .condition<AttribThread>(0)
        .queryIntoUnsorted(objs);
 
  for (const auto & obj : objs)
  {
    execute_data.available.insert(obj->PPName());
 
    // Extract the list of outputs
    const auto & pps_outputs = obj->getOutputs();
 
    // Check that the outputs lists are valid
    _app.getOutputWarehouse().checkOutputs(pps_outputs);
 
    // Check that the output object allows postprocessor output,
    // account for "all" keyword (if it is present assume "all" was desired)
    if (pps_outputs.find(name()) != pps_outputs.end() ||
        pps_outputs.find("all") != pps_outputs.end())
    {
      if (!_advanced_execute_on.contains(execute_data_name) ||
          (_advanced_execute_on[execute_data_name].isValid() &&
           _advanced_execute_on[execute_data_name].isValueSet("none")))
      {
        const bool is_pp_type = (execute_data_name == "postprocessors");
        const std::string pp_type_str = is_pp_type ? "post-processor" : "vector post-processor";
        mooseWarning("The ",
                     pp_type_str,
                     " '",
                     obj->PPName(),
                     "' has requested to be output by the '",
                     name(),
                     "' output, but ",
                     pp_type_str,
                     " output is disabled for that output object.");
      }
    }
  }
}

◆ initSample()

void SampledOutput::initSample ( )

privateinherited

Setups the output object to produce re-positioned and/or sampled results.

This is accomplished by creating a new, finer mesh that the existing solution is projected upon. This function is called by the creating action (addOutputAction) and should not be called by the user as it will create a memory leak if called multiple times.

Definition at line 133 of file SampledOutput.C.

{
  // Perform the mesh cloning, if needed
  if (!_use_sampled_output)
    return;
 
  cloneMesh();
 
  // Re-position the sampling mesh
  if (_change_position)
    for (auto & node : _mesh_ptr->getMesh().node_ptr_range())
      *node += _position;
 
  // Perform the mesh refinement
  if (_refinements > 0)
  {
    MeshRefinement mesh_refinement(_mesh_ptr->getMesh());
 
    // We want original and refined partitioning to match so we can
    // query from one to the other safely on distributed meshes.
    _mesh_ptr->getMesh().skip_partitioning(true);
    mesh_refinement.uniformly_refine(_refinements);
 
    // Note that nodesets are not propagated with mesh refinement, unless you built the nodesets
    // from the sidesets again, which is what happens for the regular mesh with initial refinement
  }
 
  // We can't allow renumbering if we want to output multiple time
  // steps to the same Exodus file
  _mesh_ptr->getMesh().allow_renumbering(false);
 
  // This should be called after changing the mesh (block restriction for example)
  if (_change_position || (_refinements > 0) || isParamValid("sampling_blocks"))
    _sampling_mesh_ptr->meshChanged();
 
  // Create the new EquationSystems
  _sampling_es = std::make_unique<EquationSystems>(_mesh_ptr->getMesh());
  _es_ptr = _sampling_es.get();
 
  // Reference the system from which we are copying
  EquationSystems & source_es = _problem_ptr->es();
 
  // If we're going to be copying from that system later, we need to keep its
  // original elements as ghost elements even if it gets grossly
  // repartitioned, since we can't repartition the sample mesh to
  // match.
  // FIXME: this is not enough. It assumes our initial partition of the sampling mesh
  // and the source mesh match. But that's usually only true in the 'refinement' case,
  // not with an arbitrary sampling mesh file
  DistributedMesh * dist_mesh = dynamic_cast<DistributedMesh *>(&source_es.get_mesh());
  if (dist_mesh)
  {
    for (auto & elem : dist_mesh->active_local_element_ptr_range())
      dist_mesh->add_extra_ghost_elem(elem);
  }
 
  // Initialize the _mesh_functions vector
  const auto num_systems = source_es.n_systems();
  _mesh_functions.resize(num_systems);
 
  // Keep track of the variable numbering in both regular and sampled system
  _variable_numbers_in_system.resize(num_systems);
 
  // Get the list of nodal and elemental output data
  const auto & nodal_data = getNodalVariableOutput();
  const auto & elemental_data = getElementalVariableOutput();
 
  // Loop over the number of systems
  for (const auto sys_num : make_range(num_systems))
  {
    // Reference to the current system
    const auto & source_sys = source_es.get_system(sys_num);
 
    // Add the system to the new EquationsSystems
    ExplicitSystem & dest_sys = _sampling_es->add_system<ExplicitSystem>(source_sys.name());
 
    // Loop through the variables in the System
    const auto num_vars = source_sys.n_vars();
    unsigned int num_actual_vars = 0;
    if (num_vars > 0)
    {
      if (_serialize)
        _serialized_solution = NumericVector<Number>::build(_communicator);
 
      // Add the variables to the system... simultaneously creating MeshFunctions for them.
      for (const auto var_num : make_range(num_vars))
      {
        // Is the variable supposed to be output?
        const auto & var_name = source_sys.variable_name(var_num);
        if (!nodal_data.count(var_name) && !elemental_data.count(var_name))
          continue;
 
        // We do what we can to preserve the block restriction
        const std::set<SubdomainID> * subdomains;
        std::set<SubdomainID> restricted_subdomains;
        if (_using_external_sampling_file && !_mesh_subdomains_match)
          subdomains = nullptr;
        else
        {
          subdomains = &source_sys.variable(var_num).active_subdomains();
          // Reduce the block restriction if the output is block restricted
          if (isParamValid("sampling_blocks") && !subdomains->empty())
          {
            const auto & sampling_blocks = _sampling_mesh_ptr->getSubdomainIDs(
                getParam<std::vector<SubdomainName>>("sampling_blocks"));
            set_intersection(subdomains->begin(),
                             subdomains->end(),
                             sampling_blocks.begin(),
                             sampling_blocks.end(),
                             std::inserter(restricted_subdomains, restricted_subdomains.begin()));
            subdomains = &restricted_subdomains;
 
            // None of the subdomains are included in the sampling, might as well skip
            if (subdomains->empty())
            {
              hideAdditionalVariable(nodal_data.count(var_name) ? "nodal" : "elemental", var_name);
              continue;
            }
          }
        }
 
        // We are going to add the variable, let's count it
        _variable_numbers_in_system[sys_num].push_back(var_num);
        num_actual_vars++;
 
        // Add the variable. We essentially support nodal variables and constant monomials
        const FEType & fe_type = source_sys.variable_type(var_num);
        if (isSampledAtNodes(fe_type))
        {
          dest_sys.add_variable(source_sys.variable_name(var_num), fe_type, subdomains);
          if (dist_mesh && !_serialize)
            paramError("serialize_sampling",
                       "Variables sampled as nodal currently require serialization with a "
                       "distributed mesh.");
        }
        else
        {
          const auto & var_name = source_sys.variable_name(var_num);
          if (fe_type != FEType(CONSTANT, MONOMIAL))
          {
            mooseInfoRepeated("Sampled output projects variable '" + var_name +
                              "' onto a constant monomial");
            if (!_serialize)
              paramWarning("serialize_sampling",
                           "Projection without serialization may fail with insufficient ghosting. "
                           "Consider setting 'serialize_sampling' to true.");
          }
          dest_sys.add_variable(var_name, FEType(CONSTANT, MONOMIAL), subdomains);
        }
        // Note: we could do more, using the generic projector. But exodus output of higher order
        // or more exotic variables is limited anyway
      }
 
      // Size for the actual number of variables output
      _mesh_functions[sys_num].resize(num_actual_vars);
    }
  }
 
  // Initialize the newly created EquationSystem
  _sampling_es->init();
}

Referenced by SampledOutput::initialSetup().

◆ initShowHideLists()

void AdvancedOutput::initShowHideLists	(	const std::vector< VariableName > &	show,
		const std::vector< VariableName > &	hide
	)

privateinherited

Parses the user-supplied input for hiding and showing variables and postprocessors into a list for each type of output.

Parameters

show	The vector of names that are to be output
hide	The vector of names that are to be suppressed from the output

Definition at line 521 of file AdvancedOutput.C.

{
 
  // Storage for user-supplied input that is unknown as a variable or postprocessor
  std::set<std::string> unknown;
 
  // If a show hide/list exists, let the data warehouse know about it. This allows for the proper
  // handling of output lists (see initOutputList)
  if (show.size() > 0)
    _execute_data.setHasShowList(true);
 
  // Populate the show lists
  for (const auto & var_name : show)
  {
    if (_problem_ptr->hasVariable(var_name))
    {
      MooseVariableFEBase & var = _problem_ptr->getVariable(
          0, var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
      const FEType type = var.feType();
      for (unsigned int i = 0; i < var.count(); ++i)
      {
        VariableName vname = var_name;
        if (var.isArray())
          vname = var.arrayVariableComponent(i);
 
        if (type.order == CONSTANT)
          _execute_data["elemental"].show.insert(vname);
        else if (FEInterface::field_type(type) == TYPE_VECTOR)
        {
          const auto geom_type =
              ((type.family == MONOMIAL_VEC) && (type.order == CONSTANT)) ? "elemental" : "nodal";
          switch (_es_ptr->get_mesh().spatial_dimension())
          {
            case 0:
            case 1:
              _execute_data[geom_type].show.insert(vname);
              break;
            case 2:
              _execute_data[geom_type].show.insert(vname + "_x");
              _execute_data[geom_type].show.insert(vname + "_y");
              break;
            case 3:
              _execute_data[geom_type].show.insert(vname + "_x");
              _execute_data[geom_type].show.insert(vname + "_y");
              _execute_data[geom_type].show.insert(vname + "_z");
              break;
          }
        }
        else
          _execute_data["nodal"].show.insert(vname);
      }
    }
    else if (_problem_ptr->hasScalarVariable(var_name))
      _execute_data["scalars"].show.insert(var_name);
    else if (hasPostprocessorByName(var_name))
      _execute_data["postprocessors"].show.insert(var_name);
    else if (hasVectorPostprocessorByName(var_name))
      _execute_data["vector_postprocessors"].show.insert(var_name);
    else if ((var_name.find("/") != std::string::npos) &&
             (hasReporterValueByName(ReporterName(var_name))))
      _execute_data["reporters"].show.insert(var_name);
    else
      unknown.insert(var_name);
  }
 
  // Populate the hide lists
  for (const auto & var_name : hide)
  {
    if (_problem_ptr->hasVariable(var_name))
    {
      MooseVariableFEBase & var = _problem_ptr->getVariable(
          0, var_name, Moose::VarKindType::VAR_ANY, Moose::VarFieldType::VAR_FIELD_ANY);
      const FEType type = var.feType();
      for (unsigned int i = 0; i < var.count(); ++i)
      {
        VariableName vname = var_name;
        if (var.isArray())
          vname = var.arrayVariableComponent(i);
 
        if (type.order == CONSTANT)
          _execute_data["elemental"].hide.insert(vname);
        else if (FEInterface::field_type(type) == TYPE_VECTOR)
        {
          switch (_es_ptr->get_mesh().spatial_dimension())
          {
            case 0:
            case 1:
              _execute_data["nodal"].hide.insert(vname);
              break;
            case 2:
              _execute_data["nodal"].hide.insert(vname + "_x");
              _execute_data["nodal"].hide.insert(vname + "_y");
              break;
            case 3:
              _execute_data["nodal"].hide.insert(vname + "_x");
              _execute_data["nodal"].hide.insert(vname + "_y");
              _execute_data["nodal"].hide.insert(vname + "_z");
              break;
          }
        }
        else
          _execute_data["nodal"].hide.insert(vname);
      }
    }
    else if (_problem_ptr->hasScalarVariable(var_name))
      _execute_data["scalars"].hide.insert(var_name);
    else if (hasPostprocessorByName(var_name))
      _execute_data["postprocessors"].hide.insert(var_name);
    else if (hasVectorPostprocessorByName(var_name))
      _execute_data["vector_postprocessors"].hide.insert(var_name);
    else if ((var_name.find("/") != std::string::npos) &&
             (hasReporterValueByName(ReporterName(var_name))))
      _execute_data["reporters"].hide.insert(var_name);
 
    else
      unknown.insert(var_name);
  }
 
  // Error if an unknown variable or postprocessor is found
  if (!unknown.empty())
  {
    std::ostringstream oss;
    oss << "Output(s) do not exist (must be variable, scalar, postprocessor, or vector "
           "postprocessor): ";
    std::copy(unknown.begin(), unknown.end(), infix_ostream_iterator<std::string>(oss, " "));
    mooseError(oss.str());
  }
}

Referenced by AdvancedOutput::init().

◆ inLinearTimeWindow()

bool PetscOutput::inLinearTimeWindow ( )

inlineprotectedinherited

Definition at line 67 of file PetscOutput.h.

  {
    return _time >= _linear_start_time - _t_tol && _time <= _linear_end_time + _t_tol;
  }

◆ inNonlinearTimeWindow()

bool PetscOutput::inNonlinearTimeWindow ( )

inlineprotectedinherited

Definition at line 63 of file PetscOutput.h.

  {
    return _time >= _nonlinear_start_time - _t_tol && _time <= _nonlinear_end_time + _t_tol;
  }

◆ interval()

const unsigned int & Output::interval ( ) const

inherited

Get the output interval.

◆ isAdvanced()

bool Output::isAdvanced ( )

inherited

Returns true if this object is an AdvancedOutput object.

Definition at line 399 of file Output.C.

{
  return _is_advanced;
}

◆ isDefaultPostprocessorValue()

bool PostprocessorInterface::isDefaultPostprocessorValue	(	const std::string &	param_name,
		const unsigned int	index = `0`
	)		const

inherited

Determine whether or not the Postprocessor is a default value.

A default value is when the value is either the value set by addParam, or is a user-set value in input instead of a name to a postprocessor.

Parameters

param_name	The name of the Postprocessor parameter
index	The index of the postprocessor

Returns: True if the Postprocessor is a default value, false if the Postprocessor is the name of a Postprocessor

Definition at line 85 of file PostprocessorInterface.C.

{
  return isDefaultPostprocessorValueByName(getPostprocessorNameInternal(param_name, index));
}

Referenced by EigenKernel::EigenKernel().

◆ isDefaultPostprocessorValueByName()

bool PostprocessorInterface::isDefaultPostprocessorValueByName ( const PostprocessorName & name ) const

privateinherited

Returns: True if the PostprocessorName name repesents a default value: the name converts to a value (set by addParam or set via input), and a Postprocessor does not exist with the same name (we do allow Postprocessors with numbered names...)

Definition at line 92 of file PostprocessorInterface.C.

{
  // We do allow actual Postprocessor objects to have names that will succeed in being
  // represented as a double... so if the name does actually exist as a PP, it's not a default
  if (_ppi_feproblem.getReporterData().hasReporterValue<PostprocessorValue>(
          PostprocessorReporterName(name)))
    return false;
 
  std::istringstream ss(name);
  Real real_value = -std::numeric_limits<Real>::max();
  return (ss >> real_value && ss.eof());
}

Referenced by PostprocessorInterface::getDefaultPostprocessorValueByName(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), and PostprocessorInterface::isDefaultPostprocessorValue().

◆ isKokkosObject()

bool MooseObject::isKokkosObject ( ) const

inlineinherited

Get whether this object is a Kokkos functor The parameter MooseBase::kokkos_object_param is set by the Kokkos base classes.

Definition at line 63 of file MooseObject.h.

63{ return parameters().isKokkosObject(); }

InputParameters::isKokkosObject

bool isKokkosObject() const

Returns whether this InputParameters belongs to a Kokkos object Checks whether MooseBase::kokkos_obje...

Definition InputParameters.C:433

Referenced by AttribKokkos::initFrom(), BlockRestrictable::initializeBlockRestrictable(), and BoundaryRestrictable::initializeBoundaryRestrictable().

◆ isParamSetByUser()

bool MooseBase::isParamSetByUser ( const std::string & name ) const

inlineinherited

Test if the supplied parameter is set by a user, as opposed to not set or set to default.

Parameters

name	The name of the parameter to test

Definition at line 205 of file MooseBase.h.

  {
    return _pars.isParamSetByUser(name);
  }

Referenced by DiffusionCG::addFEBCs(), DiffusionPhysicsBase::addInitialConditions(), CylinderComponent::addMeshGenerators(), AdvancedExtruderGenerator::AdvancedExtruderGenerator(), MFEMMesh::buildMesh(), MFEMBoundarySubMesh::buildSubMesh(), MFEMDomainSubMesh::buildSubMesh(), LibtorchNeuralNetControl::conditionalParameterError(), ConservativeAdvectionBCTempl< is_ad >::ConservativeAdvectionBCTempl(), MooseApp::copyInputs(), DiffusionPhysicsBase::DiffusionPhysicsBase(), MooseApp::errorCheck(), FileMesh::FileMesh(), FullSolveMultiApp::FullSolveMultiApp(), OrientSurfaceMeshGenerator::generate(), SurfaceSubdomainsFromAllNormalsGenerator::generate(), MFEMVectorFESpace::getFECName(), MooseBase::getRenamedParam(), DefaultConvergenceBase::getSharedExecutionerParam(), AddVariableAction::init(), MFEMMesh::init(), PhysicsBase::initializePhysics(), ElementSubdomainModifierBase::initialSetup(), MatrixSymmetryCheck::MatrixSymmetryCheck(), MeshDiagnosticsGenerator::MeshDiagnosticsGenerator(), MFEMVariable::MFEMVariable(), MortarConstraintBase::MortarConstraintBase(), MultiAppGeneralFieldFunctorTransfer::MultiAppGeneralFieldFunctorTransfer(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), OrientSurfaceMeshGenerator::OrientSurfaceMeshGenerator(), SolutionInvalidityOutput::output(), Output::Output(), MultiAppGeneralFieldTransfer::outputValueConflicts(), PetscExternalPartitioner::partition(), PolyLineMeshFollowingNodeSetGenerator::PolyLineMeshFollowingNodeSetGenerator(), MooseMesh::prepare(), SolutionUserObjectBase::readXda(), ReferenceResidualConvergence::ReferenceResidualConvergence(), PhysicsBase::reportPotentiallyMissedParameters(), MooseApp::run(), MooseApp::runInputFile(), MooseApp::runInputs(), Moose::MFEM::LinearSolverBase::SetPreconditioner(), SetupMeshAction::setupMesh(), MooseApp::setupOptions(), SideSetsFromBoundingBoxGenerator::SideSetsFromBoundingBoxGenerator(), SmoothMeshGenerator::SmoothMeshGenerator(), SurfaceSubdomainsDelaunayRemesher::SurfaceSubdomainsDelaunayRemesher(), SurfaceSubdomainsFromAllNormalsGenerator::SurfaceSubdomainsFromAllNormalsGenerator(), TagVectorAux::TagVectorAux(), TimedSubdomainModifier::TimedSubdomainModifier(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), XYDelaunayGenerator::XYDelaunayGenerator(), and XYZDelaunayGenerator::XYZDelaunayGenerator().

◆ isParamValid()

bool MooseBase::isParamValid ( const std::string & name ) const

inlineinherited

Test if the supplied parameter is valid.

Parameters

name	The name of the parameter to test

Definition at line 199 of file MooseBase.h.

199{ return _pars.isParamValid(name); }

◆ isSampledAtNodes()

bool SampledOutput::isSampledAtNodes ( const FEType & fe_type ) const

privateinherited

Used to decide which variable is sampled at nodes, then output as a nodal variable for (over)sampling purposes If not sampled at nodes, it is sampled at centroids and output as a constant monomial.

Definition at line 542 of file SampledOutput.C.

{
  // This is the same criterion as in MooseVariableData
  const auto continuity = FEInterface::get_continuity(fe_type);
  return (continuity == C_ZERO || continuity == C_ONE);
}

Referenced by SampledOutput::initSample(), and SampledOutput::updateSample().

◆ isVectorPostprocessorDistributed()

bool VectorPostprocessorInterface::isVectorPostprocessorDistributed ( const std::string & param_name ) const

inherited

Return true if the VectorPostprocessor is marked with parallel_type as DISTRIBUTED.

Definition at line 203 of file VectorPostprocessorInterface.C.

{
  return isVectorPostprocessorDistributedByName(getVectorPostprocessorName(param_name));
}

◆ isVectorPostprocessorDistributedByName()

bool VectorPostprocessorInterface::isVectorPostprocessorDistributedByName ( const VectorPostprocessorName & name ) const

inherited

Definition at line 209 of file VectorPostprocessorInterface.C.

{
  return _vpi_feproblem.getVectorPostprocessorObjectByName(name).isDistributed();
}

Referenced by VectorPostprocessorInterface::isVectorPostprocessorDistributed().

◆ jacobianSetup()

void SetupInterface::jacobianSetup ( )

virtualinherited

Gets called just before the Jacobian is computed and before this object is asked to do its job.

Reimplemented in DiffusionLHDGDirichletBC, DiffusionLHDGPrescribedGradientBC, ElementAndTraceScalarHDGBC, EqualValueEmbeddedConstraintTempl< is_ad >, ADDiracKernel, DiffusionLHDGKernel, ElementAndTraceScalarHDGKernel, ADArrayKernel, ADKernelTempl< T >, ADArrayNodalKernel, Positions, Times, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< Real >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< T >, MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< Real >, MooseVariableFE< RealEigenVector >, MooseVariableFE< RealVectorValue >, MooseVariableFE< T >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< Real >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< T >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< Real >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< T >, and Function.

Definition at line 58 of file SetupInterface.C.

59{

60}

Referenced by MooseVariableField< OutputType >::jacobianSetup(), and ComputeFVFluxJacobianThread< RangeType >::setup().

◆ meshChanged()

void SampledOutput::meshChanged ( )

overridevirtualinherited

Called on this object when the mesh changes.

Reimplemented from MeshChangedInterface.

Reimplemented in Exodus.

Definition at line 127 of file SampledOutput.C.

{
  _sampling_mesh_changed = true;
}

Referenced by Exodus::meshChanged().

◆ messagePrefix() [1/2]

std::string MooseBase::messagePrefix ( const bool hit_prefix = true ) const

inlineinherited

Returns: A prefix to be used in messages that contain the input file location associated with this object (if any) and the name and type of the object.

Definition at line 256 of file MooseBase.h.

  {
    return messagePrefix(_pars, hit_prefix);
  }

Referenced by MooseBase::callMooseError(), MooseBase::errorPrefix(), MooseBase::messagePrefix(), MooseBase::mooseDeprecated(), MooseBase::mooseDeprecatedNoTrace(), MooseBase::mooseInfo(), and MooseBase::mooseWarning().

◆ messagePrefix() [2/2]

std::string MooseBase::messagePrefix	(	const InputParameters &	params,
		const bool	hit_prefix
	)

staticprivateinherited

Internal method for getting the message prefix for an object (object type, name, etc).

Needs to be static so that we can call it externally from InputParameters for errors that do not have context of the MooseBase

Definition at line 140 of file MooseBase.C.

{
  std::string prefix = "";
 
  if (hit_prefix)
    if (const auto node = MooseBase::getHitNode(params))
      prefix += Moose::hitMessagePrefix(*node);
 
  // Don't have context without type and name
  if (!params.isMooseBaseObject())
    return prefix;
 
  const auto & name = params.getObjectName();
  const std::string base = params.hasBase() ? params.getBase() : "object";
  const bool is_main_app = base == "Application" && name == AppFactory::main_app_name;
  prefix += "The following occurred in the ";
  if (is_main_app)
    prefix += "main " + base;
  else
    prefix += base;
  if (base != params.getObjectName() && name.size() && !is_main_app)
    prefix += " '" + name + "'";
  prefix += " of type " + params.getObjectType() + ".";
  return prefix + "\n\n";
}

◆ mooseDeprecated() [1/2]

template<typename... Args>

void MooseBase::mooseDeprecated ( Args &&... args ) const

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and a stack trace.

Definition at line 317 of file MooseBase.h.

  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, true, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by MooseApp::addCapability(), DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), MooseApp::getRecoverFileBase(), MooseApp::hasRecoverFileBase(), and MooseApp::setupOptions().

◆ mooseDeprecated() [2/2]

template<typename... Args>

void SolutionInvalidInterface::mooseDeprecated ( Args &&... args ) const

inlineinherited

Definition at line 87 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseDeprecated(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": deprecation");
  }

Referenced by MultiApp::appProblem(), AddVariableAction::determineType(), MooseMesh::elem(), MooseMesh::elem(), FunctionDT::FunctionDT(), MooseMesh::getBoundariesToElems(), Control::getExecuteOptions(), MooseMesh::isTranslatedPeriodic(), MooseMesh::minPeriodicDistance(), MooseMesh::minPeriodicVector(), MooseMesh::node(), MooseMesh::node(), FixedPointSolve::numPicardIts(), RelationshipManager::operator>=(), and MooseMesh::setBoundaryToNormalMap().

◆ mooseDeprecatedNoTrace()

template<typename... Args>

void MooseBase::mooseDeprecatedNoTrace ( Args &&... args ) const

inlineinherited

Emits a deprecation warning prefixed with the object name and type, and no stack trace.

Definition at line 327 of file MooseBase.h.

  {
    moose::internal::mooseDeprecatedStream(
        _console, false, true, false, messagePrefix(true), std::forward<Args>(args)...);
  }

◆ mooseDocumentedError()

template<typename... Args>

void MooseBase::mooseDocumentedError	(	const std::string &	repo_name,
		const unsigned int	issue_num,
		Args &&...	args
	)		const

inlineinherited

Definition at line 277 of file MooseBase.h.

  {
    callMooseError(moose::internal::formatMooseDocumentedError(
                       repo_name, issue_num, argumentsToString(std::forward<Args>(args)...)),
                   /* with_prefix = */ true);
  }

Referenced by ManifoldSubdomainGenerator::ManifoldSubdomainGenerator().

◆ mooseError()

template<typename... Args>

void MooseBase::mooseError ( Args &&... args ) const

inlineinherited

Emits an error prefixed with object name and type and optionally a file path to the top-level block parameter if available.

Definition at line 271 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ true);
  }

◆ mooseErrorNonPrefixed()

template<typename... Args>

void MooseBase::mooseErrorNonPrefixed ( Args &&... args ) const

inlineinherited

Emits an error without the prefixing included in mooseError().

Definition at line 290 of file MooseBase.h.

  {
    callMooseError(argumentsToString(std::forward<Args>(args)...), /* with_prefix = */ false);
  }

◆ mooseInfo()

template<typename... Args>

void MooseBase::mooseInfo ( Args &&... args ) const

inlineinherited

Definition at line 334 of file MooseBase.h.

  {
    moose::internal::mooseInfoStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by SetupRecoverFileBaseAction::act(), AStableDirk4::AStableDirk4(), MeshDiagnosticsGenerator::checkNonConformalMeshFromAdaptivity(), PIDTransientControl::execute(), Executioner::Executioner(), Executioner::Executioner(), ExplicitRK2::ExplicitRK2(), ExplicitTVDRK2::ExplicitTVDRK2(), FixedPointSolve::findTransformedSystem(), ManifoldSubdomainGenerator::generate(), PolyLineMeshFollowingNodeSetGenerator::generate(), DataFileInterface::getDataFilePath(), ImplicitMidpoint::ImplicitMidpoint(), LStableDirk2::LStableDirk2(), LStableDirk3::LStableDirk3(), LStableDirk4::LStableDirk4(), MultiAppTransfer::mapBackWithoutCollapsing(), SolutionInvalidityOutput::output(), MooseBase::paramInfo(), MooseApp::setupOptions(), SymmetryTransformGenerator::SymmetryTransformGenerator(), TransientBase::takeStep(), and TransientBase::TransientBase().

◆ mooseWarning() [1/2]

template<typename... Args>

void MooseBase::mooseWarning ( Args &&... args ) const

inlineinherited

Emits a warning prefixed with object name and type.

Definition at line 299 of file MooseBase.h.

  {
    moose::internal::mooseWarningStream(_console, messagePrefix(true), std::forward<Args>(args)...);
  }

Referenced by DiracKernelInfo::findPoint(), DataFileInterface::getDataFilePath(), MooseApp::loadLibraryAndDependencies(), and MooseBase::paramWarning().

◆ mooseWarning() [2/2]

template<typename... Args>

void SolutionInvalidInterface::mooseWarning ( Args &&... args ) const

inlineinherited

Definition at line 73 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarning(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

Referenced by CopyMeshPartitioner::_do_partition(), AddFunctionAction::act(), AddKernelAction::act(), CommonOutputAction::act(), MaterialOutputAction::act(), MeshOnlyAction::act(), MooseMesh::addPeriodicVariable(), BoundaryMarker::BoundaryMarker(), DistributedRectilinearMeshGenerator::buildCube(), CartesianMeshGenerator::CartesianMeshGenerator(), CheckOutputAction::checkConsoleOutput(), MultiAppTransfer::checkMultiAppExecuteOn(), MeshDiagnosticsGenerator::checkNonMatchingEdges(), MeshDiagnosticsGenerator::checkPolygons(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), MultiApp::createApp(), MeshDiagnosticsGenerator::diagnosticsLog(), CartesianGridDivision::divisionIndex(), CylindricalGridDivision::divisionIndex(), SphericalGridDivision::divisionIndex(), Postprocessor::evaluateDotWarning(), FiniteDifferencePreconditioner::FiniteDifferencePreconditioner(), FixedPointSolve::FixedPointSolve(), BSplineCurveGenerator::generate(), RenumberBySubdomainGenerator::generate(), SubdomainPerElementGenerator::generate(), SurfaceMeshGeneratorBase::get2DElemNormal(), MultiAppTransfer::getAppInfo(), FunctorBinnedValuesDivision::getBinIndex(), IndicatorMarker::IndicatorMarker(), CartesianGridDivision::initialize(), CylindricalGridDivision::initialize(), SphericalGridDivision::initialize(), MFEMRefinementMarker::initialSetup(), MaterialBase::initStatefulProperties(), IterationAdaptiveDT::limitDTToPostprocessorValue(), NewmarkBeta::NewmarkBeta(), Output::Output(), MaterialOutputAction::outputHelper(), Executioner::problem(), TestSourceStepper::rejectStep(), PhysicsBase::reportPotentiallyMissedParameters(), MaterialBase::resetQpProperties(), MooseMesh::setCoordSystem(), TransientMultiApp::solveStep(), MeshRepairGenerator::splitNonConvexPolygons(), and VariableCondensationPreconditioner::VariableCondensationPreconditioner().

◆ mooseWarningNonPrefixed() [1/2]

template<typename... Args>

void MooseBase::mooseWarningNonPrefixed ( Args &&... args ) const

inlineinherited

Emits a warning without the prefixing included in mooseWarning().

Definition at line 308 of file MooseBase.h.

  {
    moose::internal::mooseWarningStream(_console, std::forward<Args>(args)...);
  }

◆ mooseWarningNonPrefixed() [2/2]

template<typename... Args>

void SolutionInvalidInterface::mooseWarningNonPrefixed ( Args &&... args ) const

inlineinherited

Definition at line 80 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::mooseWarningNonPrefixed(std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning");
  }

◆ name()

const std::string & MooseBase::name ( ) const

inlineinherited

Get the name of the class.

Returns: The name of the class

Definition at line 103 of file MooseBase.h.

  {
    mooseAssert(_name.size(), "Empty name");
    return _name;
  }

◆ onInterval()

bool Output::onInterval ( )

protectedvirtualinherited

Returns true if the output interval is satisfied.

Todo:

Definition at line 280 of file Output.C.

{
  // The output flag to return
  bool output = false;
 
  // Return true if the current step on the current output interval and within the output time range
  // and within the output step range
  if (_time >= _start_time && _time <= _end_time && _t_step >= _start_step &&
      _t_step <= _end_step && (_t_step % _time_step_interval) == 0)
    output = true;
 
  // Return false if 'sync_only' is set to true
  if (_sync_only)
    output = false;
 
  if (_sync_times_object)
  {
    const auto & sync_times = _sync_times_object->getUniqueTimes();
    if (sync_times != _sync_times)
      mooseError("The provided sync times object has changing time values. Only static time "
                 "values are supported since time steppers take sync times from the output "
                 "warehouse which determines its sync times at output construction time.");
  }
 
  // We make sync times have precendence over the other criteria by convention, since they already
  // take precedence over start/end step, start/end time, step frequency etc.
  //
  // Check if enough simulation time has passed between outputs
  if (_time > _last_output_simulation_time &&
      _last_output_simulation_time + _min_simulation_time_interval > _time + _t_tol)
    output = false;
 
  // If sync times are not skipped, return true if the current time is a sync_time
  for (const auto _sync_time : _sync_times)
  {
    if (std::abs(_sync_time - _time) < _t_tol)
      output = true;
  }
 
  // check if enough wall time has passed between outputs
  const auto now = std::chrono::steady_clock::now();
  // count below returns an interger type, so lets express on a millisecond
  // scale and convert to seconds for finer resolution
  _wall_time_since_last_output =
      std::chrono::duration_cast<std::chrono::milliseconds>(now - _last_output_wall_time).count() /
      1000.0;
  // Take the maximum wall time since last output accross all processors
  _communicator.max(_wall_time_since_last_output);
  if (_wall_time_since_last_output >= _wall_time_interval)
    output = true;
 
  // Return the output status
  return output;
}

Referenced by Console::output(), Output::outputStep(), SampledOutput::outputStep(), and Checkpoint::shouldOutput().

◆ output()

void XDA::output ( )

overrideprotectedvirtual

Overload the Output::output method, this is required for XDA output due to the method utlized for outputting single/global parameters.

Reimplemented from AdvancedOutput.

Definition at line 47 of file XDA.C.

{
  // Strings for the two filenames to be written
  std::string es_name = filename();
  std::string mesh_name = es_name;
 
  // Make sure the filename has an extension
  if (es_name.size() < 4)
    mooseError("Unacceptable filename, you must include an extension (.xda or .xdr).");
 
  // Insert the mesh suffix
  mesh_name.insert(mesh_name.size() - 4, "_mesh");
 
  // Set the binary flag
  XdrMODE mode = _binary ? ENCODE : WRITE;
 
  // Write the files
  _mesh_ptr->getMesh().write(mesh_name);
  _es_ptr->write(
      es_name, mode, EquationSystems::WRITE_DATA | EquationSystems::WRITE_ADDITIONAL_DATA);
  _file_num++;
}

Referenced by filename().

◆ outputElementalVariables()

void AdvancedOutput::outputElementalVariables ( )

protectedvirtualinherited

Performs output of elemental nonlinear variables The child class must define this method to output the nonlinear variables as desired.

See also: Exodus::outputElementalVariables

Reimplemented in Exodus.

Definition at line 212 of file AdvancedOutput.C.

{
  mooseError(
      "Individual output of elemental variables is not support for this output object named '",
      name(),
      "'");
}

Referenced by AdvancedOutput::output().

◆ outputInput()

void AdvancedOutput::outputInput ( )

protectedvirtualinherited

Performs the output of the input file By default this method does nothing and is not called, the individual Output objects are responsible for calling it.

Reimplemented in Console, and Exodus.

Definition at line 252 of file AdvancedOutput.C.

{
  mooseError("Output of the input file information is not support for this output object named '",
             name(),
             "'");
}

Referenced by AdvancedOutput::output().

◆ outputNodalVariables()

void AdvancedOutput::outputNodalVariables ( )

protectedvirtualinherited

Performs output of nodal nonlinear variables The child class must define this method to output the nonlinear variables as desired.

See also: Exodus::outputNodalVariables

Reimplemented in Exodus.

Definition at line 204 of file AdvancedOutput.C.

{
  mooseError("Individual output of nodal variables is not support for the output object named '",
             name(),
             "'");
}

Referenced by AdvancedOutput::output().

◆ outputPostprocessors()

void AdvancedOutput::outputPostprocessors ( )

protectedvirtualinherited

Performs output of postprocessors The child class must define this method to output the postprocessors as desired.

See also: Exodus::outputPostprocessors

Reimplemented in Console, CSV, Exodus, Nemesis, and TableOutput.

Definition at line 221 of file AdvancedOutput.C.

{
  mooseError("Individual output of postprocessors is not support for this output object named '",
             name(),
             "'");
}

Referenced by AdvancedOutput::output().

◆ outputReporters()

void AdvancedOutput::outputReporters ( )

protectedvirtualinherited

Output Reporter values.

The child class must define this method to output the Reporter values as desired

See also: CSV::outputReporters

Reimplemented in Console, CSV, Exodus, JSONOutput, and TableOutput.

Definition at line 260 of file AdvancedOutput.C.

{
  mooseError(
      "Output of the Reporter value(s) is not support for this output object named '", name(), "'");
}

Referenced by AdvancedOutput::output().

◆ outputScalarVariables()

void AdvancedOutput::outputScalarVariables ( )

protectedvirtualinherited

Performs output of scalar variables The child class must define this method to output the scalar variables as desired.

See also: Exodus::outputScalarVariables

Reimplemented in Console, CSV, Exodus, Nemesis, and TableOutput.

Definition at line 238 of file AdvancedOutput.C.

{
  mooseError(
      "Individual output of scalars is not support for this output object named '", name(), "'");
}

Referenced by AdvancedOutput::output().

◆ outputStep()

void SampledOutput::outputStep ( const ExecFlagType & type )

overridevirtualinherited

A single call to this function should output all the necessary data for a single timestep.

Parameters

type	The type execution flag (see Moose.h)

See also: outputNodalVariables outputElementalVariables outputScalarVariables outputPostprocessors

Reimplemented from Output.

Definition at line 85 of file SampledOutput.C.

{
  // Output is not allowed
  if (!_allow_output && type != EXEC_FORCED)
    return;
 
  // If recovering disable output of initial condition, it was already output
  if (type == EXEC_INITIAL && _app.isRecovering())
    return;
 
  // Return if the current output is not on the desired interval
  if (type != EXEC_FINAL && !onInterval())
    return;
 
  // store current simulation time
  _last_output_simulation_time = _time;
 
  // store current wall time of output
  _last_output_wall_time = std::chrono::steady_clock::now();
 
  // set current type
  _current_execute_flag = type;
 
  // Call the output method
  if (shouldOutput())
  {
    TIME_SECTION("outputStep", 2, "Outputting Step");
    updateSample();
    output();
  }
 
  _current_execute_flag = EXEC_NONE;
}

◆ outputSystemInformation()

void AdvancedOutput::outputSystemInformation ( )

protectedvirtualinherited

Todo:: Performs the output of system information By default this method does nothing and is not called by output()

Reimplemented in Console, and JSONOutput.

Definition at line 245 of file AdvancedOutput.C.

{
  mooseError(
      "Output of system information is not support for this output object named '", name(), "'");
}

Referenced by AdvancedOutput::output().

◆ outputVectorPostprocessors()

void AdvancedOutput::outputVectorPostprocessors ( )

protectedvirtualinherited

Performs output of VectorPostprocessors The child class must define this method to output the VectorPostprocessors as desired.

Reimplemented in Console, CSV, TableOutput, and XMLOutput.

Definition at line 229 of file AdvancedOutput.C.

{
  mooseError(
      "Individual output of VectorPostprocessors is not support for this output object named '",
      name(),
      "'");
}

Referenced by AdvancedOutput::output().

◆ paramError()

template<typename... Args>

void MooseBase::paramError	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits an error prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseError - only printing a message using the given args.

Definition at line 457 of file MooseBase.h.

{
  _pars.paramError(param, std::forward<Args>(args)...);
}

◆ parameters()

const InputParameters & MooseBase::parameters ( ) const

inlineinherited

Get the parameters of the object.

Returns: The parameters of the object

Definition at line 131 of file MooseBase.h.

131{ return _pars; }

◆ paramInfo()

template<typename... Args>

void MooseBase::paramInfo	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits an informational message prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseInfo - only printing a message using the given args.

Definition at line 471 of file MooseBase.h.

{
  mooseInfo(_pars.paramMessage(param, std::forward<Args>(args)...));
}

Referenced by GridPartitioner::_do_partition(), ComboMarker::ComboMarker(), Control::Control(), FunctorIC::FunctorIC(), and TransientMultiApp::TransientMultiApp().

◆ paramWarning() [1/2]

template<typename... Args>

void MooseBase::paramWarning	(	const std::string &	param,
		Args...	args
	)		const

inherited

Emits a warning prefixed with the file and line number of the given param (from the input file) along with the full parameter path+name followed by the given args as the message.

If this object's parameters were not created directly by the Parser, then this function falls back to the normal behavior of mooseWarning - only printing a message using the given args.

Definition at line 464 of file MooseBase.h.

{
  mooseWarning(_pars.paramMessage(param, std::forward<Args>(args)...));
}

◆ paramWarning() [2/2]

template<typename... Args>

void SolutionInvalidInterface::paramWarning	(	const std::string &	param,
		Args...	args
	)		const

inlineinherited

Definition at line 94 of file SolutionInvalidInterface.h.

  {
    _si_moose_base.MooseBase::paramWarning(param, std::forward<Args>(args)...);
    flagSolutionWarningMultipleRegistration(_si_moose_base.name() + ": warning for parameter '" +
                                            param + "'");
  }

Referenced by GridPartitioner::_do_partition(), CartesianMeshGenerator::CartesianMeshGenerator(), MultiAppTransfer::checkParentAppUserObjectExecuteOn(), EigenProblem::checkProblemIntegrity(), MooseMeshUtils::copyIntoMesh(), DefaultMultiAppFixedPointConvergence::DefaultMultiAppFixedPointConvergence(), MultiAppNearestNodeTransfer::execute(), FEProblemSolve::FEProblemSolve(), PlaneIDMeshGenerator::generate(), SubdomainsFromPartitionerGenerator::generate(), UniqueExtraIDMeshGenerator::generate(), ReferenceResidualConvergence::initialSetup(), FullSolveMultiApp::initialSetup(), Terminator::initialSetup(), SampledOutput::initSample(), MooseMesh::MooseMesh(), PNGOutput::PNGOutput(), FEProblemBase::setPreserveMatrixSparsityPattern(), and Terminator::Terminator().

◆ perfGraph()

PerfGraph & PerfGraphInterface::perfGraph ( )

inherited

Get the PerfGraph.

Definition at line 86 of file PerfGraphInterface.C.

{
  return _pg_moose_app.perfGraph();
}

Referenced by CommonOutputAction::act(), PerfGraphData::finalize(), PerfGraphReporter::finalize(), and PerfGraphOutput::output().

◆ petscLinearOutput()

PetscErrorCode PetscOutputInterface::petscLinearOutput	(	KSP	,
		PetscInt	its,
		PetscReal	fnorm,
		void *	void_ptr
	)

staticprotectedinherited

Performs the output onlinear iterations This is the monitor method that PETSc will call on linear iterations.

This is one of three locations where we explicitly flush the output buffers during a simulation: PetscOutput::petscNonlinearOutput() PetscOutput::petscLinearOutput() OutputWarehouse::outputStep()

All other Console output should be using newlines to avoid covering buffer errors and to avoid excessive I/O. This call is necessary. In the PETSc callback the context bypasses the OutputWarehouse.

Definition at line 76 of file PetscOutput.C.

{
  // Get the primary outputter object
  PetscOutput * primary_ptr = static_cast<PetscOutput *>(void_ptr);
 
  // loop over all interface objects
  for (const auto poi_ptr : primary_ptr->getMooseApp().getInterfaceObjects<PetscOutputInterface>())
  {
    auto ptr = poi_ptr->_petsc_output;
 
    // check time
    if (!ptr->inLinearTimeWindow())
      continue;
 
    // Update the pseudo time
    ptr->_linear_time += ptr->_linear_dt;
 
    // Set the current norm and iteration number
    ptr->_norm = norm;
    ptr->_linear_iter = its;
 
    // Set the flag indicating that output is occurring on the non-linear residual
    ptr->_on_linear_residual = true;
 
    // Perform the output
    ptr->outputStep(EXEC_LINEAR);
 
    ptr->_app.getOutputWarehouse().flushConsoleBuffer();
 
    // Reset the linear output flag and the simulation time
    ptr->_on_linear_residual = false;
  }
 
  // Done
  return (PetscErrorCode)0;
}

Referenced by PetscOutput::solveSetup().

◆ petscNonlinearOutput()

PetscErrorCode PetscOutputInterface::petscNonlinearOutput	(	SNES	,
		PetscInt	its,
		PetscReal	fnorm,
		void *	void_ptr
	)

staticprotectedinherited

Performs the output on non-linear iterations This is the monitor method that PETSc will call on non-linear iterations.

This is one of three locations where we explicitly flush the output buffers during a simulation: PetscOutput::petscNonlinearOutput() PetscOutput::petscLinearOutput() OutputWarehouse::outputStep()

All other Console output should be using newlines to avoid covering buffer errors and to avoid excessive I/O. This call is necessary. In the PETSc callback the context bypasses the OutputWarehouse.

Definition at line 26 of file PetscOutput.C.

{
  // Get the primary outputter object
  PetscOutput * primary_ptr = static_cast<PetscOutput *>(void_ptr);
 
  // loop over all interface objects
  for (const auto poi_ptr : primary_ptr->getMooseApp().getInterfaceObjects<PetscOutputInterface>())
  {
    auto ptr = poi_ptr->_petsc_output;
 
    // check time
    if (!ptr->inNonlinearTimeWindow())
      continue;
 
    // Update the pseudo times
    ptr->_nonlinear_time += ptr->_nonlinear_dt;
    ptr->_linear_time = ptr->_nonlinear_time;
 
    // Set the current norm and iteration number
    ptr->_norm = norm;
    ptr->_nonlinear_iter = its;
 
    // Set the flag indicating that output is occurring on the non-linear residual
    ptr->_on_nonlinear_residual = true;
 
    // Perform the output
    ptr->outputStep(EXEC_NONLINEAR);
 
    ptr->_app.getOutputWarehouse().flushConsoleBuffer();
 
    // Reset the non-linear output flag and the simulation time
    ptr->_on_nonlinear_residual = false;
  }
 
  // Done
  return (PetscErrorCode)0;
}

Referenced by PetscOutput::solveSetup().

◆ possiblyCheckHasReporter()

template<typename T >

void ReporterInterface::possiblyCheckHasReporter	(	const ReporterName &	reporter_name,
		const std::string &	param_name = `""`
	)		const

privateinherited

Helpers for "possibly" checking if a Reporter value exists.

This is only able to check for existance after all Reporters have been added (after the task creating them has been called). If called before said task, this will do nothing, hence the "possibly". This allows us to have errors reported directly by the object requesting the Reporter instead of through a system with less context.

Definition at line 211 of file ReporterInterface.h.

{
  if (reportersAdded() && !hasReporterValueByName<T>(reporter_name))
  {
    std::stringstream oss;
    oss << "A Reporter value with the name \"" << reporter_name << "\" and type \""
        << MooseUtils::prettyCppType<T>() << "\" was not found.";
 
    if (_ri_params.isParamValid(param_name))
      _ri_moose_object.paramError(param_name, oss.str());
    else
      _ri_moose_object.mooseError(oss.str());
  }
}

◆ possiblyCheckHasVectorPostprocessor()

void VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor	(	const std::string &	param_name,
		const std::string &	vector_name
	)		const

privateinherited

Helpers for "possibly" checking if a vpp exists.

This is only able to check for existance after all vpps have been added (after the task creating them has been called). If called before said task, this will do nothing, hence the "possibly". This allows us to have errors reported directly by the object requesting the vpp instead of through a system with less context.

Definition at line 241 of file VectorPostprocessorInterface.C.

{
  // Can't do checking if vpps have not been added
  if (!vectorPostprocessorsAdded())
    return;
 
  if (!hasVectorPostprocessor(param_name))
    _vpi_moose_object.paramError(param_name,
                                 "A VectorPostprocessor with the name \"",
                                 getVectorPostprocessorName(param_name),
                                 "\" was not found.");
  if (!hasVectorPostprocessor(param_name, vector_name))
    _vpi_moose_object.paramError(param_name,
                                 "The VectorPostprocessor \"",
                                 getVectorPostprocessorName(param_name),
                                 "\" does not have a vector named \"",
                                 vector_name,
                                 "\".");
}

Referenced by VectorPostprocessorInterface::getScatterVectorPostprocessorValue(), VectorPostprocessorInterface::getScatterVectorPostprocessorValueOld(), VectorPostprocessorInterface::getVectorPostprocessorValue(), VectorPostprocessorInterface::getVectorPostprocessorValue(), VectorPostprocessorInterface::getVectorPostprocessorValueOld(), and VectorPostprocessorInterface::getVectorPostprocessorValueOld().

◆ possiblyCheckHasVectorPostprocessorByName()

void VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName	(	const VectorPostprocessorName &	name,
		const std::string &	vector_name
	)		const

privateinherited

Definition at line 263 of file VectorPostprocessorInterface.C.

{
  // Can't do checking if vpps have not been added
  if (!vectorPostprocessorsAdded())
    return;
 
  if (!hasVectorPostprocessorByName(name))
    _vpi_moose_object.mooseError(
        "A VectorPostprocessor with the name \"", name, "\" was not found.");
  if (!hasVectorPostprocessorByName(name, vector_name))
    _vpi_moose_object.mooseError("The VectorPostprocessor \"",
                                 name,
                                 "\" does not have a vector named \"",
                                 vector_name,
                                 "\".");
}

Referenced by VectorPostprocessorInterface::getVectorPostprocessorByNameHelper(), and VectorPostprocessorInterface::getVectorPostprocessorContextByNameHelper().

◆ postprocessorsAdded()

bool PostprocessorInterface::postprocessorsAdded ( ) const

privateinherited

Returns: True if all pps have been added (the task associated with adding them is complete)

Definition at line 274 of file PostprocessorInterface.C.

{
  return _ppi_feproblem.getMooseApp().actionWarehouse().isTaskComplete("add_postprocessor");
}

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::hasPostprocessor(), and PostprocessorInterface::hasPostprocessorByName().

◆ queryParam()

template<typename T >

const T * MooseBase::queryParam ( const std::string & name ) const

inherited

Query a parameter for the object.

If a parameter of the given name and type does not exist or if the parameter is not valid, nullptr will be returned

Parameters

name	The name of the parameter

Returns: A pointer to the parameter value, if it exists

Definition at line 413 of file MooseBase.h.

{
  return _pars.queryParam<T>(name);
}

Referenced by MFEMExecutedObject::getRequestedItems(), and MFEMGeometricMultigridSolver::MFEMGeometricMultigridSolver().

◆ registerInvalidSolutionInternal()

InvalidSolutionID SolutionInvalidInterface::registerInvalidSolutionInternal	(	const std::string &	message,
		const bool	warning
	)		const

protectedinherited

Definition at line 55 of file SolutionInvalidInterface.C.

{
  return moose::internal::getSolutionInvalidityRegistry().registerInvalidity(
      _si_moose_base.type(), message, warning);
}

◆ registerRestartableDataOnApp()

RestartableDataValue & Restartable::registerRestartableDataOnApp	(	std::unique_ptr< RestartableDataValue >	data,
		THREAD_ID	tid
	)		const

privateinherited

Helper function for actually registering the restartable data.

Definition at line 63 of file Restartable.C.

{
  return _restartable_app.registerRestartableData(
      std::move(data), tid, _restartable_read_only, _metaname);
}

Referenced by Restartable::declareRestartableDataHelper().

◆ registerRestartableNameWithFilterOnApp()

void Restartable::registerRestartableNameWithFilterOnApp	(	const std::string &	name,
		Moose::RESTARTABLE_FILTER	filter
	)

privateinherited

Helper function for actually registering the restartable data.

Definition at line 71 of file Restartable.C.

{
  _restartable_app.registerRestartableNameWithFilter(name, filter);
}

Referenced by Restartable::declareRecoverableData().

◆ registerTimedSection() [1/2]

PerfID PerfGraphInterface::registerTimedSection	(	const std::string &	section_name,
		const unsigned int	level
	)		const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)

Returns: The ID of the section - use when starting timing

Definition at line 61 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(timed_section_name, level);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

◆ registerTimedSection() [2/2]

PerfID PerfGraphInterface::registerTimedSection	(	const std::string &	section_name,
		const unsigned int	level,
		const std::string &	live_message,
		const bool	print_dots = `true`
	)		const

protectedinherited

Call to register a named section for timing.

Parameters

section_name	The name of the code section to be timed
level	The importance of the timer - lower is more important (0 will always come out)
live_message	The message to be printed to the screen during execution
print_dots	Whether or not progress dots should be printed for this section

Returns: The ID of the section - use when starting timing

Definition at line 72 of file PerfGraphInterface.C.

{
  const auto timed_section_name = timedSectionName(section_name);
  if (!moose::internal::getPerfGraphRegistry().sectionExists(timed_section_name))
    return moose::internal::getPerfGraphRegistry().registerSection(
        timedSectionName(section_name), level, live_message, print_dots);
  else
    return moose::internal::getPerfGraphRegistry().sectionID(timed_section_name);
}

◆ reportersAdded()

bool ReporterInterface::reportersAdded ( ) const

privateinherited

Returns: True if all Reporters have been added (the task associated with adding them is complete)

Definition at line 92 of file ReporterInterface.C.

{
  return _ri_fe_problem_base.getMooseApp().actionWarehouse().isTaskComplete("add_reporter");
}

Referenced by ReporterInterface::getReporterContextBaseByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), and ReporterInterface::possiblyCheckHasReporter().

◆ residualSetup()

void SetupInterface::residualSetup ( )

virtualinherited

Gets called just before the residual is computed and before this object is asked to do its job.

Reimplemented in NodeFaceConstraint, Positions, Times, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< Real >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< T >, MooseVariableFE< OutputType >, MooseVariableFE< ComputeValueType >, MooseVariableFE< Real >, MooseVariableFE< RealEigenVector >, MooseVariableFE< RealVectorValue >, MooseVariableFE< T >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< Real >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< T >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< Real >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< T >, and Function.

Definition at line 63 of file SetupInterface.C.

64{

65}

Referenced by MooseVariableField< OutputType >::residualSetup(), ComputeFVFluxResidualThread< RangeType >::setup(), and ComputeFVFluxRJThread< RangeType >::setup().

◆ restartableName()

std::string Restartable::restartableName ( const std::string & data_name ) const

protectedinherited

Gets the name of a piece of restartable data given a data name, adding the system name and object name prefix.

This should only be used in this interface and in testing.

Definition at line 78 of file Restartable.C.

{
  return _restartable_system_name + "/" + _restartable_name + "/" + data_name;
}

Referenced by Restartable::declareRecoverableData(), and Restartable::declareRestartableDataHelper().

◆ setFileBase()

void FileOutput::setFileBase ( const std::string & file_base )

inherited

Sets the file base string if the 'file_base' parameter is not set.

Parameters

file_base The new file base string

Definition at line 119 of file FileOutput.C.

{
  if (!isParamValid("file_base"))
    setFileBaseInternal(file_base);
}

◆ setFileBaseInternal()

void SampledOutput::setFileBaseInternal ( const std::string & file_base )

overrideprotectedvirtualinherited

Appends the base class's file base string.

Reimplemented from FileOutput.

Definition at line 533 of file SampledOutput.C.

{
  AdvancedOutput::setFileBaseInternal(file_base);
  // ** DEPRECATED SUPPORT **
  if (getParam<bool>("append_oversample"))
    _file_base += "_oversample";
}

◆ setFileNumber()

void FileOutput::setFileNumber ( unsigned int num )

inherited

Sets the file number manually.

This method was implemented for the MultiApp system, particularly when reseting an application and a new output file is desired after the reset.

Definition at line 174 of file FileOutput.C.

{
  _file_num = num;
}

Referenced by OutputWarehouse::setFileNumbers().

◆ setWallTimeIntervalFromCommandLineParam()

void Output::setWallTimeIntervalFromCommandLineParam ( )

protectedinherited

Function to set the wall time interval based on value of command line parameter (used for testing only).

Parameters

cli_param_name The name of the command line parameter to set the wall time interval to

Definition at line 336 of file Output.C.

{
  if (_app.isParamValid("output_wall_time_interval"))
  {
    _wall_time_interval = _app.getParam<Real>("output_wall_time_interval");
 
    // If default value of _wall_time_interval was just overriden and user did not
    // explicitly specify _time_step_interval, override default value of
    // _time_step_interval so output does not occur after every time step
    if (_time_step_interval_set_by_addparam)
      _time_step_interval = std::numeric_limits<unsigned int>::max();
  }
}

Referenced by Checkpoint::Checkpoint().

◆ shouldOutput()

bool AdvancedOutput::shouldOutput ( )

protectedvirtualinherited

Handles logic for determining if a step should be output.

Returns: True if a call if output should be performed

Reimplemented from FileOutput.

Definition at line 267 of file AdvancedOutput.C.

{
  if (!checkFilename())
    return false;
 
  if (hasOutput(_current_execute_flag))
    return true;
  else
    return Output::shouldOutput();
}

Referenced by SampledOutput::outputStep().

◆ solveSetup()

void PetscOutput::solveSetup ( )

overrideprivatevirtualinherited

Internal setup function that executes at the beginning of the time step.

Reimplemented from Output.

Definition at line 218 of file PetscOutput.C.

{
  // Update the pseudo times
  _nonlinear_time = _time_old; // non-linear time starts with the previous time step
  if (_dt != 0)
    // set the pseudo non-linear timestep as fraction
    // of real timestep for transient executioners
    _nonlinear_dt = _dt / _nonlinear_dt_divisor;
  else
    // set the pseudo non-linear timestep for steady
    // executioners (here _dt==0)
    _nonlinear_dt = 1. / _nonlinear_dt_divisor;
 
  _linear_dt = _nonlinear_dt / _linear_dt_divisor; // set the pseudo linear timestep
 
  // only the first PetscOutput object registers a DM monitor for linear and nonlinear
  // all other PetscOutput objects are dispatched from that one monitor (per app).
  if (_app.getInterfaceObjects<PetscOutputInterface>()[0] != this)
    return;
 
  ActionWarehouse & awh = _app.actionWarehouse();
  const auto actions = awh.getActions<CommonOutputAction>();
  mooseAssert(actions.size() <= 1, "Should not be more than one CommonOutputAction");
  const Action * common = actions.empty() ? nullptr : *actions.begin();
 
  // Extract the non-linear and linear solvers from PETSc
  NonlinearSystemBase & nl = _problem_ptr->currentNonlinearSystem();
  SNES snes = nl.getSNES();
  KSP ksp;
  LibmeshPetscCallA(_communicator.get(), SNESGetKSP(snes, &ksp));
 
  // Set the PETSc monitor functions (register the nonlinear callback so that linear outputs
  // get an updated nonlinear iteration number)
  // Not every Output should register its own DM monitor! Just register one each of nonlinear
  // and linear and dispatch all Outputs from there!
  if (common && common->getParam<bool>("print_nonlinear_residuals"))
    LibmeshPetscCallA(_communicator.get(),
                      SNESMonitorSet(snes, petscNonlinearOutput, this, LIBMESH_PETSC_NULLPTR));
  if (common && common->getParam<bool>("print_linear_residuals"))
    LibmeshPetscCallA(_communicator.get(),
                      KSPMonitorSet(ksp, petscLinearOutput, this, LIBMESH_PETSC_NULLPTR));
}

◆ subdomainSetup()

void SetupInterface::subdomainSetup ( )

virtualinherited

Gets called when the subdomain changes (i.e.

in a Jacobian or residual loop) and before this object is asked to do its job

Reimplemented in Material, MaterialBase, GeneralUserObject, NodalUserObject, ThreadedGeneralUserObject, Constraint, Moose::Kokkos::AuxKernel, Moose::Kokkos::MaterialBase, and Moose::Kokkos::UserObject.

Definition at line 68 of file SetupInterface.C.

69{

70}

◆ supportsMaterialPropertyOutput()

bool XDA::supportsMaterialPropertyOutput ( ) const

inlineoverridevirtual

A virtual function that stores whether output type supports material output.

Defaults to false, if a particular output type supports material output it can be overridden in the child class.

Reimplemented from Output.

Definition at line 28 of file XDA.h.

28{ return true; }

◆ time()

Real PetscOutput::time ( )

overridevirtualinherited

Get the output time.

This outputter enables the ability to perform output on the nonlinear and linear iterations performed by PETSc. To separate theses outputs within the output a pseudo time is defined, this function provides this time and it should be used in place of _time from Outputter.

Reimplemented from Output.

Definition at line 262 of file PetscOutput.C.

{
  if (_on_nonlinear_residual)
    return _nonlinear_time;
  else if (_on_linear_residual)
    return _linear_time;
  else
    return Output::time();
}

Referenced by PetscOutput::getOutputTime(), MFEMDataCollection::output(), and FileOutput::setFileBaseInternal().

◆ timedSectionName()

std::string PerfGraphInterface::timedSectionName ( const std::string & section_name ) const

protectedinherited

Returns: The name of the timed section with the name section_name.

Optionally adds a prefix if one is defined.

Definition at line 55 of file PerfGraphInterface.C.

{
  return _prefix.empty() ? "" : (_prefix + "::") + section_name;
}

Referenced by PerfGraphInterface::registerTimedSection(), and PerfGraphInterface::registerTimedSection().

◆ timeOld()

Real Output::timeOld ( )

virtualinherited

Get the old output time.

Returns: The old output time, which may be different than the simulation time

See also: time()

Definition at line 360 of file Output.C.

{
  if (_transient)
    return _time_old;
  else
    return _t_step - 1;
}

Referenced by Console::writeTimestepInformation().

◆ timeStep()

int Output::timeStep ( )

virtualinherited

Get the current time step.

Definition at line 387 of file Output.C.

{
  return _t_step;
}

Referenced by Checkpoint::filename(), JSONOutput::filename(), CSV::getVectorPostprocessorFileName(), Checkpoint::shouldOutput(), and Console::writeTimestepInformation().

◆ timestepSetup()

void SetupInterface::timestepSetup ( )

virtualinherited

Gets called at the beginning of the timestep before this object is asked to do its job.

Reimplemented in VectorPostprocessorVisualizationAux, EqualValueEmbeddedConstraintTempl< is_ad >, PIDTransientControl, Function, ElementSubdomainModifierBase, Console, JSONOutput, Positions, MemoryUsage, NumNonlinearIterations, Times, SolutionUserObjectBase, MooseLinearVariableFV< OutputType >, MooseLinearVariableFV< ComputeValueType >, MooseLinearVariableFV< Real >, MooseLinearVariableFV< RealEigenVector >, MooseLinearVariableFV< RealVectorValue >, MooseLinearVariableFV< T >, MooseVariableField< OutputType >, MooseVariableField< ComputeValueType >, MooseVariableField< Real >, MooseVariableField< RealEigenVector >, MooseVariableField< RealVectorValue >, MooseVariableField< T >, MooseVariableFV< OutputType >, MooseVariableFV< ComputeValueType >, MooseVariableFV< Real >, MooseVariableFV< RealEigenVector >, MooseVariableFV< RealVectorValue >, MooseVariableFV< T >, and VectorMemoryUsage.

Definition at line 53 of file SetupInterface.C.

54{

55}

Referenced by JSONOutput::timestepSetup(), and MooseVariableField< OutputType >::timestepSetup().

◆ type()

const std::string & MooseBase::type ( ) const

inlineinherited

Get the type of this class.

Returns: the name of the type of this class

Definition at line 93 of file MooseBase.h.

  {
    mooseAssert(_type.size(), "Empty type");
    return _type;
  }

◆ typeAndName()

std::string MooseBase::typeAndName ( ) const

inherited

Get the class's combined type and name; useful in error handling.

Returns: The type and name of this class in the form '<type()> "<name()>"'.

Definition at line 57 of file MooseBase.C.

{
  return type() + std::string(" \"") + name() + std::string("\"");
}

Referenced by MaterialPropertyStorage::addProperty(), FEProblemBase::checkUserObjectNameCollision(), MeshGeneratorSystem::dataDrivenError(), ReporterContext< T >::finalize(), ReporterData::getReporterInfo(), MFEMSamplerBase::initialSetup(), MFEMVariableSamplerBase::initialSetup(), WebServerControl::outputMessage(), and Action::timedAct().

◆ uniqueName()

MooseObjectName MooseBase::uniqueName ( ) const

inherited

Returns: The unique name for accessing input parameters of this object in the InputParameterWarehouse

Definition at line 69 of file MooseBase.C.

{
  if (!_pars.have_parameter<std::string>(unique_name_param))
    mooseError("uniqueName(): Object does not have a unique name");
  return MooseObjectName(_pars.get<std::string>(unique_name_param));
}

Referenced by MooseBase::connectControllableParams(), and Action::uniqueActionName().

◆ uniqueParameterName()

MooseObjectParameterName MooseBase::uniqueParameterName ( const std::string & parameter_name ) const

inherited

Returns: The unique parameter name of a valid parameter of this object for accessing parameter controls

Definition at line 63 of file MooseBase.C.

{
  return MooseObjectParameterName(getBase(), name(), parameter_name);
}

◆ updateSample()

void SampledOutput::updateSample ( )

protectedvirtualinherited

Performs the update of the solution vector for the sample/re-positioned mesh.

Definition at line 296 of file SampledOutput.C.

{
  // Do nothing if oversampling and changing position are not enabled
  if (!_use_sampled_output)
    return;
 
  // We need the mesh functions to extend the whole domain so we serialize both the mesh and the
  // solution. We need this because the partitioning of the sampling mesh may not match the
  // partitioning of the source mesh
  if (_serialize)
  {
    _problem_ptr->mesh().getMesh().gather_to_zero();
    _mesh_ptr->getMesh().gather_to_zero();
  }
 
  // Get a reference to actual equation system
  EquationSystems & source_es = _problem_ptr->es();
  const auto num_systems = source_es.n_systems();
 
  // Loop through each system
  for (const auto sys_num : make_range(num_systems))
  {
    if (!_mesh_functions[sys_num].empty())
    {
      // Get references to the source and destination systems
      System & source_sys = source_es.get_system(sys_num);
      System & dest_sys = _sampling_es->get_system(sys_num);
 
      // Update the solution for the sampling mesh
      if (_serialize)
      {
        _serialized_solution->clear();
        _serialized_solution->init(source_sys.n_dofs(), false, SERIAL);
        // Pull down a full copy of this vector on every processor so we can get values in
        // parallel
        source_sys.solution->localize(*_serialized_solution);
      }
 
      // Update the mesh functions
      for (const auto var_num : index_range(_mesh_functions[sys_num]))
      {
        const auto original_var_num = _variable_numbers_in_system[sys_num][var_num];
 
        // If the mesh has changed, the MeshFunctions need to be re-built, otherwise simply clear
        // it for re-initialization
        // TODO: inherit from MeshChangedInterface and rebuild mesh functions on meshChanged()
        if (!_mesh_functions[sys_num][var_num] || _sampling_mesh_changed)
          _mesh_functions[sys_num][var_num] = std::make_unique<MeshFunction>(
              source_es,
              _serialize ? *_serialized_solution : *source_sys.solution,
              source_sys.get_dof_map(),
              original_var_num);
        else
          _mesh_functions[sys_num][var_num]->clear();
 
        // Initialize the MeshFunctions for application to the sampled solution
        _mesh_functions[sys_num][var_num]->init();
 
        // Mesh functions are still defined on the original mesh, which might not fully overlap
        // with the sampling mesh. We don't want to error with a libMesh assert on the out of mesh
        // mode
        _mesh_functions[sys_num][var_num]->enable_out_of_mesh_mode(-1e6);
      }
 
      // Fill solution vectors by evaluating mesh functions on sampling mesh
      for (const auto var_num : index_range(_mesh_functions[sys_num]))
      {
        // we serialized the mesh and the solution vector, we might as well just do this only on
        // processor 0.
        if (_serialize && processor_id() > 0)
          break;
 
        const auto original_var_num = _variable_numbers_in_system[sys_num][var_num];
        const FEType & fe_type = source_sys.variable_type(original_var_num);
        // we use the original variable block restriction for sampling
        const auto * var_blocks = &source_sys.variable(original_var_num).active_subdomains();
        // NOTE: if we have overlapping domains between the sampling mesh and the source mesh
        // we would get a value from the source mesh domain. We could further restrict this
        // block restriction with the sampling mesh block restriction to prevent this.
 
        // Loop over the mesh, nodes for nodal data, elements for element data
        if (isSampledAtNodes(fe_type))
        {
          for (const auto & node : (_serialize ? _mesh_ptr->getMesh().node_ptr_range()
                                               : _mesh_ptr->getMesh().local_node_ptr_range()))
          {
            // Avoid working on ghosted dofs
            if (node->n_dofs(sys_num, var_num) &&
                (_serialize || processor_id() == node->processor_id()))
            {
              // the node has to be within the domain of the mesh function
              DenseVector<Real> value(1);
              if (var_blocks->size())
                (*_mesh_functions[sys_num][var_num])(
                    *node - _position, /*time*/ 0., value, var_blocks);
              else
                value[0] = (*_mesh_functions[sys_num][var_num])(*node - _position);
 
              if (value[0] != -1e6)
                dest_sys.solution->set(node->dof_number(sys_num, var_num, /*comp=*/0), value[0]);
              else
                mooseDoOnce(mooseWarning(
                    "Sampling at location ",
                    *node - _position,
                    " by process ",
                    std::to_string(processor_id()),
                    " was outside the problem mesh.\nThis message will not be repeated"));
            }
          }
        }
        else
        {
          const auto elem_range = _serialize
                                      ? _mesh_ptr->getMesh().active_element_ptr_range()
                                      : _mesh_ptr->getMesh().active_local_element_ptr_range();
          for (const auto & elem : elem_range)
          {
            if (elem->n_dofs(sys_num, var_num) &&
                (_serialize || processor_id() == elem->processor_id()))
            {
              DenseVector<Real> value(1);
              if (var_blocks->size())
                (*_mesh_functions[sys_num][var_num])(
                    elem->true_centroid() - _position, /*time*/ 0., value, var_blocks);
              else
                value[0] = (*_mesh_functions[sys_num][var_num])(elem->true_centroid() - _position);
 
              if (value[0] != -1e6)
                dest_sys.solution->set(elem->dof_number(sys_num, var_num, /*comp=*/0), value[0]);
              else
                mooseDoOnce(mooseWarning(
                    "Sampling at location ",
                    elem->true_centroid() - _position,
                    " was outside the problem mesh.\nThis message will not be repeated."));
            }
          }
        }
      }
 
      // We modified the solution vector directly, we have to close it
      dest_sys.solution->close();
    }
  }
 
  // Set this to false so that new output files are not created, since the sampling mesh
  // doesn't actually change
  _sampling_mesh_changed = false;
}

Referenced by SampledOutput::outputStep().

◆ validParams()

InputParameters XDA::validParams ( )

static

Definition at line 25 of file XDA.C.

{
  // Get the base class parameters
  InputParameters params = SampledOutput::validParams();
 
  // Add description for the XDA class
  params.addClassDescription("Object for outputting data in the XDA/XDR format.");
 
  /* Set a private parameter for controlling the output type (XDR = binary), the value
     of this parameter is set by the AddOutputAction*/
  params.addPrivateParam<bool>("_binary", false);
 
  // Return the InputParameters
  return params;
}

◆ vectorPostprocessorsAdded()

bool VectorPostprocessorInterface::vectorPostprocessorsAdded ( ) const

privateinherited

Returns: True if all vpps have been added (the task associated with adding them is complete)

Definition at line 319 of file VectorPostprocessorInterface.C.

{
  return _vpi_feproblem.getMooseApp().actionWarehouse().isTaskComplete("add_vector_postprocessor");
}

Referenced by VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessor(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), VectorPostprocessorInterface::hasVectorPostprocessorByName(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), and VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName().

◆ wantOutput()

bool AdvancedOutput::wantOutput	(	const std::string &	name,
		const ExecFlagType &	type
	)

privateinherited

Handles logic for determining if a step should be output.

Returns: True if a call if output should be performed

Definition at line 343 of file AdvancedOutput.C.

{
  // Ignore EXEC_FORCED for system information and input, there is no reason to force this
  if (type == EXEC_FORCED && (name == "system_information" || name == "input"))
    return false;
 
  // Do not output if the 'none' is contained by the execute_on
  if (_advanced_execute_on.contains(name) && _advanced_execute_on[name].isValueSet("none"))
    return false;
 
  // Data output flag, true if data exists to be output
  bool execute_data_flag = true;
 
  // Set flag to false, if the OutputData exists and the output variable list is empty
  std::map<std::string, OutputData>::const_iterator iter = _execute_data.find(name);
  if (iter != _execute_data.end() && iter->second.output.empty())
    execute_data_flag = false;
 
  // Set flag to false, if the OutputOnWarehouse DOES NOT contain an entry
  if (!_advanced_execute_on.contains(name))
    execute_data_flag = false;
 
  // Force the output, if there is something to output and the time has not been output
  if (type == EXEC_FORCED && execute_data_flag && _last_execute_time[name] != _time)
    return true;
 
  // Return true (output should occur) if three criteria are satisfied, else do not output:
  //   (1) The execute_data_flag = true (i.e, there is data to output)
  //   (2) The current output type is contained in the list of output execution types
  //   (3) The current execution time is "final" or "forced" and the data has not already been
  //   output
  if (execute_data_flag && _advanced_execute_on[name].isValueSet(type) &&
      !(type == EXEC_FINAL && _last_execute_time[name] == _time))
    return true;
  else
    return false;
}

Referenced by AdvancedOutput::hasOutput(), Console::initialSetup(), AdvancedOutput::output(), and Console::output().

Member Data Documentation

◆ _action_factory

ActionFactory& ParallelParamObject::_action_factory

protectedinherited

Builds Actions.

Definition at line 40 of file ParallelParamObject.h.

Referenced by AddActionComponentAction::act(), CreateMeshSetupActionsForComponents::act(), ActionComponent::checkRequiredTasks(), PhysicsBase::checkRequiredTasks(), CommonOutputAction::create(), AddVariableAction::createInitialConditionAction(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), CreateExecutionerAction::setupAutoPreconditioning(), and ReadExecutorParamsAction::setupAutoPreconditioning().

◆ _advanced_execute_on

OutputOnWarehouse Output::_advanced_execute_on

protectedinherited

Storage for the individual component execute flags.

Definition at line 277 of file Output.h.

Referenced by AdvancedOutput::advancedExecuteOn(), Output::advancedExecuteOn(), AdvancedOutput::AdvancedOutput(), AdvancedOutput::hasOutput(), AdvancedOutput::hasOutput(), AdvancedOutput::hasOutputHelper(), AdvancedOutput::init(), Console::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), and AdvancedOutput::wantOutput().

◆ _allow_output

bool Output::_allow_output

protectedinherited

Flag for disabling output.

Definition at line 268 of file Output.h.

Referenced by Output::allowOutput(), Output::outputStep(), and SampledOutput::outputStep().

◆ _app

MooseApp& MooseBase::_app

protectedinherited

The MOOSE application this is associated with.

Definition at line 375 of file MooseBase.h.

Referenced by AB2PredictorCorrector::AB2PredictorCorrector(), FEProblemBase::acceptInvalidSolution(), FEProblemBase::addAnyRedistributers(), MeshGenerator::addChildMeshGenerator(), FEProblemBase::addMaterialHelper(), MeshGenerator::addMeshSubgenerator(), MeshGenerator::addMeshSubgenerator(), FEProblemBase::addOutput(), MeshGenerator::addParentMeshGenerator(), FEProblemBase::allowOutput(), AStableDirk4::AStableDirk4(), FileMesh::buildMesh(), MooseMesh::buildTypedMesh(), MooseMesh::cacheFaceInfoVariableOwnership(), MooseMesh::cacheFVElementalDoFs(), DefaultNonlinearConvergence::checkConvergence(), MeshGenerator::checkGetMesh(), FEProblemBase::checkICRestartError(), FEProblemBase::checkProblemIntegrity(), LibmeshPartitioner::clone(), BlockWeightedPartitioner::clone(), CopyMeshPartitioner::clone(), GridPartitioner::clone(), HierarchicalGridPartitioner::clone(), PetscExternalPartitioner::clone(), RandomPartitioner::clone(), SingleRankPartitioner::clone(), ElementPointNeighborLayers::clone(), ElementSideNeighborLayers::clone(), GhostAllPointNeighbors::clone(), GhostBoundary::clone(), GhostEverything::clone(), GhostHigherDLowerDPointNeighbors::clone(), GhostLowerDElems::clone(), GhostPrimaryFace::clone(), ProxyRelationshipManager::clone(), RedistributeProperties::clone(), SampledOutput::cloneMesh(), FEProblemBase::computeJacobianSys(), FEProblemBase::computeJacobianTags(), FEProblemBase::computeLinearSystemTags(), FEProblemBase::computeResidualAndJacobian(), FEProblemBase::computeResidualSys(), FEProblemBase::computeResidualTags(), Console::Console(), TimeStepper::constrainStep(), Control::Control(), CopyMeshPartitioner::CopyMeshPartitioner(), MultiApp::createApp(), MultiApp::createApps(), FEProblemBase::customSetup(), MeshGenerator::declareMeshProperty(), MeshGenerator::declareNullMeshName(), MooseMesh::determineUseDistributedMesh(), DumpObjectsProblem::dumpObjectHelper(), DumpObjectsProblem::DumpObjectsProblem(), DumpObjectsProblem::dumpVariableHelper(), EigenExecutionerBase::EigenExecutionerBase(), EigenKernel::EigenKernel(), PIDTransientControl::execute(), Eigenvalue::execute(), InversePowerMethod::execute(), NonlinearEigen::execute(), SteadyBase::execute(), TransientBase::execute(), MFEMSteady::execute(), PseudoTimestep::execute(), IterationInfo::execute(), EigenProblem::execute(), Executioner::Executioner(), Executioner::Executioner(), ExtraIDIntegralReporter::ExtraIDIntegralReporter(), FEProblemBase::FEProblemBase(), FileOutput::FileOutput(), NEML2Assembly::finalize(), ChangeOverFixedPointPostprocessor::finalize(), RadialAverage::finalize(), FixedPointSolve::FixedPointSolve(), FEProblemBase::forceOutput(), FullSolveMultiApp::FullSolveMultiApp(), FunctorSmootherTempl< T >::FunctorSmootherTempl(), FVAdvection::FVAdvection(), FileMeshGenerator::generate(), MeshGenerator::generateInternal(), MeshGenerator::generateInternalCSG(), MeshGenerator::getCSGBaseByName(), FEProblemBase::getExecutor(), MeshGenerator::getMeshByName(), NumFixedPointIterations::getValue(), NumRelationshipManagers::getValue(), GhostingUserObject::GhostingUserObject(), MooseMesh::init(), Eigenvalue::init(), InversePowerMethod::init(), NonlinearEigen::init(), TransientBase::init(), MFEMMesh::init(), FEProblemBase::init(), CompositionDT::init(), SubProblem::initialSetup(), PIDTransientControl::initialSetup(), RealFunctionControl::initialSetup(), TimePeriod::initialSetup(), EigenProblemSolve::initialSetup(), FEProblemSolve::initialSetup(), Console::initialSetup(), FEProblemBase::initialSetup(), AdvancedOutput::initOutputList(), FEProblemBase::initPetscOutputAndSomeSolverSettings(), EigenProblem::initPetscOutputAndSomeSolverSettings(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), FEProblemBase::meshChanged(), MeshGenerator::MeshGenerator(), MFEMProblemSolve::MFEMProblemSolve(), MooseMesh::MooseMesh(), MooseMesh::MooseMesh(), MooseObject::MooseObject(), MultiAppGeneralFieldTransfer::MultiAppGeneralFieldTransfer(), EigenExecutionerBase::normalizeSolution(), NumFailedTimeSteps::NumFailedTimeSteps(), Checkpoint::output(), Exodus::output(), Nemesis::output(), PerfGraphOutput::output(), Tecplot::output(), MortarNodalGeometryOutput::output(), ControlOutput::outputActiveObjects(), ControlOutput::outputChangedControls(), ControlOutput::outputControls(), Exodus::outputEmptyTimestep(), Console::outputInput(), Exodus::outputInput(), Exodus::outputNodalVariables(), JSONOutput::outputReporters(), Output::outputStep(), SampledOutput::outputStep(), FEProblemBase::outputStep(), Console::outputSystemInformation(), JSONOutput::outputSystemInformation(), OverlayMeshGenerator::OverlayMeshGenerator(), MultiApp::parentOutputPositionChanged(), TransientBase::preExecute(), FEProblemBase::projectSolution(), AnnularMesh::safeClone(), ConcentricCircleMesh::safeClone(), FileMesh::safeClone(), GeneratedMesh::safeClone(), ImageMesh::safeClone(), MeshGeneratorMesh::safeClone(), PatternedMesh::safeClone(), RinglebMesh::safeClone(), SpiralAnnularMesh::safeClone(), StitchedMesh::safeClone(), TiledMesh::safeClone(), MFEMMesh::safeClone(), MultiApp::setAppOutputFileBase(), FileOutput::setFileBaseInternal(), MeshGenerator::setMeshProperty(), MeshGenerator::setMeshPropertyHelper(), FEProblemBase::setRestartFile(), TransientMultiApp::setupApp(), TimeSequenceStepperBase::setupSequence(), TransientBase::setupTimeIntegrator(), Output::setWallTimeIntervalFromCommandLineParam(), SideSetExtruderGenerator::SideSetExtruderGenerator(), SolutionInvalidityReporter::SolutionInvalidityReporter(), FixedPointSolve::solve(), FEProblemBase::solve(), EigenProblem::solve(), FEProblemBase::solveLinearSystem(), PetscOutput::solveSetup(), FixedPointSolve::solveStep(), TransientMultiApp::solveStep(), FEProblemBase::subdomainSetup(), FEProblemBase::theWarehouse(), TimeExtremeValue::TimeExtremeValue(), TimeIntegratedPostprocessor::TimeIntegratedPostprocessor(), TimeIntervalTimes::TimeIntervalTimes(), TimePeriod::TimePeriod(), SubProblem::timestepSetup(), PIDTransientControl::timestepSetup(), FEProblemBase::timestepSetup(), TransientBase::TransientBase(), MooseMesh::update(), NEML2FEInterpolation::updateDofMap(), NEML2FEInterpolation::updateGradPhi(), NEML2FEInterpolation::updateInterpolations(), FEProblemBase::updateMortarMesh(), NEML2FEInterpolation::updatePhi(), Console::write(), and FEProblemBase::~FEProblemBase().

◆ _binary

bool XDA::_binary

private

Flag for binary output.

Definition at line 45 of file XDA.h.

Referenced by filename(), and output().

◆ _broadcast_by_default

const bool VectorPostprocessorInterface::_broadcast_by_default

privateinherited

Whether or not to force broadcasting by default.

Definition at line 360 of file VectorPostprocessorInterface.h.

Referenced by VectorPostprocessorInterface::getVectorPostprocessorValueByName(), VectorPostprocessorInterface::getVectorPostprocessorValueByName(), VectorPostprocessorInterface::getVectorPostprocessorValueOldByName(), and VectorPostprocessorInterface::getVectorPostprocessorValueOldByName().

◆ _change_position

const bool SampledOutput::_change_position

protectedinherited

Flag for re-positioning.

Definition at line 68 of file SampledOutput.h.

Referenced by SampledOutput::initSample().

◆ _console

const ConsoleStream ConsoleStreamInterface::_console

inherited

An instance of helper class to write streams to the Console objects.

Definition at line 31 of file ConsoleStreamInterface.h.

◆ _current_execute_flag

ExecFlagType Output::_current_execute_flag

protectedinherited

Current execute on flag.

This is different from the flag provided by FEProblemBase::getCurrentExecuteOnFlag() const, as outputs are triggered in PETSc callbacks which cannot update FEProblemBase::_current_execute_on_flag so we shadow it with a new member of the same name.

Definition at line 211 of file Output.h.

Referenced by CSV::getVectorPostprocessorFileName(), AdvancedOutput::output(), Console::output(), ControlOutput::output(), CSV::output(), ProgressOutput::output(), Output::outputStep(), SampledOutput::outputStep(), AdvancedOutput::shouldOutput(), Output::shouldOutput(), Checkpoint::shouldOutput(), and PerfGraphOutput::shouldOutput().

◆ _default_values

std::map<PostprocessorName, std::unique_ptr<PostprocessorValue> > PostprocessorInterface::_default_values

mutableprivateinherited

Holds the default postprocessor values that are requested (key is PostprocessorName)

Definition at line 162 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::getPostprocessorValueInternal().

◆ _dt

Real& Output::_dt

protectedinherited

Time step delta.

Definition at line 223 of file Output.h.

Referenced by Output::dt(), and PetscOutput::solveSetup().

◆ _dt_old

Real& Output::_dt_old

protectedinherited

Old time step delta.

Definition at line 226 of file Output.h.

Referenced by Output::dtOld(), and Console::writeTimestepInformation().

◆ _elemental_as_nodal

bool AdvancedOutput::_elemental_as_nodal

protectedinherited

Flags to control nodal output.

Definition at line 291 of file AdvancedOutput.h.

Referenced by Exodus::Exodus(), and AdvancedOutput::init().

◆ _empty_execute_enum

ExecFlagEnum SetupInterface::_empty_execute_enum

privateinherited

Empty ExecFlagEnum for the case when the "execute_on" parameter is not included.

This is private because others should not be messing with it.

Definition at line 79 of file SetupInterface.h.

Referenced by SetupInterface::SetupInterface().

◆ _enabled

const bool& MooseObject::_enabled

protectedinherited

Reference to the "enable" InputParameters, used by Controls for toggling on/off MooseObjects.

Definition at line 71 of file MooseObject.h.

Referenced by MooseObject::enabled().

◆ _end_step

int Output::_end_step

protectedinherited

End outputting at this time step.

Definition at line 259 of file Output.h.

Referenced by Output::onInterval().

◆ _end_time

Real Output::_end_time

protectedinherited

End outputting time.

Definition at line 253 of file Output.h.

◆ _es_ptr

libMesh::EquationSystems* Output::_es_ptr

protectedinherited

Reference the the libMesh::EquationSystems object that contains the data.

Definition at line 194 of file Output.h.

Referenced by Exodus::handleExodusIOMeshRenumbering(), AdvancedOutput::initAvailableLists(), SampledOutput::initSample(), AdvancedOutput::initShowHideLists(), PNGOutput::makeMeshFunc(), GMVOutput::output(), Nemesis::output(), Tecplot::output(), VTKOutput::output(), output(), Output::Output(), Exodus::outputElementalVariables(), Exodus::outputEmptyTimestep(), Exodus::outputNodalVariables(), and Exodus::outputSetup().

◆ _execute_data

OutputDataWarehouse AdvancedOutput::_execute_data

privateinherited

Storage structures for the various output types.

Definition at line 366 of file AdvancedOutput.h.

◆ _execute_enum

const ExecFlagEnum& SetupInterface::_execute_enum

protectedinherited

Execute settings for this object.

Definition at line 83 of file SetupInterface.h.

◆ _execute_on

ExecFlagEnum Output::_execute_on

protectedinherited

The common Execution types; this is used as the default execution type for everything except system information and input.

Definition at line 203 of file Output.h.

Referenced by AdvancedOutput::AdvancedOutput(), Checkpoint::checkpointInfo(), Console::Console(), Output::executeOn(), AdvancedOutput::initExecutionTypes(), Console::initialSetup(), Console::output(), Output::Output(), PetscOutput::PetscOutput(), Output::shouldOutput(), and PerfGraphOutput::shouldOutput().

◆ _factory

Factory& ParallelParamObject::_factory

protectedinherited

The Factory associated with the MooseApp.

Definition at line 37 of file ParallelParamObject.h.

Referenced by ElementIDOutputAction::act(), AdaptivityAction::act(), AddControlAction::act(), AddNodalNormalsAction::act(), AddPeriodicBCAction::act(), AutoCheckpointAction::act(), CombineComponentsMeshes::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateDisplacedProblemAction::act(), CreateExecutionerAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), DisplayGhostingAction::act(), MaterialDerivativeTestAction::act(), MaterialOutputAction::act(), PartitionerAction::act(), SetAdaptivityOptionsAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), SetupPreconditionerAction::act(), SetupPredictorAction::act(), SetupResidualDebugAction::act(), SetupTimeStepperAction::act(), ComponentJunction::addMeshGenerators(), ComponentMeshTransformHelper::addMeshGenerators(), CylinderComponent::addMeshGenerators(), DiffusionPhysicsBase::addPostprocessors(), CreateDisplacedProblemAction::addProxyRelationshipManagers(), AddActionComponentAction::addRelationshipManagers(), SampledOutput::cloneMesh(), DynamicObjectRegistrationAction::DynamicObjectRegistrationAction(), PhysicsBase::getFactory(), ActionComponent::getFactory(), PhysicsBase::getFactory(), MaterialOutputAction::getParams(), and ProjectedStatefulMaterialStorageAction::processProperty().

◆ _file_base

std::string FileOutput::_file_base

protectedinherited

◆ _file_num

unsigned int& FileOutput::_file_num

protectedinherited

A file number counter, initialized to 0 (this must be controlled by the child class, see Exodus)

Definition at line 80 of file FileOutput.h.

Referenced by Exodus::customizeFileOutput(), DOFMapOutput::filename(), Exodus::filename(), GMVOutput::filename(), Tecplot::filename(), VTKOutput::filename(), filename(), FileOutput::FileOutput(), FileOutput::getFileNumber(), MFEMDataCollection::output(), GMVOutput::output(), Gnuplot::output(), Tecplot::output(), VTKOutput::output(), output(), FileOutput::setFileNumber(), and DOFMapOutput::writeStreamToFile().

◆ _fni_feproblem

FEProblemBase& FunctionInterface::_fni_feproblem

privateinherited

Reference to FEProblemBase instance.

Definition at line 156 of file FunctionInterface.h.

Referenced by FunctionInterface::getFunctionByName(), and FunctionInterface::hasFunctionByName().

◆ _fni_object

const MooseObject& FunctionInterface::_fni_object

privateinherited

Reference to the object.

Definition at line 149 of file FunctionInterface.h.

Referenced by FunctionInterface::getKokkosFunctionByName().

◆ _fni_params

const InputParameters& FunctionInterface::_fni_params

privateinherited

Parameters of the object with this interface.

Definition at line 153 of file FunctionInterface.h.

Referenced by FunctionInterface::getFunction(), FunctionInterface::getKokkosFunction(), and FunctionInterface::hasFunction().

◆ _fni_tid

const THREAD_ID FunctionInterface::_fni_tid

privateinherited

Thread ID.

Definition at line 159 of file FunctionInterface.h.

Referenced by FunctionInterface::getFunctionByName(), and FunctionInterface::hasFunctionByName().

◆ _is_advanced

bool Output::_is_advanced

protectedinherited

Flag for advanced output testing.

Definition at line 271 of file Output.h.

Referenced by AdvancedOutput::AdvancedOutput(), and Output::isAdvanced().

◆ _last_execute_time

std::map<std::string, Real>& AdvancedOutput::_last_execute_time

privateinherited

Storage for the last output time for the various output types, this is used to avoid duplicate output when using OUTPUT_FINAL flag.

Definition at line 369 of file AdvancedOutput.h.

Referenced by AdvancedOutput::clearLastExecuteTime(), AdvancedOutput::output(), and AdvancedOutput::wantOutput().

◆ _last_output_simulation_time

Real& Output::_last_output_simulation_time

protectedinherited

last simulation time an output has occured

Definition at line 280 of file Output.h.

Referenced by Output::onInterval(), Output::outputStep(), and SampledOutput::outputStep().

◆ _last_output_wall_time

std::chrono::time_point<std::chrono::steady_clock> Output::_last_output_wall_time

protectedinherited

last wall time an output has occured

Definition at line 283 of file Output.h.

Referenced by Output::onInterval(), Output::outputStep(), and SampledOutput::outputStep().

◆ _linear_dt

Real PetscOutput::_linear_dt

privateinherited

Psuedo linear time step.

Definition at line 111 of file PetscOutput.h.

Referenced by PetscOutput::solveSetup().

◆ _linear_dt_divisor

Real PetscOutput::_linear_dt_divisor

privateinherited

Pseudo linear timestep divisor.

Definition at line 117 of file PetscOutput.h.

Referenced by PetscOutput::solveSetup().

◆ _linear_end_time

Real PetscOutput::_linear_end_time

privateinherited

Linear residual output end time.

Definition at line 129 of file PetscOutput.h.

Referenced by PetscOutput::inLinearTimeWindow(), and PetscOutput::PetscOutput().

◆ _linear_iter

PetscInt PetscOutput::_linear_iter

protectedinherited

Current linear iteration returned from PETSc.

Definition at line 87 of file PetscOutput.h.

Referenced by CSV::getVectorPostprocessorFileName(), Console::output(), JSONOutput::outputReporters(), and XMLOutput::outputVectorPostprocessors().

◆ _linear_start_time

Real PetscOutput::_linear_start_time

privateinherited

Linear residual output start time.

Definition at line 123 of file PetscOutput.h.

Referenced by PetscOutput::inLinearTimeWindow(), and PetscOutput::PetscOutput().

◆ _linear_time

Real PetscOutput::_linear_time

privateinherited

Psuedo linear time.

Definition at line 108 of file PetscOutput.h.

Referenced by PetscOutputInterface::petscLinearOutput(), and PetscOutput::time().

◆ _mci_feproblem

FEProblemBase& MeshChangedInterface::_mci_feproblem

protectedinherited

Reference to FEProblemBase instance.

Definition at line 44 of file MeshChangedInterface.h.

Referenced by MeshChangedInterface::MeshChangedInterface().

◆ _mesh_functions

std::vector<std::vector<std::unique_ptr<libMesh::MeshFunction> > > SampledOutput::_mesh_functions

privateinherited

A vector of pointers to the mesh functions on the sampled mesh This is only populated when the initSample() function is called, it must be cleaned up by the destructor.

Outer-indexing by system Inner-indexing for each variable in a system

Definition at line 101 of file SampledOutput.h.

Referenced by SampledOutput::initSample(), and SampledOutput::updateSample().

◆ _mesh_ptr

MooseMesh* Output::_mesh_ptr

protectedinherited

A convenience pointer to the current mesh (reference or displaced depending on "use_displaced")

Definition at line 197 of file Output.h.

Referenced by SampledOutput::cloneMesh(), SampledOutput::initSample(), PNGOutput::output(), Tecplot::output(), output(), Output::Output(), Exodus::outputSetup(), and SampledOutput::updateSample().

◆ _mesh_subdomains_match

bool SampledOutput::_mesh_subdomains_match

privateinherited

A flag tracking whether the sampling and source meshes match in terms of subdomains.

Definition at line 113 of file SampledOutput.h.

Referenced by SampledOutput::cloneMesh(), and SampledOutput::initSample().

◆ _metaname

const RestartableDataMapName Restartable::_metaname

privateinherited

Restartable metadata name.

Definition at line 247 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _min_simulation_time_interval

const Real Output::_min_simulation_time_interval

protectedinherited

Minimum simulation time between outputs.

Definition at line 238 of file Output.h.

Referenced by Output::onInterval().

◆ _name

const std::string& MooseBase::_name

protectedinherited

The name of this class.

Definition at line 381 of file MooseBase.h.

◆ _nonlinear_dt

Real PetscOutput::_nonlinear_dt

privateinherited

The pseuedo non-linear time step.

Definition at line 105 of file PetscOutput.h.

Referenced by PetscOutput::solveSetup().

◆ _nonlinear_dt_divisor

Real PetscOutput::_nonlinear_dt_divisor

privateinherited

Pseudo non-linear timestep divisor.

Definition at line 114 of file PetscOutput.h.

Referenced by PetscOutput::solveSetup().

◆ _nonlinear_end_time

Real PetscOutput::_nonlinear_end_time

privateinherited

Non-linear residual output end time.

Definition at line 126 of file PetscOutput.h.

Referenced by PetscOutput::inNonlinearTimeWindow(), and PetscOutput::PetscOutput().

◆ _nonlinear_iter

PetscInt PetscOutput::_nonlinear_iter

protectedinherited

Current non-linear iteration returned from PETSc.

Definition at line 84 of file PetscOutput.h.

Referenced by CSV::getVectorPostprocessorFileName(), Console::output(), JSONOutput::outputReporters(), and XMLOutput::outputVectorPostprocessors().

◆ _nonlinear_start_time

Real PetscOutput::_nonlinear_start_time

privateinherited

Non-linear residual output start time.

Definition at line 120 of file PetscOutput.h.

Referenced by PetscOutput::inNonlinearTimeWindow(), and PetscOutput::PetscOutput().

◆ _nonlinear_time

Real PetscOutput::_nonlinear_time

privateinherited

The psuedo non-linear time.

Definition at line 102 of file PetscOutput.h.

Referenced by PetscOutputInterface::petscNonlinearOutput(), PetscOutput::solveSetup(), and PetscOutput::time().

◆ _norm

Real PetscOutput::_norm

protectedinherited

Current norm returned from PETSc.

Definition at line 81 of file PetscOutput.h.

Referenced by Console::output().

◆ _num

unsigned int Output::_num

protectedinherited

The number of outputs written.

Definition at line 229 of file Output.h.

◆ _on_linear_residual

bool PetscOutput::_on_linear_residual

protectedinherited

True if current output calls is on the linear residual (used by time())

Definition at line 90 of file PetscOutput.h.

Referenced by PetscOutput::time().

◆ _on_nonlinear_residual

bool PetscOutput::_on_nonlinear_residual

protectedinherited

True if current output call is on the non-linear residual (used by time())

Definition at line 93 of file PetscOutput.h.

Referenced by JSONOutput::outputReporters(), XMLOutput::outputVectorPostprocessors(), and PetscOutput::time().

◆ _output_if_base_contains

std::vector<std::string> FileOutput::_output_if_base_contains

protectedinherited

Storage for 'output_if_base_contains'.

Definition at line 86 of file FileOutput.h.

Referenced by FileOutput::checkFilename().

◆ _padding

unsigned int FileOutput::_padding

protectedinherited

Number of digits to pad the extensions.

Definition at line 83 of file FileOutput.h.

Referenced by Checkpoint::filename(), Exodus::filename(), GMVOutput::filename(), JSONOutput::filename(), Nemesis::filename(), Tecplot::filename(), VTKOutput::filename(), filename(), and CSV::getVectorPostprocessorFileName().

◆ _parent

const ParallelParamObject& DataFileInterface::_parent

privateinherited

Definition at line 58 of file DataFileInterface.h.

Referenced by DataFileInterface::getDataFileName(), DataFileInterface::getDataFileNameByName(), and DataFileInterface::getDataFilePath().

◆ _pars

const InputParameters& MooseBase::_pars

protectedinherited

The object's parameters.

Definition at line 384 of file MooseBase.h.

Referenced by AddAuxKernelAction::act(), AddFVICAction::act(), AddICAction::act(), CommonOutputAction::act(), ComposeTimeStepperAction::act(), CreateProblemAction::act(), CreateProblemDefaultAction::act(), SetupDebugAction::act(), SetupMeshAction::act(), AddMFEMComplexBCComponentAction::act(), AddMFEMComplexKernelComponentAction::act(), FunctorMaterial::addFunctorPropertyByBlocks(), BreakMeshByBlockGenerator::BreakMeshByBlockGenerator(), PNGOutput::calculateRescalingValues(), MooseBase::callMooseError(), MooseBase::connectControllableParams(), Console::Console(), MooseApp::copyInputs(), MaterialBase::declareADProperty(), Moose::Kokkos::MaterialBase::declareKokkosOnDemandProperty(), Moose::Kokkos::MaterialBase::declareKokkosProperty(), MaterialBase::declareProperty(), FEProblemSolve::FEProblemSolve(), FileMeshGenerator::generate(), MooseBase::getBase(), MooseBase::getCheckedPointerParam(), MaterialBase::getGenericZeroMaterialProperty(), MooseBase::getHitNode(), MeshGenerator::getMeshGeneratorNameFromParam(), MeshGenerator::getMeshGeneratorNamesFromParam(), MooseBase::getParam(), MooseBase::getParam(), MooseBase::hasBase(), MeshGenerator::hasGenerateCSG(), MeshGenerator::hasGenerateData(), AddVariableAction::init(), AdvancedOutput::initExecutionTypes(), EigenProblemSolve::initialSetup(), Console::initialSetup(), MooseBase::isParamSetByUser(), MooseBase::isParamValid(), MultiApp::keepSolutionDuringRestore(), MooseBase::messagePrefix(), MooseBase::MooseBase(), MultiSystemSolveObject::MultiSystemSolveObject(), MooseApp::outputMachineReadableData(), MooseBase::paramError(), MooseBase::parameters(), MooseBase::paramInfo(), MooseBase::paramWarning(), MooseMesh::prepare(), MooseBase::queryParam(), MooseMesh::setCoordSystem(), MooseMesh::setPartitionerHelper(), SetupMeshAction::setupMesh(), TransientBase::setupTimeIntegrator(), MooseApp::showInputs(), and MooseBase::uniqueName().

◆ _petsc_output

PetscOutput* PetscOutputInterface::_petsc_output

protectedinherited

Definition at line 23 of file PetscOutput.h.

Referenced by PetscOutputInterface::petscLinearOutput(), and PetscOutputInterface::petscNonlinearOutput().

◆ _pg_moose_app

MooseApp& PerfGraphInterface::_pg_moose_app

protectedinherited

The MooseApp that owns the PerfGraph.

Definition at line 135 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::perfGraph().

◆ _position

Point SampledOutput::_position

privateinherited

When oversampling, the output is shift by this amount.

Definition at line 107 of file SampledOutput.h.

Referenced by SampledOutput::initSample(), and SampledOutput::updateSample().

◆ _postprocessors_as_reporters

const bool AdvancedOutput::_postprocessors_as_reporters

privateinherited

Flags for outputting PP/VPP data as a reporter.

Definition at line 372 of file AdvancedOutput.h.

Referenced by AdvancedOutput::initAvailableLists().

◆ _ppi_feproblem

const FEProblemBase& PostprocessorInterface::_ppi_feproblem

privateinherited

Reference the the FEProblemBase class.

Definition at line 159 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::hasPostprocessorByName(), PostprocessorInterface::isDefaultPostprocessorValueByName(), and PostprocessorInterface::postprocessorsAdded().

◆ _ppi_moose_object

const MooseObject& PostprocessorInterface::_ppi_moose_object

privateinherited

The MooseObject that uses this interface.

Definition at line 153 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::checkParam(), PostprocessorInterface::getPostprocessorNameInternal(), PostprocessorInterface::getPostprocessorValueByNameInternal(), PostprocessorInterface::getPostprocessorValueInternal(), PostprocessorInterface::hasPostprocessor(), and PostprocessorInterface::hasPostprocessorByName().

◆ _ppi_params

const InputParameters& PostprocessorInterface::_ppi_params

privateinherited

PostprocessorInterface Parameters.

Definition at line 156 of file PostprocessorInterface.h.

Referenced by PostprocessorInterface::checkParam(), PostprocessorInterface::coupledPostprocessors(), and PostprocessorInterface::getPostprocessorNameInternal().

◆ _prefix

const std::string PerfGraphInterface::_prefix

protectedinherited

A prefix to use for all sections.

Definition at line 138 of file PerfGraphInterface.h.

Referenced by PerfGraphInterface::timedSectionName().

◆ _problem_ptr

FEProblemBase* Output::_problem_ptr

protectedinherited

Pointer the the FEProblemBase object for output object (use this)

Definition at line 185 of file Output.h.

Referenced by PNGOutput::calculateRescalingValues(), SampledOutput::cloneMesh(), Exodus::handleExodusIOMeshRenumbering(), AdvancedOutput::initAvailableLists(), JSONOutput::initialSetup(), AdvancedOutput::initPostprocessorOrVectorPostprocessorLists(), SampledOutput::initSample(), AdvancedOutput::initShowHideLists(), PNGOutput::makeMeshFunc(), Console::meshChanged(), Checkpoint::output(), CSV::output(), DOFMapOutput::output(), MaterialPropertyDebugOutput::output(), ReporterDebugOutput::output(), SolutionHistory::output(), VariableResidualNormsDebugOutput::output(), Output::Output(), Exodus::outputEmptyTimestep(), Exodus::outputNodalVariables(), Exodus::outputPostprocessors(), Nemesis::outputPostprocessors(), TableOutput::outputPostprocessorsRow(), JSONOutput::outputReporters(), Exodus::outputScalarVariables(), Nemesis::outputScalarVariables(), TableOutput::outputScalarVariables(), Exodus::outputSetup(), Nemesis::outputSetup(), Console::outputSystemInformation(), XMLOutput::outputVectorPostprocessors(), BlockRestrictionDebugOutput::printBlockRestrictionGroups(), BlockRestrictionDebugOutput::printBlockRestrictionMap(), BlockRestrictionDebugOutput::printBoundaryRestrictionGroups(), MaterialPropertyDebugOutput::printMaterialMap(), TopResidualDebugOutput::printTopResiduals(), SolutionInvalidityOutput::shouldOutput(), TableOutput::shouldOutputPostprocessorsRow(), PetscOutput::solveSetup(), Checkpoint::updateCheckpointFiles(), SampledOutput::updateSample(), and Console::writeVariableNorms().

◆ _refinements

const unsigned int SampledOutput::_refinements

protectedinherited

The number of oversampling refinements.

Definition at line 62 of file SampledOutput.h.

Referenced by SampledOutput::initSample().

◆ _reporter_data

const ReporterData& AdvancedOutput::_reporter_data

protectedinherited

Storage for Reporter values.

Definition at line 294 of file AdvancedOutput.h.

Referenced by AdvancedOutput::initAvailableLists(), CSV::output(), TableOutput::outputReporter(), Exodus::outputReporters(), TableOutput::outputVectorPostprocessors(), and XMLOutput::outputVectorPostprocessors().

◆ _restartable_app

MooseApp& Restartable::_restartable_app

protectedinherited

Reference to the application.

Definition at line 234 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp(), and Restartable::registerRestartableNameWithFilterOnApp().

◆ _restartable_name

std::string Restartable::_restartable_name

privateinherited

The name of the object.

Definition at line 250 of file Restartable.h.

Referenced by Restartable::declareRestartableDataWithObjectNameWithContext(), and Restartable::restartableName().

◆ _restartable_read_only

const bool Restartable::_restartable_read_only

protectedinherited

Flag for toggling read only status (see ReporterData)

Definition at line 243 of file Restartable.h.

Referenced by Restartable::registerRestartableDataOnApp().

◆ _restartable_system_name

const std::string Restartable::_restartable_system_name

protectedinherited

The system name this object is in.

Definition at line 237 of file Restartable.h.

Referenced by Restartable::restartableName().

◆ _restartable_tid

const THREAD_ID Restartable::_restartable_tid

protectedinherited

The thread ID for this object.

Definition at line 240 of file Restartable.h.

Referenced by Restartable::declareRestartableDataHelper().

◆ _ri_fe_problem_base

FEProblemBase& ReporterInterface::_ri_fe_problem_base

privateinherited

Provides access to FEProblemBase::getReporterData.

Definition at line 137 of file ReporterInterface.h.

Referenced by ReporterInterface::reportersAdded().

◆ _ri_moose_object

const MooseObject& ReporterInterface::_ri_moose_object

privateinherited

The MooseObject needing this interface.

Definition at line 143 of file ReporterInterface.h.

Referenced by ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterName(), ReporterInterface::getReporterValueByName(), ReporterInterface::hasReporterValue(), ReporterInterface::hasReporterValueByName(), and ReporterInterface::possiblyCheckHasReporter().

◆ _ri_params

const InputParameters& ReporterInterface::_ri_params

privateinherited

Parameters for the MooseObject inherting from this interface.

Definition at line 134 of file ReporterInterface.h.

Referenced by ReporterInterface::getReporterName(), and ReporterInterface::possiblyCheckHasReporter().

◆ _ri_reporter_data

const ReporterData& ReporterInterface::_ri_reporter_data

privateinherited

The ReporterData.

Definition at line 140 of file ReporterInterface.h.

Referenced by ReporterInterface::getReporterContextBaseByName(), ReporterInterface::getReporterValueByName(), and ReporterInterface::hasReporterValueByName().

◆ _sampling_es

std::unique_ptr<EquationSystems> SampledOutput::_sampling_es

privateinherited

Equation system holding the solution vectors for the sampled variables.

Definition at line 119 of file SampledOutput.h.

Referenced by SampledOutput::initSample(), SampledOutput::updateSample(), and SampledOutput::~SampledOutput().

◆ _sampling_mesh_changed

bool SampledOutput::_sampling_mesh_changed

privateinherited

A flag indicating that the mesh has changed and the sampled mesh needs to be re-initialized.

Definition at line 110 of file SampledOutput.h.

Referenced by SampledOutput::meshChanged(), and SampledOutput::updateSample().

◆ _sampling_mesh_ptr

std::unique_ptr<MooseMesh> SampledOutput::_sampling_mesh_ptr

privateinherited

Mesh used for sampling. The Output class' _mesh_ptr will refer to this mesh if sampling is being used.

Definition at line 122 of file SampledOutput.h.

Referenced by SampledOutput::cloneMesh(), SampledOutput::initSample(), and SampledOutput::~SampledOutput().

◆ _scalar_as_nodal

bool AdvancedOutput::_scalar_as_nodal

protectedinherited

Definition at line 291 of file AdvancedOutput.h.

Referenced by AdvancedOutput::init().

◆ _sequence

bool Output::_sequence

protectedinherited

Flag for forcing call to outputSetup() with every call to output() (restartable)

Definition at line 200 of file Output.h.

◆ _serialize

bool SampledOutput::_serialize

privateinherited

Flag indicating whether we are outputting in serial or parallel.

Definition at line 116 of file SampledOutput.h.

Referenced by SampledOutput::cloneMesh(), SampledOutput::initSample(), and SampledOutput::updateSample().

◆ _serialized_solution

std::unique_ptr<NumericVector<Number> > SampledOutput::_serialized_solution

privateinherited

Sample solution vector.

Definition at line 130 of file SampledOutput.h.

Referenced by SampledOutput::initSample(), and SampledOutput::updateSample().

◆ _si_moose_base

const MooseBase& SolutionInvalidInterface::_si_moose_base

privateinherited

The MooseBase that owns this interface.

Definition at line 111 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal(), SolutionInvalidInterface::mooseDeprecated(), SolutionInvalidInterface::mooseWarning(), SolutionInvalidInterface::mooseWarningNonPrefixed(), SolutionInvalidInterface::paramWarning(), and SolutionInvalidInterface::registerInvalidSolutionInternal().

◆ _si_problem

const FEProblemBase* SolutionInvalidInterface::_si_problem

privateinherited

A pointer to FEProblem base.

Definition at line 114 of file SolutionInvalidInterface.h.

Referenced by SolutionInvalidInterface::flagInvalidSolutionInternal().

◆ _start_step

int Output::_start_step

protectedinherited

Start outputting at this time step.

Definition at line 256 of file Output.h.

Referenced by Output::onInterval().

◆ _start_time

Real Output::_start_time

protectedinherited

Start outputting time.

Definition at line 250 of file Output.h.

Referenced by Output::onInterval().

◆ _sync_only

bool Output::_sync_only

protectedinherited

Flag for only executing at sync times.

Definition at line 265 of file Output.h.

Referenced by Output::onInterval().

◆ _sync_times

std::set<Real> Output::_sync_times

protectedinherited

Sync times for this outputter.

Definition at line 244 of file Output.h.

Referenced by Output::getSyncTimes(), Output::onInterval(), and Output::Output().

◆ _sync_times_object

const Times* const Output::_sync_times_object

protectedinherited

Sync times object for this outputter.

Definition at line 247 of file Output.h.

Referenced by Output::onInterval(), and Output::Output().

◆ _t_step

int& Output::_t_step

protectedinherited

The current time step.

Definition at line 220 of file Output.h.

Referenced by PNGOutput::makePNG(), Output::onInterval(), TableOutput::outputReporter(), TableOutput::outputVectorPostprocessors(), Output::time(), Output::timeOld(), and Output::timeStep().

◆ _t_tol

Real Output::_t_tol

protectedinherited

Time checking tolerance.

Definition at line 262 of file Output.h.

Referenced by PetscOutput::inLinearTimeWindow(), PetscOutput::inNonlinearTimeWindow(), and Output::onInterval().

◆ _time

Real& Output::_time

protectedinherited

The current time for output purposes.

Definition at line 214 of file Output.h.

Referenced by PetscOutput::inLinearTimeWindow(), PetscOutput::inNonlinearTimeWindow(), PNGOutput::makePNG(), Output::onInterval(), AdvancedOutput::output(), TableOutput::outputReporter(), Output::outputStep(), SampledOutput::outputStep(), TableOutput::outputVectorPostprocessors(), Output::time(), and AdvancedOutput::wantOutput().

◆ _time_old

Real& Output::_time_old

protectedinherited

The old time.

Definition at line 217 of file Output.h.

Referenced by PetscOutput::solveSetup(), and Output::timeOld().

◆ _time_step_interval

unsigned int Output::_time_step_interval

protectedinherited

The output time step interval.

Definition at line 235 of file Output.h.

Referenced by AutoCheckpointAction::act(), Output::onInterval(), and Output::setWallTimeIntervalFromCommandLineParam().

◆ _time_step_interval_set_by_addparam

const bool Output::_time_step_interval_set_by_addparam

protectedinherited

Whether time step interval is set by AddParam.

Definition at line 232 of file Output.h.

Referenced by Output::setWallTimeIntervalFromCommandLineParam().

◆ _transient

bool Output::_transient

protectedinherited

Transient flag (true = transient)

Definition at line 188 of file Output.h.

Referenced by Output::dt(), Output::dtOld(), Output::time(), Output::timeOld(), and Console::writeTimestepInformation().

◆ _type

const std::string& MooseBase::_type

protectedinherited

The type of this class.

Definition at line 378 of file MooseBase.h.

Referenced by FillBetweenCurvesGenerator::generate(), FillBetweenPointVectorsGenerator::generate(), FillBetweenSidesetsGenerator::generate(), MooseBase::MooseBase(), FEProblemBase::solverTypeString(), and MooseBase::type().

◆ _use_displaced

bool Output::_use_displaced

protectedinherited

Flag for using displaced mesh.

Definition at line 191 of file Output.h.

Referenced by Output::Output().

◆ _use_sampled_output

bool SampledOutput::_use_sampled_output

protectedinherited

Flag indicating that the sampled output should be used to re-sample the underlying EquationSystem of the output.

Definition at line 71 of file SampledOutput.h.

Referenced by SampledOutput::initSample(), Exodus::outputSetup(), and SampledOutput::updateSample().

◆ _using_external_sampling_file

const bool SampledOutput::_using_external_sampling_file

protectedinherited

Flag indicating another file is being used for the sampling.

Definition at line 65 of file SampledOutput.h.

Referenced by SampledOutput::cloneMesh(), and SampledOutput::initSample().

◆ _variable_numbers_in_system

std::vector<std::vector<unsigned int> > SampledOutput::_variable_numbers_in_system

privateinherited

A vector of vectors that keeps track of the variable numbers in each system for each mesh function.

Definition at line 104 of file SampledOutput.h.

Referenced by SampledOutput::initSample(), and SampledOutput::updateSample().

◆ _vectorpostprocessors_as_reporters

const bool AdvancedOutput::_vectorpostprocessors_as_reporters

privateinherited

Definition at line 372 of file AdvancedOutput.h.

Referenced by AdvancedOutput::initAvailableLists().

◆ _vpi_feproblem

const FEProblemBase& VectorPostprocessorInterface::_vpi_feproblem

privateinherited

Reference the FEProblemBase class.

Definition at line 366 of file VectorPostprocessorInterface.h.

◆ _vpi_moose_object

const MooseObject& VectorPostprocessorInterface::_vpi_moose_object

privateinherited

The MooseObject that uses this interface.

Definition at line 363 of file VectorPostprocessorInterface.h.

Referenced by VectorPostprocessorInterface::getVectorPostprocessorByNameHelper(), VectorPostprocessorInterface::getVectorPostprocessorContextByNameHelper(), VectorPostprocessorInterface::getVectorPostprocessorName(), VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessor(), and VectorPostprocessorInterface::possiblyCheckHasVectorPostprocessorByName().

◆ _vpi_tid

const THREAD_ID VectorPostprocessorInterface::_vpi_tid

privateinherited

Thread ID.

Definition at line 369 of file VectorPostprocessorInterface.h.

◆ _wall_time_interval

Real Output::_wall_time_interval

protectedinherited

Target wall time between outputs in seconds.

Definition at line 241 of file Output.h.

Referenced by Checkpoint::checkpointInfo(), Output::onInterval(), Output::setWallTimeIntervalFromCommandLineParam(), and Checkpoint::shouldOutput().

◆ _wall_time_since_last_output

Real Output::_wall_time_since_last_output

protectedinherited

time in seconds since last output

Definition at line 286 of file Output.h.

Referenced by Output::onInterval(), and Checkpoint::shouldOutput().

◆ app_param

const std::string MooseBase::app_param = "_moose_app"

staticinherited

The name of the parameter that contains the MooseApp.

Definition at line 59 of file MooseBase.h.

Referenced by FEProblemBase::addAnyRedistributers(), MeshGenerator::addMeshSubgenerator(), InputParameters::callMooseError(), ActionFactory::create(), ActionFactory::getValidParams(), Factory::getValidParams(), AutomaticMortarGeneration::initOutput(), SetupMeshAction::modifyParamsForUseSplit(), and MortarNodalGeometryOutput::validParams().

◆ kokkos_object_param

const std::string MooseBase::kokkos_object_param = "_kokkos_object"

staticinherited

The name of the parameter that indicates an object is a Kokkos functor.

Definition at line 64 of file MooseBase.h.

Referenced by InputParameters::isKokkosObject().

◆ moose_base_param

const std::string MooseBase::moose_base_param = "_moose_base"

staticinherited

The name of the parameter that contains the moose system base.

Definition at line 61 of file MooseBase.h.

Referenced by InputParameters::getBase(), InputParameters::hasBase(), and InputParameters::registerBase().

◆ name_param

const std::string MooseBase::name_param = "_object_name"

staticinherited

The name of the parameter that contains the object name.

Definition at line 55 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), ActionUnitTest::buildMinimalObjects(), MooseObjectUnitTest::buildObjects(), AppFactory::create(), InputParameters::getObjectName(), AutomaticMortarGeneration::initOutput(), InputParameters::isMooseBaseObject(), MooseMesh::prepare(), CouplingFunctorCheckAction::validParams(), and MooseBase::validParams().

◆ type_param

const std::string MooseBase::type_param = "_type"

staticinherited

The name of the parameter that contains the object type.

Definition at line 53 of file MooseBase.h.

Referenced by ActionFactory::create(), AppFactory::create(), InputParameters::getObjectType(), Factory::initialize(), InputParameters::isMooseBaseObject(), InputParameters::queryObjectType(), MooseBase::validParams(), and MortarNodalGeometryOutput::validParams().

◆ unique_name_param

const std::string MooseBase::unique_name_param = "_unique_name"

staticinherited

The name of the parameter that contains the unique object name.

Definition at line 57 of file MooseBase.h.

Referenced by InputParameterWarehouse::addInputParameters(), AppFactory::create(), InputParameterWarehouse::removeInputParameters(), MooseBase::uniqueName(), and MooseBase::validParams().

◆ usingCombinedWarningSolutionWarnings

MooseObject::usingCombinedWarningSolutionWarnings

inherited

Definition at line 67 of file MooseObject.h.

The documentation for this class was generated from the following files:

include/outputs/XDA.h
src/outputs/XDA.C

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Private Member Functions

Static Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ DataFileParameterType

Constructor & Destructor Documentation

◆ XDA()

Member Function Documentation

◆ addDeprecatedInputParameters()

◆ addPostprocessorDependencyHelper()

◆ addReporterDependencyHelper()

◆ addValidParams()

◆ addVectorPostprocessorDependencyHelper()

◆ advancedExecuteOn()

◆ allowOutput()

◆ callMooseError() [1/2]

◆ callMooseError() [2/2]

◆ checkFilename()

◆ checkParam()

◆ clearLastExecuteTime()

◆ cloneMesh()

◆ connectControllableParams()

◆ coupledPostprocessors()

◆ customSetup()

◆ declareManagedRestartableDataWithContext()

◆ declareRecoverableData()

◆ declareRestartableData()

◆ declareRestartableDataHelper()

◆ declareRestartableDataWithContext()

◆ declareRestartableDataWithObjectName()

◆ declareRestartableDataWithObjectNameWithContext()

◆ dt()

◆ dtOld()

◆ enabled()

◆ enableOutputTypes()

◆ errorPrefix()

◆ executeOn()

◆ filename()

◆ flagInvalidSolutionInternal()

◆ getBase()

◆ getCheckedPointerParam()

◆ getDataFileName()

◆ getDataFileNameByName()

◆ getDataFilePath()

◆ getDefaultExecFlagEnum()

◆ getDefaultPostprocessorValueByName()

◆ getElementalVariableOutput()

◆ getExecuteOnEnum()

◆ getFileNumber()

◆ getFunction()

◆ getFunctionByName()

◆ getHitNode() [1/2]

◆ getHitNode() [2/2]

◆ getKokkosFunction() [1/2]

◆ getKokkosFunction() [2/2]

◆ getKokkosFunctionByName() [1/2]

◆ getKokkosFunctionByName() [2/2]

◆ getKokkosFunctionByNameHelper()

◆ getMooseApp()

◆ getNodalVariableOutput()

◆ getOutputTime()

◆ getOutputTypes()

◆ getParam() [1/2]

◆ getParam() [2/2]

◆ getPostprocessorName()

◆ getPostprocessorNameInternal()

◆ getPostprocessorOutput()

◆ getPostprocessorValue()

◆ getPostprocessorValueByName()

◆ getPostprocessorValueByNameInternal()

◆ getPostprocessorValueInternal()