[PL] num_components moved to other class

ProcessLib/CachedSecondaryVariable.cpp

@@ -36,10 +36,10 @@ SecondaryVariableFunctions CachedSecondaryVariable::getExtrapolator()
         NumLib::LocalToGlobalIndexMap const& dof_table,
         std::unique_ptr<GlobalVector> & /*result_cache*/
         ) -> GlobalVector const& {
-        _extrapolator.calculateResiduals(*_extrapolatables, x, dof_table);
+        _extrapolator.calculateResiduals(1, *_extrapolatables, x, dof_table);
         return _extrapolator.getElementResiduals();
     };
-    return {BaseLib::easyBind(&CachedSecondaryVariable::evalField, this),
+    return {1, BaseLib::easyBind(&CachedSecondaryVariable::evalField, this),
             eval_residuals};
 }
 
@@ -63,7 +63,7 @@ GlobalVector const& CachedSecondaryVariable::evalFieldNoArgs() const
     }
     DBUG("Recomputing %s.", _internal_variable_name.c_str());
     _extrapolator.extrapolate(
-        *_extrapolatables, *_current_solution, *_dof_table);
+        1, *_extrapolatables, *_current_solution, *_dof_table);
     auto const& nodal_values = _extrapolator.getNodalValues();
     MathLib::LinAlg::copy(nodal_values, _cached_nodal_values);
     _needs_recomputation = false;

ProcessLib/Process.cpp

@@ -217,16 +217,14 @@ void Process::finishNamedFunctionsInitialization()
     for (auto const& named_function :
          _named_function_caller.getNamedFunctions()) {
         auto const& name = named_function.getName();
-        // secondary variables generated from named functions have the prefix
-        // "fct_".
         _secondary_variables.addSecondaryVariable(
-            "fct_" + name, 1,
-            {BaseLib::easyBind(
-                 &GlobalVectorFromNamedFunction::call,
-                 GlobalVectorFromNamedFunction(
-                     _named_function_caller.getSpecificFunctionCaller(name), _mesh,
-                     getSingleComponentDOFTable(),
-                     _secondary_variable_context)),
+            name,
+            {1, BaseLib::easyBind(
+                    &GlobalVectorFromNamedFunction::call,
+                    GlobalVectorFromNamedFunction(
+                        _named_function_caller.getSpecificFunctionCaller(name),
+                        _mesh, getSingleComponentDOFTable(),
+                        _secondary_variable_context)),
              nullptr});
     }
 }

ProcessLib/ProcessOutput.cpp

@@ -120,9 +120,8 @@ void doProcessOutput(std::string const& file_name,
     // the following section is for the output of secondary variables
 
     auto add_secondary_var = [&](SecondaryVariable const& var,
-                             std::string const& output_name)
-    {
-        assert(var.n_components == 1); // TODO implement other cases
+                                 std::string const& output_name) {
+        assert(var.fcts.num_components == 1);  // TODO implement other cases
 
         {
             DBUG("  secondary variable %s", output_name.c_str());
@@ -135,7 +134,8 @@ void doProcessOutput(std::string const& file_name,
                     var.fcts.eval_field(x, dof_table, result_cache);
 
             // Copy result
-            for (GlobalIndexType i = 0; i < nodal_values.size(); ++i) {
+            for (GlobalIndexType i = 0; i < nodal_values.size(); ++i)
+            {
                 assert(!std::isnan(nodal_values[i]));
                 (*result)[i] = nodal_values[i];
             }

ProcessLib/SecondaryVariable.cpp

@@ -25,16 +25,15 @@ void SecondaryVariableCollection::addNameMapping(std::string const& internal_nam
 }
 
 void SecondaryVariableCollection::addSecondaryVariable(
-    std::string const& internal_name,
-    const unsigned num_components,
-    SecondaryVariableFunctions&& fcts)
+    std::string const& internal_name, SecondaryVariableFunctions&& fcts)
 {
     if (!_configured_secondary_variables
              .emplace(std::make_pair(
                  internal_name,
                  SecondaryVariable{internal_name /* TODO change */,
-                                   num_components, std::move(fcts)}))
-             .second) {
+                                   std::move(fcts)}))
+             .second)
+    {
         OGS_FATAL(
             "The secondary variable with internal name `%s' has already been "
             "set up.",

ProcessLib/SecondaryVariable.h

@@ -43,10 +43,12 @@ struct SecondaryVariableFunctions final
 
     SecondaryVariableFunctions() = default;
 
-    template<typename F1, typename F2>
-    SecondaryVariableFunctions(F1&& eval_field_, F2&& eval_residuals_)
-        : eval_field(std::forward<F1>(eval_field_))
-        , eval_residuals(std::forward<F2>(eval_residuals_))
+    template <typename F1, typename F2>
+    SecondaryVariableFunctions(const unsigned num_components_, F1&& eval_field_,
+                               F2&& eval_residuals_)
+        : num_components(num_components_),
+          eval_field(std::forward<F1>(eval_field_)),
+          eval_residuals(std::forward<F2>(eval_residuals_))
     {
         // Used to detect nasty implicit conversions.
         static_assert(std::is_same<GlobalVector const&,
@@ -66,9 +68,11 @@ struct SecondaryVariableFunctions final
             " to a GlobalVector");
     }
 
-    template<typename F1>
-    SecondaryVariableFunctions(F1&& eval_field_, std::nullptr_t)
-        : eval_field(std::forward<F1>(eval_field_))
+    template <typename F1>
+    SecondaryVariableFunctions(const unsigned num_components_, F1&& eval_field_,
+                               std::nullptr_t)
+        : num_components(num_components_),
+          eval_field(std::forward<F1>(eval_field_))
     {
         // Used to detect nasty implicit conversions.
         static_assert(std::is_same<GlobalVector const&,
@@ -80,15 +84,15 @@ struct SecondaryVariableFunctions final
             " to a GlobalVector");
     }
 
-    Function eval_field;
-    Function eval_residuals;
+    const unsigned num_components;  //!< Number of components of the variable.
+    Function const eval_field;
+    Function const eval_residuals;
 };
 
 //! Stores information about a specific secondary variable
 struct SecondaryVariable final
 {
     std::string const name;      //!< Name of the variable; used, e.g., for output.
-    const unsigned n_components; //!< Number of components of the variable.
 
     //! Functions used for computing the secondary variable.
     SecondaryVariableFunctions fcts;
@@ -106,7 +110,6 @@ public:
      *
      * \param internal_name the tag in the project file associated with this
      * secondary variable.
-     * \param num_components the variable's number of components.
      * \param fcts functions that compute the variable.
      *
      * \note
@@ -115,7 +118,6 @@ public:
      * All other variables are silently ignored.
      */
     void addSecondaryVariable(std::string const& internal_name,
-                              const unsigned num_components,
                               SecondaryVariableFunctions&& fcts);
 
     //! Returns the secondary variable with the given external name.
@@ -147,13 +149,14 @@ private:
  */
 template <typename LocalAssemblerCollection>
 SecondaryVariableFunctions makeExtrapolator(
+    const unsigned num_components,
     NumLib::Extrapolator& extrapolator,
     LocalAssemblerCollection const& local_assemblers,
     typename NumLib::ExtrapolatableLocalAssemblerCollection<
         LocalAssemblerCollection>::IntegrationPointValuesMethod
         integration_point_values_method)
 {
-    auto const eval_field = [&extrapolator, &local_assemblers,
+    auto const eval_field = [num_components, &extrapolator, &local_assemblers,
                              integration_point_values_method](
         GlobalVector const& x,
         NumLib::LocalToGlobalIndexMap const& dof_table,
@@ -161,11 +164,12 @@ SecondaryVariableFunctions makeExtrapolator(
         ) -> GlobalVector const& {
         auto const extrapolatables = NumLib::makeExtrapolatable(
             local_assemblers, integration_point_values_method);
-        extrapolator.extrapolate(extrapolatables, x, dof_table);
+        extrapolator.extrapolate(num_components, extrapolatables, x, dof_table);
         return extrapolator.getNodalValues();
     };
 
-    auto const eval_residuals = [&extrapolator, &local_assemblers,
+    auto const eval_residuals = [num_components, &extrapolator,
+                                 &local_assemblers,
                                  integration_point_values_method](
         GlobalVector const& x,
         NumLib::LocalToGlobalIndexMap const& dof_table,
@@ -173,10 +177,11 @@ SecondaryVariableFunctions makeExtrapolator(
         ) -> GlobalVector const& {
         auto const extrapolatables = NumLib::makeExtrapolatable(
             local_assemblers, integration_point_values_method);
-        extrapolator.calculateResiduals(extrapolatables, x, dof_table);
+        extrapolator.calculateResiduals(num_components, extrapolatables, x,
+                                        dof_table);
         return extrapolator.getElementResiduals();
     };
-    return {eval_field, eval_residuals};
+    return {num_components, eval_field, eval_residuals};
 }
 
 }  // namespace ProcessLib