give threaded general user objects their own subclass

Since a threaded (vs not) object requires very specific code handling,
we do not generally want the ability for objects to be dynamically
toggled between threaded vs not handling - this could easily result in
unintentional, subtle errors.  Also, the new general warehouse handling
of user objects will be much better served by this as an explicit
separate class.

ref idaholab#11834

framework/include/userobject/GeneralUserObject.h

@@ -77,4 +77,14 @@ class GeneralUserObject : public UserObject,
   std::set<std::string> _supplied_vars;
 };
 
+/// An instance of this object type has one copy per thread that runs on each thread.
+class ThreadedGeneralUserObject : public GeneralUserObject
+{
+public:
+  ThreadedGeneralUserObject(const InputParameters & parameters) : GeneralUserObject(parameters) {}
+  virtual ~ThreadedGeneralUserObject() = default;
+  virtual void threadJoin(const UserObject &) override;
+  virtual void subdomainSetup() override{};
+};
+
 #endif

framework/src/problems/FEProblemBase.C

@@ -2632,6 +2632,8 @@ FEProblemBase::addUserObject(std::string user_object_name,
     std::shared_ptr<NodalUserObject> nuo = std::dynamic_pointer_cast<NodalUserObject>(user_object);
     std::shared_ptr<GeneralUserObject> guo =
         std::dynamic_pointer_cast<GeneralUserObject>(user_object);
+    std::shared_ptr<GeneralUserObject> tguo =
+        std::dynamic_pointer_cast<ThreadedGeneralUserObject>(user_object);
 
     // Account for displaced mesh use
     if (_displaced_problem != NULL && parameters.get<bool>("use_displaced_mesh"))
@@ -2643,15 +2645,12 @@ FEProblemBase::addUserObject(std::string user_object_name,
     }
 
     // Add the object to the correct warehouse
-    if (guo)
+    if (tguo)
+      _threaded_general_user_objects.addObject(guo, tid);
+    else if (guo)
     {
-      if (guo->getParam<bool>("threaded"))
-        _threaded_general_user_objects.addObject(guo, tid);
-      else
-      {
-        _general_user_objects.addObject(guo);
-        break;
-      }
+      _general_user_objects.addObject(guo);
+      break;
     }
     else if (nuo)
       _nodal_user_objects.addObject(nuo, tid);

framework/src/userobject/GeneralUserObject.C

@@ -15,8 +15,6 @@ validParams<GeneralUserObject>()
 {
   InputParameters params = validParams<UserObject>();
   params += validParams<MaterialPropertyInterface>();
-  params.addParam<bool>(
-      "threaded", false, "true if there should be threaded copies of this user object.");
   params.addParam<bool>(
       "force_preaux", false, "Forces the GeneralUserObject to be executed in PREAUX");
   params.addParamNamesToGroup("force_preaux", "Advanced");
@@ -116,3 +114,9 @@ GeneralUserObject::subdomainSetup()
   mooseError("GeneralUserObjects do not execute subdomainSetup method, this function does nothing "
              "and should not be used.");
 }
+
+void
+ThreadedGeneralUserObject::threadJoin(const UserObject &)
+{
+  mooseError("ThreadedGeneralUserObject failed to override threadJoin");
+}

modules/fluid_properties/include/userobjects/FluidProperties.h

@@ -18,7 +18,7 @@ class FluidProperties;
 template <>
 InputParameters validParams<FluidProperties>();
 
-class FluidProperties : public GeneralUserObject
+class FluidProperties : public ThreadedGeneralUserObject
 {
 public:
   FluidProperties(const InputParameters & parameters);

modules/fluid_properties/src/userobjects/FluidProperties.C

@@ -15,11 +15,11 @@ validParams<FluidProperties>()
 {
   InputParameters params = validParams<GeneralUserObject>();
   params.registerBase("FluidProperties");
-  params.set<bool>("threaded") = true;
   return params;
 }
 
-FluidProperties::FluidProperties(const InputParameters & parameters) : GeneralUserObject(parameters)
+FluidProperties::FluidProperties(const InputParameters & parameters)
+  : ThreadedGeneralUserObject(parameters)
 {
 }
 

test/include/userobjects/PrimeProductUserObject.h

@@ -22,7 +22,7 @@ InputParameters validParams<PrimeProductUserObject>();
  * its thread ID. Then when threads join the product of all prime numbers is computed, which is the
  * final value provided by this user object.
  */
-class PrimeProductUserObject : public GeneralUserObject
+class PrimeProductUserObject : public ThreadedGeneralUserObject
 {
 public:
   PrimeProductUserObject(const InputParameters & params);

test/src/userobjects/PrimeProductUserObject.C

@@ -21,7 +21,7 @@ validParams<PrimeProductUserObject>()
 }
 
 PrimeProductUserObject::PrimeProductUserObject(const InputParameters & params)
-  : GeneralUserObject(params)
+  : ThreadedGeneralUserObject(params)
 {
   if (libMesh::n_threads() > 20)
     mooseError("This object works only with up to 20 threads. If you need more, add more prime "

test/tests/userobjects/threaded_general_user_object/test.i

@@ -32,7 +32,6 @@
 [UserObjects]
   [./prime_product]
     type = PrimeProductUserObject
-    threaded = true
     execute_on = timestep_end
   [../]
 []