Merge pull request idaholab#3983 from idaholab/integration

Integration

framework/include/actions/ActionFactory.h

@@ -41,7 +41,7 @@ class MooseApp;
 /**
  * Typedef for function to build objects
  */
-typedef Action * (*buildActionPtr)(const std::string & name, InputParameters parameters);
+typedef MooseSharedPointer<Action> (*buildActionPtr)(const std::string & name, InputParameters parameters);
 
 /**
  * Typedef for validParams
@@ -53,9 +53,9 @@ typedef InputParameters (*paramsActionPtr)();
  * Build an object of type T
  */
 template<class T>
-Action * buildAction(const std::string & name, InputParameters parameters)
+MooseSharedPointer<Action> buildAction(const std::string & name, InputParameters parameters)
 {
-  return new T(name, parameters);
+  return MooseSharedPointer<Action>(new T(name, parameters));
 }
 
 /**
@@ -83,7 +83,7 @@ class ActionFactory
 
   std::string getTaskName(const std::string & action);
 
-  Action * create(const std::string & action, const std::string & name, InputParameters params);
+  MooseSharedPointer<Action> create(const std::string & action, const std::string & name, InputParameters params);
 
   InputParameters getValidParams(const std::string & name);
 

framework/include/actions/ActionWarehouse.h

@@ -63,7 +63,7 @@ class ActionWarehouse :
   /**
    * This method add an \p Action instance to the warehouse.
    */
-  void addActionBlock(Action * blk);
+  void addActionBlock(MooseSharedPointer<Action> blk);
 
   /**
    * This method checks the actions stored in the warehouse against the list of required registered
@@ -148,6 +148,8 @@ class ActionWarehouse :
    */
   void buildBuildableActions(const std::string &task);
 
+  std::vector<MooseSharedPointer<Action> > _all_ptrs;
+
   /// The MooseApp this Warehouse is associated with
   MooseApp & _app;
   /// Reference to a "syntax" of actions

framework/include/actions/MaterialOutputAction.h

@@ -87,8 +87,8 @@ class MaterialOutputAction :
    * @param variable_name The AuxVariable name to create
    * @param material A pointer to the Material object containing the property of interest
    */
-  MooseObjectAction * createAction(const std::string & type, const std::string & property_name,
-                                   const std::string & variable_name, Material * material);
+  MooseSharedPointer<MooseObjectAction> createAction(const std::string & type, const std::string & property_name,
+                                                     const std::string & variable_name, Material * material);
 
   /// Pointer the MaterialData object storing the block restricted materials
   MaterialData * _block_material_data;

framework/include/base/AuxiliarySystem.h

@@ -137,7 +137,7 @@ class AuxiliarySystem : public SystemTempl<TransientExplicitSystem>
   /// Serialized version of the solution vector
   NumericVector<Number> & _serialized_solution;
   /// Time integrator
-  TimeIntegrator * _time_integrator;
+  MooseSharedPointer<TimeIntegrator> _time_integrator;
   /// solution vector for u^dot
   NumericVector<Number> & _u_dot;
 

framework/include/constraints/ConstraintWarehouse.h

@@ -37,11 +37,11 @@ class ConstraintWarehouse : public Warehouse<Constraint>
   void residualSetup();
   void jacobianSetup();
 
-  void addNodalConstraint(NodalConstraint * nfc);
+  void addNodalConstraint(MooseSharedPointer<NodalConstraint> nfc);
 
-  void addNodeFaceConstraint(unsigned int slave, unsigned int master, NodeFaceConstraint * nfc);
+  void addNodeFaceConstraint(unsigned int slave, unsigned int master, MooseSharedPointer<NodeFaceConstraint> nfc);
 
-  void addFaceFaceConstraint(const std::string & name, FaceFaceConstraint * ffc);
+  void addFaceFaceConstraint(const std::string & name, MooseSharedPointer<FaceFaceConstraint> ffc);
 
   std::vector<NodalConstraint *> & getNodalConstraints();
 
@@ -53,6 +53,12 @@ class ConstraintWarehouse : public Warehouse<Constraint>
   void subdomainsCovered(std::set<SubdomainID> & subdomains_covered, std::set<std::string> & unique_variables) const;
 
 protected:
+  /**
+   * We are using MooseSharedPointer to handle the cleanup of the pointers at the end of execution.
+   * This is necessary since several warehouses might be sharing a single instance of a MooseObject.
+   */
+  std::vector<MooseSharedPointer<Constraint> > _all_ptrs;
+
   /// nodal constraints on a boundary
   std::vector<NodalConstraint *> _nodal_constraints;
 

framework/src/actions/ActionFactory.C

@@ -25,7 +25,7 @@ ActionFactory::~ActionFactory()
 {
 }
 
-Action *
+MooseSharedPointer<Action>
 ActionFactory::create(const std::string & action, const std::string & name, InputParameters params)
 {
   params.addPrivateParam("_moose_app", &_app);
@@ -57,7 +57,7 @@ ActionFactory::create(const std::string & action, const std::string & name, Inpu
   if (!build_info)
     mooseError(std::string("Unable to find buildable Action from supplied InputParameters Object for ") + name);
 
-  Action * action_obj = (*build_info->_build_pointer)(name, params);
+  MooseSharedPointer<Action> action_obj = (*build_info->_build_pointer)(name, params);
 
 //  if (params.get<std::string>("task") == "")
 //    params.set<std::string>("task") = build_info->_task;

framework/src/actions/ActionWarehouse.C

@@ -53,13 +53,8 @@ ActionWarehouse::build()
 void
 ActionWarehouse::clear()
 {
-  std::set<Action *> unique_action_ptrs;
-  for (std::map<std::string, std::vector<Action *> >::iterator it = _action_blocks.begin(); it != _action_blocks.end(); ++it)
-    for (std::vector<Action *>::iterator jt = (*it).second.begin(); jt != (*it).second.end(); ++jt)
-      unique_action_ptrs.insert(*jt);
-
-  for (std::set<Action *>::iterator it = unique_action_ptrs.begin(); it != unique_action_ptrs.end(); ++it)
-    delete *it;
+  for (std::vector<MooseSharedPointer<Action> >::iterator it = _all_ptrs.begin(); it != _all_ptrs.end(); ++it)
+    it->reset();
 
   _action_blocks.clear();
   _generator_valid = false;
@@ -73,7 +68,7 @@ ActionWarehouse::clear()
 }
 
 void
-ActionWarehouse::addActionBlock(Action * action)
+ActionWarehouse::addActionBlock(MooseSharedPointer<Action> action)
 {
   /**
    * Note: This routine uses the XTerm colors directly which is not advised for general purpose output coloring.
@@ -131,8 +126,8 @@ ActionWarehouse::addActionBlock(Action * action)
 
     // Make sure that the ObjectAction task and Action task are consistent
     // otherwise that means that is action was built by the wrong type
-    MooseObjectAction * moa = dynamic_cast<MooseObjectAction *>(action);
-    if (moa)
+    MooseSharedPointer<MooseObjectAction> moa = MooseSharedNamespace::dynamic_pointer_cast<MooseObjectAction>(action);
+    if (moa.get())
     {
       InputParameters mparams = moa->getObjectParams();
 
@@ -154,7 +149,8 @@ ActionWarehouse::addActionBlock(Action * action)
       Moose::err << COLOR_YELLOW << "Adding Action:         " << COLOR_DEFAULT << action->type() << " (" << COLOR_YELLOW << *it << COLOR_DEFAULT << ")\n";
 
     // Add it to the warehouse
-    _action_blocks[*it].push_back(action);
+    _all_ptrs.push_back(action);
+    _action_blocks[*it].push_back(action.get());
   }
 
   if (_show_parser)

framework/src/actions/CommonOutputAction.C

@@ -151,7 +151,7 @@ CommonOutputAction::create(std::string object_type)
   long_name += object_type;
 
   // Create the action
-  MooseObjectAction * action = static_cast<MooseObjectAction *>(_action_factory.create("AddOutputAction", long_name, _action_params));
+  MooseSharedPointer<MooseObjectAction> action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(_action_factory.create("AddOutputAction", long_name, _action_params));
 
   // Set flag indicating that the object to be created was created with short-cut syntax
   action->getObjectParams().set<bool>("_built_by_moose") = true;

framework/src/actions/MaterialOutputAction.C

@@ -175,13 +175,10 @@ MaterialOutputAction::buildMaterialOutputObjects(FEProblem * problem_ptr)
   }
 }
 
-MooseObjectAction *
+MooseSharedPointer<MooseObjectAction>
 MaterialOutputAction::createAction(const std::string & type, const std::string & property_name,
                                    const std::string & variable_name, Material * material)
 {
-  // Declare the pointer to be returned by this method
-  MooseObjectAction * action;
-
   // Append the list of variables to create
   _variable_names.insert(variable_name);
 
@@ -200,7 +197,7 @@ MaterialOutputAction::createAction(const std::string & type, const std::string &
   action_params.set<std::string>("task") = "add_aux_kernel";
 
   // Create the action
-  action = static_cast<MooseObjectAction *>(_action_factory.create("AddKernelAction", long_name.str(), action_params));
+  MooseSharedPointer<MooseObjectAction> action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(_action_factory.create("AddKernelAction", long_name.str(), action_params));
 
   // Set the object parameters
   InputParameters & object_params = action->getObjectParams();
@@ -221,8 +218,7 @@ template<>
 void
 MaterialOutputAction::materialOutputHelper<Real>(const std::string & property_name, Material * material)
 {
-  MooseObjectAction * action = createAction("MaterialRealAux", property_name, property_name, material);
-  _awh.addActionBlock(action);
+  _awh.addActionBlock(createAction("MaterialRealAux", property_name, property_name, material));
 }
 
 template<>
@@ -234,7 +230,7 @@ MaterialOutputAction::materialOutputHelper<RealVectorValue>(const std::string &
     std::ostringstream oss;
     oss << property_name << "_" << i;
 
-    MooseObjectAction * action = createAction("MaterialRealVectorValueAux", property_name, oss.str(), material);
+    MooseSharedPointer<MooseObjectAction> action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(createAction("MaterialRealVectorValueAux", property_name, oss.str(), material));
     action->getObjectParams().set<unsigned int>("component") = i;
     _awh.addActionBlock(action);
   }
@@ -251,7 +247,7 @@ MaterialOutputAction::materialOutputHelper<RealTensorValue>(const std::string &
       std::ostringstream oss;
       oss << property_name << "_" << i << j;
 
-      MooseObjectAction * action = createAction("MaterialRealTensorValueAux", property_name, oss.str(), material);
+      MooseSharedPointer<MooseObjectAction> action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(createAction("MaterialRealTensorValueAux", property_name, oss.str(), material));
       action->getObjectParams().set<unsigned int>("row") = i;
       action->getObjectParams().set<unsigned int>("column") = j;
       _awh.addActionBlock(action);

framework/src/actions/SetupDebugAction.C

@@ -77,7 +77,7 @@ SetupDebugAction::createOutputAction(const std::string & type, const std::string
   // Create the action
   std::string long_name = "Outputs/";
   long_name += name;
-  MooseObjectAction * action = static_cast<MooseObjectAction *>(_action_factory.create("AddOutputAction", long_name, _action_params));
+  MooseSharedPointer<MooseObjectAction> action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(_action_factory.create("AddOutputAction", long_name, _action_params));
 
   // Set the object parameters
   InputParameters & object_params = action->getObjectParams();
@@ -87,5 +87,5 @@ SetupDebugAction::createOutputAction(const std::string & type, const std::string
   _awh.addActionBlock(action);
 
   // Return the pointer to the action
-  return dynamic_cast<MooseObjectAction *>(action);
+  return action.get();
 }

framework/src/base/AuxiliarySystem.C

@@ -35,7 +35,6 @@ AuxiliarySystem::AuxiliarySystem(FEProblem & subproblem, const std::string & nam
     SystemTempl<TransientExplicitSystem>(subproblem, name, Moose::VAR_AUXILIARY),
     _mproblem(subproblem),
     _serialized_solution(*NumericVector<Number>::build(_mproblem.comm()).release()),
-    _time_integrator(NULL),
     _u_dot(addVector("u_dot", true, GHOSTED)),
     _need_serialized_solution(false)
 {
@@ -46,7 +45,6 @@ AuxiliarySystem::AuxiliarySystem(FEProblem & subproblem, const std::string & nam
 AuxiliarySystem::~AuxiliarySystem()
 {
   delete &_serialized_solution;
-  delete _time_integrator;
 }
 
 void
@@ -119,8 +117,7 @@ void
 AuxiliarySystem::addTimeIntegrator(const std::string & type, const std::string & name, InputParameters parameters)
 {
   parameters.set<SystemBase *>("_sys") = this;
-  TimeIntegrator * ti = static_cast<TimeIntegrator *>(_factory.create(type, name, parameters));
-  _time_integrator = ti;
+  _time_integrator = MooseSharedNamespace::static_pointer_cast<TimeIntegrator>(_factory.create_shared_ptr(type, name, parameters));
 }
 
 void

framework/src/base/NonlinearSystem.C

@@ -562,25 +562,25 @@ NonlinearSystem::addConstraint(const std::string & c_name, const std::string & n
 {
   parameters.set<THREAD_ID>("_tid") = 0;
 
-  MooseObject * obj = _factory.create(c_name, name, parameters);
-  _fe_problem._objects_by_name[0][name].push_back(obj);
+  MooseSharedPointer<Constraint> constraint = MooseSharedNamespace::static_pointer_cast<Constraint>(_factory.create_shared_ptr(c_name, name, parameters));
+  _fe_problem._objects_by_name[0][name].push_back(constraint.get());
   for (THREAD_ID tid = 1; tid < libMesh::n_threads(); tid++)
     _fe_problem._objects_by_name[tid][name] = std::vector<MooseObject *>();
 
-  NodalConstraint    * nc = dynamic_cast<NodalConstraint *>(obj);
-  NodeFaceConstraint * nfc = dynamic_cast<NodeFaceConstraint *>(obj);
-  FaceFaceConstraint * ffc = dynamic_cast<FaceFaceConstraint *>(obj);
-  if (nfc != NULL)
+  MooseSharedPointer<NodalConstraint>    nc =  MooseSharedNamespace::dynamic_pointer_cast<NodalConstraint>(constraint);
+  MooseSharedPointer<NodeFaceConstraint> nfc = MooseSharedNamespace::dynamic_pointer_cast<NodeFaceConstraint>(constraint);
+  MooseSharedPointer<FaceFaceConstraint> ffc = MooseSharedNamespace::dynamic_pointer_cast<FaceFaceConstraint>(constraint);
+  if (nfc.get())
   {
     unsigned int slave = _mesh.getBoundaryID(parameters.get<BoundaryName>("slave"));
     unsigned int master = _mesh.getBoundaryID(parameters.get<BoundaryName>("master"));
     _constraints[0].addNodeFaceConstraint(slave, master, nfc);
   }
-  else if (ffc != NULL)
+  else if (ffc.get())
   {
     _constraints[0].addFaceFaceConstraint(parameters.get<std::string>("interface"), ffc);
   }
-  else if (nc != NULL)
+  else if (nc.get())
   {
     _constraints[0].addNodalConstraint(nc);
   }

framework/src/constraints/ConstraintWarehouse.C

@@ -24,20 +24,6 @@ ConstraintWarehouse::ConstraintWarehouse() :
 
 ConstraintWarehouse::~ConstraintWarehouse()
 {
-  for (std::map<BoundaryID, std::vector<NodeFaceConstraint *> >::iterator i = _node_face_constraints.begin(); i != _node_face_constraints.end(); ++i)
-    for (std::vector<NodeFaceConstraint *>::iterator k=(i->second).begin(); k!=(i->second).end(); ++k)
-      delete *k;
-
-  for (std::map<BoundaryID, std::vector<NodeFaceConstraint *> >::iterator i = _displaced_node_face_constraints.begin(); i != _displaced_node_face_constraints.end(); ++i)
-    for (std::vector<NodeFaceConstraint *>::iterator k=(i->second).begin(); k!=(i->second).end(); ++k)
-      delete *k;
-
-  for (std::map<std::string, std::vector<FaceFaceConstraint *> >::iterator i = _face_face_constraints.begin(); i != _face_face_constraints.end(); ++i)
-    for (std::vector<FaceFaceConstraint *>::iterator k=(i->second).begin(); k!=(i->second).end(); ++k)
-      delete *k;
-
-  for (std::vector<NodalConstraint *>::iterator i = _nodal_constraints.begin(); i != _nodal_constraints.end(); ++i)
-    delete *i;
 }
 
 void
@@ -117,26 +103,30 @@ ConstraintWarehouse::jacobianSetup()
 }
 
 void
-ConstraintWarehouse::addNodalConstraint(NodalConstraint * nc)
+ConstraintWarehouse::addNodalConstraint(MooseSharedPointer<NodalConstraint> nc)
 {
-  _nodal_constraints.push_back(nc);
+  _all_ptrs.push_back(nc);
+  _nodal_constraints.push_back(nc.get());
 }
 
 void
-ConstraintWarehouse::addNodeFaceConstraint(unsigned int slave, unsigned int /*master*/, NodeFaceConstraint *nfc)
+ConstraintWarehouse::addNodeFaceConstraint(unsigned int slave, unsigned int /*master*/, MooseSharedPointer<NodeFaceConstraint> nfc)
 {
+  _all_ptrs.push_back(nfc);
+
   bool displaced = nfc->parameters().have_parameter<bool>("use_displaced_mesh") && nfc->getParam<bool>("use_displaced_mesh");
 
   if (displaced)
-    _displaced_node_face_constraints[slave].push_back(nfc);
+    _displaced_node_face_constraints[slave].push_back(nfc.get());
   else
-    _node_face_constraints[slave].push_back(nfc);
+    _node_face_constraints[slave].push_back(nfc.get());
 }
 
 void
-ConstraintWarehouse::addFaceFaceConstraint(const std::string & name, FaceFaceConstraint * ffc)
+ConstraintWarehouse::addFaceFaceConstraint(const std::string & name, MooseSharedPointer<FaceFaceConstraint> ffc)
 {
-  _face_face_constraints[name].push_back(ffc);
+  _all_ptrs.push_back(ffc);
+  _face_face_constraints[name].push_back(ffc.get());
 }
 
 std::vector<NodalConstraint *> &

framework/src/executioners/CoupledExecutioner.C

@@ -122,8 +122,8 @@ CoupledExecutioner::addVariableAction(const std::string & task, ActionWarehouse
         params.set<MooseEnum>("family") = src_params.get<MooseEnum>("family");
         params.set<MooseEnum>("order") = src_params.get<MooseEnum>("order");
 
-        Action * dest_action = _app.getActionFactory().create("AddAuxVariableAction", dest_name, params);
-        mooseAssert (dest_action != NULL, std::string("Action AddAuxVariableAction not created"));
+        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);
       }
     }

framework/src/parser/Parser.C

@@ -203,12 +203,11 @@ Parser::parse(const std::string &input_filename)
           params.set<std::string>("registered_identifier") = registered_identifier;
 
           // Create the Action
-          Action * action_obj = _action_factory.create(it->second._action, curr_identifier, params);
-          mooseAssert (action_obj != NULL, std::string("Action") + it->second._action + " not created");
+          MooseSharedPointer<Action> action_obj = _action_factory.create(it->second._action, curr_identifier, params);
 
           // extract the MooseObject params if necessary
-          MooseObjectAction * object_action = dynamic_cast<MooseObjectAction *>(action_obj);
-          if (object_action)
+          MooseSharedPointer<MooseObjectAction> object_action = MooseSharedNamespace::dynamic_pointer_cast<MooseObjectAction>(action_obj);
+          if (object_action.get())
             extractParams(curr_identifier, object_action->getObjectParams());
 
           // add it to the warehouse

test/src/actions/ApplyCoupledVariablesTestAction.C

@@ -44,7 +44,7 @@ ApplyCoupledVariablesTestAction::act()
 
   // Create the action
   std::string long_name = "Kernels/_coef_diffusion";
-  MooseObjectAction * action = static_cast<MooseObjectAction *>(_action_factory.create("AddKernelAction", long_name, action_params));
+  MooseSharedPointer<MooseObjectAction> action = MooseSharedNamespace::static_pointer_cast<MooseObjectAction>(_action_factory.create("AddKernelAction", long_name, action_params));
 
   // Apply the parameters from the this action to the object being created
   action->getObjectParams().applyParameters(_pars);