diff --git a/ProcessLib/ComponentTransport/ComponentTransportProcess.cpp b/ProcessLib/ComponentTransport/ComponentTransportProcess.cpp
index fe54ae8b9c3508ec7d76f5c2c5d217937aac87f9..238e76fef24b6371846024fe84914dd0eda2a3a6 100644
--- a/ProcessLib/ComponentTransport/ComponentTransportProcess.cpp
+++ b/ProcessLib/ComponentTransport/ComponentTransportProcess.cpp
@@ -20,6 +20,7 @@ namespace ProcessLib
 namespace ComponentTransport
 {
 ComponentTransportProcess::ComponentTransportProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -32,7 +33,7 @@ ComponentTransportProcess::ComponentTransportProcess(
     bool const use_monolithic_scheme,
     std::unique_ptr<ProcessLib::SurfaceFluxData>&& surfaceflux,
     std::vector<std::pair<int, std::string>>&& process_id_to_component_name_map)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               use_monolithic_scheme),
diff --git a/ProcessLib/ComponentTransport/ComponentTransportProcess.h b/ProcessLib/ComponentTransport/ComponentTransportProcess.h
index 1166ff5334b84f2379738895c3377802f556e506..d65e9b7c90a64257719e5e3cc0716a5898351d30 100644
--- a/ProcessLib/ComponentTransport/ComponentTransportProcess.h
+++ b/ProcessLib/ComponentTransport/ComponentTransportProcess.h
@@ -89,6 +89,7 @@ class ComponentTransportProcess final : public Process
 {
 public:
     ComponentTransportProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/ComponentTransport/CreateComponentTransportProcess.cpp b/ProcessLib/ComponentTransport/CreateComponentTransportProcess.cpp
index 576a0cc5642f2717bc5413d770d05b6b18ecacdf..28b84824a1996f48da4cd48e2099782be333cbb6 100644
--- a/ProcessLib/ComponentTransport/CreateComponentTransportProcess.cpp
+++ b/ProcessLib/ComponentTransport/CreateComponentTransportProcess.cpp
@@ -26,6 +26,7 @@ namespace ProcessLib
 namespace ComponentTransport
 {
 std::unique_ptr<Process> createComponentTransportProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -196,11 +197,11 @@ std::unique_ptr<Process> createComponentTransportProcess(
     }
 
     return std::make_unique<ComponentTransportProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        use_monolithic_scheme, std::move(surfaceflux),
-        std::move(process_id_to_component_name_map));
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), use_monolithic_scheme,
+        std::move(surfaceflux), std::move(process_id_to_component_name_map));
 }
 
 }  // namespace ComponentTransport
diff --git a/ProcessLib/ComponentTransport/CreateComponentTransportProcess.h b/ProcessLib/ComponentTransport/CreateComponentTransportProcess.h
index 7f85498bdfbeb831716efa37b37107b045a58f2e..af270e61903ee19c1163b03d39871f500fe61580 100644
--- a/ProcessLib/ComponentTransport/CreateComponentTransportProcess.h
+++ b/ProcessLib/ComponentTransport/CreateComponentTransportProcess.h
@@ -22,6 +22,7 @@ namespace ProcessLib
 namespace ComponentTransport
 {
 std::unique_ptr<Process> createComponentTransportProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/GroundwaterFlow/CreateGroundwaterFlowProcess.cpp b/ProcessLib/GroundwaterFlow/CreateGroundwaterFlowProcess.cpp
index 816bd67db4c4524a32532bdc60dd8d2a9a3ea7a7..9e508590709e6cb80148e86c9c9cf12e35f2f099 100644
--- a/ProcessLib/GroundwaterFlow/CreateGroundwaterFlowProcess.cpp
+++ b/ProcessLib/GroundwaterFlow/CreateGroundwaterFlowProcess.cpp
@@ -22,6 +22,7 @@ namespace ProcessLib
 namespace GroundwaterFlow
 {
 std::unique_ptr<Process> createGroundwaterFlowProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -79,10 +80,10 @@ std::unique_ptr<Process> createGroundwaterFlowProcess(
     }
 
     return std::make_unique<GroundwaterFlowProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        std::move(surfaceflux));
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), std::move(surfaceflux));
 }
 
 }  // namespace GroundwaterFlow
diff --git a/ProcessLib/GroundwaterFlow/CreateGroundwaterFlowProcess.h b/ProcessLib/GroundwaterFlow/CreateGroundwaterFlowProcess.h
index 009fc80362712b4cefdc04b6ddc2bae59145d5ed..94bf1ce7b1dcb948440af3673bc8b3774a6d642b 100644
--- a/ProcessLib/GroundwaterFlow/CreateGroundwaterFlowProcess.h
+++ b/ProcessLib/GroundwaterFlow/CreateGroundwaterFlowProcess.h
@@ -18,6 +18,7 @@ namespace ProcessLib
 namespace GroundwaterFlow
 {
 std::unique_ptr<Process> createGroundwaterFlowProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/GroundwaterFlow/GroundwaterFlowProcess.cpp b/ProcessLib/GroundwaterFlow/GroundwaterFlowProcess.cpp
index e25befb3081b458a75f959d0bb23250ca32472c3..a4609498f41df31298a78ab3b05343635edf87aa 100644
--- a/ProcessLib/GroundwaterFlow/GroundwaterFlowProcess.cpp
+++ b/ProcessLib/GroundwaterFlow/GroundwaterFlowProcess.cpp
@@ -18,6 +18,7 @@ namespace ProcessLib
 namespace GroundwaterFlow
 {
 GroundwaterFlowProcess::GroundwaterFlowProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -28,7 +29,7 @@ GroundwaterFlowProcess::GroundwaterFlowProcess(
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
     std::unique_ptr<ProcessLib::SurfaceFluxData>&& surfaceflux)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data)),
diff --git a/ProcessLib/GroundwaterFlow/GroundwaterFlowProcess.h b/ProcessLib/GroundwaterFlow/GroundwaterFlowProcess.h
index c25f2dba7c6a0368d28cfb258fa44ef1a329447b..9fd04fd81f8cf598aa73d39ad2598dc4958687bd 100644
--- a/ProcessLib/GroundwaterFlow/GroundwaterFlowProcess.h
+++ b/ProcessLib/GroundwaterFlow/GroundwaterFlowProcess.h
@@ -26,6 +26,7 @@ class GroundwaterFlowProcess final : public Process
 {
 public:
     GroundwaterFlowProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/HT/CreateHTProcess.cpp b/ProcessLib/HT/CreateHTProcess.cpp
index 78b8117c712fb80299fe7f7ae6a76ff7889369a4..0eb565cd3bb62a0f0b8328ea79f697adc5b64dd7 100644
--- a/ProcessLib/HT/CreateHTProcess.cpp
+++ b/ProcessLib/HT/CreateHTProcess.cpp
@@ -26,6 +26,7 @@ namespace ProcessLib
 namespace HT
 {
 std::unique_ptr<Process> createHTProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -156,11 +157,12 @@ std::unique_ptr<Process> createHTProcess(
                                          named_function_caller);
 
     return std::make_unique<HTProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(material_properties),
-        std::move(secondary_variables), std::move(named_function_caller),
-        use_monolithic_scheme, std::move(surfaceflux),
-        _heat_transport_process_id, _hydraulic_process_id);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(material_properties), std::move(secondary_variables),
+        std::move(named_function_caller), use_monolithic_scheme,
+        std::move(surfaceflux), _heat_transport_process_id,
+        _hydraulic_process_id);
 }
 
 }  // namespace HT
diff --git a/ProcessLib/HT/CreateHTProcess.h b/ProcessLib/HT/CreateHTProcess.h
index 4ac2b63871cef949ab5eb99f7421e13081b8e275..de78735ab32a7773e8de95dfb3ae24e1a8529ce0 100644
--- a/ProcessLib/HT/CreateHTProcess.h
+++ b/ProcessLib/HT/CreateHTProcess.h
@@ -23,6 +23,7 @@ namespace ProcessLib
 namespace HT
 {
 std::unique_ptr<Process> createHTProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/HT/HTProcess.cpp b/ProcessLib/HT/HTProcess.cpp
index 300725dd1fc51499c54dd52ec1ecc7a5ef6bef3a..9616152224c53d659f96b12d36ab0f4c62a76d03 100644
--- a/ProcessLib/HT/HTProcess.cpp
+++ b/ProcessLib/HT/HTProcess.cpp
@@ -25,6 +25,7 @@ namespace ProcessLib
 namespace HT
 {
 HTProcess::HTProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -38,7 +39,7 @@ HTProcess::HTProcess(
     std::unique_ptr<ProcessLib::SurfaceFluxData>&& surfaceflux,
     const int heat_transport_process_id,
     const int hydraulic_process_id)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               use_monolithic_scheme),
diff --git a/ProcessLib/HT/HTProcess.h b/ProcessLib/HT/HTProcess.h
index d5f03eb344ea6bc2d06e0af9ecc5ea0fd394f537..1d59a7bc4ed9eaaa3887f922c1105d020ad34574 100644
--- a/ProcessLib/HT/HTProcess.h
+++ b/ProcessLib/HT/HTProcess.h
@@ -50,6 +50,7 @@ class HTProcess final : public Process
 {
 public:
     HTProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/HeatConduction/CreateHeatConductionProcess.cpp b/ProcessLib/HeatConduction/CreateHeatConductionProcess.cpp
index 94c7520a31d6d2ad55beb1fad4df71111e0aeee7..9be788ad2facb385068ee8052fd6e51ee318226f 100644
--- a/ProcessLib/HeatConduction/CreateHeatConductionProcess.cpp
+++ b/ProcessLib/HeatConduction/CreateHeatConductionProcess.cpp
@@ -20,6 +20,7 @@ namespace ProcessLib
 namespace HeatConduction
 {
 std::unique_ptr<Process> createHeatConductionProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -82,9 +83,10 @@ std::unique_ptr<Process> createHeatConductionProcess(
                                          named_function_caller);
 
     return std::make_unique<HeatConductionProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller));
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller));
 }
 
 }  // namespace HeatConduction
diff --git a/ProcessLib/HeatConduction/CreateHeatConductionProcess.h b/ProcessLib/HeatConduction/CreateHeatConductionProcess.h
index 5c9481568bccc305fb9925ad28b8c5bbe13ef1fd..bcfaf823516658d8f69a2eb268a7fccf5b138b66 100644
--- a/ProcessLib/HeatConduction/CreateHeatConductionProcess.h
+++ b/ProcessLib/HeatConduction/CreateHeatConductionProcess.h
@@ -17,6 +17,7 @@ namespace ProcessLib
 namespace HeatConduction
 {
 std::unique_ptr<Process> createHeatConductionProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/HeatConduction/HeatConductionProcess.cpp b/ProcessLib/HeatConduction/HeatConductionProcess.cpp
index 2e0f2c37fb1a577798bd99906b888b61c732c099..d77a6e178d6d8f9efbee544e073aad2a9805860b 100644
--- a/ProcessLib/HeatConduction/HeatConductionProcess.cpp
+++ b/ProcessLib/HeatConduction/HeatConductionProcess.cpp
@@ -18,6 +18,7 @@ namespace ProcessLib
 namespace HeatConduction
 {
 HeatConductionProcess::HeatConductionProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -27,7 +28,7 @@ HeatConductionProcess::HeatConductionProcess(
     HeatConductionProcessData&& process_data,
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data))
diff --git a/ProcessLib/HeatConduction/HeatConductionProcess.h b/ProcessLib/HeatConduction/HeatConductionProcess.h
index b073add6204e33101738604c785a43534c5972fe..17868151b941b841c28ef739206eab2260115e85 100644
--- a/ProcessLib/HeatConduction/HeatConductionProcess.h
+++ b/ProcessLib/HeatConduction/HeatConductionProcess.h
@@ -22,6 +22,7 @@ class HeatConductionProcess final : public Process
 
 public:
     HeatConductionProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/HeatTransportBHE/CreateHeatTransportBHEProcess.cpp b/ProcessLib/HeatTransportBHE/CreateHeatTransportBHEProcess.cpp
index fddb992557bd38691323b2065adb0d33316445a9..ea51b6a168c5c658b411e5e7c46861f45c4c3899 100644
--- a/ProcessLib/HeatTransportBHE/CreateHeatTransportBHEProcess.cpp
+++ b/ProcessLib/HeatTransportBHE/CreateHeatTransportBHEProcess.cpp
@@ -25,6 +25,7 @@ namespace ProcessLib
 namespace HeatTransportBHE
 {
 std::unique_ptr<Process> createHeatTransportBHEProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -225,9 +226,10 @@ std::unique_ptr<Process> createHeatTransportBHEProcess(
                                          named_function_caller);
 
     return std::make_unique<HeatTransportBHEProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller));
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller));
 }
 }  // namespace HeatTransportBHE
 }  // namespace ProcessLib
diff --git a/ProcessLib/HeatTransportBHE/CreateHeatTransportBHEProcess.h b/ProcessLib/HeatTransportBHE/CreateHeatTransportBHEProcess.h
index 12571971481e63e15c907e233267eee599661885..fe0f26efbc4d1cb95e233c1a26c9827cc2e258b7 100644
--- a/ProcessLib/HeatTransportBHE/CreateHeatTransportBHEProcess.h
+++ b/ProcessLib/HeatTransportBHE/CreateHeatTransportBHEProcess.h
@@ -17,6 +17,7 @@ namespace ProcessLib
 namespace HeatTransportBHE
 {
 std::unique_ptr<Process> createHeatTransportBHEProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.cpp b/ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.cpp
index c5ec1b9ef0e71656b0ebe3ae64447af069d39e8b..ae15fcca42f07bfbd2ef16ce41370f7d9a9d27ba 100644
--- a/ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.cpp
+++ b/ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.cpp
@@ -24,6 +24,7 @@ namespace ProcessLib
 namespace HeatTransportBHE
 {
 HeatTransportBHEProcess::HeatTransportBHEProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -33,7 +34,7 @@ HeatTransportBHEProcess::HeatTransportBHEProcess(
     HeatTransportBHEProcessData&& process_data,
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data)),
diff --git a/ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.h b/ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.h
index 11ce3d4d90254be7a45b66faaf9ed30fc73482be..1054795e89cb7189cebab16a3f2db418f871e43c 100644
--- a/ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.h
+++ b/ProcessLib/HeatTransportBHE/HeatTransportBHEProcess.h
@@ -24,6 +24,7 @@ class HeatTransportBHEProcess final : public Process
 {
 public:
     HeatTransportBHEProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/HydroMechanics/CreateHydroMechanicsProcess.cpp b/ProcessLib/HydroMechanics/CreateHydroMechanicsProcess.cpp
index ee0c9f538c933615ba2e673e1ca80afd429470d2..80b00d24701b6bcc5e3765ef2b0a6216da0e8ab7 100644
--- a/ProcessLib/HydroMechanics/CreateHydroMechanicsProcess.cpp
+++ b/ProcessLib/HydroMechanics/CreateHydroMechanicsProcess.cpp
@@ -26,6 +26,7 @@ namespace HydroMechanics
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createHydroMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -204,13 +205,14 @@ std::unique_ptr<Process> createHydroMechanicsProcess(
                                          named_function_caller);
 
     return std::make_unique<HydroMechanicsProcess<DisplacementDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        use_monolithic_scheme);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), use_monolithic_scheme);
 }
 
 template std::unique_ptr<Process> createHydroMechanicsProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -221,6 +223,7 @@ template std::unique_ptr<Process> createHydroMechanicsProcess<2>(
     BaseLib::ConfigTree const& config);
 
 template std::unique_ptr<Process> createHydroMechanicsProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/HydroMechanics/CreateHydroMechanicsProcess.h b/ProcessLib/HydroMechanics/CreateHydroMechanicsProcess.h
index ddead7b65910d4c31ddc7fcb8856bcc4f940ac7a..fda7a2177331141e448ab08d60b26b8499479a86 100644
--- a/ProcessLib/HydroMechanics/CreateHydroMechanicsProcess.h
+++ b/ProcessLib/HydroMechanics/CreateHydroMechanicsProcess.h
@@ -39,6 +39,7 @@ namespace HydroMechanics
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createHydroMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -49,6 +50,7 @@ std::unique_ptr<Process> createHydroMechanicsProcess(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createHydroMechanicsProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -59,6 +61,7 @@ extern template std::unique_ptr<Process> createHydroMechanicsProcess<2>(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createHydroMechanicsProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/HydroMechanics/HydroMechanicsProcess.cpp b/ProcessLib/HydroMechanics/HydroMechanicsProcess.cpp
index 3ed900d0a0b0a5c0315a301f78d668c8d5b7c8f1..0ceeb1c0237fc9da145b5a06f1efc6dd5b435fc5 100644
--- a/ProcessLib/HydroMechanics/HydroMechanicsProcess.cpp
+++ b/ProcessLib/HydroMechanics/HydroMechanicsProcess.cpp
@@ -25,6 +25,7 @@ namespace HydroMechanics
 {
 template <int DisplacementDim>
 HydroMechanicsProcess<DisplacementDim>::HydroMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -35,7 +36,7 @@ HydroMechanicsProcess<DisplacementDim>::HydroMechanicsProcess(
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
     bool const use_monolithic_scheme)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               use_monolithic_scheme),
diff --git a/ProcessLib/HydroMechanics/HydroMechanicsProcess.h b/ProcessLib/HydroMechanics/HydroMechanicsProcess.h
index ece83764fa4304c48b3326efb9fcd05ff8b8b019..97393ce655e5038e4c4dcc1faaf4f2d465fbbad4 100644
--- a/ProcessLib/HydroMechanics/HydroMechanicsProcess.h
+++ b/ProcessLib/HydroMechanics/HydroMechanicsProcess.h
@@ -28,6 +28,7 @@ class HydroMechanicsProcess final : public Process
 {
 public:
     HydroMechanicsProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/LIE/HydroMechanics/CreateHydroMechanicsProcess.cpp b/ProcessLib/LIE/HydroMechanics/CreateHydroMechanicsProcess.cpp
index 68d6e22a4ed4e063358a170a8e69443155ba1401..d15fa4f1b7361c2e7e9db230e3a1eaaaab41ec43 100644
--- a/ProcessLib/LIE/HydroMechanics/CreateHydroMechanicsProcess.cpp
+++ b/ProcessLib/LIE/HydroMechanics/CreateHydroMechanicsProcess.cpp
@@ -29,6 +29,7 @@ namespace HydroMechanics
 {
 template <unsigned GlobalDim>
 std::unique_ptr<Process> createHydroMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -344,13 +345,14 @@ std::unique_ptr<Process> createHydroMechanicsProcess(
                                          named_function_caller);
 
     return std::make_unique<HydroMechanicsProcess<GlobalDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        use_monolithic_scheme);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), use_monolithic_scheme);
 }
 
 template std::unique_ptr<Process> createHydroMechanicsProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -360,6 +362,7 @@ template std::unique_ptr<Process> createHydroMechanicsProcess<2>(
     unsigned const integration_order,
     BaseLib::ConfigTree const& config);
 template std::unique_ptr<Process> createHydroMechanicsProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/LIE/HydroMechanics/CreateHydroMechanicsProcess.h b/ProcessLib/LIE/HydroMechanics/CreateHydroMechanicsProcess.h
index aefd54066dd152adbbd8b0c6c6d73f77b50a361e..d4121c9b9e004f6be493aad6dfd601d69a89a29b 100644
--- a/ProcessLib/LIE/HydroMechanics/CreateHydroMechanicsProcess.h
+++ b/ProcessLib/LIE/HydroMechanics/CreateHydroMechanicsProcess.h
@@ -41,6 +41,7 @@ namespace HydroMechanics
 {
 template <unsigned GlobalDim>
 std::unique_ptr<Process> createHydroMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/LIE/HydroMechanics/HydroMechanicsProcess.cpp b/ProcessLib/LIE/HydroMechanics/HydroMechanicsProcess.cpp
index 70b5336a859e2bb8fcbb76c2131f688c0e6f2669..7aaf7e23fc5863061c3866a5f65bd6c9c14853f8 100644
--- a/ProcessLib/LIE/HydroMechanics/HydroMechanicsProcess.cpp
+++ b/ProcessLib/LIE/HydroMechanics/HydroMechanicsProcess.cpp
@@ -37,6 +37,7 @@ namespace HydroMechanics
 {
 template <int GlobalDim>
 HydroMechanicsProcess<GlobalDim>::HydroMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -47,7 +48,7 @@ HydroMechanicsProcess<GlobalDim>::HydroMechanicsProcess(
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
     bool const use_monolithic_scheme)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               use_monolithic_scheme),
diff --git a/ProcessLib/LIE/HydroMechanics/HydroMechanicsProcess.h b/ProcessLib/LIE/HydroMechanics/HydroMechanicsProcess.h
index cff95684784e1be498a22680ab8ef8b72592fb8c..a0e172f49ac8027b7b1c9562c9e5da0e5f12991c 100644
--- a/ProcessLib/LIE/HydroMechanics/HydroMechanicsProcess.h
+++ b/ProcessLib/LIE/HydroMechanics/HydroMechanicsProcess.h
@@ -31,6 +31,7 @@ class HydroMechanicsProcess final : public Process
 
 public:
     HydroMechanicsProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/LIE/SmallDeformation/CreateSmallDeformationProcess.cpp b/ProcessLib/LIE/SmallDeformation/CreateSmallDeformationProcess.cpp
index b8dff71f0157b5bbcbc1275359f3fe468e238b72..ddcf601cba3d741127f8b70a98f63d528f83ceee 100644
--- a/ProcessLib/LIE/SmallDeformation/CreateSmallDeformationProcess.cpp
+++ b/ProcessLib/LIE/SmallDeformation/CreateSmallDeformationProcess.cpp
@@ -29,6 +29,7 @@ namespace SmallDeformation
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createSmallDeformationProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -193,12 +194,14 @@ std::unique_ptr<Process> createSmallDeformationProcess(
                                          named_function_caller);
 
     return std::make_unique<SmallDeformationProcess<DisplacementDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller));
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller));
 }
 
 template std::unique_ptr<Process> createSmallDeformationProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -209,6 +212,7 @@ template std::unique_ptr<Process> createSmallDeformationProcess<2>(
     BaseLib::ConfigTree const& config);
 
 template std::unique_ptr<Process> createSmallDeformationProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/LIE/SmallDeformation/CreateSmallDeformationProcess.h b/ProcessLib/LIE/SmallDeformation/CreateSmallDeformationProcess.h
index 556023140e109e9d353fe71bb62d48dde12b90ca..aaa20f5f36ecb3fa297380f9240dcdad5cfd3cb3 100644
--- a/ProcessLib/LIE/SmallDeformation/CreateSmallDeformationProcess.h
+++ b/ProcessLib/LIE/SmallDeformation/CreateSmallDeformationProcess.h
@@ -41,6 +41,7 @@ namespace SmallDeformation
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createSmallDeformationProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/LIE/SmallDeformation/SmallDeformationProcess.cpp b/ProcessLib/LIE/SmallDeformation/SmallDeformationProcess.cpp
index 416501e73c5d1c5b1fdcb65c60d15913783c7b99..0aa37b2f53df138ed9cff636e427711750a9c348 100644
--- a/ProcessLib/LIE/SmallDeformation/SmallDeformationProcess.cpp
+++ b/ProcessLib/LIE/SmallDeformation/SmallDeformationProcess.cpp
@@ -30,6 +30,7 @@ namespace SmallDeformation
 {
 template <int DisplacementDim>
 SmallDeformationProcess<DisplacementDim>::SmallDeformationProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -39,7 +40,7 @@ SmallDeformationProcess<DisplacementDim>::SmallDeformationProcess(
     SmallDeformationProcessData<DisplacementDim>&& process_data,
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data))
diff --git a/ProcessLib/LIE/SmallDeformation/SmallDeformationProcess.h b/ProcessLib/LIE/SmallDeformation/SmallDeformationProcess.h
index 706f198d43f0a3ffcc63dfd131b9de6cb3b323ac..088c5d606b943a3387643a09f9306db3961037e2 100644
--- a/ProcessLib/LIE/SmallDeformation/SmallDeformationProcess.h
+++ b/ProcessLib/LIE/SmallDeformation/SmallDeformationProcess.h
@@ -28,6 +28,7 @@ class SmallDeformationProcess final : public Process
 
 public:
     SmallDeformationProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/LiquidFlow/CreateLiquidFlowProcess.cpp b/ProcessLib/LiquidFlow/CreateLiquidFlowProcess.cpp
index 17ad2706f14e8d3f0f8fbe36f63090ea1c070557..6e1d55e36a425af8aeeb33cc7f737b50e3aa44aa 100644
--- a/ProcessLib/LiquidFlow/CreateLiquidFlowProcess.cpp
+++ b/ProcessLib/LiquidFlow/CreateLiquidFlowProcess.cpp
@@ -26,6 +26,7 @@ namespace ProcessLib
 namespace LiquidFlow
 {
 std::unique_ptr<Process> createLiquidFlowProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -101,11 +102,11 @@ std::unique_ptr<Process> createLiquidFlowProcess(
         INFO("The liquid flow is in homogeneous porous media.");
     }
 
-    return std::unique_ptr<Process>{new LiquidFlowProcess{
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(secondary_variables),
-        std::move(named_function_caller), material_ids, gravity_axis_id, g,
-        reference_temperature, mat_config}};
+    return std::make_unique<LiquidFlowProcess>(
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(secondary_variables), std::move(named_function_caller),
+        material_ids, gravity_axis_id, g, reference_temperature, mat_config);
 }
 
 }  // namespace LiquidFlow
diff --git a/ProcessLib/LiquidFlow/CreateLiquidFlowProcess.h b/ProcessLib/LiquidFlow/CreateLiquidFlowProcess.h
index b333fe1818616dc47dd3815147c9fb15a80e7c01..b92aac81a48c7eed7691a42de8984e3b7a8fbf1e 100644
--- a/ProcessLib/LiquidFlow/CreateLiquidFlowProcess.h
+++ b/ProcessLib/LiquidFlow/CreateLiquidFlowProcess.h
@@ -20,6 +20,7 @@ namespace ProcessLib
 namespace LiquidFlow
 {
 std::unique_ptr<Process> createLiquidFlowProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/LiquidFlow/LiquidFlowProcess.cpp b/ProcessLib/LiquidFlow/LiquidFlowProcess.cpp
index c477aa1f4230cebf1623001ce8c6ff14f907840c..64be0d697ea34be4dd0537fde8154a76d480d779 100644
--- a/ProcessLib/LiquidFlow/LiquidFlowProcess.cpp
+++ b/ProcessLib/LiquidFlow/LiquidFlowProcess.cpp
@@ -31,6 +31,7 @@ namespace ProcessLib
 namespace LiquidFlow
 {
 LiquidFlowProcess::LiquidFlowProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -44,7 +45,7 @@ LiquidFlowProcess::LiquidFlowProcess(
     double const gravitational_acceleration,
     double const reference_temperature,
     BaseLib::ConfigTree const& config)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _gravitational_axis_id(gravitational_axis_id),
diff --git a/ProcessLib/LiquidFlow/LiquidFlowProcess.h b/ProcessLib/LiquidFlow/LiquidFlowProcess.h
index 6e839dcbb15ffaf7b0561f278dc211370f2ebb63..bbaec93f45a196b50fd685aafe22b1b185438306 100644
--- a/ProcessLib/LiquidFlow/LiquidFlowProcess.h
+++ b/ProcessLib/LiquidFlow/LiquidFlowProcess.h
@@ -58,6 +58,7 @@ class LiquidFlowProcess final : public Process
 {
 public:
     LiquidFlowProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
         std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
diff --git a/ProcessLib/PhaseField/CreatePhaseFieldProcess.cpp b/ProcessLib/PhaseField/CreatePhaseFieldProcess.cpp
index 82068b53d71cbd4ccb12d2c782ee50540f4167d2..a102299db5c6180e7873104dae541a6bb1864ffc 100644
--- a/ProcessLib/PhaseField/CreatePhaseFieldProcess.cpp
+++ b/ProcessLib/PhaseField/CreatePhaseFieldProcess.cpp
@@ -26,6 +26,7 @@ namespace PhaseField
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createPhaseFieldProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -204,13 +205,14 @@ std::unique_ptr<Process> createPhaseFieldProcess(
                                          named_function_caller);
 
     return std::make_unique<PhaseFieldProcess<DisplacementDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        use_monolithic_scheme);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), use_monolithic_scheme);
 }
 
 template std::unique_ptr<Process> createPhaseFieldProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -221,6 +223,7 @@ template std::unique_ptr<Process> createPhaseFieldProcess<2>(
     BaseLib::ConfigTree const& config);
 
 template std::unique_ptr<Process> createPhaseFieldProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/PhaseField/CreatePhaseFieldProcess.h b/ProcessLib/PhaseField/CreatePhaseFieldProcess.h
index d7c8d2afc93f2f9c2880652017769beedbea5c0e..8e12f1d3cfb71645fa806148a2ba7656c60efdf2 100644
--- a/ProcessLib/PhaseField/CreatePhaseFieldProcess.h
+++ b/ProcessLib/PhaseField/CreatePhaseFieldProcess.h
@@ -39,6 +39,7 @@ namespace PhaseField
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createPhaseFieldProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -49,6 +50,7 @@ std::unique_ptr<Process> createPhaseFieldProcess(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createPhaseFieldProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -59,6 +61,7 @@ extern template std::unique_ptr<Process> createPhaseFieldProcess<2>(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createPhaseFieldProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/PhaseField/PhaseFieldProcess.cpp b/ProcessLib/PhaseField/PhaseFieldProcess.cpp
index f33ba34db09d1f147ce8f3bed4d91ce9ed83a512..897b11e8fe85250ff821b7568a3286c3934b9710 100644
--- a/ProcessLib/PhaseField/PhaseFieldProcess.cpp
+++ b/ProcessLib/PhaseField/PhaseFieldProcess.cpp
@@ -26,6 +26,7 @@ namespace PhaseField
 {
 template <int DisplacementDim>
 PhaseFieldProcess<DisplacementDim>::PhaseFieldProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -36,7 +37,7 @@ PhaseFieldProcess<DisplacementDim>::PhaseFieldProcess(
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
     bool const use_monolithic_scheme)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               use_monolithic_scheme),
diff --git a/ProcessLib/PhaseField/PhaseFieldProcess.h b/ProcessLib/PhaseField/PhaseFieldProcess.h
index d552a483864975d5f473f7aebc8ec3c76ce1e4a1..dc2fe463950322cb112b96abd316c2665e674549 100644
--- a/ProcessLib/PhaseField/PhaseFieldProcess.h
+++ b/ProcessLib/PhaseField/PhaseFieldProcess.h
@@ -49,6 +49,7 @@ class PhaseFieldProcess final : public Process
 {
 public:
     PhaseFieldProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/Process.h b/ProcessLib/Process.h
index c604a17bf515e1ef424d6d231fa26db4c873bbbc..5aaa5c523446b43ee1851fc8e140578a49c746ed 100644
--- a/ProcessLib/Process.h
+++ b/ProcessLib/Process.h
@@ -45,7 +45,8 @@ public:
     using NonlinearSolver = NumLib::NonlinearSolverBase;
     using TimeDiscretization = NumLib::TimeDiscretization;
 
-    Process(MeshLib::Mesh& mesh,
+    Process(std::string name_,
+            MeshLib::Mesh& mesh,
             std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
             std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
                 parameters,
diff --git a/ProcessLib/RichardsComponentTransport/CreateRichardsComponentTransportProcess.cpp b/ProcessLib/RichardsComponentTransport/CreateRichardsComponentTransportProcess.cpp
index 716a63eba490dd360abc0c1752447cee25731830..102f2a73eb2d01784b25658e3bb3f5df948bfebb 100644
--- a/ProcessLib/RichardsComponentTransport/CreateRichardsComponentTransportProcess.cpp
+++ b/ProcessLib/RichardsComponentTransport/CreateRichardsComponentTransportProcess.cpp
@@ -24,6 +24,7 @@ namespace ProcessLib
 namespace RichardsComponentTransport
 {
 std::unique_ptr<Process> createRichardsComponentTransportProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -171,10 +172,10 @@ std::unique_ptr<Process> createRichardsComponentTransportProcess(
                                          named_function_caller);
 
     return std::make_unique<RichardsComponentTransportProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        use_monolithic_scheme);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), use_monolithic_scheme);
 }
 
 }  // namespace RichardsComponentTransport
diff --git a/ProcessLib/RichardsComponentTransport/CreateRichardsComponentTransportProcess.h b/ProcessLib/RichardsComponentTransport/CreateRichardsComponentTransportProcess.h
index 6ab1ff83b093085c243345e30a0847ae73138b19..4402b005e5065d4f23d9af07fdb4038373c881cf 100644
--- a/ProcessLib/RichardsComponentTransport/CreateRichardsComponentTransportProcess.h
+++ b/ProcessLib/RichardsComponentTransport/CreateRichardsComponentTransportProcess.h
@@ -17,6 +17,7 @@ namespace ProcessLib
 namespace RichardsComponentTransport
 {
 std::unique_ptr<Process> createRichardsComponentTransportProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/RichardsComponentTransport/RichardsComponentTransportProcess.cpp b/ProcessLib/RichardsComponentTransport/RichardsComponentTransportProcess.cpp
index db26bbd754e16332550fb0f19245c4216ffc6b16..3c4cbc2f275bfa2621fd88e4aaeb682bcfc1926a 100644
--- a/ProcessLib/RichardsComponentTransport/RichardsComponentTransportProcess.cpp
+++ b/ProcessLib/RichardsComponentTransport/RichardsComponentTransportProcess.cpp
@@ -18,6 +18,7 @@ namespace ProcessLib
 namespace RichardsComponentTransport
 {
 RichardsComponentTransportProcess::RichardsComponentTransportProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -28,7 +29,7 @@ RichardsComponentTransportProcess::RichardsComponentTransportProcess(
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
     bool const use_monolithic_scheme)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               use_monolithic_scheme),
diff --git a/ProcessLib/RichardsComponentTransport/RichardsComponentTransportProcess.h b/ProcessLib/RichardsComponentTransport/RichardsComponentTransportProcess.h
index dda41a7185bc3b5922e513ce02d2be308591bf83..3e30588146c15efd67e9e431a498605613f3fb13 100644
--- a/ProcessLib/RichardsComponentTransport/RichardsComponentTransportProcess.h
+++ b/ProcessLib/RichardsComponentTransport/RichardsComponentTransportProcess.h
@@ -102,6 +102,7 @@ class RichardsComponentTransportProcess final : public Process
 {
 public:
     RichardsComponentTransportProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/RichardsFlow/CreateRichardsFlowProcess.cpp b/ProcessLib/RichardsFlow/CreateRichardsFlowProcess.cpp
index 2c5fb72c9f530810e6cd5facc2edbd9a8542b06b..69ae467085d299ddfe59cf916a245204fb430114 100644
--- a/ProcessLib/RichardsFlow/CreateRichardsFlowProcess.cpp
+++ b/ProcessLib/RichardsFlow/CreateRichardsFlowProcess.cpp
@@ -23,6 +23,7 @@ namespace ProcessLib
 namespace RichardsFlow
 {
 std::unique_ptr<Process> createRichardsFlowProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -100,10 +101,10 @@ std::unique_ptr<Process> createRichardsFlowProcess(
                                          mass_lumping, temperature};
 
     return std::make_unique<RichardsFlowProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        mat_config, curves);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), mat_config, curves);
 }
 
 }  // namespace RichardsFlow
diff --git a/ProcessLib/RichardsFlow/CreateRichardsFlowProcess.h b/ProcessLib/RichardsFlow/CreateRichardsFlowProcess.h
index 3e1c3d9024e06577c65a19957f17131da91b0fd9..9b909c3c10e41b5ba79ea6fc8f7e7c4e04b024fe 100644
--- a/ProcessLib/RichardsFlow/CreateRichardsFlowProcess.h
+++ b/ProcessLib/RichardsFlow/CreateRichardsFlowProcess.h
@@ -17,6 +17,7 @@ namespace ProcessLib
 namespace RichardsFlow
 {
 std::unique_ptr<Process> createRichardsFlowProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/RichardsFlow/RichardsFlowProcess.cpp b/ProcessLib/RichardsFlow/RichardsFlowProcess.cpp
index 5700226b402a474a38757f2cdf3f5803f3f65bfb..a20c66f88f314716b86875f43ff1148b3e36f180 100644
--- a/ProcessLib/RichardsFlow/RichardsFlowProcess.cpp
+++ b/ProcessLib/RichardsFlow/RichardsFlowProcess.cpp
@@ -18,6 +18,7 @@ namespace ProcessLib
 namespace RichardsFlow
 {
 RichardsFlowProcess::RichardsFlowProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -31,7 +32,7 @@ RichardsFlowProcess::RichardsFlowProcess(
     std::map<std::string,
              std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
     /*curves*/)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data))
diff --git a/ProcessLib/RichardsFlow/RichardsFlowProcess.h b/ProcessLib/RichardsFlow/RichardsFlowProcess.h
index 9569cc383345f2c02975e5d2a71e3fb111363446..333baacf707a343bc3dc573a2e5245495e7810e5 100644
--- a/ProcessLib/RichardsFlow/RichardsFlowProcess.h
+++ b/ProcessLib/RichardsFlow/RichardsFlowProcess.h
@@ -23,6 +23,7 @@ class RichardsFlowProcess final : public Process
 {
 public:
     RichardsFlowProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/RichardsMechanics/CreateRichardsMechanicsProcess.cpp b/ProcessLib/RichardsMechanics/CreateRichardsMechanicsProcess.cpp
index 32602b0bc4fc634f79267579cb40f1c70a66a442..72edbee59de593f14c3f991777bcc09eed099c71 100644
--- a/ProcessLib/RichardsMechanics/CreateRichardsMechanicsProcess.cpp
+++ b/ProcessLib/RichardsMechanics/CreateRichardsMechanicsProcess.cpp
@@ -27,6 +27,7 @@ namespace RichardsMechanics
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createRichardsMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -207,13 +208,14 @@ std::unique_ptr<Process> createRichardsMechanicsProcess(
                                          named_function_caller);
 
     return std::make_unique<RichardsMechanicsProcess<DisplacementDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        use_monolithic_scheme);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), use_monolithic_scheme);
 }
 
 template std::unique_ptr<Process> createRichardsMechanicsProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -224,6 +226,7 @@ template std::unique_ptr<Process> createRichardsMechanicsProcess<2>(
     BaseLib::ConfigTree const& config);
 
 template std::unique_ptr<Process> createRichardsMechanicsProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/RichardsMechanics/CreateRichardsMechanicsProcess.h b/ProcessLib/RichardsMechanics/CreateRichardsMechanicsProcess.h
index 3460009ad5e02f0b9f20b8234beef7ddf6e859cc..3d60778d13a56815e49cd507e3e4677fb197f16a 100644
--- a/ProcessLib/RichardsMechanics/CreateRichardsMechanicsProcess.h
+++ b/ProcessLib/RichardsMechanics/CreateRichardsMechanicsProcess.h
@@ -44,6 +44,7 @@ namespace RichardsMechanics
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createRichardsMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -54,6 +55,7 @@ std::unique_ptr<Process> createRichardsMechanicsProcess(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createRichardsMechanicsProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -64,6 +66,7 @@ extern template std::unique_ptr<Process> createRichardsMechanicsProcess<2>(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createRichardsMechanicsProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.cpp b/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.cpp
index e769eb695aaf2d9a83807dc653eb1983eae1ce4d..e637303488ba3a7f471476b5d4357dd2ef83f26b 100644
--- a/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.cpp
+++ b/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.cpp
@@ -25,6 +25,7 @@ namespace RichardsMechanics
 {
 template <int DisplacementDim>
 RichardsMechanicsProcess<DisplacementDim>::RichardsMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -35,7 +36,7 @@ RichardsMechanicsProcess<DisplacementDim>::RichardsMechanicsProcess(
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
     bool const use_monolithic_scheme)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               use_monolithic_scheme),
diff --git a/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.h b/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.h
index 42abbab1fdb8e36a60ba05259bf63f97caf67863..de7dc832efd529176710dba79da32ec536f000cb 100644
--- a/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.h
+++ b/ProcessLib/RichardsMechanics/RichardsMechanicsProcess.h
@@ -28,6 +28,7 @@ class RichardsMechanicsProcess final : public Process
 {
 public:
     RichardsMechanicsProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/SmallDeformation/CreateSmallDeformationProcess.cpp b/ProcessLib/SmallDeformation/CreateSmallDeformationProcess.cpp
index 4dc667f676241411666041c8470baf0957558970..363001b2f25dbed08d46e6b66bfa78e497767650 100644
--- a/ProcessLib/SmallDeformation/CreateSmallDeformationProcess.cpp
+++ b/ProcessLib/SmallDeformation/CreateSmallDeformationProcess.cpp
@@ -25,6 +25,7 @@ namespace SmallDeformation
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createSmallDeformationProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -130,12 +131,14 @@ std::unique_ptr<Process> createSmallDeformationProcess(
                                          named_function_caller);
 
     return std::make_unique<SmallDeformationProcess<DisplacementDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller));
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller));
 }
 
 template std::unique_ptr<Process> createSmallDeformationProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -146,6 +149,7 @@ template std::unique_ptr<Process> createSmallDeformationProcess<2>(
     BaseLib::ConfigTree const& config);
 
 template std::unique_ptr<Process> createSmallDeformationProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/SmallDeformation/CreateSmallDeformationProcess.h b/ProcessLib/SmallDeformation/CreateSmallDeformationProcess.h
index 2f65e1df4a6c828ca6017aec84b1daf223121317..67cfb3f971042e99edc33fb6ae373b9146ef3b23 100644
--- a/ProcessLib/SmallDeformation/CreateSmallDeformationProcess.h
+++ b/ProcessLib/SmallDeformation/CreateSmallDeformationProcess.h
@@ -39,6 +39,7 @@ namespace SmallDeformation
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createSmallDeformationProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -49,6 +50,7 @@ std::unique_ptr<Process> createSmallDeformationProcess(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createSmallDeformationProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -59,6 +61,7 @@ extern template std::unique_ptr<Process> createSmallDeformationProcess<2>(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createSmallDeformationProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/SmallDeformation/SmallDeformationProcess.cpp b/ProcessLib/SmallDeformation/SmallDeformationProcess.cpp
index 15e5712f48745601fdb4b5e569125d4faa609d73..9dd1e09bbd732e06c8f4a401db6a74398bf68fc1 100644
--- a/ProcessLib/SmallDeformation/SmallDeformationProcess.cpp
+++ b/ProcessLib/SmallDeformation/SmallDeformationProcess.cpp
@@ -24,6 +24,7 @@ namespace SmallDeformation
 {
 template <int DisplacementDim>
 SmallDeformationProcess<DisplacementDim>::SmallDeformationProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -33,7 +34,7 @@ SmallDeformationProcess<DisplacementDim>::SmallDeformationProcess(
     SmallDeformationProcessData<DisplacementDim>&& process_data,
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data))
diff --git a/ProcessLib/SmallDeformation/SmallDeformationProcess.h b/ProcessLib/SmallDeformation/SmallDeformationProcess.h
index 43b781fd77df2b74e464c68a571e7b609004448c..f2fea57c3940b19749e7052ce51be3b31bb87dce 100644
--- a/ProcessLib/SmallDeformation/SmallDeformationProcess.h
+++ b/ProcessLib/SmallDeformation/SmallDeformationProcess.h
@@ -57,6 +57,7 @@ class SmallDeformationProcess final : public Process
 {
 public:
     SmallDeformationProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/SmallDeformationNonlocal/CreateSmallDeformationNonlocalProcess.cpp b/ProcessLib/SmallDeformationNonlocal/CreateSmallDeformationNonlocalProcess.cpp
index 23e7b42a1712d4d024534adb7656b19c585f3c6c..6f80ecc93fb0668b2651347ab4d6b7926074ee70 100644
--- a/ProcessLib/SmallDeformationNonlocal/CreateSmallDeformationNonlocalProcess.cpp
+++ b/ProcessLib/SmallDeformationNonlocal/CreateSmallDeformationNonlocalProcess.cpp
@@ -27,6 +27,7 @@ namespace SmallDeformationNonlocal
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createSmallDeformationNonlocalProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -121,12 +122,14 @@ std::unique_ptr<Process> createSmallDeformationNonlocalProcess(
                                          named_function_caller);
 
     return std::make_unique<SmallDeformationNonlocalProcess<DisplacementDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller));
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller));
 }
 
 template std::unique_ptr<Process> createSmallDeformationNonlocalProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -137,6 +140,7 @@ template std::unique_ptr<Process> createSmallDeformationNonlocalProcess<2>(
     BaseLib::ConfigTree const& config);
 
 template std::unique_ptr<Process> createSmallDeformationNonlocalProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/SmallDeformationNonlocal/CreateSmallDeformationNonlocalProcess.h b/ProcessLib/SmallDeformationNonlocal/CreateSmallDeformationNonlocalProcess.h
index 35ad5af8c7644131c1fb148fb45ba54d5eac2364..0296e5a17da4a53453fb28f8df2d6f1c878adcb5 100644
--- a/ProcessLib/SmallDeformationNonlocal/CreateSmallDeformationNonlocalProcess.h
+++ b/ProcessLib/SmallDeformationNonlocal/CreateSmallDeformationNonlocalProcess.h
@@ -41,6 +41,7 @@ namespace SmallDeformationNonlocal
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createSmallDeformationNonlocalProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -52,6 +53,7 @@ std::unique_ptr<Process> createSmallDeformationNonlocalProcess(
 
 extern template std::unique_ptr<Process>
 createSmallDeformationNonlocalProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -63,6 +65,7 @@ createSmallDeformationNonlocalProcess<2>(
 
 extern template std::unique_ptr<Process>
 createSmallDeformationNonlocalProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.cpp b/ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.cpp
index bb57a0f0812900c063a76e382cd84c86db2e3c72..a519165e138f78fd2d942c95345089e654382c43 100644
--- a/ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.cpp
+++ b/ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.cpp
@@ -24,6 +24,7 @@ namespace SmallDeformationNonlocal
 template <int DisplacementDim>
 SmallDeformationNonlocalProcess<DisplacementDim>::
     SmallDeformationNonlocalProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
@@ -35,7 +36,7 @@ SmallDeformationNonlocalProcess<DisplacementDim>::
         SmallDeformationNonlocalProcessData<DisplacementDim>&& process_data,
         SecondaryVariableCollection&& secondary_variables,
         NumLib::NamedFunctionCaller&& named_function_caller)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data))
diff --git a/ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.h b/ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.h
index 0aa405f9fa510343aa50127d07cbad88024478e8..8cc5e6646d315e581a90718015c7dd46f2e7cce7 100644
--- a/ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.h
+++ b/ProcessLib/SmallDeformationNonlocal/SmallDeformationNonlocalProcess.h
@@ -30,6 +30,7 @@ class SmallDeformationNonlocalProcess final : public Process
 {
 public:
     SmallDeformationNonlocalProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/TES/CreateTESProcess.cpp b/ProcessLib/TES/CreateTESProcess.cpp
index 18529dad88f62e287ce963fd0c7daa6d2f68d188..249c38ffaea205eb73a01ccbebdbbaea41d0f474 100644
--- a/ProcessLib/TES/CreateTESProcess.cpp
+++ b/ProcessLib/TES/CreateTESProcess.cpp
@@ -17,6 +17,7 @@ namespace ProcessLib
 namespace TES
 {
 std::unique_ptr<Process> createTESProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -54,9 +55,10 @@ std::unique_ptr<Process> createTESProcess(
                                          named_function_caller);
 
     return std::make_unique<TESProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(secondary_variables),
-        std::move(named_function_caller), config);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(secondary_variables), std::move(named_function_caller),
+        config);
 }
 
 }  // namespace TES
diff --git a/ProcessLib/TES/CreateTESProcess.h b/ProcessLib/TES/CreateTESProcess.h
index 19ab317d38b655a7c4f5d69254ac862e8cb7b70b..2c2f77028470ca2ebe8b1185e762fbb73d23457c 100644
--- a/ProcessLib/TES/CreateTESProcess.h
+++ b/ProcessLib/TES/CreateTESProcess.h
@@ -17,6 +17,7 @@ namespace ProcessLib
 namespace TES
 {
 std::unique_ptr<Process> createTESProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/TES/TESProcess.cpp b/ProcessLib/TES/TESProcess.cpp
index fff9197d14f17a83a42792654adbd711b3cc52fb..28daf999742b25f2de9b7140540d04f262455034 100644
--- a/ProcessLib/TES/TESProcess.cpp
+++ b/ProcessLib/TES/TESProcess.cpp
@@ -17,6 +17,7 @@ namespace ProcessLib
 namespace TES
 {
 TESProcess::TESProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -26,7 +27,7 @@ TESProcess::TESProcess(
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
     const BaseLib::ConfigTree& config)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller))
 {
diff --git a/ProcessLib/TES/TESProcess.h b/ProcessLib/TES/TESProcess.h
index 9779b6352728bcd28f497cd0ef727f45fa8bae54..86ba0a1ea73d671a260da3431d88adbae3371d0d 100644
--- a/ProcessLib/TES/TESProcess.h
+++ b/ProcessLib/TES/TESProcess.h
@@ -31,6 +31,7 @@ class TESProcess final : public Process
 {
 public:
     TESProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
         std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
diff --git a/ProcessLib/ThermalTwoPhaseFlowWithPP/CreateThermalTwoPhaseFlowWithPPProcess.cpp b/ProcessLib/ThermalTwoPhaseFlowWithPP/CreateThermalTwoPhaseFlowWithPPProcess.cpp
index dca8ef5122903c556930c9df7ef5ed51176ad7d5..2ecc9baa56aa7c996f4542e387b0c7dbe3b890a2 100644
--- a/ProcessLib/ThermalTwoPhaseFlowWithPP/CreateThermalTwoPhaseFlowWithPPProcess.cpp
+++ b/ProcessLib/ThermalTwoPhaseFlowWithPP/CreateThermalTwoPhaseFlowWithPPProcess.cpp
@@ -27,6 +27,7 @@ namespace ProcessLib
 namespace ThermalTwoPhaseFlowWithPP
 {
 std::unique_ptr<Process> createThermalTwoPhaseFlowWithPPProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -138,10 +139,10 @@ std::unique_ptr<Process> createThermalTwoPhaseFlowWithPPProcess(
                                                       std::move(material)};
 
     return std::make_unique<ThermalTwoPhaseFlowWithPPProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        mat_config, curves);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), mat_config, curves);
 }
 
 }  // namespace ThermalTwoPhaseFlowWithPP
diff --git a/ProcessLib/ThermalTwoPhaseFlowWithPP/CreateThermalTwoPhaseFlowWithPPProcess.h b/ProcessLib/ThermalTwoPhaseFlowWithPP/CreateThermalTwoPhaseFlowWithPPProcess.h
index 450dcb2ffaa79066a34f8eb7eb0ba3fec6d4ff0b..f5319316190b3c0b922f7080d0c16880d931f6ba 100644
--- a/ProcessLib/ThermalTwoPhaseFlowWithPP/CreateThermalTwoPhaseFlowWithPPProcess.h
+++ b/ProcessLib/ThermalTwoPhaseFlowWithPP/CreateThermalTwoPhaseFlowWithPPProcess.h
@@ -18,6 +18,7 @@ namespace ProcessLib
 namespace ThermalTwoPhaseFlowWithPP
 {
 std::unique_ptr<Process> createThermalTwoPhaseFlowWithPPProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/ThermalTwoPhaseFlowWithPP/ThermalTwoPhaseFlowWithPPProcess.cpp b/ProcessLib/ThermalTwoPhaseFlowWithPP/ThermalTwoPhaseFlowWithPPProcess.cpp
index a448deb03052d86a35a808e849f6cc0f36cb121c..85ce16e56e2929ee9c09f402d33eed3ecdaa1673 100644
--- a/ProcessLib/ThermalTwoPhaseFlowWithPP/ThermalTwoPhaseFlowWithPPProcess.cpp
+++ b/ProcessLib/ThermalTwoPhaseFlowWithPP/ThermalTwoPhaseFlowWithPPProcess.cpp
@@ -25,6 +25,7 @@ namespace ProcessLib
 namespace ThermalTwoPhaseFlowWithPP
 {
 ThermalTwoPhaseFlowWithPPProcess::ThermalTwoPhaseFlowWithPPProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -38,7 +39,7 @@ ThermalTwoPhaseFlowWithPPProcess::ThermalTwoPhaseFlowWithPPProcess(
     std::map<std::string,
              std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
     /*curves*/)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data))
diff --git a/ProcessLib/ThermalTwoPhaseFlowWithPP/ThermalTwoPhaseFlowWithPPProcess.h b/ProcessLib/ThermalTwoPhaseFlowWithPP/ThermalTwoPhaseFlowWithPPProcess.h
index 5cac5af027f2b9257648b9c5eabd9083d6f0c583..4426073f98f525aa7801a3d53730b6be939ba88d 100644
--- a/ProcessLib/ThermalTwoPhaseFlowWithPP/ThermalTwoPhaseFlowWithPPProcess.h
+++ b/ProcessLib/ThermalTwoPhaseFlowWithPP/ThermalTwoPhaseFlowWithPPProcess.h
@@ -38,6 +38,7 @@ class ThermalTwoPhaseFlowWithPPProcess final : public Process
 {
 public:
     ThermalTwoPhaseFlowWithPPProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
         std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
diff --git a/ProcessLib/ThermoHydroMechanics/CreateThermoHydroMechanicsProcess.cpp b/ProcessLib/ThermoHydroMechanics/CreateThermoHydroMechanicsProcess.cpp
index 2b30d9659f4c888839ebc46271192966993a46cb..443f72b20c600a1308a33d293cc89730366a97ac 100644
--- a/ProcessLib/ThermoHydroMechanics/CreateThermoHydroMechanicsProcess.cpp
+++ b/ProcessLib/ThermoHydroMechanics/CreateThermoHydroMechanicsProcess.cpp
@@ -27,6 +27,7 @@ namespace ThermoHydroMechanics
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createThermoHydroMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -289,13 +290,14 @@ std::unique_ptr<Process> createThermoHydroMechanicsProcess(
                                          named_function_caller);
 
     return std::make_unique<ThermoHydroMechanicsProcess<DisplacementDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        use_monolithic_scheme);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), use_monolithic_scheme);
 }
 
 template std::unique_ptr<Process> createThermoHydroMechanicsProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -306,6 +308,7 @@ template std::unique_ptr<Process> createThermoHydroMechanicsProcess<2>(
     BaseLib::ConfigTree const& config);
 
 template std::unique_ptr<Process> createThermoHydroMechanicsProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/ThermoHydroMechanics/CreateThermoHydroMechanicsProcess.h b/ProcessLib/ThermoHydroMechanics/CreateThermoHydroMechanicsProcess.h
index aab4795f2387f8b3dc9564d7fa1af626a9062ead..99641a62eb6d2aad89d9575a9174e16fc3c49f6a 100644
--- a/ProcessLib/ThermoHydroMechanics/CreateThermoHydroMechanicsProcess.h
+++ b/ProcessLib/ThermoHydroMechanics/CreateThermoHydroMechanicsProcess.h
@@ -40,6 +40,7 @@ namespace ThermoHydroMechanics
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createThermoHydroMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -50,6 +51,7 @@ std::unique_ptr<Process> createThermoHydroMechanicsProcess(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createThermoHydroMechanicsProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -60,6 +62,7 @@ extern template std::unique_ptr<Process> createThermoHydroMechanicsProcess<2>(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createThermoHydroMechanicsProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/ThermoHydroMechanics/ThermoHydroMechanicsProcess.cpp b/ProcessLib/ThermoHydroMechanics/ThermoHydroMechanicsProcess.cpp
index bf7ba62e719ac51246ed4b387338e90b7ce7ebf6..9f6cef0bb3c274cadb39e7122ba5e6788db1430b 100644
--- a/ProcessLib/ThermoHydroMechanics/ThermoHydroMechanicsProcess.cpp
+++ b/ProcessLib/ThermoHydroMechanics/ThermoHydroMechanicsProcess.cpp
@@ -26,6 +26,7 @@ namespace ThermoHydroMechanics
 {
 template <int DisplacementDim>
 ThermoHydroMechanicsProcess<DisplacementDim>::ThermoHydroMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -36,7 +37,7 @@ ThermoHydroMechanicsProcess<DisplacementDim>::ThermoHydroMechanicsProcess(
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
     bool const use_monolithic_scheme)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               use_monolithic_scheme),
diff --git a/ProcessLib/ThermoHydroMechanics/ThermoHydroMechanicsProcess.h b/ProcessLib/ThermoHydroMechanics/ThermoHydroMechanicsProcess.h
index 06e715747b012b63942b07fcee6eda1b78657d33..20b7e76606122aeae661c48c394d519147619368 100644
--- a/ProcessLib/ThermoHydroMechanics/ThermoHydroMechanicsProcess.h
+++ b/ProcessLib/ThermoHydroMechanics/ThermoHydroMechanicsProcess.h
@@ -30,6 +30,7 @@ class ThermoHydroMechanicsProcess final : public Process
 {
 public:
     ThermoHydroMechanicsProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/ThermoMechanicalPhaseField/CreateThermoMechanicalPhaseFieldProcess.cpp b/ProcessLib/ThermoMechanicalPhaseField/CreateThermoMechanicalPhaseFieldProcess.cpp
index ab90b585a1c570ab088b82cc54c0eec2a2c2a278..12c118bcde61b5d1517a7988054533aa7a3aa5a0 100644
--- a/ProcessLib/ThermoMechanicalPhaseField/CreateThermoMechanicalPhaseFieldProcess.cpp
+++ b/ProcessLib/ThermoMechanicalPhaseField/CreateThermoMechanicalPhaseFieldProcess.cpp
@@ -26,6 +26,7 @@ namespace ThermoMechanicalPhaseField
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createThermoMechanicalPhaseFieldProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -238,14 +239,15 @@ std::unique_ptr<Process> createThermoMechanicalPhaseFieldProcess(
                                          named_function_caller);
 
     return std::make_unique<ThermoMechanicalPhaseFieldProcess<DisplacementDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        mechanics_related_process_id, phase_field_process_id,
-        heat_conduction_process_id);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), mechanics_related_process_id,
+        phase_field_process_id, heat_conduction_process_id);
 }
 
 template std::unique_ptr<Process> createThermoMechanicalPhaseFieldProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -256,6 +258,7 @@ template std::unique_ptr<Process> createThermoMechanicalPhaseFieldProcess<2>(
     BaseLib::ConfigTree const& config);
 
 template std::unique_ptr<Process> createThermoMechanicalPhaseFieldProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/ThermoMechanicalPhaseField/CreateThermoMechanicalPhaseFieldProcess.h b/ProcessLib/ThermoMechanicalPhaseField/CreateThermoMechanicalPhaseFieldProcess.h
index 6c67907b3b165288d17d49866edfdfdfa8b530d9..df35d6d353b21fde37a44a18065f10cc314fc6c5 100644
--- a/ProcessLib/ThermoMechanicalPhaseField/CreateThermoMechanicalPhaseFieldProcess.h
+++ b/ProcessLib/ThermoMechanicalPhaseField/CreateThermoMechanicalPhaseFieldProcess.h
@@ -39,6 +39,7 @@ namespace ThermoMechanicalPhaseField
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createThermoMechanicalPhaseFieldProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -50,6 +51,7 @@ std::unique_ptr<Process> createThermoMechanicalPhaseFieldProcess(
 
 extern template std::unique_ptr<Process>
 createThermoMechanicalPhaseFieldProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -61,6 +63,7 @@ createThermoMechanicalPhaseFieldProcess<2>(
 
 extern template std::unique_ptr<Process>
 createThermoMechanicalPhaseFieldProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/ThermoMechanicalPhaseField/ThermoMechanicalPhaseFieldProcess-impl.h b/ProcessLib/ThermoMechanicalPhaseField/ThermoMechanicalPhaseFieldProcess-impl.h
index d8f13f88c7eaf8424b12c73a0c4a1d0230e117b0..70bb459ec379b9e94e4c9ae7b51720a02bae6ce4 100644
--- a/ProcessLib/ThermoMechanicalPhaseField/ThermoMechanicalPhaseFieldProcess-impl.h
+++ b/ProcessLib/ThermoMechanicalPhaseField/ThermoMechanicalPhaseFieldProcess-impl.h
@@ -26,6 +26,7 @@ namespace ThermoMechanicalPhaseField
 template <int DisplacementDim>
 ThermoMechanicalPhaseFieldProcess<DisplacementDim>::
     ThermoMechanicalPhaseFieldProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
@@ -40,7 +41,7 @@ ThermoMechanicalPhaseFieldProcess<DisplacementDim>::
         int const mechanics_related_process_id,
         int const phase_field_process_id,
         int const heat_conduction_process_id)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               false),
diff --git a/ProcessLib/ThermoMechanicalPhaseField/ThermoMechanicalPhaseFieldProcess.h b/ProcessLib/ThermoMechanicalPhaseField/ThermoMechanicalPhaseFieldProcess.h
index 96b06ef12c2bf11d446a5daa8f2ff573151e52a1..b1da0669b740579df373ad82ebda389734598ddd 100644
--- a/ProcessLib/ThermoMechanicalPhaseField/ThermoMechanicalPhaseFieldProcess.h
+++ b/ProcessLib/ThermoMechanicalPhaseField/ThermoMechanicalPhaseFieldProcess.h
@@ -54,6 +54,7 @@ class ThermoMechanicalPhaseFieldProcess final : public Process
 {
 public:
     ThermoMechanicalPhaseFieldProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/ThermoMechanics/CreateThermoMechanicsProcess.cpp b/ProcessLib/ThermoMechanics/CreateThermoMechanicsProcess.cpp
index 28125527442939c424a92557596461d8a2d51980..405f850269fe666ee6c96eba4e15c16f8b707ad0 100644
--- a/ProcessLib/ThermoMechanics/CreateThermoMechanicsProcess.cpp
+++ b/ProcessLib/ThermoMechanics/CreateThermoMechanicsProcess.cpp
@@ -26,6 +26,7 @@ namespace ThermoMechanics
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createThermoMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -174,13 +175,14 @@ std::unique_ptr<Process> createThermoMechanicsProcess(
                                          named_function_caller);
 
     return std::make_unique<ThermoMechanicsProcess<DisplacementDim>>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        use_monolithic_scheme);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), use_monolithic_scheme);
 }
 
 template std::unique_ptr<Process> createThermoMechanicsProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -191,6 +193,7 @@ template std::unique_ptr<Process> createThermoMechanicsProcess<2>(
     BaseLib::ConfigTree const& config);
 
 template std::unique_ptr<Process> createThermoMechanicsProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/ThermoMechanics/CreateThermoMechanicsProcess.h b/ProcessLib/ThermoMechanics/CreateThermoMechanicsProcess.h
index 33fa996ebb5da3c7efe22c37a3a7ba80eba83605..2c8e328f2a6ad247c6855cc68320db38deeae71b 100644
--- a/ProcessLib/ThermoMechanics/CreateThermoMechanicsProcess.h
+++ b/ProcessLib/ThermoMechanics/CreateThermoMechanicsProcess.h
@@ -39,6 +39,7 @@ namespace ThermoMechanics
 {
 template <int DisplacementDim>
 std::unique_ptr<Process> createThermoMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -49,6 +50,7 @@ std::unique_ptr<Process> createThermoMechanicsProcess(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createThermoMechanicsProcess<2>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -59,6 +61,7 @@ extern template std::unique_ptr<Process> createThermoMechanicsProcess<2>(
     BaseLib::ConfigTree const& config);
 
 extern template std::unique_ptr<Process> createThermoMechanicsProcess<3>(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/ThermoMechanics/ThermoMechanicsProcess.cpp b/ProcessLib/ThermoMechanics/ThermoMechanicsProcess.cpp
index 1c6ffa068239a061df636d5476a38cdac35d71fe..5df40fcff52e15e888c8389e6c0fbec75242d4d3 100644
--- a/ProcessLib/ThermoMechanics/ThermoMechanicsProcess.cpp
+++ b/ProcessLib/ThermoMechanics/ThermoMechanicsProcess.cpp
@@ -23,6 +23,7 @@ namespace ThermoMechanics
 {
 template <int DisplacementDim>
 ThermoMechanicsProcess<DisplacementDim>::ThermoMechanicsProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -33,7 +34,7 @@ ThermoMechanicsProcess<DisplacementDim>::ThermoMechanicsProcess(
     SecondaryVariableCollection&& secondary_variables,
     NumLib::NamedFunctionCaller&& named_function_caller,
     bool const use_monolithic_scheme)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller),
               use_monolithic_scheme),
diff --git a/ProcessLib/ThermoMechanics/ThermoMechanicsProcess.h b/ProcessLib/ThermoMechanics/ThermoMechanicsProcess.h
index 8acc1fc037f0812bc28be101924ed0bc828a26b3..67f7cdb91e8ae3b1b4e523c84d4aa13342a1c583 100644
--- a/ProcessLib/ThermoMechanics/ThermoMechanicsProcess.h
+++ b/ProcessLib/ThermoMechanics/ThermoMechanicsProcess.h
@@ -63,6 +63,7 @@ class ThermoMechanicsProcess final : public Process
 {
 public:
     ThermoMechanicsProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&&
             jacobian_assembler,
diff --git a/ProcessLib/TwoPhaseFlowWithPP/CreateTwoPhaseFlowWithPPProcess.cpp b/ProcessLib/TwoPhaseFlowWithPP/CreateTwoPhaseFlowWithPPProcess.cpp
index bf80c7a301a029ca702b2dfc222476752a4981c3..aae871671ca3f0c505daad3839136cccac6482a8 100644
--- a/ProcessLib/TwoPhaseFlowWithPP/CreateTwoPhaseFlowWithPPProcess.cpp
+++ b/ProcessLib/TwoPhaseFlowWithPP/CreateTwoPhaseFlowWithPPProcess.cpp
@@ -24,6 +24,7 @@ namespace ProcessLib
 namespace TwoPhaseFlowWithPP
 {
 std::unique_ptr<Process> createTwoPhaseFlowWithPPProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -98,10 +99,10 @@ std::unique_ptr<Process> createTwoPhaseFlowWithPPProcess(
         specific_body_force, has_gravity, mass_lumping, temperature, std::move(material)};
 
     return std::make_unique<TwoPhaseFlowWithPPProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        mat_config, curves);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), mat_config, curves);
 }
 
 }  // namespace TwoPhaseFlowWithPP
diff --git a/ProcessLib/TwoPhaseFlowWithPP/CreateTwoPhaseFlowWithPPProcess.h b/ProcessLib/TwoPhaseFlowWithPP/CreateTwoPhaseFlowWithPPProcess.h
index f73dd488d1d89bafbe43e619c9df1c02854d1c3d..94701d90625330e93aa58821f703d6b96f938904 100644
--- a/ProcessLib/TwoPhaseFlowWithPP/CreateTwoPhaseFlowWithPPProcess.h
+++ b/ProcessLib/TwoPhaseFlowWithPP/CreateTwoPhaseFlowWithPPProcess.h
@@ -17,6 +17,7 @@ namespace ProcessLib
 namespace TwoPhaseFlowWithPP
 {
 std::unique_ptr<Process> createTwoPhaseFlowWithPPProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPProcess.cpp b/ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPProcess.cpp
index 4c5152c1de04de15e2af5b40e105e7a687e80554..c7558a5178921e1cd4102dc92d521e366644abce 100644
--- a/ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPProcess.cpp
+++ b/ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPProcess.cpp
@@ -24,6 +24,7 @@ namespace ProcessLib
 namespace TwoPhaseFlowWithPP
 {
 TwoPhaseFlowWithPPProcess::TwoPhaseFlowWithPPProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -37,7 +38,7 @@ TwoPhaseFlowWithPPProcess::TwoPhaseFlowWithPPProcess(
     std::map<std::string,
              std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
     /*curves*/)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data))
diff --git a/ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPProcess.h b/ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPProcess.h
index 849abea0464bef275f5b51563c50b83ad7bfdd40..0c1678a95b28d7bae9f7a4075959b57b11fafdfb 100644
--- a/ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPProcess.h
+++ b/ProcessLib/TwoPhaseFlowWithPP/TwoPhaseFlowWithPPProcess.h
@@ -36,6 +36,7 @@ class TwoPhaseFlowWithPPProcess final : public Process
 {
 public:
     TwoPhaseFlowWithPPProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
         std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&
diff --git a/ProcessLib/TwoPhaseFlowWithPrho/CreateTwoPhaseFlowWithPrhoProcess.cpp b/ProcessLib/TwoPhaseFlowWithPrho/CreateTwoPhaseFlowWithPrhoProcess.cpp
index 104272d7d461cf1cfca00b0e3c29d7695854bb01..5bc45f50a8bcff2de846eb86d04bcb7fb2e9b61c 100644
--- a/ProcessLib/TwoPhaseFlowWithPrho/CreateTwoPhaseFlowWithPrhoProcess.cpp
+++ b/ProcessLib/TwoPhaseFlowWithPrho/CreateTwoPhaseFlowWithPrhoProcess.cpp
@@ -24,6 +24,7 @@ namespace ProcessLib
 namespace TwoPhaseFlowWithPrho
 {
 std::unique_ptr<Process> createTwoPhaseFlowWithPrhoProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
@@ -111,10 +112,10 @@ std::unique_ptr<Process> createTwoPhaseFlowWithPrhoProcess(
         diff_coeff_a,        temperature, std::move(material)};
 
     return std::make_unique<TwoPhaseFlowWithPrhoProcess>(
-        mesh, std::move(jacobian_assembler), parameters, integration_order,
-        std::move(process_variables), std::move(process_data),
-        std::move(secondary_variables), std::move(named_function_caller),
-        mat_config, curves);
+        std::move(name), mesh, std::move(jacobian_assembler), parameters,
+        integration_order, std::move(process_variables),
+        std::move(process_data), std::move(secondary_variables),
+        std::move(named_function_caller), mat_config, curves);
 }
 
 }  // namespace TwoPhaseFlowWithPrho
diff --git a/ProcessLib/TwoPhaseFlowWithPrho/CreateTwoPhaseFlowWithPrhoProcess.h b/ProcessLib/TwoPhaseFlowWithPrho/CreateTwoPhaseFlowWithPrhoProcess.h
index 38b796e9920db87d193c4fc4ce00a8b508e79084..f11b2d3f3209b4d27665112e572d58c03ac7f849 100644
--- a/ProcessLib/TwoPhaseFlowWithPrho/CreateTwoPhaseFlowWithPrhoProcess.h
+++ b/ProcessLib/TwoPhaseFlowWithPrho/CreateTwoPhaseFlowWithPrhoProcess.h
@@ -17,6 +17,7 @@ namespace ProcessLib
 namespace TwoPhaseFlowWithPrho
 {
 std::unique_ptr<Process> createTwoPhaseFlowWithPrhoProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<ProcessLib::AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<ProcessVariable> const& variables,
diff --git a/ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoProcess.cpp b/ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoProcess.cpp
index ad4e4c122bc4e3cf5f26253187ee648780d56346..71d4c3d1d5a4908d8478294fa8a744f6500a7c91 100644
--- a/ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoProcess.cpp
+++ b/ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoProcess.cpp
@@ -24,6 +24,7 @@ namespace ProcessLib
 namespace TwoPhaseFlowWithPrho
 {
 TwoPhaseFlowWithPrhoProcess::TwoPhaseFlowWithPrhoProcess(
+    std::string name,
     MeshLib::Mesh& mesh,
     std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
     std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const& parameters,
@@ -37,7 +38,7 @@ TwoPhaseFlowWithPrhoProcess::TwoPhaseFlowWithPrhoProcess(
     std::map<std::string,
              std::unique_ptr<MathLib::PiecewiseLinearInterpolation>> const&
     /*curves*/)
-    : Process(mesh, std::move(jacobian_assembler), parameters,
+    : Process(std::move(name), mesh, std::move(jacobian_assembler), parameters,
               integration_order, std::move(process_variables),
               std::move(secondary_variables), std::move(named_function_caller)),
       _process_data(std::move(process_data))
diff --git a/ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoProcess.h b/ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoProcess.h
index 9e622a4389bb4d20c902e54370097639c573420d..80f6272651c9c125ce11decb3533eb380e565787 100644
--- a/ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoProcess.h
+++ b/ProcessLib/TwoPhaseFlowWithPrho/TwoPhaseFlowWithPrhoProcess.h
@@ -34,6 +34,7 @@ class TwoPhaseFlowWithPrhoProcess final : public Process
 {
 public:
     TwoPhaseFlowWithPrhoProcess(
+        std::string name,
         MeshLib::Mesh& mesh,
         std::unique_ptr<AbstractJacobianAssembler>&& jacobian_assembler,
         std::vector<std::unique_ptr<ParameterLib::ParameterBase>> const&