diff --git a/src/language/modules/WriterModule.cpp b/src/language/modules/WriterModule.cpp
index bb5ccdf3dd41c58632f3e438587e330fe5777530..c447ed188ce794aeea9ddec00775254d405e211b 100644
--- a/src/language/modules/WriterModule.cpp
+++ b/src/language/modules/WriterModule.cpp
@@ -192,81 +192,80 @@ WriterModule::WriterModule()
 
                               ));
 
-  this->_addBuiltinFunction(
-    "write",
-    std::make_shared<
-      BuiltinFunctionEmbedder<void(std::shared_ptr<const IWriter>,
+  this->_addBuiltinFunction("write",
+                            std::make_shared<BuiltinFunctionEmbedder<
+                              void(std::shared_ptr<const IWriter>,
                                    const std::vector<std::shared_ptr<const NamedDiscreteFunction>>&, const double&)>>(
 
-      [](std::shared_ptr<const IWriter> writer,
-         const std::vector<std::shared_ptr<const NamedDiscreteFunction>>& named_discrete_function_list,
-         const double& time) -> void {
-        Assert(named_discrete_function_list.size() > 0);
-
-        std::shared_ptr p_mesh = named_discrete_function_list[0]->discreteFunction()->mesh();
-        for (size_t i = 1; i < named_discrete_function_list.size(); ++i) {
-          if (p_mesh != named_discrete_function_list[i]->discreteFunction()->mesh()) {
-            std::ostringstream error_msg;
-            error_msg << "discrete functions must be defined on the same mesh!\n"
-                      << rang::fgB::yellow << "note:" << rang::style::reset << " cannot write " << rang::fgB::blue
-                      << named_discrete_function_list[0]->name() << rang::style::reset << " and " << rang::fgB::blue
-                      << named_discrete_function_list[i]->name() << rang::style::reset << " in the same file.";
-            throw NormalError(error_msg.str());
-          }
-        }
-
-        OutputNamedItemValueSet named_item_value_set;
-
-        for (auto& named_discrete_function : named_discrete_function_list) {
-          const IDiscreteFunction& i_discrete_function = *named_discrete_function->discreteFunction();
-
-          switch (i_discrete_function.descriptor().type()) {
-          case DiscreteFunctionType::P0: {
-            WriterModule::registerDiscreteFunctionP0(*named_discrete_function, named_item_value_set);
-            break;
-          }
-          default: {
-            std::ostringstream error_msg;
-            error_msg << "the type of discrete function of " << rang::fgB::blue << named_discrete_function->name()
-                      << rang::style::reset << " is not supported";
-            throw NormalError(error_msg.str());
-          }
-          }
-        }
-
-        switch (p_mesh->dimension()) {
-        case 1: {
-          using MeshType                             = Mesh<Connectivity<1>>;
-          const std::shared_ptr<const MeshType> mesh = std::dynamic_pointer_cast<const MeshType>(p_mesh);
-
-          named_item_value_set.add(NamedItemValue{"cell_number", mesh->connectivity().cellNumber()});
-          named_item_value_set.add(NamedItemValue{"node_number", mesh->connectivity().nodeNumber()});
+                              [](std::shared_ptr<const IWriter> writer,
+                                 const std::vector<std::shared_ptr<const NamedDiscreteFunction>>&
+                                   named_discrete_function_list,
+                                 const double& time) -> void {
+                                Assert(named_discrete_function_list.size() > 0);
+
+                                std::shared_ptr p_mesh = named_discrete_function_list[0]->discreteFunction()->mesh();
+                                for (size_t i = 1; i < named_discrete_function_list.size(); ++i) {
+                                  if (p_mesh != named_discrete_function_list[i]->discreteFunction()->mesh()) {
+                                    std::ostringstream error_msg;
+                                    error_msg << "discrete functions must be defined on the same mesh!\n"
+                                              << rang::fgB::yellow << "note:" << rang::style::reset << " cannot write "
+                                              << rang::fgB::blue << named_discrete_function_list[0]->name()
+                                              << rang::style::reset << " and " << rang::fgB::blue
+                                              << named_discrete_function_list[i]->name() << rang::style::reset
+                                              << " in the same file.";
+                                    throw NormalError(error_msg.str());
+                                  }
+                                }
 
-          writer->write(mesh, named_item_value_set, time, true);
-          break;
-        }
-        case 2: {
-          using MeshType                             = Mesh<Connectivity<2>>;
-          const std::shared_ptr<const MeshType> mesh = std::dynamic_pointer_cast<const MeshType>(p_mesh);
+                                OutputNamedItemValueSet named_item_value_set;
+
+                                for (auto& named_discrete_function : named_discrete_function_list) {
+                                  const IDiscreteFunction& i_discrete_function =
+                                    *named_discrete_function->discreteFunction();
+
+                                  switch (i_discrete_function.descriptor().type()) {
+                                  case DiscreteFunctionType::P0: {
+                                    WriterModule::registerDiscreteFunctionP0(*named_discrete_function,
+                                                                             named_item_value_set);
+                                    break;
+                                  }
+                                  default: {
+                                    std::ostringstream error_msg;
+                                    error_msg << "the type of discrete function of " << rang::fgB::blue
+                                              << named_discrete_function->name() << rang::style::reset
+                                              << " is not supported";
+                                    throw NormalError(error_msg.str());
+                                  }
+                                  }
+                                }
 
-          named_item_value_set.add(NamedItemValue{"cell_number", mesh->connectivity().cellNumber()});
-          named_item_value_set.add(NamedItemValue{"node_number", mesh->connectivity().nodeNumber()});
+                                switch (p_mesh->dimension()) {
+                                case 1: {
+                                  using MeshType = Mesh<Connectivity<1>>;
+                                  const std::shared_ptr<const MeshType> mesh =
+                                    std::dynamic_pointer_cast<const MeshType>(p_mesh);
 
-          writer->write(mesh, named_item_value_set, time, true);
-          break;
-        }
-        case 3: {
-          using MeshType                             = Mesh<Connectivity<3>>;
-          const std::shared_ptr<const MeshType> mesh = std::dynamic_pointer_cast<const MeshType>(p_mesh);
+                                  writer->write(mesh, named_item_value_set, time, true);
+                                  break;
+                                }
+                                case 2: {
+                                  using MeshType = Mesh<Connectivity<2>>;
+                                  const std::shared_ptr<const MeshType> mesh =
+                                    std::dynamic_pointer_cast<const MeshType>(p_mesh);
 
-          named_item_value_set.add(NamedItemValue{"cell_number", mesh->connectivity().cellNumber()});
-          named_item_value_set.add(NamedItemValue{"node_number", mesh->connectivity().nodeNumber()});
+                                  writer->write(mesh, named_item_value_set, time, true);
+                                  break;
+                                }
+                                case 3: {
+                                  using MeshType = Mesh<Connectivity<3>>;
+                                  const std::shared_ptr<const MeshType> mesh =
+                                    std::dynamic_pointer_cast<const MeshType>(p_mesh);
 
-          writer->write(mesh, named_item_value_set, time, true);
-          break;
-        }
-        }
-      }
+                                  writer->write(mesh, named_item_value_set, time, true);
+                                  break;
+                                }
+                                }
+                              }
 
-      ));
+                              ));
 }
diff --git a/src/output/VTKWriter.cpp b/src/output/VTKWriter.cpp
index 796a1c0ff9703697be92be2633ab2ca2a92805bb..a0b4921abba97cbe2ff6e08be2358114d91d3e84 100644
--- a/src/output/VTKWriter.cpp
+++ b/src/output/VTKWriter.cpp
@@ -272,10 +272,15 @@ VTKWriter::_write_cell_value(std::ofstream&, const std::string&, const NodeValue
 template <typename MeshType>
 void
 VTKWriter::_write(const std::shared_ptr<const MeshType>& mesh,
-                  const OutputNamedItemValueSet& output_named_item_value_set,
+                  const OutputNamedItemValueSet& given_output_named_item_value_set,
                   double time,
                   bool forced_output) const
 {
+  OutputNamedItemValueSet output_named_item_value_set{given_output_named_item_value_set};
+  // Adding basic mesh information
+  output_named_item_value_set.add(NamedItemValue{"cell_number", mesh->connectivity().cellNumber()});
+  output_named_item_value_set.add(NamedItemValue{"node_number", mesh->connectivity().nodeNumber()});
+
   if (time == m_last_time)
     return;   // output already performed
   if ((time - m_last_time >= m_time_period) or forced_output) {