diff --git a/src/language/modules/SchemeModule.cpp b/src/language/modules/SchemeModule.cpp
index 4279c969d7e3b40b0cef33a790180bc438b3db4c..523ad87290144b3819322b77b6f71a3b1b6b0cab 100644
--- a/src/language/modules/SchemeModule.cpp
+++ b/src/language/modules/SchemeModule.cpp
@@ -406,19 +406,17 @@ SchemeModule::SchemeModule()
   this->_addBuiltinFunction("parabolicheat",
                             std::make_shared<BuiltinFunctionEmbedder<
                               std::shared_ptr<const IDiscreteFunction>(const std::shared_ptr<const IDiscreteFunction>&,
-                                                                       const std::shared_ptr<const IDiscreteFunction>&,
                                                                        const std::shared_ptr<const IDiscreteFunction>&,
                                                                        const std::shared_ptr<const IDiscreteFunction>&,
                                                                        const std::vector<std::shared_ptr<
                                                                          const IBoundaryConditionDescriptor>>&)>>(
 
                               [](const std::shared_ptr<const IDiscreteFunction>& alpha,
-                                 const std::shared_ptr<const IDiscreteFunction>& mu,
                                  const std::shared_ptr<const IDiscreteFunction>& mu_dual,
                                  const std::shared_ptr<const IDiscreteFunction>& f,
-                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_list)
-                                -> const std::shared_ptr<const IDiscreteFunction> {
-                                return ScalarDiamondSchemeHandler{alpha, mu, mu_dual, f, bc_list}.solution();
+                                 const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>&
+                                   bc_descriptor_list) -> const std::shared_ptr<const IDiscreteFunction> {
+                                return ScalarDiamondSchemeHandler{alpha, mu_dual, f, bc_descriptor_list}.solution();
                               }
 
                               ));
diff --git a/src/scheme/ScalarDiamondScheme.cpp b/src/scheme/ScalarDiamondScheme.cpp
index 464d943841e5f1a718398b0b3a3c3ec26553a83d..93538514fc93ac7a566bddc270228beee34479c0 100644
--- a/src/scheme/ScalarDiamondScheme.cpp
+++ b/src/scheme/ScalarDiamondScheme.cpp
@@ -1,4 +1,3 @@
-
 #include <scheme/ScalarDiamondScheme.hpp>
 
 #include <scheme/DiscreteFunctionP0.hpp>
@@ -277,11 +276,14 @@ class ScalarDiamondSchemeHandler::ScalarDiamondScheme : public ScalarDiamondSche
 
   ScalarDiamondScheme(const std::shared_ptr<const MeshType>& mesh,
                       const std::shared_ptr<const DiscreteFunctionP0<Dimension, double>>& alpha,
-                      const std::shared_ptr<const DiscreteFunctionP0<Dimension, double>>& mu,
                       const std::shared_ptr<const DiscreteFunctionP0<Dimension, double>>& dual_mu,
                       const std::shared_ptr<const DiscreteFunctionP0<Dimension, double>>& f,
                       const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list)
   {
+    if (DiamondDualMeshManager::instance().getDiamondDualMesh(mesh) != dual_mu->mesh()) {
+      throw NormalError("diffusion coefficient is not defined on the dual mesh!");
+    }
+
     constexpr ItemType FaceType = [] {
       if constexpr (Dimension > 1) {
         return ItemType::face;
@@ -489,7 +491,6 @@ class ScalarDiamondSchemeHandler::ScalarDiamondScheme : public ScalarDiamondSche
           DiamondDualConnectivityManager::instance().getConnectivityToDiamondDualConnectivityDataMapper(
             mesh->connectivity());
 
-        CellValue<const double> kappaj      = mu->cellValues();
         CellValue<const double> dual_kappaj = dual_mu->cellValues();
 
         const CellValue<const double> dual_Vj = diamond_mesh_data.Vj();
@@ -757,28 +758,21 @@ ScalarDiamondSchemeHandler::solution() const
 
 ScalarDiamondSchemeHandler::ScalarDiamondSchemeHandler(
   const std::shared_ptr<const IDiscreteFunction>& alpha,
-  const std::shared_ptr<const IDiscreteFunction>& mu,
   const std::shared_ptr<const IDiscreteFunction>& dual_mu,
   const std::shared_ptr<const IDiscreteFunction>& f,
   const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list)
 {
-  const std::shared_ptr i_mesh = getCommonMesh({alpha, mu, f});
-  checkDiscretizationType({alpha, mu, dual_mu, f}, DiscreteFunctionType::P0);
+  const std::shared_ptr i_mesh = getCommonMesh({alpha, f});
+  checkDiscretizationType({alpha, dual_mu, f}, DiscreteFunctionType::P0);
 
   switch (i_mesh->dimension()) {
   case 1: {
     using MeshType                   = Mesh<Connectivity<1>>;
     using DiscreteScalarFunctionType = DiscreteFunctionP0<1, double>;
 
-    std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
-
-    if (DiamondDualMeshManager::instance().getDiamondDualMesh(mesh) != dual_mu->mesh()) {
-      throw NormalError("mu_dual is not defined on the dual mesh");
-    }
-
     m_scheme =
-      std::make_unique<ScalarDiamondScheme<1>>(mesh, std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(alpha),
-                                               std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(mu),
+      std::make_unique<ScalarDiamondScheme<1>>(std::dynamic_pointer_cast<const MeshType>(i_mesh),
+                                               std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(alpha),
                                                std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(dual_mu),
                                                std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(f),
                                                bc_descriptor_list);
@@ -788,15 +782,9 @@ ScalarDiamondSchemeHandler::ScalarDiamondSchemeHandler(
     using MeshType                   = Mesh<Connectivity<2>>;
     using DiscreteScalarFunctionType = DiscreteFunctionP0<2, double>;
 
-    std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
-
-    if (DiamondDualMeshManager::instance().getDiamondDualMesh(mesh) != dual_mu->mesh()) {
-      throw NormalError("mu_dual is not defined on the dual mesh");
-    }
-
     m_scheme =
-      std::make_unique<ScalarDiamondScheme<2>>(mesh, std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(alpha),
-                                               std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(mu),
+      std::make_unique<ScalarDiamondScheme<2>>(std::dynamic_pointer_cast<const MeshType>(i_mesh),
+                                               std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(alpha),
                                                std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(dual_mu),
                                                std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(f),
                                                bc_descriptor_list);
@@ -806,15 +794,9 @@ ScalarDiamondSchemeHandler::ScalarDiamondSchemeHandler(
     using MeshType                   = Mesh<Connectivity<3>>;
     using DiscreteScalarFunctionType = DiscreteFunctionP0<3, double>;
 
-    std::shared_ptr mesh = std::dynamic_pointer_cast<const MeshType>(i_mesh);
-
-    if (DiamondDualMeshManager::instance().getDiamondDualMesh(mesh) != dual_mu->mesh()) {
-      throw NormalError("mu_dual is not defined on the dual mesh");
-    }
-
     m_scheme =
-      std::make_unique<ScalarDiamondScheme<3>>(mesh, std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(alpha),
-                                               std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(mu),
+      std::make_unique<ScalarDiamondScheme<3>>(std::dynamic_pointer_cast<const MeshType>(i_mesh),
+                                               std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(alpha),
                                                std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(dual_mu),
                                                std::dynamic_pointer_cast<const DiscreteScalarFunctionType>(f),
                                                bc_descriptor_list);
diff --git a/src/scheme/ScalarDiamondScheme.hpp b/src/scheme/ScalarDiamondScheme.hpp
index 5cffe9326ef241d8aeb465939cbdd3ec285414e1..efdd2937b0c4127b170a96fd780a493db41b8178 100644
--- a/src/scheme/ScalarDiamondScheme.hpp
+++ b/src/scheme/ScalarDiamondScheme.hpp
@@ -42,7 +42,6 @@ class ScalarDiamondSchemeHandler
 
   ScalarDiamondSchemeHandler(
     const std::shared_ptr<const IDiscreteFunction>& alpha,
-    const std::shared_ptr<const IDiscreteFunction>& mu,
     const std::shared_ptr<const IDiscreteFunction>& mu_dual,
     const std::shared_ptr<const IDiscreteFunction>& f,
     const std::vector<std::shared_ptr<const IBoundaryConditionDescriptor>>& bc_descriptor_list);