Output::Output(const InputParameters & parameters) :
MooseObject(parameters),
Restartable(parameters, "Output"),
MeshChangedInterface(parameters),
SetupInterface(this),
_problem_ptr(getParam<FEProblem *>("_fe_problem")),
_transient(_problem_ptr->isTransient()),
_use_displaced(getParam<bool>("use_displaced")),
_es_ptr(_use_displaced ? &_problem_ptr->getDisplacedProblem()->es() : &_problem_ptr->es()),
_execute_on(getParam<MultiMooseEnum>("execute_on")),
_time(_problem_ptr->time()),
_time_old(_problem_ptr->timeOld()),
_t_step(_problem_ptr->timeStep()),
_dt(_problem_ptr->dt()),
_dt_old(_problem_ptr->dtOld()),
_num(0),
_interval(getParam<unsigned int>("interval")),
_sync_times(std::set<Real>(getParam<std::vector<Real> >("sync_times").begin(), getParam<std::vector<Real> >("sync_times").end())),
_start_time(isParamValid("start_time") ? getParam<Real>("start_time") : -std::numeric_limits<Real>::max()),
_end_time(isParamValid("end_time") ? getParam<Real>("end_time") : std::numeric_limits<Real>::max()),
_t_tol(getParam<Real>("time_tolerance")),
_sync_only(getParam<bool>("sync_only")),
_initialized(false),
_allow_output(true),
_is_advanced(false),
_advanced_execute_on(_execute_on, parameters)
{
// Apply the additional output flags
if (isParamValid("additional_execute_on"))
{
MultiMooseEnum add = getParam<MultiMooseEnum>("additional_execute_on");
for (MooseEnumIterator it = add.begin(); it != add.end(); ++it)
_execute_on.push_back(*it);
}
}
void
Output::
applyOutputOnShortCutFlags(MultiMooseEnum & input)
{
/*
* output_initial/final/failed are false by default
* If they are enabled, then update the output_on
* to include this execution time.
*/
if (getParam<bool>("output_initial"))
input.push_back("initial");
if (getParam<bool>("output_final"))
input.push_back("final");
if (getParam<bool>("output_failed"))
input.push_back("failed");
/*
* output_timestep_end is true by default
* If it is disabled, then update the output_on
* by removing it from the execution time.
*/
if (!getParam<bool>("output_timestep_end"))
input.erase("timestep_end");
}
std::vector<ExecFlagType> vectorStringsToEnum<ExecFlagType>(const MultiMooseEnum & v)
{
std::vector<ExecFlagType> exec_flags(v.size());
for (unsigned int i=0; i<v.size(); ++i)
exec_flags[i] = stringToEnum<ExecFlagType>(v[i]);
return exec_flags;
}
void
RankTwoScalarAction::act()
{
std::vector<MaterialPropertyName> tensors = getParam<std::vector<MaterialPropertyName> >("rank_two_tensor");
const MultiMooseEnum scalar_types = getParam<MultiMooseEnum>("scalar_type");
for (unsigned int i = 0; i < tensors.size(); i++)
{
for (int j = 0; j < LIBMESH_DIM; j++)
{
for (int k = 0; k < LIBMESH_DIM; k++)
{
InputParameters pp_params = _factory.getValidParams("MaterialTensorIntegral");
pp_params.set<MaterialPropertyName>("rank_two_tensor") = tensors[ i ];
pp_params.set<unsigned int>("index_i") = j;
pp_params.set<unsigned int>("index_j") = k;
pp_params.set<std::vector<OutputName> >("outputs") = { "none" };
if (isParamValid("block"))
{
pp_params.set<std::vector<SubdomainName> >("block") = getParam<std::vector<SubdomainName> >("block");
}
_problem->addPostprocessor(
"MaterialTensorIntegral", std::string(tensors[ i ]) + std::to_string(j) + std::to_string(k), pp_params);
}
}
for (unsigned int j = 0; j < scalar_types.size(); j++)
{
InputParameters pp_params = _factory.getValidParams("RankTwoScalarPostprocessor");
for (int j = 0; j < LIBMESH_DIM; j++)
{
for (int k = 0; k < LIBMESH_DIM; k++)
{
pp_params.set<PostprocessorName>(std::string("index") + std::to_string(j) + std::to_string(k)) =
std::string(tensors[ i ]) + std::to_string(j) + std::to_string(k);
}
}
pp_params.set<MooseEnum>("scalar_type") = scalar_types[ j ];
_problem->addPostprocessor("RankTwoScalarPostprocessor",
std::string(tensors[ i ]) + std::string("_") + std::string(scalar_types[ j ]),
pp_params);
}
}
// InputParameters pp_params = _factory.getValidParams("VolumePostprocessor");
// if (isParamValid("block"))
// {
// pp_params.set<std::vector<SubdomainName> >("block") = getParam<std::vector<SubdomainName> >("block");
// }
// _problem->addPostprocessor("VolumePostprocessor", "Volume", pp_params);
}
bool
MultiMooseEnum::operator==(const MultiMooseEnum & value) const
{
// Not the same if the lengths are different
if (value.size() != size())
return false;
// Return false if this enum does not contain an item from the other
for (MooseEnumIterator it = value.begin(); it != value.end(); ++it)
if (!contains(*it))
return false;
// If you get here, they must be the same
return true;
}
bool
MultiMooseEnum::operator==(const MultiMooseEnum & value) const
{
// Not the same if the lengths are different
if (value.size() != size())
return false;
// Return false if this enum does not contain an item from the other
for (const auto & me : value)
if (!contains(me))
return false;
// If you get here, they must be the same
return true;
}
void
AdvancedOutput<T>::addValidParams(InputParameters & params, const MultiMooseEnum & types)
{
// Nodal output
if (types.contains("nodal"))
params.addParam<MultiMooseEnum>("output_nodal_on", T::getExecuteOptions(), "Control the output of nodal variables");
// Elemental output
if (types.contains("elemental"))
{
params.addParam<MultiMooseEnum>("output_elemental_on", T::getExecuteOptions(), "Control the output of elemental variables");
// 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 materialproperties that should be written to the output");
params.addParamNamesToGroup("output_material_properties show_material_properties", "Materials");
params.addParamNamesToGroup("show_material_properties", "Materials");
}
// Scalar variable output
if (types.contains("scalar"))
params.addParam<MultiMooseEnum>("output_scalars_on", T::getExecuteOptions(), "Control the output of scalar variables");
// Nodal and scalar output
if (types.contains("nodal") && types.contains("scalar"))
params.addParam<bool>("scalar_as_nodal", false, "Output scalar variables as nodal");
// Elemental and nodal
if (types.contains("elemental") && types.contains("nodal"))
params.addParam<bool>("elemental_as_nodal", false, "Output elemental nonlinear variables as nodal");
// Postprocessors
if (types.contains("postprocessor"))
params.addParam<MultiMooseEnum>("output_postprocessors_on", T::getExecuteOptions(), "Control of when postprocessors are output");
// Vector Postprocessors
if (types.contains("vector_postprocessor"))
params.addParam<MultiMooseEnum>("output_vector_postprocessors_on", T::getExecuteOptions(), "Enable/disable the output of VectorPostprocessors");
// Input file
if (types.contains("input"))
params.addParam<MultiMooseEnum>("output_input_on", T::getExecuteOptions(), "Enable/disable the output of the input file");
// System Information
if (types.contains("system_information"))
params.addParam<MultiMooseEnum>("output_system_information_on", T::getExecuteOptions(), "Control when the output of the simulation information occurs");
// Store everything in the 'Variables' group
params.addParamNamesToGroup("scalar_as_nodal elemental_as_nodal output_scalars_on output_nodal_on output_elemental_on output_postprocessors_on output_vector_postprocessors_on output_system_information_on output_input_on", "Variables");
}
