CumulativeValuePostprocessor::CumulativeValuePostprocessor(const InputParameters & parameters) :
GeneralPostprocessor(parameters),
_sum(0.0),
_sum_old(getPostprocessorValueOldByName(name())),
_pps_value(getPostprocessorValue("postprocessor"))
{
}
// DEPRECATED CONSTRUCTOR
TotalVariableValue::TotalVariableValue(const std::string & deprecated_name, InputParameters parameters) :
GeneralPostprocessor(deprecated_name, parameters),
_value(0),
_value_old(getPostprocessorValueOldByName(name())),
_pps_value(getPostprocessorValue("value")),
_pps_value_old(getPostprocessorValueOld("value"))
{
}
TotalVariableValue::TotalVariableValue(const InputParameters & parameters) :
GeneralPostprocessor(parameters),
_value(0),
_value_old(getPostprocessorValueOldByName(name())),
_pps_value(getPostprocessorValue("value")),
_pps_value_old(getPostprocessorValueOld("value"))
{
}
TestPostprocessor::TestPostprocessor(const InputParameters & parameters) :
GeneralPostprocessor(parameters),
_test_type(getParam<MooseEnum>("test_type")),
_old_val(getPostprocessorValueOldByName(name())),
_older_val(getPostprocessorValueOlderByName(name()))
{
if (_test_type == "report_old" && !isParamValid("report_name"))
mooseError("Must set 'report_name' parameter when using the 'report_old' test type.");
}
EigenKernel::EigenKernel(const InputParameters & parameters) :
KernelBase(parameters),
_u(_is_implicit ? _var.sln() : _var.slnOld()),
_grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld()),
_eigen(getParam<bool>("eigen")),
_eigen_sys(dynamic_cast<EigenSystem *>(&_fe_problem.getNonlinearSystem())),
_eigenvalue(NULL)
{
// The name to the postprocessor storing the eigenvalue
std::string eigen_pp_name;
// If the "eigen_postprocessor" is given, use it. The isParamValid does not work here because of the default value, which
// you don't want to use if an EigenExecutioner exists.
if (hasPostprocessor("eigen_postprocessor"))
eigen_pp_name = getParam<PostprocessorName>("eigen_postprocessor");
// Attempt to extract the eigenvalue postprocessor from the Executioner
else
{
EigenExecutionerBase * exec = dynamic_cast<EigenExecutionerBase *>(_app.getExecutioner());
if (exec)
eigen_pp_name = exec->getParam<PostprocessorName>("bx_norm");
}
// If the postprocessor name was not provided and an EigenExecutionerBase is not being used,
// use the default value from the "eigen_postprocessor" parameter
if (eigen_pp_name.empty())
_eigenvalue = &getDefaultPostprocessorValue("eigen_postprocessor");
// If the name does exist, then use the postprocessor value
else
{
if (_is_implicit)
_eigenvalue = &getPostprocessorValueByName(eigen_pp_name);
else
{
EigenExecutionerBase * exec = dynamic_cast<EigenExecutionerBase *>(_app.getExecutioner());
if (exec)
_eigenvalue = &exec->eigenvalueOld();
else
_eigenvalue = &getPostprocessorValueOldByName(eigen_pp_name);
}
}
}
EigenKernel::EigenKernel(const std::string & name, InputParameters parameters) :
KernelBase(name,parameters),
_u(_is_implicit ? _var.sln() : _var.slnOld()),
_grad_u(_is_implicit ? _var.gradSln() : _var.gradSlnOld()),
_eigen(getParam<bool>("eigen")),
_eigen_sys(NULL),
_eigenvalue(NULL)
{
if (_eigen)
{
_eigen_sys = static_cast<EigenSystem *>(&_fe_problem.getNonlinearSystem());
_eigen_pp = _fe_problem.parameters().get<PostprocessorName>("eigen_postprocessor");
if (_is_implicit)
_eigenvalue = &getPostprocessorValueByName(_eigen_pp);
else
_eigenvalue = &getPostprocessorValueOldByName(_eigen_pp);
}
else
{
if (!_fe_problem.parameters().isParamValid("eigenvalue"))
_fe_problem.parameters().set<Real>("eigenvalue") = 1.0;
_eigenvalue = &_fe_problem.parameters().get<Real>("eigenvalue");
}
}
