InputParameters validParams<PTGeothermal>()
{
InputParameters params = validParams<Material>();
MooseEnum stat("constant compressibility wseos", "constant");
params.addParam<MooseEnum>("fluid_property_formulation", stat,
"Fluid property formulation, default = constant");
MooseEnum stabilizer("none zero supg supg_dc", "none");
params.addParam<MooseEnum>("stabilizer", stabilizer,
"Energy transport stabilizer, default = none");
params.addParam<bool>(
"pressure_dependent_permeability", false,
"Flag true if permeability is pressure dependent, default = false");
params.addParam<Real>(
"reference_pressure", 101325,
"Reference pressure [Pa], default = 101325");
params.addParam<Real>(
"reference_temperature", 297.15,
"Reference temperature [K], default = 297.15");
params.addParam<Real>(
"permeability", 1.0e-12,
"Intrinsic permeability [m^2], default = 1.0e-12");
params.addParam<Real>(
"porosity", 0.3,
"Rock porosity, default = 0.3");
params.addParam<Real>(
"compressibility", 1.0e-5,
"Total compressibility of the researvoir, default = 1.0e-5");
params.addParam<Real>(
"density_rock", 2.50e3,
"Rock density [kg/m^3]");
params.addParam<Real>(
"gravity", 9.80665,
"Gravity acceleration constant [m/s^2], default = 9.80665");
params.addParam<RealGradient>(
"gravity_direction", RealGradient(0,0,-1),
"Gravity unit directional vector, default = '0 0 -1'");
params.addParam<RealGradient>(
"constant_pressure_gradient", RealGradient(0,0,0),
"Constant pressure gradient, default = '0 0 0'");
params.addCoupledVar(
"pressure",
"Assign nonlinear variable for pressure [Pa], if mass balance is involved");
params.addCoupledVar(
"temperature",
"Assign nonlinear variable for temperature [K], if energy balance is involved");
params.addParam<Real>(
"density_water", 1000,
"Initial water density [kg/m^3], default = 1000");
params.addParam<Real>(
"viscosity_water", 0.001,
"Initial water viscosity [Pa.s], default = 0.001");
params.addParam<Real>(
"specific_heat_rock", 0.92e3,
"Specific heat of the rock [J/(kg.K)], default = 0.92e3");
params.addParam<Real>(
"specific_heat_water", 4.186e3,
"Specific heat of water [J/(kg.K)], default = 4.186e3");
params.addParam<Real>(
"thermal_conductivity", 2.5,
"Thermal conductivity of the reservoir [W/(m.K)], default = 2.5");
params.addParam<Real>(
"supg_dc_threshold", 1e-12,
"Threshold magnitude of temperature gradient to include SUPG discontinuity capturing, default = 1e-12");
return params;
}
InputParameters validParams<ElementVariablePostprocessor>()
{
InputParameters params = validParams<ElementPostprocessor>();
params.addCoupledVar("variable", "The name of the variable that this postprocessor operates on");
return params;
}
void
ContactAction::act()
{
if (!_problem->getDisplacedProblem())
{
mooseError("Contact requires updated coordinates. Use the 'displacements = ...' line in the Mesh block.");
}
// Determine number of dimensions
unsigned int dim(1);
if (_disp_y != "")
{
++dim;
}
if (_disp_z != "")
{
++dim;
}
std::string short_name(_name);
// Chop off "Contact/"
short_name.erase(0, 8);
std::vector<NonlinearVariableName> vars;
vars.push_back(_disp_x);
vars.push_back(_disp_y);
vars.push_back(_disp_z);
{
InputParameters params = _factory.getValidParams("ContactMaster");
// Extract global params
_app.parser().extractParams(_name, params);
// Create master objects
params.set<std::string>("model") = _model;
params.set<std::string>("formulation") = _formulation;
params.set<MooseEnum>("order") = _order;
params.set<BoundaryName>("boundary") = _master;
params.set<BoundaryName>("slave") = _slave;
params.set<Real>("penalty") = _penalty;
params.set<Real>("friction_coefficient") = _friction_coefficient;
params.set<Real>("tension_release") = _tension_release;
params.addRequiredCoupledVar("nodal_area", "The nodal area");
params.set<std::vector<VariableName> >("nodal_area") = std::vector<VariableName>(1, "nodal_area_"+short_name);
if (isParamValid("tangential_tolerance"))
{
params.set<Real>("tangential_tolerance") = getParam<Real>("tangential_tolerance");
}
if (isParamValid("normal_smoothing_distance"))
{
params.set<Real>("normal_smoothing_distance") = getParam<Real>("normal_smoothing_distance");
}
if (isParamValid("normal_smoothing_method"))
{
params.set<std::string>("normal_smoothing_method") = getParam<std::string>("normal_smoothing_method");
}
params.addCoupledVar("disp_x", "The x displacement");
params.set<std::vector<VariableName> >("disp_x") = std::vector<VariableName>(1, _disp_x);
params.addCoupledVar("disp_y", "The y displacement");
if (dim > 1)
{
params.set<std::vector<VariableName> >("disp_y") = std::vector<VariableName>(1, _disp_y);
}
params.addCoupledVar("disp_z", "The z displacement");
if (dim == 3)
{
params.set<std::vector<VariableName> >("disp_z") = std::vector<VariableName>(1, _disp_z);
}
params.set<bool>("use_displaced_mesh") = true;
for (unsigned int i(0); i < dim; ++i)
{
std::stringstream name;
name << short_name;
name << "_master_";
name << i;
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = vars[i];
_problem->addDiracKernel("ContactMaster",
name.str(),
params);
}
}
{
InputParameters params = _factory.getValidParams("SlaveConstraint");
// Extract global params
_app.parser().extractParams(_name, params);
// Create slave objects
params.set<std::string>("model") = _model;
params.set<std::string>("formulation") = _formulation;
params.set<MooseEnum>("order") = _order;
params.set<BoundaryName>("boundary") = _slave;
params.set<BoundaryName>("master") = _master;
params.set<Real>("penalty") = _penalty;
params.set<Real>("friction_coefficient") = _friction_coefficient;
params.addRequiredCoupledVar("nodal_area", "The nodal area");
params.set<std::vector<VariableName> >("nodal_area") = std::vector<VariableName>(1, "nodal_area_"+short_name);
if (isParamValid("tangential_tolerance"))
{
params.set<Real>("tangential_tolerance") = getParam<Real>("tangential_tolerance");
}
if (isParamValid("normal_smoothing_distance"))
{
params.set<Real>("normal_smoothing_distance") = getParam<Real>("normal_smoothing_distance");
}
if (isParamValid("normal_smoothing_method"))
{
params.set<std::string>("normal_smoothing_method") = getParam<std::string>("normal_smoothing_method");
}
params.addCoupledVar("disp_x", "The x displacement");
params.set<std::vector<VariableName> >("disp_x") = std::vector<VariableName>(1, _disp_x);
params.addCoupledVar("disp_y", "The y displacement");
if (dim > 1)
{
params.set<std::vector<VariableName> >("disp_y") = std::vector<VariableName>(1, _disp_y);
}
params.addCoupledVar("disp_z", "The z displacement");
if (dim == 3)
{
params.set<std::vector<VariableName> >("disp_z") = std::vector<VariableName>(1, _disp_z);
}
params.set<bool>("use_displaced_mesh") = true;
for (unsigned int i(0); i < dim; ++i)
{
std::stringstream name;
name << short_name;
name << "_slave_";
name << i;
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = vars[i];
_problem->addDiracKernel("SlaveConstraint",
name.str(),
params);
}
}
++counter;
}
void
ContactAction::act()
{
if (!_problem->getDisplacedProblem())
mooseError("Contact requires updated coordinates. Use the 'displacements = ...' line in the Mesh block.");
// Determine number of dimensions
unsigned int numdims(1);
if (_disp_y != "")
++numdims;
if (_disp_z != "")
++numdims;
std::string action_name = MooseUtils::shortName(name());
std::vector<NonlinearVariableName> vars;
vars.push_back(_disp_x);
vars.push_back(_disp_y);
vars.push_back(_disp_z);
if ( _current_task == "add_dirac_kernel" )
{
// MechanicalContactConstraint has to be added after the init_problem task, so it cannot be
// added for the add_constraint task.
if (_system == "Constraint")
{
InputParameters params = _factory.getValidParams("MechanicalContactConstraint");
// Extract global params
if (isParamValid("parser_syntax"))
_app.parser().extractParams(getParam<std::string>("parser_syntax"), params);
else
mooseError("The 'parser_syntax' parameter is not valid, which indicates that this actions was not created by the Parser, which is not currently supported.");
// Create Constraint objects
params.set<std::string>("model") = _model;
params.set<std::string>("formulation") = _formulation;
params.set<MooseEnum>("order") = _order;
params.set<BoundaryName>("boundary") = _master;
params.set<BoundaryName>("slave") = _slave;
params.set<Real>("penalty") = _penalty;
params.set<Real>("friction_coefficient") = _friction_coefficient;
params.set<Real>("tension_release") = _tension_release;
params.addRequiredCoupledVar("nodal_area", "The nodal area");
params.set<std::vector<VariableName> >("nodal_area") = std::vector<VariableName>(1, "nodal_area_" + name());
if (isParamValid("tangential_tolerance"))
params.set<Real>("tangential_tolerance") = getParam<Real>("tangential_tolerance");
if (isParamValid("capture_tolerance"))
params.set<Real>("capture_tolerance") = getParam<Real>("capture_tolerance");
if (isParamValid("normal_smoothing_distance"))
params.set<Real>("normal_smoothing_distance") = getParam<Real>("normal_smoothing_distance");
if (isParamValid("normal_smoothing_method"))
params.set<std::string>("normal_smoothing_method") = getParam<std::string>("normal_smoothing_method");
params.addCoupledVar("disp_x", "The x displacement");
params.set<std::vector<VariableName> >("disp_x") = std::vector<VariableName>(1, _disp_x);
params.addCoupledVar("disp_y", "The y displacement");
if (numdims > 1)
params.set<std::vector<VariableName> >("disp_y") = std::vector<VariableName>(1, _disp_y);
params.addCoupledVar("disp_z", "The z displacement");
if (numdims == 3)
params.set<std::vector<VariableName> >("disp_z") = std::vector<VariableName>(1, _disp_z);
params.set<bool>("use_displaced_mesh") = true;
for (unsigned int i(0); i < numdims; ++i)
{
std::string name = action_name + "_constraint_" + Moose::stringify(i);
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = vars[i];
params.set<std::vector<VariableName> >("master_variable") = std::vector<VariableName>(1,vars[i]);
_problem->addConstraint("MechanicalContactConstraint", name, params);
}
}
if (_system == "DiracKernel")
{
{
InputParameters params = _factory.getValidParams("ContactMaster");
// Extract global params
if (isParamValid("parser_syntax"))
_app.parser().extractParams(getParam<std::string>("parser_syntax"), params);
else
mooseError("The 'parser_syntax' parameter is not valid, which indicates that this actions was not created by the Parser, which is not currently supported.");
// Create master objects
params.set<std::string>("model") = _model;
params.set<std::string>("formulation") = _formulation;
params.set<MooseEnum>("order") = _order;
params.set<BoundaryName>("boundary") = _master;
params.set<BoundaryName>("slave") = _slave;
params.set<Real>("penalty") = _penalty;
params.set<Real>("friction_coefficient") = _friction_coefficient;
params.set<Real>("tension_release") = _tension_release;
params.addRequiredCoupledVar("nodal_area", "The nodal area");
params.set<std::vector<VariableName> >("nodal_area") = std::vector<VariableName>(1, "nodal_area_" + name());
if (isParamValid("tangential_tolerance"))
params.set<Real>("tangential_tolerance") = getParam<Real>("tangential_tolerance");
if (isParamValid("capture_tolerance"))
params.set<Real>("capture_tolerance") = getParam<Real>("capture_tolerance");
if (isParamValid("normal_smoothing_distance"))
params.set<Real>("normal_smoothing_distance") = getParam<Real>("normal_smoothing_distance");
if (isParamValid("normal_smoothing_method"))
params.set<std::string>("normal_smoothing_method") = getParam<std::string>("normal_smoothing_method");
params.addCoupledVar("disp_x", "The x displacement");
params.set<std::vector<VariableName> >("disp_x") = std::vector<VariableName>(1, _disp_x);
params.addCoupledVar("disp_y", "The y displacement");
if (numdims > 1)
params.set<std::vector<VariableName> >("disp_y") = std::vector<VariableName>(1, _disp_y);
params.addCoupledVar("disp_z", "The z displacement");
if (numdims == 3)
params.set<std::vector<VariableName> >("disp_z") = std::vector<VariableName>(1, _disp_z);
params.set<bool>("use_displaced_mesh") = true;
for (unsigned int i(0); i < numdims; ++i)
{
std::string name = action_name + "_master_" + Moose::stringify(i);
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = vars[i];
_problem->addDiracKernel("ContactMaster", name, params);
}
}
{
InputParameters params = _factory.getValidParams("SlaveConstraint");
// Extract global params
if (isParamValid("parser_syntax"))
_app.parser().extractParams(getParam<std::string>("parser_syntax"), params);
else
mooseError("The 'parser_syntax' parameter is not valid, which indicates that this actions was not created by the Parser, which is not currently supported.");
// Create slave objects
params.set<std::string>("model") = _model;
params.set<std::string>("formulation") = _formulation;
params.set<MooseEnum>("order") = _order;
params.set<BoundaryName>("boundary") = _slave;
params.set<BoundaryName>("master") = _master;
params.set<Real>("penalty") = _penalty;
params.set<Real>("friction_coefficient") = _friction_coefficient;
params.addRequiredCoupledVar("nodal_area", "The nodal area");
params.set<std::vector<VariableName> >("nodal_area") = std::vector<VariableName>(1, "nodal_area_" +name());
if (isParamValid("tangential_tolerance"))
params.set<Real>("tangential_tolerance") = getParam<Real>("tangential_tolerance");
if (isParamValid("capture_tolerance"))
params.set<Real>("capture_tolerance") = getParam<Real>("capture_tolerance");
if (isParamValid("normal_smoothing_distance"))
params.set<Real>("normal_smoothing_distance") = getParam<Real>("normal_smoothing_distance");
if (isParamValid("normal_smoothing_method"))
params.set<std::string>("normal_smoothing_method") = getParam<std::string>("normal_smoothing_method");
params.addCoupledVar("disp_x", "The x displacement");
params.set<std::vector<VariableName> >("disp_x") = std::vector<VariableName>(1, _disp_x);
params.addCoupledVar("disp_y", "The y displacement");
if (numdims > 1)
params.set<std::vector<VariableName> >("disp_y") = std::vector<VariableName>(1, _disp_y);
params.addCoupledVar("disp_z", "The z displacement");
if (numdims == 3)
params.set<std::vector<VariableName> >("disp_z") = std::vector<VariableName>(1, _disp_z);
params.set<bool>("use_displaced_mesh") = true;
for (unsigned int i(0); i < numdims; ++i)
{
std::string name = action_name + "_slave_" + Moose::stringify(i);
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = vars[i];
_problem->addDiracKernel("SlaveConstraint", name, params);
}
}
}
}
}
void
BubblesPostprocessorsAction::act()
{
std::vector<PostprocessorName> pp_names;
std::vector<PostprocessorName> swelling_pp_names;
if ( _conc || _total_conc || _total_atoms )
{
for ( int i=0; i<_G; ++i )
{
std::string pp_to_use = "BoundedElementAverage";
pp_names.push_back(_c[i] + "_conc");
InputParameters params = _factory.getValidParams(pp_to_use);
params.set<MultiMooseEnum>("execute_on") = "timestep_end";
params.set<std::vector<VariableName> >("variable") = std::vector<VariableName>(1, _c[i]);
params.set<Real>("lower") = 0;
std::vector<OutputName> outs;
if ( _conc )
outs = getParam<std::vector<OutputName> >("concentrations");
else
outs.push_back("none");
params.set<std::vector<OutputName> >("outputs") = outs;
_problem->addPostprocessor(pp_to_use, pp_names[i], params);
}
}
if (_total_conc)
{
std::string pp_to_use = "SumOfPostprocessors";
std::string this_pp_name = "total_conc";
InputParameters params = _factory.getValidParams(pp_to_use);
params.set<MultiMooseEnum>("execute_on") = "timestep_end";
params.set<std::vector<PostprocessorName> >("postprocessors") = pp_names;
std::vector<OutputName> outs(getParam<std::vector<OutputName> >("total_concentrations"));
params.set<std::vector<OutputName> >("outputs") = outs;
_problem->addPostprocessor(pp_to_use, this_pp_name, params);
}
if (_total_atoms)
{
std::string pp_to_use = "SumOfPostprocessors";
std::string this_pp_name = "total_atoms";
InputParameters params = _factory.getValidParams(pp_to_use);
params.set<MultiMooseEnum>("execute_on") = "timestep_end";
params.set<std::vector<PostprocessorName> >("postprocessors") = pp_names;
params.set<std::vector<Real> >("factors") = _atoms;
std::vector<OutputName> outs(getParam<std::vector<OutputName> >("total_atoms"));
params.set<std::vector<OutputName> >("outputs") = outs;
_problem->addPostprocessor(pp_to_use, this_pp_name, params);
}
if (_swelling || _total_swelling)
{
for ( int i=0; i<_G; ++i )
{
std::string pp_to_use = "SwellingPostprocessor";
swelling_pp_names.push_back(_c[i] + "_swelling");
InputParameters params = _factory.getValidParams(pp_to_use);
params.set<MultiMooseEnum>("execute_on") = "timestep_end";
params.set<std::vector<VariableName> >("variable") = std::vector<VariableName>(1, _c[i]);
params.addCoupledVar("r", "");
params.set<std::vector<VariableName> >("r") = std::vector<VariableName>(1, _r[i]);
params.set<Real>("width") = _widths[i];
std::vector<OutputName> outs;
if ( _swelling )
outs = getParam<std::vector<OutputName> >("swelling");
else
outs.push_back("none");
params.set<std::vector<OutputName> >("outputs") = outs;
_problem->addPostprocessor(pp_to_use, swelling_pp_names[i], params);
}
}
if (_total_swelling)
{
std::string pp_to_use = "SumOfPostprocessors";
std::string this_pp_name = "gas_swelling";
InputParameters params = _factory.getValidParams(pp_to_use);
params.set<MultiMooseEnum>("execute_on") = "timestep_end";
params.set<std::vector<PostprocessorName> >("postprocessors") = swelling_pp_names;
std::vector<OutputName> outs(getParam<std::vector<OutputName> >("total_swelling"));
params.set<std::vector<OutputName> >("outputs") = outs;
_problem->addPostprocessor(pp_to_use, this_pp_name, params);
}
if (_c1_loss)
{
std::vector<PostprocessorName> these_pp_names;
for ( int i=0; i<_G; ++i )
{
std::string pp_to_use = "C1LossPostprocessor";
these_pp_names.push_back(_c[i] + "_c1_loss");
InputParameters params = _factory.getValidParams(pp_to_use);
params.set<MultiMooseEnum>("execute_on") = "timestep_end";
params.set<std::vector<VariableName> >("variable") = std::vector<VariableName>(1, _c[i]);
params.addCoupledVar("r", "");
params.set<std::vector<VariableName> >("r") = std::vector<VariableName>(1, _r[i]);
params.addCoupledVar("c1", "");
params.set<std::vector<VariableName> >("c1") = std::vector<VariableName>(1, _c[0]);
params.addCoupledVar("fission_rate", "");
params.set<std::vector<VariableName> >("fission_rate") = std::vector<VariableName>(1, getParam<VariableName>("fission_rate"));
params.set<Real>("width") = _widths[i];
params.set<Real>("atoms") = _atoms[i];
params.set<std::vector<OutputName> >("outputs") = getParam<std::vector<OutputName> >("c1_loss");
_problem->addPostprocessor(pp_to_use, these_pp_names[i], params);
}
}
if (_gain_rate)
{
std::vector<PostprocessorName> these_pp_names;
for ( int i=0; i<_G; ++i )
{
std::string pp_to_use = "GainRatePostprocessor";
these_pp_names.push_back(_c[i] + "_gain_rate");
InputParameters params = _factory.getValidParams(pp_to_use);
params.set<MultiMooseEnum>("execute_on") = "timestep_end";
params.set<std::vector<VariableName> >("variable") = std::vector<VariableName>(1, _c[i]);
params.addCoupledVar("r", "");
params.set<std::vector<VariableName> >("r") = std::vector<VariableName>(1, _r[i]);
params.addCoupledVar("c1", "");
params.set<std::vector<VariableName> >("c1") = std::vector<VariableName>(1, _c[0]);
params.set<Real>("width") = _widths[i];
params.set<std::vector<OutputName> >("outputs") = getParam<std::vector<OutputName> >("gain_rate");
_problem->addPostprocessor(pp_to_use, these_pp_names[i], params);
}
}
if (_knockout_rate)
{
std::vector<PostprocessorName> these_pp_names;
for ( int i=0; i<_G; ++i )
{
std::string pp_to_use = "KnockoutRatePostprocessor";
these_pp_names.push_back(_c[i] + "_knockout_rate");
InputParameters params = _factory.getValidParams(pp_to_use);
params.set<MultiMooseEnum>("execute_on") = "timestep_end";
params.set<std::vector<VariableName> >("variable") = std::vector<VariableName>(1, _c[i]);
params.addCoupledVar("r", "");
params.set<std::vector<VariableName> >("r") = std::vector<VariableName>(1, _r[i]);
params.addCoupledVar("c1", "");
params.set<std::vector<VariableName> >("c1") = std::vector<VariableName>(1, _c[0]);
params.addCoupledVar("fission_rate", "");
params.set<std::vector<VariableName> >("fission_rate") = std::vector<VariableName>(1, getParam<VariableName>("fission_rate"));
params.set<Real>("width") = _widths[i];
params.set<Real>("atoms") = _atoms[i];
params.set<std::vector<OutputName> >("outputs") = getParam<std::vector<OutputName> >("knockout_rate");
_problem->addPostprocessor(pp_to_use, these_pp_names[i], params);
}
}
}
void
ThermalContactBCsAction::act()
{
bool quadrature = getParam<bool>("quadrature");
InputParameters params = _factory.getValidParams(getParam<std::string>("type"));
// Extract global params
_app.parser().extractParams(_name, params);
if(isParamValid("save_in"))
{
params.set<std::vector<std::string> >("save_in") = getParam<std::vector<std::string> >("save_in");
}
params.set<NonlinearVariableName>("variable") = getParam<NonlinearVariableName>("variable");
if(!quadrature)
{
std::vector<VariableName> vars(1);
vars[0] = "penetration";
params.set<std::vector<VariableName> >("gap_distance") = vars;
vars[0] = ThermalContactAuxVarsAction::getGapValueName(_pars);
params.set<std::vector<VariableName> >("gap_temp") = vars;
}
else
{
params.set<bool>("quadrature") = true;
params.set<BoundaryName>("paired_boundary") = getParam<BoundaryName>("master");
params.set<MooseEnum>("order") = getParam<MooseEnum>("order");
params.set<bool>("warnings") = getParam<bool>("warnings");
params.set<bool>("use_displaced_mesh") = true;
}
std::vector<BoundaryName> bnds(1, getParam<BoundaryName>("slave"));
params.set<std::vector<BoundaryName> >("boundary") = bnds;
params.set<std::string>("appended_property_name") = getParam<std::string>("appended_property_name");
if (isParamValid("disp_x"))
{
params.addCoupledVar("disp_x", "The x displacement");
std::vector<VariableName> disp_x(1, getParam<VariableName>("disp_x"));
params.set< std::vector<VariableName> >("disp_x") = disp_x;
}
if (isParamValid("disp_y"))
{
params.addCoupledVar("disp_y", "The y displacement");
std::vector<VariableName> disp_y(1, getParam<VariableName>("disp_y"));
params.set< std::vector<VariableName> >("disp_y") = disp_y;
}
if (isParamValid("disp_z"))
{
params.addCoupledVar("disp_z", "The z displacement");
std::vector<VariableName> disp_z(1, getParam<VariableName>("disp_z"));
params.set< std::vector<VariableName> >("disp_z") = disp_z;
}
_problem->addBoundaryCondition(getParam<std::string>("type"),
"gap_bc_" + Moose::stringify(n),
params);
if(quadrature)
{
// Swap master and slave for this one
std::vector<BoundaryName> bnds(1, getParam<BoundaryName>("master"));
params.set<std::vector<BoundaryName> >("boundary") = bnds;
params.set<BoundaryName>("paired_boundary") = getParam<BoundaryName>("slave");
_problem->addBoundaryCondition(getParam<std::string>("type"),
"gap_bc_master_" + Moose::stringify(n),
params);
}
++n;
}
void
SolidMechanicsAction::act()
{
// list of subdomains IDs per coordinate system
std::map<Moose::CoordinateSystemType, std::vector<SubdomainName> > coord_map;
std::set<SubdomainID> subdomains;
if (isParamValid("block")) // Should it be restricted to certain blocks?
{
Moose::out<<"Restricting to blocks!"<<std::endl;
std::vector<SubdomainName> block = getParam<std::vector<SubdomainName> >("block");
for (unsigned int i=0; i < block.size(); i++)
subdomains.insert(_problem->mesh().getSubdomainID(block[i]));
}
else // Put it everywhere
subdomains = _problem->mesh().meshSubdomains();
for (std::set<SubdomainID>::const_iterator it = subdomains.begin(); it != subdomains.end(); ++it)
{
SubdomainID sid = *it;
Moose::CoordinateSystemType coord_type = _problem->getCoordSystem(sid);
// Convert the SubdomainID into SubdomainName since kernel params take SubdomainNames (this is retarded...)
std::stringstream ss;
ss << sid;
SubdomainName sname = ss.str();
coord_map[coord_type].push_back(sname);
}
for (std::map<Moose::CoordinateSystemType, std::vector<SubdomainName> >::iterator it = coord_map.begin(); it != coord_map.end(); ++it)
{
Moose::CoordinateSystemType coord_type = (*it).first;
std::vector<SubdomainName> & blocks = (*it).second;
// Determine whether RZ or RSPHERICAL
bool rz(false);
bool rspherical(false);
unsigned int dim(1);
std::vector<std::string> keys;
std::vector<VariableName> vars;
std::vector<std::vector<AuxVariableName> > save_in;
std::vector<std::vector<AuxVariableName> > diag_save_in;
std::string type("StressDivergence");
if (getParam<MooseEnum>("type") == 0) // truss
{
type = "StressDivergenceTruss";
}
else if (coord_type == Moose::COORD_RZ)
{
rz = true;
type = "StressDivergenceRZ";
dim = 2;
keys.push_back("disp_r");
keys.push_back("disp_z");
vars.push_back(_disp_r);
vars.push_back(_disp_z);
save_in.resize(dim);
if (isParamValid("save_in_disp_r"))
save_in[0] = getParam<std::vector<AuxVariableName> >("save_in_disp_r");
if (isParamValid("save_in_disp_z"))
save_in[1] = getParam<std::vector<AuxVariableName> >("save_in_disp_z");
diag_save_in.resize(dim);
if (isParamValid("diag_save_in_disp_r"))
diag_save_in[0] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_r");
if (isParamValid("diag_save_in_disp_z"))
diag_save_in[1] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_z");
}
else if (coord_type == Moose::COORD_RSPHERICAL)
{
rspherical = true;
type = "StressDivergenceRSpherical";
dim = 1;
keys.push_back("disp_r");
vars.push_back(_disp_r);
save_in.resize(dim);
if (isParamValid("save_in_disp_r"))
save_in[0] = getParam<std::vector<AuxVariableName> >("save_in_disp_r");
diag_save_in.resize(dim);
if (isParamValid("diag_save_in_disp_r"))
diag_save_in[0] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_r");
}
if (!rz && !rspherical && _disp_x == "")
{
mooseError("disp_x must be specified");
}
if (!rz && !rspherical)
{
keys.push_back("disp_x");
vars.push_back(_disp_x);
if ( _disp_y != "" )
{
++dim;
keys.push_back("disp_y");
vars.push_back(_disp_y);
if ( _disp_z != "" )
{
++dim;
keys.push_back("disp_z");
vars.push_back(_disp_z);
}
}
save_in.resize(dim);
if (isParamValid("save_in_disp_x"))
save_in[0] = getParam<std::vector<AuxVariableName> >("save_in_disp_x");
if (isParamValid("save_in_disp_y"))
save_in[1] = getParam<std::vector<AuxVariableName> >("save_in_disp_y");
if (isParamValid("save_in_disp_z"))
save_in[2] = getParam<std::vector<AuxVariableName> >("save_in_disp_z");
diag_save_in.resize(dim);
if (isParamValid("diag_save_in_disp_x"))
diag_save_in[0] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_x");
if (isParamValid("diag_save_in_disp_y"))
diag_save_in[1] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_y");
if (isParamValid("diag_save_in_disp_z"))
diag_save_in[2] = getParam<std::vector<AuxVariableName> >("diag_save_in_disp_z");
}
unsigned int num_coupled(dim);
if (_temp != "")
{
++num_coupled;
keys.push_back("temp");
vars.push_back(_temp);
}
InputParameters params = _factory.getValidParams(type);
for (unsigned j(0); j < num_coupled; ++j)
{
params.addCoupledVar(keys[j], "");
params.set<std::vector<VariableName> >(keys[j]) = std::vector<VariableName>(1, vars[j]);
}
params.set<bool>("use_displaced_mesh") = getParam<bool>("use_displaced_mesh");
params.set<std::string>("appended_property_name") = getParam<std::string>("appended_property_name");
for (unsigned int i(0); i < dim; ++i)
{
std::stringstream name;
name << _name;
name << i;
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = vars[i];
params.set<std::vector<SubdomainName> >("block") = blocks;
params.set<std::vector<AuxVariableName> >("save_in") = save_in[i];
params.set<std::vector<AuxVariableName> >("diag_save_in") = diag_save_in[i];
params.set<Real>("zeta") = _zeta;
params.set<Real>("alpha") = _alpha;
_problem->addKernel(type, name.str(), params);
}
}
}
InputParameters validParams<StatefulTest>()
{
InputParameters params = validParams<Material>();
params.addCoupledVar("coupled", "Coupled Value to be used in initQpStatefulProperties()");
return params;
}
InputParameters validParams<FluidHeatTransfer>()
{
InputParameters params = validParams<Kernel>();
params.addCoupledVar("coupled", "Name of the wall temperature variable to be coupled.");
return params;
}
InputParameters validParams<EnthalpyTimeDerivative>()
{
InputParameters params = validParams<TimeDerivative>();
params.addCoupledVar("pressure","Use coupled pressuer here to calculate the time derivative");
return params;
}
InputParameters validParams<SideIntegralVariableUserObject>()
{
InputParameters params = validParams<SideIntegralUserObject>();
params.addCoupledVar("variable", "The name of the variable that this boundary condition applies to");
return params;
}
void
TensorMechanicsAction::act()
{
std::vector<NonlinearVariableName> displacements;
//This code will be the up-to-date version using the displacement string
if (isParamValid("displacements"))
displacements = getParam<std::vector<NonlinearVariableName> > ("displacements");
//This code is for the depricated version that allows three unique displacement variables
else if (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.");
displacements.push_back(getParam<NonlinearVariableName>("disp_x"));
if (isParamValid("disp_y"))
{
displacements.push_back(getParam<NonlinearVariableName>("disp_y"));
if (isParamValid("disp_z"))
displacements.push_back(getParam<NonlinearVariableName>("disp_z"));
}
}
else
mooseError("The input file should specify a string of displacement names; these names should match the Variable block names.");
std::vector<VariableName> coupled_displacements; //vector to hold the string of coupled disp variables
unsigned int dim = displacements.size();
for (unsigned int i = 0; i < dim; ++i)
coupled_displacements.push_back(displacements[i]);
// Retain this code 'as is' because StressDivergenceTensors inherits from Kernel.C
std::vector<std::vector<AuxVariableName> > save_in;
save_in.resize(dim);
if (isParamValid("save_in_disp_x"))
save_in[0] = getParam<std::vector<AuxVariableName> >("save_in_disp_x");
if (isParamValid("save_in_disp_y"))
save_in[1] = getParam<std::vector<AuxVariableName> >("save_in_disp_y");
if (isParamValid("save_in_disp_z"))
save_in[2] = getParam<std::vector<AuxVariableName> >("save_in_disp_z");
InputParameters params = _factory.getValidParams("StressDivergenceTensors");
params.set<std::vector<VariableName> >("displacements") = coupled_displacements;
if (isParamValid("temp"))
params.addCoupledVar("temp", "");
params.set<bool>("use_displaced_mesh") = getParam<bool>("use_displaced_mesh");
if (isParamValid("base_name"))
params.set<std::string>("base_name") = getParam<std::string>("base_name");
std::string short_name = "TensorMechanics";
for (unsigned int i = 0; i < dim; ++i)
{
std::stringstream name;
name << short_name;
name << i;
params.set<unsigned int>("component") = i;
params.set<NonlinearVariableName>("variable") = displacements[i];
params.set<std::vector<AuxVariableName> >("save_in") = save_in[i];
_problem->addKernel("StressDivergenceTensors", name.str(), params);
}
}
InputParameters validParams<ImplicitODEx>()
{
InputParameters params = validParams<ODEKernel>();
params.addCoupledVar("y", "variable Y coupled into this kernel");
return params;
}
