void
EBSDMeshErrorTest::fileDoesNotExist()
{
// generate input parameter set
InputParameters params = _factory->getValidParams("EBSDMesh");
params.addPrivateParam("_moose_app", _app);
params.set<std::string>("name", "EBSD");
// set filename
params.set<FileName>("filename") = "FILEDOESNOTEXIST";
// construct mesh object
EBSDMesh * mesh = new EBSDMesh("unit_test_mesh", params);
try
{
// trigger mesh building with invalid EBSD filename
mesh->buildMesh();
}
catch(const std::exception & e)
{
std::string msg(e.what());
CPPUNIT_ASSERT( msg.find("Can't open EBSD file: FILEDOESNOTEXIST") != std::string::npos );
}
// delete mesh object
delete mesh;
}
void
EBSDMeshErrorTest::headerErrorHelper(const char * filename, const char * error)
{
// generate input parameter set
InputParameters params = _factory->getValidParams("EBSDMesh");
params.addPrivateParam("_moose_app", _app);
params.set<std::string>("name", "EBSD");
// set filename
params.set<FileName>("filename") = filename;
params.set<unsigned int>("uniform_refine") = 2;
// construct mesh object
EBSDMesh * mesh = new EBSDMesh("unit_test_mesh", params);
try
{
// trigger mesh building with invalid EBSD filename
mesh->buildMesh();
}
catch(const std::exception & e)
{
std::string msg(e.what());
CPPUNIT_ASSERT_MESSAGE( filename, msg.find(error) != std::string::npos );
}
// delete mesh object
delete mesh;
}
void
EBSDMeshErrorTest::testParam(unsigned int nparam, const char ** param_list)
{
for (unsigned int i = 0; i < nparam; ++i)
{
// generate input parameter set
InputParameters params = _factory->getValidParams("EBSDMesh");
params.addPrivateParam("_moose_app", _app);
params.set<std::string>("name", "EBSD");
// set a single parameter
params.set<T>(param_list[i]) = T(1.0);
// set filename (is a required param but not used in these tests)
params.set<FileName>("filename") = "DUMMY";
try
{
// construct mesh object
EBSDMesh * mesh = new EBSDMesh("unit_test_mesh", params);
delete mesh;
}
catch(const std::exception & e)
{
std::string msg(e.what());
CPPUNIT_ASSERT( msg.find("Do not specify mesh geometry information, it is read from the EBSD file.") != std::string::npos );
}
}
}
CoupledExecutioner::CoupledExecutioner(const std::string & name, InputParameters parameters) :
Executioner(name, parameters)
{
InputParameters params = emptyInputParameters();
params.addPrivateParam("_moose_app", &_app);
_problem = MooseSharedNamespace::static_pointer_cast<CoupledProblem>(_app.getFactory().create("CoupledProblem", "master_problem", params));
}
MooseSharedPointer<Action>
ActionFactory::create(const std::string & action, const std::string & action_name, InputParameters parameters)
{
parameters.addPrivateParam("_moose_app", &_app);
parameters.addPrivateParam("action_type", action);
std::pair<ActionFactory::iterator, ActionFactory::iterator> iters;
BuildInfo *build_info = NULL;
// Check to make sure that all required parameters are supplied
parameters.checkParams(action_name);
iters = _name_to_build_info.equal_range(action);
// Find the Action that matches the one we have registered based on unique_id
unsigned short count = 0;
for (ActionFactory::iterator it = iters.first; it != iters.second; ++it)
{
++count;
if (parameters.have_parameter<unsigned int>("unique_id") && it->second._unique_id == parameters.get<unsigned int>("unique_id"))
{
build_info = &(it->second);
break;
}
}
// For backwards compatibility - If there is only one Action registered but it doesn't contain a unique_id that
// matches, then surely it must still be the correct one
if (count == 1 && !build_info)
build_info = &(iters.first->second);
if (!build_info)
mooseError(std::string("Unable to find buildable Action from supplied InputParameters Object for ") + action_name);
// Add the name to the parameters and create the object
parameters.set<std::string>("_action_name") = action_name;
MooseSharedPointer<Action> action_obj = (*build_info->_build_pointer)(parameters);
if (parameters.get<std::string>("task") == "")
action_obj->appendTask(build_info->_task);
return action_obj;
}
InputParameters
Factory::getValidParams(const std::string & obj_name)
{
std::map<std::string, paramsPtr>::iterator it = _name_to_params_pointer.find(obj_name);
// Check if the object is registered
if (it == _name_to_params_pointer.end())
reportUnregisteredError(obj_name);
// Print out deprecated message, if it exists
deprecatedMessage(obj_name);
// Return the parameters
paramsPtr & func = it->second;
InputParameters params = (*func)();
params.addPrivateParam("_moose_app", &_app);
return params;
}
InputParameters
ActionFactory::getValidParams(const std::string & name)
{
/**
* If an Action is registered more than once, it'll appear in the _name_to_build_info data
* structure multiple times. The actual parameters function remains the same however
* so we can safely use the first instance
*/
ActionFactory::iterator iter = _name_to_build_info.find(name);
if (iter == _name_to_build_info.end())
mooseError(std::string("A '") + name + "' is not a registered Action\n\n");
InputParameters params = (iter->second._params_pointer)();
params.addPrivateParam<unsigned int>("unique_id", iter->second._unique_id);
params.addPrivateParam("_moose_app", &_app);
return params;
}
InputParameters
AdvancedOutput<T>::enableOutputTypes(const std::string & names)
{
// The parameters object that will be returned
InputParameters params = emptyInputParameters();
// Set private parameter indicating that this method was called
params.addPrivateParam("_output_valid_params_was_called", true);
// Get the MultiEnum of output types
MultiMooseEnum output_types = AdvancedOutput<T>::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
AdvancedOutput::addValidParams(params, output_types);
return params;
}
void
CoupledExecutioner::addVariableAction(const std::string & task, ActionWarehouse & src, const std::string & src_var_name, ActionWarehouse & dest, const std::string & dest_var_name)
{
// first, try to find if the destination warehouse already has the variable we are going to add
bool dest_var_exists = false;
for (ActionIterator ai = dest.actionBlocksWithActionBegin(task); ai != dest.actionBlocksWithActionEnd(task); ai++)
{
Action * action = *ai;
if (action->getShortName() == dest_var_name)
{
dest_var_exists = true;
break;
}
}
if (!dest_var_exists)
{
for (ActionIterator ai = src.actionBlocksWithActionBegin(task); ai != src.actionBlocksWithActionEnd(task); ai++)
{
Action * action = *ai;
if (action->getShortName() == src_var_name)
{
// take the action params and change them to create an aux variable
InputParameters src_params = action->parameters();
InputParameters params = _app.getActionFactory().getValidParams("AddAuxVariableAction");
params.addPrivateParam("_moose_app", &_app);
std::string dest_name("AuxVariables/" + dest_var_name);
params.set<Parser *>("parser") = NULL; // set parser to NULL, since this action was not create by a parser
params.set<ActionWarehouse *>("awh") = &dest; // move the action into destination action warehouse
params.set<MooseEnum>("family") = src_params.get<MooseEnum>("family");
params.set<MooseEnum>("order") = src_params.get<MooseEnum>("order");
MooseSharedPointer<Action> dest_action = _app.getActionFactory().create("AddAuxVariableAction", dest_name, params);
mooseAssert (dest_action.get(), std::string("Action AddAuxVariableAction not created"));
dest.addActionBlock(dest_action);
}
}
}
}
