Real
SinglePhaseFluidProperties::rho(Real p, Real T) const
{
mooseDeprecated(name(), ": rho() is deprecated. Use rho_from_p_T() instead");
return rho_from_p_T(p, T);
}
MooseObjectPtr
Factory::create(const std::string & obj_name,
const std::string & name,
InputParameters parameters,
THREAD_ID tid /* =0 */,
bool print_deprecated /* =true */)
{
if (print_deprecated)
mooseDeprecated("Factory::create() is deprecated, please use Factory::create<T>() instead");
// Pointer to the object constructor
std::map<std::string, buildPtr>::iterator it = _name_to_build_pointer.find(obj_name);
// Check if the object is registered
if (it == _name_to_build_pointer.end())
reportUnregisteredError(obj_name);
// Print out deprecated message, if it exists
deprecatedMessage(obj_name);
// Create the actual parameters object that the object will reference
InputParameters & params =
_app.getInputParameterWarehouse().addInputParameters(name, parameters, tid);
// Check to make sure that all required parameters are supplied
params.checkParams(name);
// register type name as constructed
_constructed_types.insert(obj_name);
// Actually call the function pointer. You can do this in one line,
// but it's a bit more obvious what's happening if you do it in two...
buildPtr & func = it->second;
return (*func)(params);
}
IdealGasFluidPropertiesPT::IdealGasFluidPropertiesPT(const InputParameters & parameters)
: IdealGasFluidProperties(parameters)
{
mooseDeprecated(
name(),
": IdealGasFluidPropertiesPT is deprecated. Just use IdealGasFluidProperties instead");
}
void
SinglePhaseFluidProperties::henryConstant_dT(Real T, Real & Kh, Real & dKh_dT) const
{
mooseDeprecated(name(), ": henryConstant_dT() is deprecated. Use henryConstant() instead");
henryConstant(T, Kh, dKh_dT);
}
PorousFlowFluidStateBrineCO2IC::PorousFlowFluidStateBrineCO2IC(const InputParameters & parameters)
: PorousFlowFluidStateIC(parameters)
{
mooseDeprecated(name(),
": the PorousFlowFluidStateBrineCO2IC IC is deprecated. Just use "
"PorousFlowFluidStateIC instead");
}
void
SinglePhaseFluidProperties::mu_dpT(Real p, Real T, Real & mu, Real & dmu_dp, Real & dmu_dT) const
{
mooseDeprecated(name(), ": mu_dpT() is deprecated. Use mu_from_p_T() instead");
mu_from_p_T(p, T, mu, dmu_dp, dmu_dT);
}
bool
PorousFlowAddMaterialJoiner::hasJoiner(std::string property)
{
// Get the list of materials in the input file
auto actions = _awh.getActions<AddMaterialAction>();
for (auto & action : actions)
{
AddMaterialAction * material = const_cast<AddMaterialAction *>(action);
if (material->getMooseObjectType() == "PorousFlowJoiner")
{
// If a PorousFlowJoiner material has been included in the input file,
// let the user know that it should be removed
mooseDeprecated("PorousFlowJoiner materials are no longer required in the input "
"file.\nPlease remove all PorousFlowJoiner materials from this input file to "
"get rid of this warning");
const std::string joiner_property =
material->getObjectParams().get<std::string>("material_property");
// Check if the given material property is joined by this material
if (joiner_property == property)
return true;
}
}
// If no PorousFlowJoiner materials matched property, return false
return false;
}
void
SinglePhaseFluidProperties::e_dpT(Real p, Real T, Real & e, Real & de_dp, Real & de_dT) const
{
mooseDeprecated(name(), ": e_dpT() is deprecated. Use e_from_p_T() instead");
e_from_p_T(p, T, e, de_dp, de_dT);
}
void
SinglePhaseFluidProperties::rho_mu(Real p, Real T, Real & rho, Real & mu) const
{
mooseDeprecated(name(), ": rho_mu() is deprecated. Use rho_mu_from_p_T() instead");
rho_mu_from_p_T(p, T, rho, mu);
}
void
SinglePhaseFluidProperties::h_dpT(Real p, Real T, Real & h, Real & dh_dp, Real & dh_dT) const
{
mooseDeprecated(name(), ": h_dpT() is deprecated. Use h_from_p_T() instead");
h_from_p_T(p, T, h, dh_dp, dh_dT);
}
std::shared_ptr<FEProblem>
ActionWarehouse::problem()
{
mooseDeprecated(
"ActionWarehouse::problem() is deprecated, please use ActionWarehouse::problemBase() \n");
return std::dynamic_pointer_cast<FEProblem>(_problem);
}
void
SinglePhaseFluidProperties::vaporPressure_dT(Real T, Real & psat, Real & dpsat_dT) const
{
mooseDeprecated(name(), ": vaporPressure_dT() is deprecated. Use vaporPressure() instead");
vaporPressure(T, psat, dpsat_dT);
}
void
SinglePhaseFluidProperties::k_dpT(Real p, Real T, Real & k, Real & dk_dp, Real & dk_dT) const
{
mooseDeprecated(name(), ": k_dpT() is deprecated. Use k_from_p_T() instead");
k_from_p_T(p, T, k, dk_dp, dk_dT);
}
void
FunctionalExpansionToolsApp::associateSyntax(Syntax & /*syntax*/, ActionFactory & action_factory)
{
mooseDeprecated("use registerAll instead of associateSyntax");
Registry::registerActionsTo(action_factory, {"FunctionalExpansionToolsApp"});
/* Uncomment Syntax parameters and register your new objects here! */
}
PorousFlowPorosityHM::PorousFlowPorosityHM(const InputParameters & parameters)
: PorousFlowPorosity(parameters)
{
mooseDeprecated("PorousFlowPorosityHM is deprecated. In your input file please replace\n "
"type = PorousFlowPorosityHM\nwith\n type = PorousFlowPorosity\n "
"mechanical = true\n fluid = true");
}
void
SinglePhaseFluidProperties::rho_dpT(
Real p, Real T, Real & rho, Real & drho_dp, Real & drho_dT) const
{
mooseDeprecated(name(), ": rho_dpT() is deprecated. Use rho_from_p_T() instead");
rho_from_p_T(p, T, rho, drho_dp, drho_dT);
}
void
SinglePhaseFluidProperties::mu_drhoT_from_rho_T(
Real rho, Real T, Real drho_dT, Real & mu, Real & dmu_drho, Real & dmu_dT) const
{
mooseDeprecated(name(), ":mu_drhoT_from_rho_T() is deprecated. Use mu_from_rho_T() instead");
mu_from_rho_T(rho, T, drho_dT, mu, dmu_drho, dmu_dT);
}
void
SinglePhaseFluidProperties::henryConstantIAPWS_dT(
Real T, Real & Kh, Real & dKh_dT, Real A, Real B, Real C) const
{
mooseDeprecated(name(),
":henryConstantIAPWS_dT() is deprecated. Use henryConstantIAPWS() instead");
henryConstantIAPWS(T, Kh, dKh_dT, A, B, C);
}
const std::vector<ExecFlagType> &
MultiAppTransfer::execFlags() const
{
mooseDeprecated("The execFlags() methos is being removed because MOOSE has been updated to use a "
"ExecFlagEnum for execute flags. The current flags should be retrieved from "
"the \"exeucte_on\" parameters of your object or by using the \"_execute_enum\" "
"reference to the parameter or the getExecuteOnEnum() method.");
return _exec_flags;
}
void
RankFourTensor::fillFromInputVector(const std::vector<Real> input, bool all_21)
{
mooseDeprecated();
if (all_21)
fillFromInputVector(input, symmetric21);
else
fillFromInputVector(input, symmetric9);
}
MooseEnumBase::MooseEnumBase(std::string names, bool allow_out_of_range) :
_out_of_range_index(allow_out_of_range ? INVALID_ID + 1 : 0)
{
if (names.find(',') != std::string::npos)
{
mooseDeprecated("Please use a space to separate options in a MooseEnum, commas are deprecated\nMooseEnum initialized with names: \"" << names << '\"');
fillNames(names, ",");
}
else
fillNames(names);
}
RichardsApp::RichardsApp(const InputParameters & parameters) : MooseApp(parameters)
{
Moose::registerObjects(_factory);
RichardsApp::registerObjects(_factory);
Moose::associateSyntax(_syntax, _action_factory);
RichardsApp::associateSyntax(_syntax, _action_factory);
mooseDeprecated("Please use the PorousFlow module instead. If Richards contains functionality "
"not included in PorousFlow, please contact the moose-users google group");
}
TensorMechanicsMaterial::TensorMechanicsMaterial(const InputParameters & parameters)
: Material(parameters),
_grad_disp_x(coupledGradient("disp_x")),
_grad_disp_y(coupledGradient("disp_y")),
_grad_disp_z(_mesh.dimension() == 3 ? coupledGradient("disp_z") : _grad_zero),
_grad_disp_x_old(_fe_problem.isTransient() ? coupledGradientOld("disp_x") : _grad_zero),
_grad_disp_y_old(_fe_problem.isTransient() ? coupledGradientOld("disp_y") : _grad_zero),
_grad_disp_z_old(_fe_problem.isTransient() && _mesh.dimension() == 3
? coupledGradientOld("disp_z")
: _grad_zero),
_base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
_stress(declareProperty<RankTwoTensor>(_base_name + "stress")),
_total_strain(declareProperty<RankTwoTensor>(_base_name + "total_strain")),
_elastic_strain(declareProperty<RankTwoTensor>(_base_name + "elastic_strain")),
_elasticity_tensor_name(_base_name + "elasticity_tensor"),
_elasticity_tensor(declareProperty<RankFourTensor>(_elasticity_tensor_name)),
_Jacobian_mult(declareProperty<RankFourTensor>(_base_name + "Jacobian_mult")),
_Euler_angles(getParam<Real>("euler_angle_1"),
getParam<Real>("euler_angle_2"),
getParam<Real>("euler_angle_3")),
_Cijkl(getParam<std::vector<Real>>("C_ijkl"),
(RankFourTensor::FillMethod)(int)getParam<MooseEnum>("fill_method")),
_prefactor_function(isParamValid("elasticity_tensor_prefactor")
? &getFunction("elasticity_tensor_prefactor")
: NULL)
{
mooseDeprecated("EigenStrainBaseMaterial is deprecated. Please use the TensorMechanics "
"plug-and-play system instead: "
"http://mooseframework.org/wiki/PhysicsModules/TensorMechanics/"
"PlugAndPlayMechanicsApproach/");
const std::vector<FunctionName> & fcn_names(
getParam<std::vector<FunctionName>>("initial_stress"));
const unsigned num = fcn_names.size();
if (!(num == 0 || num == 3 * 3))
mooseError(
"Either zero or ",
3 * 3,
" initial stress functions must be provided to TensorMechanicsMaterial. You supplied ",
num,
"\n");
_initial_stress.resize(num);
for (unsigned i = 0; i < num; ++i)
_initial_stress[i] = &getFunctionByName(fcn_names[i]);
}
void
Factory::deprecatedMessage(const std::string obj_name)
{
std::map<std::string, std::time_t>::iterator time_it = _deprecated_time.find(obj_name);
// If the object is not deprecated return
if (time_it == _deprecated_time.end())
return;
// Get the current time
std::time_t now;
time(&now);
// Get the stop time
std::time_t t_end = time_it->second;
// Message storage
std::ostringstream msg;
std::map<std::string, std::string>::iterator name_it = _deprecated_name.find(obj_name);
// Expired object
if (now > t_end)
{
msg << "***** Invalid Object: " << obj_name << " *****\n";
msg << "Expired on " << ctime(&t_end);
// Append replacement object, if it exsits
if (name_it != _deprecated_name.end())
msg << "Update your application using the '" << name_it->second << "' object";
// Produce the error message
mooseDeprecationExpired(msg.str());
}
// Expiring object
else
{
// Build the basic message
msg << "Deprecated Object: " << obj_name << "\n";
msg << "This object will be removed on " << ctime(&t_end);
// Append replacement object, if it exsits
if (name_it != _deprecated_name.end())
msg << "Replace " << obj_name << " with " << name_it->second;
// Produce the error message
mooseDeprecated(msg.str());
}
}
StressDivergenceTensors::StressDivergenceTensors(const InputParameters & parameters) :
Kernel(parameters),
_base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
_stress(getMaterialPropertyByName<RankTwoTensor>(_base_name + "stress")),
_Jacobian_mult(getMaterialPropertyByName<ElasticityTensorR4>(_base_name + "Jacobian_mult")),
_component(getParam<unsigned int>("component")),
_ndisp(coupledComponents("displacements")),
_disp(3),
_disp_var(3),
_temp_coupled(isCoupled("temp")),
_temp_var(_temp_coupled ? coupled("temp") : 0)
{
if (_ndisp)
{
for (unsigned int i = 0; i < _ndisp; ++i)
{
_disp[i] = &coupledValue("displacements", i);
_disp_var[i] = coupled("displacements", i);
}
}
//This code is for the depricated version that allows three unique displacement variables
else if ((_ndisp == 0) && isParamValid("disp_x"))
{
mooseDeprecated("StressDivergenceTensors has been updated to accept a string of displacement variable names, e.g. displacements = 'disp_x disp_y' in the input file.");
_disp[0] = &coupledValue("disp_x");
_disp_var[0] = coupled("disp_x");
++_ndisp;
if (isParamValid("disp_y"))
{
_disp[1] = &coupledValue("disp_y");
_disp_var[1] = coupled("disp_y");
++_ndisp;
if (isParamValid("disp_z"))
{
_disp[2] = &coupledValue("disp_z");
_disp_var[2] = coupled("disp_z");
++_ndisp;
}
}
}
else
mooseError("The input file should specify a string of displacement names; these names should match the Variable block names.");
// Checking for consistency between mesh size and length of the provided displacements vector
if (_ndisp != _mesh.dimension())
mooseError("The number of displacement variables supplied must match the mesh dimension.");
}
SlaveConstraint::SlaveConstraint(const InputParameters & parameters)
: DiracKernel(parameters),
_component(getParam<unsigned int>("component")),
_model(ContactMaster::contactModel(getParam<std::string>("model"))),
_formulation(ContactMaster::contactFormulation(getParam<std::string>("formulation"))),
_normalize_penalty(getParam<bool>("normalize_penalty")),
_penetration_locator(
getPenetrationLocator(getParam<BoundaryName>("master"),
getParam<BoundaryName>("boundary"),
Utility::string_to_enum<Order>(getParam<MooseEnum>("order")))),
_penalty(getParam<Real>("penalty")),
_friction_coefficient(getParam<Real>("friction_coefficient")),
_residual_copy(_sys.residualGhosted()),
_vars(3, libMesh::invalid_uint),
_mesh_dimension(_mesh.dimension()),
_nodal_area_var(getVar("nodal_area", 0)),
_aux_system(_nodal_area_var->sys()),
_aux_solution(_aux_system.currentSolution())
{
if (isParamValid("displacements"))
{
// modern parameter scheme for displacements
for (unsigned int i = 0; i < coupledComponents("displacements"); ++i)
_vars[i] = coupled("displacements", i);
}
else
{
// Legacy parameter scheme for displacements
if (isParamValid("disp_x"))
_vars[0] = coupled("disp_x");
if (isParamValid("disp_y"))
_vars[1] = coupled("disp_y");
if (isParamValid("disp_z"))
_vars[2] = coupled("disp_z");
mooseDeprecated("use the `displacements` parameter rather than the `disp_*` parameters (those "
"will go away with the deprecation of the Solid Mechanics module).");
}
if (parameters.isParamValid("tangential_tolerance"))
_penetration_locator.setTangentialTolerance(getParam<Real>("tangential_tolerance"));
if (parameters.isParamValid("normal_smoothing_distance"))
_penetration_locator.setNormalSmoothingDistance(getParam<Real>("normal_smoothing_distance"));
if (parameters.isParamValid("normal_smoothing_method"))
_penetration_locator.setNormalSmoothingMethod(
parameters.get<std::string>("normal_smoothing_method"));
}
LinearElasticMaterial::LinearElasticMaterial(const InputParameters & parameters) :
TensorMechanicsMaterial(parameters),
_T(coupledValue("T")),
_T0(getParam<Real>("T0")),
_thermal_expansion_coeff(getParam<Real>("thermal_expansion_coeff")),
_applied_strain_vector(getParam<std::vector<Real> >("applied_strain_vector"))
{
mooseDeprecated("LinearElasticMaterial is deprecated. Refer to http://mooseframework.org/wiki/PhysicsModules/TensorMechanics/Deprecations/LinearElasticMaterial to convert this input file.");
//Initialize applied strain tensor from input vector
if (_applied_strain_vector.size() == 6)
_applied_strain_tensor.fillFromInputVector(_applied_strain_vector);
else
_applied_strain_tensor.zero();
}
GrainAdvectionVelocity::GrainAdvectionVelocity(const InputParameters & parameters)
: DerivativeMaterialInterface<Material>(parameters),
_grain_tracker(getUserObject<GrainTrackerInterface>("grain_data")),
_grain_force_torque(getUserObject<GrainForceAndTorqueInterface>("grain_force")),
_grain_volumes(getVectorPostprocessorValue("grain_volumes", "feature_volumes")),
_grain_forces(_grain_force_torque.getForceValues()),
_grain_torques(_grain_force_torque.getTorqueValues()),
_mt(getParam<Real>("translation_constant")),
_mr(getParam<Real>("rotation_constant")),
_op_num(coupledComponents("etas")),
_base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : ""),
_velocity_advection(
declareProperty<std::vector<RealGradient>>(_base_name + "advection_velocity"))
{
mooseDeprecated("Use GrainAdvectionAux for visualizing advection velocities.");
}
ComputeStrainBase::ComputeStrainBase(const InputParameters & parameters) :
DerivativeMaterialInterface<Material>(parameters),
_ndisp(coupledComponents("displacements")),
_disp(3),
_grad_disp(3),
_grad_disp_old(3),
_T(coupledValue("temperature")),
_T0(getParam<Real>("temperature_ref")),
_thermal_expansion_coeff(getParam<Real>("thermal_expansion_coeff")),
_no_thermal_eigenstrains(false),
_base_name(isParamValid("base_name") ? getParam<std::string>("base_name") + "_" : "" ),
_mechanical_strain(declareProperty<RankTwoTensor>(_base_name + "mechanical_strain")),
_total_strain(declareProperty<RankTwoTensor>(_base_name + "total_strain")),
_stateful_displacements(getParam<bool>("stateful_displacements") && _fe_problem.isTransient()),
_volumetric_locking_correction(getParam<bool>("volumetric_locking_correction"))
{
// Checking for consistency between mesh size and length of the provided displacements vector
if (_ndisp != _mesh.dimension())
mooseError("The number of variables supplied in 'displacements' must match the mesh dimension.");
if (parameters.isParamSetByUser("thermal_expansion_coeff"))
_no_thermal_eigenstrains = true;
if (_no_thermal_eigenstrains)
mooseDeprecated("The calculation of the thermal strains has been moved to the material ComputeThermalExpansionEigenStrains");
// fetch coupled variables and gradients (as stateful properties if necessary)
for (unsigned int i = 0; i < _ndisp; ++i)
{
_disp[i] = &coupledValue("displacements", i);
_grad_disp[i] = &coupledGradient("displacements", i);
if (_stateful_displacements)
_grad_disp_old[i] = &coupledGradientOld("displacements" ,i);
else
_grad_disp_old[i] = &_grad_zero;
}
// set unused dimensions to zero
for (unsigned i = _ndisp; i < 3; ++i)
{
_disp[i] = &_zero;
_grad_disp[i] = &_grad_zero;
_grad_disp_old[i] = &_grad_zero;
}
}
PorousFlow2PhasePS_VG::PorousFlow2PhasePS_VG(const InputParameters & parameters)
: PorousFlow2PhasePS(parameters),
_m(getParam<Real>("m")),
_pc_max(getParam<Real>("pc_max")),
_p0(getParam<Real>("p0")),
_alpha(1.0 / _p0)
{
mooseDeprecated("PorousFlow2PhasePS_VG is deprecated. Please use PorousFlow2PhasePS and a "
"PorousFlowCapillaryPressureVG UserObject instead");
if (_dictator.numPhases() != 2)
mooseError("The Dictator proclaims that the number of phases is ",
_dictator.numPhases(),
" whereas PorousFlow2PhasePS_VG can only be used for 2-phase simulation. Be aware "
"that the Dictator has noted your mistake.");
}