diff --git a/src/analysis/GaussLegendreQuadratureDescriptor.hpp b/src/analysis/GaussLegendreQuadratureDescriptor.hpp
index 4cccc87e0185c041bcf4fd85d013852b1ec69828..c37122516fa67650307aaab421120da9353f51d0 100644
--- a/src/analysis/GaussLegendreQuadratureDescriptor.hpp
+++ b/src/analysis/GaussLegendreQuadratureDescriptor.hpp
@@ -33,7 +33,7 @@ class GaussLegendreQuadratureDescriptor final : public IQuadratureDescriptor
   name() const
   {
     std::ostringstream os;
-    os << "GaussLegendre(" << m_degree << ")";
+    os << ::name(this->type()) << "(" << m_degree << ")";
     return os.str();
   }
 
diff --git a/src/analysis/GaussLobattoQuadratureDescriptor.hpp b/src/analysis/GaussLobattoQuadratureDescriptor.hpp
index 5b939437b71b868896b08bfeb4652c0e279b1de4..0cc3a8e6ef108af6708098c0735338621ed880a4 100644
--- a/src/analysis/GaussLobattoQuadratureDescriptor.hpp
+++ b/src/analysis/GaussLobattoQuadratureDescriptor.hpp
@@ -33,7 +33,7 @@ class GaussLobattoQuadratureDescriptor final : public IQuadratureDescriptor
   name() const
   {
     std::ostringstream os;
-    os << "GaussLobatto(" << m_degree << ")";
+    os << ::name(this->type()) << "(" << m_degree << ")";
     return os.str();
   }
 
diff --git a/src/analysis/GaussQuadratureDescriptor.hpp b/src/analysis/GaussQuadratureDescriptor.hpp
index 13282f65d347b7acb4a6c8b94ebed811d136b26c..752ac40d4fa3b609f848ea82bf10b0576a3e794f 100644
--- a/src/analysis/GaussQuadratureDescriptor.hpp
+++ b/src/analysis/GaussQuadratureDescriptor.hpp
@@ -33,7 +33,7 @@ class GaussQuadratureDescriptor final : public IQuadratureDescriptor
   name() const
   {
     std::ostringstream os;
-    os << "Gauss(" << m_degree << ")";
+    os << ::name(this->type()) << "(" << m_degree << ")";
     return os.str();
   }
 
diff --git a/src/analysis/QuadratureManager.cpp b/src/analysis/QuadratureManager.cpp
index a8063a2f6c758d16ec6b3ac1490e72e3b46fea8d..ca63299d184197d3a63168b87111646aec9bf5b7 100644
--- a/src/analysis/QuadratureManager.cpp
+++ b/src/analysis/QuadratureManager.cpp
@@ -176,19 +176,19 @@ QuadratureManager::QuadratureManager()
     m_pyramid_gauss_formula_list{this->_buildPyramidGaussFormulaList()},
     m_tetrahedron_gauss_formula_list{this->_buildTetrahedronGaussFormulaList()}
 {
-  Assert(this->maxGaussLegendreDegree() == TensorialGaussLegendreQuadrature<1>::max_degree);
-  Assert(this->maxGaussLegendreDegree() == TensorialGaussLegendreQuadrature<2>::max_degree);
-  Assert(this->maxGaussLegendreDegree() == TensorialGaussLegendreQuadrature<3>::max_degree);
+  Assert(m_line_gauss_legendre_formula_list.size() * 2 - 1 == TensorialGaussLegendreQuadrature<1>::max_degree);
+  Assert(m_square_gauss_legendre_formula_list.size() * 2 - 1 == TensorialGaussLegendreQuadrature<2>::max_degree);
+  Assert(m_cube_gauss_legendre_formula_list.size() * 2 - 1 == TensorialGaussLegendreQuadrature<3>::max_degree);
 
-  Assert(this->maxGaussLobattoDegree() == TensorialGaussLobattoQuadrature<1>::max_degree);
-  Assert(this->maxGaussLobattoDegree() == TensorialGaussLobattoQuadrature<2>::max_degree);
-  Assert(this->maxGaussLobattoDegree() == TensorialGaussLobattoQuadrature<3>::max_degree);
+  Assert(m_line_gauss_lobatto_formula_list.size() * 2 - 1 == TensorialGaussLobattoQuadrature<1>::max_degree);
+  Assert(m_square_gauss_lobatto_formula_list.size() * 2 - 1 == TensorialGaussLobattoQuadrature<2>::max_degree);
+  Assert(m_cube_gauss_lobatto_formula_list.size() * 2 - 1 == TensorialGaussLobattoQuadrature<3>::max_degree);
 
-  Assert(this->maxSquareGaussDegree() == SquareGaussQuadrature::max_degree);
-  Assert(this->maxTriangleGaussDegree() == TriangleGaussQuadrature::max_degree);
+  Assert(m_square_gauss_formula_list.size() * 2 - 1 == SquareGaussQuadrature::max_degree);
+  Assert(m_triangle_gauss_formula_list.size() == TriangleGaussQuadrature::max_degree);
 
-  Assert(this->maxCubeGaussDegree() == CubeGaussQuadrature::max_degree);
-  Assert(this->maxPrismGaussDegree() == PrismGaussQuadrature::max_degree);
-  Assert(this->maxPyramidGaussDegree() == PyramidGaussQuadrature::max_degree);
-  Assert(this->maxTetrahedronGaussDegree() == TetrahedronGaussQuadrature::max_degree);
+  Assert(m_cube_gauss_formula_list.size() * 2 - 1 == CubeGaussQuadrature::max_degree);
+  Assert(m_prism_gauss_formula_list.size() == PrismGaussQuadrature::max_degree);
+  Assert(m_pyramid_gauss_formula_list.size() == PyramidGaussQuadrature::max_degree);
+  Assert(m_tetrahedron_gauss_formula_list.size() == TetrahedronGaussQuadrature::max_degree);
 }
diff --git a/src/analysis/QuadratureManager.hpp b/src/analysis/QuadratureManager.hpp
index d205c457fa17be4abbefa9f239d8db51dabde087..b0f81c543c0612181cc5728b2c7ef36fc1e25515 100644
--- a/src/analysis/QuadratureManager.hpp
+++ b/src/analysis/QuadratureManager.hpp
@@ -44,24 +44,6 @@ class QuadratureManager
   Array<const QuadratureFormula<3>> _buildTetrahedronGaussFormulaList();
 
  public:
-  size_t
-  maxGaussLegendreDegree() const
-  {
-    Assert(m_square_gauss_legendre_formula_list.size() == m_line_gauss_legendre_formula_list.size());
-    Assert(m_cube_gauss_legendre_formula_list.size() == m_line_gauss_legendre_formula_list.size());
-
-    return m_line_gauss_legendre_formula_list.size() * 2 - 1;
-  }
-
-  size_t
-  maxGaussLobattoDegree() const
-  {
-    Assert(m_square_gauss_lobatto_formula_list.size() == m_line_gauss_lobatto_formula_list.size());
-    Assert(m_cube_gauss_lobatto_formula_list.size() == m_line_gauss_lobatto_formula_list.size());
-
-    return m_line_gauss_lobatto_formula_list.size() * 2 - 1;
-  }
-
   const QuadratureFormula<1>&
   getLineFormula(const IQuadratureDescriptor& quadrature_descriptor) const
   {
@@ -171,116 +153,111 @@ class QuadratureManager
     }
   }
 
-  const QuadratureFormula<1>&
-  getLineGaussLegendreFormula(const size_t degree) const
-  {
-    return m_line_gauss_legendre_formula_list[degree / 2];
-  }
-
-  const QuadratureFormula<1>&
-  getLineGaussLobattoFormula(const size_t degree) const
-  {
-    return m_line_gauss_lobatto_formula_list[degree / 2];
-  }
-
   size_t
-  maxSquareGaussDegree() const
+  maxLineDegree(const QuadratureType type) const
   {
-    return m_square_gauss_formula_list.size() * 2 - 1;
-  }
-
-  const QuadratureFormula<2>&
-  getSquareGaussFormula(const size_t degree) const
-  {
-    return m_square_gauss_formula_list[degree / 2];
-  }
-
-  const QuadratureFormula<2>&
-  getSquareGaussLegendreFormula(const size_t degree) const
-  {
-    return m_square_gauss_legendre_formula_list[degree / 2];
-  }
-
-  const QuadratureFormula<2>&
-  getSquareGaussLobattoFormula(const size_t degree) const
-  {
-    return m_square_gauss_lobatto_formula_list[degree / 2];
+    switch (type) {
+    case QuadratureType::Gauss:
+    case QuadratureType::GaussLegendre: {
+      return m_line_gauss_legendre_formula_list.size() * 2 - 1;
+    }
+    case QuadratureType::GaussLobatto: {
+      return m_line_gauss_lobatto_formula_list.size() * 2 - 1;
+    }
+    default: {
+      throw UnexpectedError("invalid quadrature type");
+    }
+    }
   }
 
   size_t
-  maxTriangleGaussDegree() const
-  {
-    return m_triangle_gauss_formula_list.size();
-  }
-
-  const QuadratureFormula<2>&
-  getTriangleGaussFormula(const size_t degree) const
+  maxSquareDegree(const QuadratureType type) const
   {
-    Assert(degree > 0);
-    return m_triangle_gauss_formula_list[degree - 1];
+    switch (type) {
+    case QuadratureType::Gauss: {
+      return m_square_gauss_formula_list.size() * 2 - 1;
+    }
+    case QuadratureType::GaussLegendre: {
+      return m_square_gauss_legendre_formula_list.size() * 2 - 1;
+    }
+    case QuadratureType::GaussLobatto: {
+      return m_square_gauss_lobatto_formula_list.size() * 2 - 1;
+    }
+    default: {
+      throw UnexpectedError("invalid quadrature type");
+    }
+    }
   }
 
   size_t
-  maxCubeGaussDegree() const
+  maxTriangleDegree(const QuadratureType type) const
   {
-    return m_cube_gauss_formula_list.size() * 2 - 1;
-  }
-
-  const QuadratureFormula<3>&
-  getCubeGaussFormula(const size_t degree) const
-  {
-    return m_cube_gauss_formula_list[degree / 2];
-  }
-
-  const QuadratureFormula<3>&
-  getCubeGaussLegendreFormula(const size_t degree) const
-  {
-    return m_cube_gauss_legendre_formula_list[degree / 2];
-  }
-
-  const QuadratureFormula<3>&
-  getCubeGaussLobattoFormula(const size_t degree) const
-  {
-    return m_cube_gauss_lobatto_formula_list[degree / 2];
+    switch (type) {
+    case QuadratureType::Gauss: {
+      return m_triangle_gauss_formula_list.size();
+    }
+    default: {
+      throw UnexpectedError(name(type) + " is not defined on triangle");
+    }
+    }
   }
 
   size_t
-  maxPrismGaussDegree() const
+  maxCubeDegree(const QuadratureType type) const
   {
-    return m_prism_gauss_formula_list.size();
-  }
-
-  const QuadratureFormula<3>&
-  getPrismGaussFormula(const size_t degree) const
-  {
-    Assert(degree > 0);
-    return m_prism_gauss_formula_list[degree - 1];
+    switch (type) {
+    case QuadratureType::Gauss: {
+      return m_cube_gauss_formula_list.size() * 2 - 1;
+    }
+    case QuadratureType::GaussLegendre: {
+      return m_cube_gauss_legendre_formula_list.size() * 2 - 1;
+    }
+    case QuadratureType::GaussLobatto: {
+      return m_cube_gauss_lobatto_formula_list.size() * 2 - 1;
+    }
+    default: {
+      throw UnexpectedError("invalid quadrature type");
+    }
+    }
   }
 
   size_t
-  maxPyramidGaussDegree() const
+  maxPrismDegree(const QuadratureType type) const
   {
-    return m_prism_gauss_formula_list.size();
-  }
-
-  const QuadratureFormula<3>&
-  getPyramidGaussFormula(const size_t degree) const
-  {
-    Assert(degree > 0);
-    return m_pyramid_gauss_formula_list[degree - 1];
+    switch (type) {
+    case QuadratureType::Gauss: {
+      return m_prism_gauss_formula_list.size();
+    }
+    default: {
+      throw UnexpectedError(::name(type) + " is not defined on prism");
+    }
+    }
   }
 
   size_t
-  maxTetrahedronGaussDegree() const
+  maxPyramidDegree(const QuadratureType type) const
   {
-    return m_tetrahedron_gauss_formula_list.size();
+    switch (type) {
+    case QuadratureType::Gauss: {
+      return m_pyramid_gauss_formula_list.size();
+    }
+    default: {
+      throw UnexpectedError(::name(type) + " is not defined on pyramid");
+    }
+    }
   }
 
-  const QuadratureFormula<3>&
-  getTetrahedronGaussFormula(const size_t degree) const
+  size_t
+  maxTetrahedronDegree(const QuadratureType type) const
   {
-    Assert(degree > 0);
-    return m_tetrahedron_gauss_formula_list[degree - 1];
+    switch (type) {
+    case QuadratureType::Gauss: {
+      return m_tetrahedron_gauss_formula_list.size();
+    }
+    default: {
+      throw UnexpectedError(::name(type) + " is not defined on tetrahedron");
+    }
+    }
   }
 
   static void create();
diff --git a/src/analysis/QuadratureType.hpp b/src/analysis/QuadratureType.hpp
index 795961591a5fffefe9a6579943246895c136f861..1c67daa0daec9f4692e909194a5f2861245f0c7a 100644
--- a/src/analysis/QuadratureType.hpp
+++ b/src/analysis/QuadratureType.hpp
@@ -1,6 +1,11 @@
 #ifndef QUADRATURE_TYPE_HPP
 #define QUADRATURE_TYPE_HPP
 
+#include <utils/Exceptions.hpp>
+#include <utils/PugsMacros.hpp>
+
+#include <string>
+
 enum class QuadratureType
 {
   Gauss         = 0,
@@ -8,4 +13,24 @@ enum class QuadratureType
   GaussLobatto  = 2,
 };
 
+PUGS_INLINE
+std::string
+name(QuadratureType type)
+{
+  switch (type) {
+  case QuadratureType::Gauss: {
+    return "Gauss";
+  }
+  case QuadratureType::GaussLegendre: {
+    return "Gauss-Legendre";
+  }
+  case QuadratureType::GaussLobatto: {
+    return "Gauss-Lobatto";
+  }
+  default: {
+    throw UnexpectedError("unknown quadrature type name");
+  }
+  }
+}
+
 #endif   // QUADRATURE_TYPE_HPP
diff --git a/tests/test_CubeGaussQuadrature.cpp b/tests/test_CubeGaussQuadrature.cpp
index 73d687a621c5975ec525d342067d5a14c3b18efb..1db30eb178be24be223f63b5f6a68aa441261909 100644
--- a/tests/test_CubeGaussQuadrature.cpp
+++ b/tests/test_CubeGaussQuadrature.cpp
@@ -5,6 +5,7 @@
 #include <algebra/TinyMatrix.hpp>
 
 #include <analysis/CubeGaussQuadrature.hpp>
+#include <analysis/GaussQuadratureDescriptor.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <utils/Exceptions.hpp>
 
@@ -202,7 +203,7 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 0 and 1")
   {
-    const QuadratureFormula<3>& l1 = QuadratureManager::instance().getCubeGaussFormula(1);
+    const QuadratureFormula<3>& l1 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(1));
 
     REQUIRE(l1.numberOfPoints() == 1);
 
@@ -215,8 +216,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 2 and 3")
   {
-    const QuadratureFormula<3>& l2 = QuadratureManager::instance().getCubeGaussFormula(2);
-    const QuadratureFormula<3>& l3 = QuadratureManager::instance().getCubeGaussFormula(3);
+    const QuadratureFormula<3>& l2 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(2));
+    const QuadratureFormula<3>& l3 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(3));
 
     REQUIRE(&l2 == &l3);
 
@@ -233,8 +234,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 4 and 5")
   {
-    const QuadratureFormula<3>& l4 = QuadratureManager::instance().getCubeGaussFormula(4);
-    const QuadratureFormula<3>& l5 = QuadratureManager::instance().getCubeGaussFormula(5);
+    const QuadratureFormula<3>& l4 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(4));
+    const QuadratureFormula<3>& l5 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(5));
 
     REQUIRE(&l4 == &l5);
 
@@ -253,8 +254,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 6 and 7")
   {
-    const QuadratureFormula<3>& l6 = QuadratureManager::instance().getCubeGaussFormula(6);
-    const QuadratureFormula<3>& l7 = QuadratureManager::instance().getCubeGaussFormula(7);
+    const QuadratureFormula<3>& l6 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(6));
+    const QuadratureFormula<3>& l7 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(7));
 
     REQUIRE(&l6 == &l7);
 
@@ -275,8 +276,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 8 and 9")
   {
-    const QuadratureFormula<3>& l8 = QuadratureManager::instance().getCubeGaussFormula(8);
-    const QuadratureFormula<3>& l9 = QuadratureManager::instance().getCubeGaussFormula(9);
+    const QuadratureFormula<3>& l8 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(8));
+    const QuadratureFormula<3>& l9 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(9));
 
     REQUIRE(&l8 == &l9);
 
@@ -299,8 +300,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 10 and 11")
   {
-    const QuadratureFormula<3>& l10 = QuadratureManager::instance().getCubeGaussFormula(10);
-    const QuadratureFormula<3>& l11 = QuadratureManager::instance().getCubeGaussFormula(11);
+    const QuadratureFormula<3>& l10 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(10));
+    const QuadratureFormula<3>& l11 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(11));
 
     REQUIRE(&l10 == &l11);
 
@@ -325,8 +326,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 12 and 13")
   {
-    const QuadratureFormula<3>& l12 = QuadratureManager::instance().getCubeGaussFormula(12);
-    const QuadratureFormula<3>& l13 = QuadratureManager::instance().getCubeGaussFormula(13);
+    const QuadratureFormula<3>& l12 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(12));
+    const QuadratureFormula<3>& l13 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(13));
 
     REQUIRE(&l12 == &l13);
 
@@ -353,8 +354,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 14 and 15")
   {
-    const QuadratureFormula<3>& l14 = QuadratureManager::instance().getCubeGaussFormula(14);
-    const QuadratureFormula<3>& l15 = QuadratureManager::instance().getCubeGaussFormula(15);
+    const QuadratureFormula<3>& l14 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(14));
+    const QuadratureFormula<3>& l15 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(15));
 
     REQUIRE(&l14 == &l15);
 
@@ -383,8 +384,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 16 and 17")
   {
-    const QuadratureFormula<3>& l16 = QuadratureManager::instance().getCubeGaussFormula(16);
-    const QuadratureFormula<3>& l17 = QuadratureManager::instance().getCubeGaussFormula(17);
+    const QuadratureFormula<3>& l16 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(16));
+    const QuadratureFormula<3>& l17 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(17));
 
     REQUIRE(&l16 == &l17);
 
@@ -415,8 +416,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 18 and 19")
   {
-    const QuadratureFormula<3>& l18 = QuadratureManager::instance().getCubeGaussFormula(18);
-    const QuadratureFormula<3>& l19 = QuadratureManager::instance().getCubeGaussFormula(19);
+    const QuadratureFormula<3>& l18 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(18));
+    const QuadratureFormula<3>& l19 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(19));
 
     REQUIRE(&l18 == &l19);
 
@@ -449,8 +450,8 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("degree 20 and 21")
   {
-    const QuadratureFormula<3>& l20 = QuadratureManager::instance().getCubeGaussFormula(20);
-    const QuadratureFormula<3>& l21 = QuadratureManager::instance().getCubeGaussFormula(21);
+    const QuadratureFormula<3>& l20 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(20));
+    const QuadratureFormula<3>& l21 = QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(21));
 
     REQUIRE(&l20 == &l21);
 
@@ -486,12 +487,13 @@ TEST_CASE("CubeGaussQuadrature", "[analysis]")
 
   SECTION("max implemented degree")
   {
-    REQUIRE(QuadratureManager::instance().maxCubeGaussDegree() == CubeGaussQuadrature::max_degree);
+    REQUIRE(QuadratureManager::instance().maxCubeDegree(QuadratureType::Gauss) == CubeGaussQuadrature::max_degree);
   }
 
   SECTION("Access functions")
   {
-    const QuadratureFormula<3>& quadrature_formula = QuadratureManager::instance().getCubeGaussFormula(7);
+    const QuadratureFormula<3>& quadrature_formula =
+      QuadratureManager::instance().getCubeFormula(GaussQuadratureDescriptor(7));
 
     auto point_list  = quadrature_formula.pointList();
     auto weight_list = quadrature_formula.weightList();
diff --git a/tests/test_PrismGaussQuadrature.cpp b/tests/test_PrismGaussQuadrature.cpp
index eb76c14e31349310616f7a9ad37e8063ec6d50e0..e1956601c591922fcc4e57acedb12b7bc351f903 100644
--- a/tests/test_PrismGaussQuadrature.cpp
+++ b/tests/test_PrismGaussQuadrature.cpp
@@ -2,6 +2,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <analysis/GaussQuadratureDescriptor.hpp>
 #include <analysis/PrismGaussQuadrature.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <geometry/AffineTransformation.hpp>
@@ -212,7 +213,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 1")
   {
-    const QuadratureFormula<3>& l1 = QuadratureManager::instance().getPrismGaussFormula(1);
+    const QuadratureFormula<3>& l1 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(1));
 
     REQUIRE(l1.numberOfPoints() == 1);
 
@@ -225,7 +226,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 2")
   {
-    const QuadratureFormula<3>& l2 = QuadratureManager::instance().getPrismGaussFormula(2);
+    const QuadratureFormula<3>& l2 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(2));
 
     REQUIRE(l2.numberOfPoints() == 5);
 
@@ -240,7 +241,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 3")
   {
-    const QuadratureFormula<3>& l3 = QuadratureManager::instance().getPrismGaussFormula(3);
+    const QuadratureFormula<3>& l3 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(3));
 
     REQUIRE(l3.numberOfPoints() == 8);
 
@@ -255,7 +256,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 4")
   {
-    const QuadratureFormula<3>& l4 = QuadratureManager::instance().getPrismGaussFormula(4);
+    const QuadratureFormula<3>& l4 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(4));
 
     REQUIRE(l4.numberOfPoints() == 11);
 
@@ -271,7 +272,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 5")
   {
-    const QuadratureFormula<3>& l5 = QuadratureManager::instance().getPrismGaussFormula(5);
+    const QuadratureFormula<3>& l5 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(5));
 
     REQUIRE(l5.numberOfPoints() == 16);
 
@@ -288,7 +289,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 6")
   {
-    const QuadratureFormula<3>& l6 = QuadratureManager::instance().getPrismGaussFormula(6);
+    const QuadratureFormula<3>& l6 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(6));
 
     REQUIRE(l6.numberOfPoints() == 28);
 
@@ -307,7 +308,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 7")
   {
-    const QuadratureFormula<3>& l7 = QuadratureManager::instance().getPrismGaussFormula(7);
+    const QuadratureFormula<3>& l7 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(7));
 
     REQUIRE(l7.numberOfPoints() == 35);
 
@@ -326,7 +327,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 8")
   {
-    const QuadratureFormula<3>& l8 = QuadratureManager::instance().getPrismGaussFormula(8);
+    const QuadratureFormula<3>& l8 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(8));
 
     REQUIRE(l8.numberOfPoints() == 46);
 
@@ -347,7 +348,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 9")
   {
-    const QuadratureFormula<3>& l9 = QuadratureManager::instance().getPrismGaussFormula(9);
+    const QuadratureFormula<3>& l9 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(9));
 
     REQUIRE(l9.numberOfPoints() == 59);
 
@@ -368,7 +369,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 10")
   {
-    const QuadratureFormula<3>& l10 = QuadratureManager::instance().getPrismGaussFormula(10);
+    const QuadratureFormula<3>& l10 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(10));
 
     REQUIRE(l10.numberOfPoints() == 84);
 
@@ -391,7 +392,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 11")
   {
-    const QuadratureFormula<3>& l11 = QuadratureManager::instance().getPrismGaussFormula(11);
+    const QuadratureFormula<3>& l11 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(11));
 
     REQUIRE(l11.numberOfPoints() == 99);
 
@@ -414,7 +415,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 12")
   {
-    const QuadratureFormula<3>& l12 = QuadratureManager::instance().getPrismGaussFormula(12);
+    const QuadratureFormula<3>& l12 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(12));
 
     REQUIRE(l12.numberOfPoints() == 136);
 
@@ -439,7 +440,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 13")
   {
-    const QuadratureFormula<3>& l13 = QuadratureManager::instance().getPrismGaussFormula(13);
+    const QuadratureFormula<3>& l13 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(13));
 
     REQUIRE(l13.numberOfPoints() == 162);
 
@@ -464,7 +465,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 14")
   {
-    const QuadratureFormula<3>& l14 = QuadratureManager::instance().getPrismGaussFormula(14);
+    const QuadratureFormula<3>& l14 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(14));
 
     REQUIRE(l14.numberOfPoints() == 194);
 
@@ -492,7 +493,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 15")
   {
-    const QuadratureFormula<3>& l15 = QuadratureManager::instance().getPrismGaussFormula(15);
+    const QuadratureFormula<3>& l15 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(15));
 
     REQUIRE(l15.numberOfPoints() == 238);
 
@@ -519,7 +520,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 16")
   {
-    const QuadratureFormula<3>& l16 = QuadratureManager::instance().getPrismGaussFormula(16);
+    const QuadratureFormula<3>& l16 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(16));
 
     REQUIRE(l16.numberOfPoints() == 287);
 
@@ -549,7 +550,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 17")
   {
-    const QuadratureFormula<3>& l17 = QuadratureManager::instance().getPrismGaussFormula(17);
+    const QuadratureFormula<3>& l17 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(17));
 
     REQUIRE(l17.numberOfPoints() == 338);
 
@@ -579,7 +580,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 18")
   {
-    const QuadratureFormula<3>& l18 = QuadratureManager::instance().getPrismGaussFormula(18);
+    const QuadratureFormula<3>& l18 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(18));
 
     REQUIRE(l18.numberOfPoints() == 396);
 
@@ -612,7 +613,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 19")
   {
-    const QuadratureFormula<3>& l19 = QuadratureManager::instance().getPrismGaussFormula(19);
+    const QuadratureFormula<3>& l19 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(19));
 
     REQUIRE(l19.numberOfPoints() == 420);
 
@@ -645,7 +646,7 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("degree 20")
   {
-    const QuadratureFormula<3>& l20 = QuadratureManager::instance().getPrismGaussFormula(20);
+    const QuadratureFormula<3>& l20 = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(20));
 
     REQUIRE(l20.numberOfPoints() == 518);
 
@@ -680,6 +681,6 @@ TEST_CASE("PrismGaussQuadrature", "[analysis]")
 
   SECTION("max implemented degree")
   {
-    REQUIRE(QuadratureManager::instance().maxPrismGaussDegree() == PrismGaussQuadrature::max_degree);
+    REQUIRE(QuadratureManager::instance().maxPrismDegree(QuadratureType::Gauss) == PrismGaussQuadrature::max_degree);
   }
 }
diff --git a/tests/test_PrismTransformation.cpp b/tests/test_PrismTransformation.cpp
index 95f48a4bfc502d513fdbe055de8a35220c9b573f..5b19f9b08ca5631370eed4a4787e9c521a8f7ccf 100644
--- a/tests/test_PrismTransformation.cpp
+++ b/tests/test_PrismTransformation.cpp
@@ -1,6 +1,7 @@
 #include <catch2/catch_approx.hpp>
 #include <catch2/catch_test_macros.hpp>
 
+#include <analysis/GaussQuadratureDescriptor.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <geometry/PrismTransformation.hpp>
 
@@ -71,7 +72,7 @@ TEST_CASE("PrismTransformation", "[geometry]")
     {
       // due to the z component of the jacobian determinant, degree 3
       // polynomials must be exactly integrated
-      const QuadratureFormula<3>& gauss = QuadratureManager::instance().getPrismGaussFormula(3);
+      const QuadratureFormula<3>& gauss = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(3));
 
       double volume = 0;
       for (size_t i = 0; i < gauss.numberOfPoints(); ++i) {
@@ -93,7 +94,7 @@ TEST_CASE("PrismTransformation", "[geometry]")
       };
 
       // 5 is the minimum quadrature rule to integrate the polynomial on the prism
-      const QuadratureFormula<3>& gauss = QuadratureManager::instance().getPrismGaussFormula(5);
+      const QuadratureFormula<3>& gauss = QuadratureManager::instance().getPrismFormula(GaussQuadratureDescriptor(5));
 
       double integral = 0;
       for (size_t i = 0; i < gauss.numberOfPoints(); ++i) {
diff --git a/tests/test_PyramidGaussQuadrature.cpp b/tests/test_PyramidGaussQuadrature.cpp
index 38c04a3d6e48acc5fd8a604f4c19b619d838aed9..9c8bfc9cc301d64d486fa617b7630ff88f012df2 100644
--- a/tests/test_PyramidGaussQuadrature.cpp
+++ b/tests/test_PyramidGaussQuadrature.cpp
@@ -2,6 +2,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <analysis/GaussQuadratureDescriptor.hpp>
 #include <analysis/PyramidGaussQuadrature.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <geometry/AffineTransformation.hpp>
@@ -153,7 +154,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 1")
   {
-    const QuadratureFormula<3>& l1 = QuadratureManager::instance().getPyramidGaussFormula(1);
+    const QuadratureFormula<3>& l1 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(1));
 
     REQUIRE(l1.numberOfPoints() == 1);
 
@@ -164,7 +165,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 2")
   {
-    const QuadratureFormula<3>& l2 = QuadratureManager::instance().getPyramidGaussFormula(2);
+    const QuadratureFormula<3>& l2 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(2));
 
     REQUIRE(l2.numberOfPoints() == 5);
 
@@ -176,7 +177,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 3")
   {
-    const QuadratureFormula<3>& l3 = QuadratureManager::instance().getPyramidGaussFormula(3);
+    const QuadratureFormula<3>& l3 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(3));
 
     REQUIRE(l3.numberOfPoints() == 6);
 
@@ -189,7 +190,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 4")
   {
-    const QuadratureFormula<3>& l4 = QuadratureManager::instance().getPyramidGaussFormula(4);
+    const QuadratureFormula<3>& l4 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(4));
 
     REQUIRE(l4.numberOfPoints() == 10);
 
@@ -203,7 +204,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 5")
   {
-    const QuadratureFormula<3>& l5 = QuadratureManager::instance().getPyramidGaussFormula(5);
+    const QuadratureFormula<3>& l5 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(5));
 
     REQUIRE(l5.numberOfPoints() == 15);
 
@@ -218,7 +219,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 6")
   {
-    const QuadratureFormula<3>& l6 = QuadratureManager::instance().getPyramidGaussFormula(6);
+    const QuadratureFormula<3>& l6 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(6));
 
     REQUIRE(l6.numberOfPoints() == 23);
 
@@ -234,7 +235,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 7")
   {
-    const QuadratureFormula<3>& l7 = QuadratureManager::instance().getPyramidGaussFormula(7);
+    const QuadratureFormula<3>& l7 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(7));
 
     REQUIRE(l7.numberOfPoints() == 31);
 
@@ -251,7 +252,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 8")
   {
-    const QuadratureFormula<3>& l8 = QuadratureManager::instance().getPyramidGaussFormula(8);
+    const QuadratureFormula<3>& l8 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(8));
 
     REQUIRE(l8.numberOfPoints() == 47);
 
@@ -269,7 +270,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 9")
   {
-    const QuadratureFormula<3>& l9 = QuadratureManager::instance().getPyramidGaussFormula(9);
+    const QuadratureFormula<3>& l9 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(9));
 
     REQUIRE(l9.numberOfPoints() == 62);
 
@@ -288,7 +289,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 10")
   {
-    const QuadratureFormula<3>& l10 = QuadratureManager::instance().getPyramidGaussFormula(10);
+    const QuadratureFormula<3>& l10 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(10));
 
     REQUIRE(l10.numberOfPoints() == 80);
 
@@ -308,7 +309,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 11")
   {
-    const QuadratureFormula<3>& l11 = QuadratureManager::instance().getPyramidGaussFormula(11);
+    const QuadratureFormula<3>& l11 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(11));
 
     REQUIRE(l11.numberOfPoints() == 103);
 
@@ -329,7 +330,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 12")
   {
-    const QuadratureFormula<3>& l12 = QuadratureManager::instance().getPyramidGaussFormula(12);
+    const QuadratureFormula<3>& l12 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(12));
 
     REQUIRE(l12.numberOfPoints() == 127);
 
@@ -351,7 +352,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 13")
   {
-    const QuadratureFormula<3>& l13 = QuadratureManager::instance().getPyramidGaussFormula(13);
+    const QuadratureFormula<3>& l13 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(13));
 
     REQUIRE(l13.numberOfPoints() == 152);
 
@@ -374,7 +375,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 14")
   {
-    const QuadratureFormula<3>& l14 = QuadratureManager::instance().getPyramidGaussFormula(14);
+    const QuadratureFormula<3>& l14 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(14));
 
     REQUIRE(l14.numberOfPoints() == 184);
 
@@ -398,7 +399,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 15")
   {
-    const QuadratureFormula<3>& l15 = QuadratureManager::instance().getPyramidGaussFormula(15);
+    const QuadratureFormula<3>& l15 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(15));
 
     REQUIRE(l15.numberOfPoints() == 234);
 
@@ -423,7 +424,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 16")
   {
-    const QuadratureFormula<3>& l16 = QuadratureManager::instance().getPyramidGaussFormula(16);
+    const QuadratureFormula<3>& l16 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(16));
 
     REQUIRE(l16.numberOfPoints() == 285);
 
@@ -449,7 +450,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 17")
   {
-    const QuadratureFormula<3>& l17 = QuadratureManager::instance().getPyramidGaussFormula(17);
+    const QuadratureFormula<3>& l17 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(17));
 
     REQUIRE(l17.numberOfPoints() == 319);
 
@@ -476,7 +477,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 18")
   {
-    const QuadratureFormula<3>& l18 = QuadratureManager::instance().getPyramidGaussFormula(18);
+    const QuadratureFormula<3>& l18 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(18));
 
     REQUIRE(l18.numberOfPoints() == 357);
 
@@ -504,7 +505,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 19")
   {
-    const QuadratureFormula<3>& l19 = QuadratureManager::instance().getPyramidGaussFormula(19);
+    const QuadratureFormula<3>& l19 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(19));
 
     REQUIRE(l19.numberOfPoints() == 418);
 
@@ -533,7 +534,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("degree 20")
   {
-    const QuadratureFormula<3>& l20 = QuadratureManager::instance().getPyramidGaussFormula(20);
+    const QuadratureFormula<3>& l20 = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(20));
 
     REQUIRE(l20.numberOfPoints() == 489);
 
@@ -563,6 +564,7 @@ TEST_CASE("PyramidGaussQuadrature", "[analysis]")
 
   SECTION("max implemented degree")
   {
-    REQUIRE(QuadratureManager::instance().maxPyramidGaussDegree() == PyramidGaussQuadrature::max_degree);
+    REQUIRE(QuadratureManager::instance().maxPyramidDegree(QuadratureType::Gauss) ==
+            PyramidGaussQuadrature::max_degree);
   }
 }
diff --git a/tests/test_PyramidTransformation.cpp b/tests/test_PyramidTransformation.cpp
index 38fb5fc1eea7918b157e7aede0324cc3f243890f..80933bd44d2b9e9f1ff357d6e2969aa7e082abbb 100644
--- a/tests/test_PyramidTransformation.cpp
+++ b/tests/test_PyramidTransformation.cpp
@@ -1,6 +1,7 @@
 #include <catch2/catch_approx.hpp>
 #include <catch2/catch_test_macros.hpp>
 
+#include <analysis/GaussQuadratureDescriptor.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <geometry/PyramidTransformation.hpp>
 
@@ -62,7 +63,7 @@ TEST_CASE("PyramidTransformation", "[geometry]")
     SECTION("volume calculation")
     {
       // The jacobian determinant is a degree 1 polynomial
-      const QuadratureFormula<3>& gauss = QuadratureManager::instance().getPyramidGaussFormula(1);
+      const QuadratureFormula<3>& gauss = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(1));
 
       double volume = 0;
       for (size_t i = 0; i < gauss.numberOfPoints(); ++i) {
@@ -84,7 +85,7 @@ TEST_CASE("PyramidTransformation", "[geometry]")
       };
 
       // 3 is the minimum quadrature rule to integrate the polynomial on the pyramid
-      const QuadratureFormula<3>& gauss = QuadratureManager::instance().getPyramidGaussFormula(3);
+      const QuadratureFormula<3>& gauss = QuadratureManager::instance().getPyramidFormula(GaussQuadratureDescriptor(3));
       double integral                   = 0;
       for (size_t i = 0; i < gauss.numberOfPoints(); ++i) {
         integral += gauss.weight(i) * t.jacobianDeterminant(gauss.point(i)) * p(gauss.point(i));
diff --git a/tests/test_Q1Transformation.cpp b/tests/test_Q1Transformation.cpp
index 5649129330e3108bb18c77dbe48a9a32c0548591..caa46f5bf003ad503b620fb02fe6662cc027a27d 100644
--- a/tests/test_Q1Transformation.cpp
+++ b/tests/test_Q1Transformation.cpp
@@ -1,6 +1,7 @@
 #include <catch2/catch_approx.hpp>
 #include <catch2/catch_test_macros.hpp>
 
+#include <analysis/GaussLegendreQuadratureDescriptor.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <geometry/Q1Transformation.hpp>
 
@@ -89,7 +90,8 @@ TEST_CASE("Q1Transformation", "[geometry]")
       SECTION("Gauss order 1")
       {
         // One point is enough in 2d
-        const QuadratureFormula<2>& gauss = QuadratureManager::instance().getSquareGaussLegendreFormula(1);
+        const QuadratureFormula<2>& gauss =
+          QuadratureManager::instance().getSquareFormula(GaussLegendreQuadratureDescriptor(1));
 
         double surface = 0;
         for (size_t i = 0; i < gauss.numberOfPoints(); ++i) {
@@ -111,7 +113,8 @@ TEST_CASE("Q1Transformation", "[geometry]")
 
         // Jacbian determinant is a degree 1 polynomial, so the
         // following formula is required to reach exactness
-        const QuadratureFormula<2>& gauss = QuadratureManager::instance().getSquareGaussLegendreFormula(3);
+        const QuadratureFormula<2>& gauss =
+          QuadratureManager::instance().getSquareFormula(GaussLegendreQuadratureDescriptor(3));
 
         double integral = 0;
         for (size_t i = 0; i < gauss.numberOfPoints(); ++i) {
@@ -196,7 +199,8 @@ TEST_CASE("Q1Transformation", "[geometry]")
       SECTION("Gauss order 3")
       {
         // The jacobian determinant is of maximal degree 2 in each variable
-        const QuadratureFormula<3>& gauss = QuadratureManager::instance().getCubeGaussLegendreFormula(2);
+        const QuadratureFormula<3>& gauss =
+          QuadratureManager::instance().getCubeFormula(GaussLegendreQuadratureDescriptor(2));
 
         double volume = 0;
         for (size_t i = 0; i < gauss.numberOfPoints(); ++i) {
@@ -219,7 +223,8 @@ TEST_CASE("Q1Transformation", "[geometry]")
 
         // Jacbian determinant is a degree 2 polynomial, so the
         // following formula is required to reach exactness
-        const QuadratureFormula<3>& gauss = QuadratureManager::instance().getCubeGaussLegendreFormula(4);
+        const QuadratureFormula<3>& gauss =
+          QuadratureManager::instance().getCubeFormula(GaussLegendreQuadratureDescriptor(4));
 
         double integral = 0;
         for (size_t i = 0; i < gauss.numberOfPoints(); ++i) {
diff --git a/tests/test_SquareGaussQuadrature.cpp b/tests/test_SquareGaussQuadrature.cpp
index 1d2f799124d9296f51a7f093bc8e24c243efc5e4..5e6b9d6e5ee066cd8db48c6a2297bfc3d12cfcd8 100644
--- a/tests/test_SquareGaussQuadrature.cpp
+++ b/tests/test_SquareGaussQuadrature.cpp
@@ -4,6 +4,7 @@
 
 #include <algebra/TinyMatrix.hpp>
 
+#include <analysis/GaussQuadratureDescriptor.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <analysis/SquareGaussQuadrature.hpp>
 #include <utils/Exceptions.hpp>
@@ -173,7 +174,7 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 0 and 1")
   {
-    const QuadratureFormula<2>& l1 = QuadratureManager::instance().getSquareGaussFormula(1);
+    const QuadratureFormula<2>& l1 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(1));
 
     REQUIRE(l1.numberOfPoints() == 1);
 
@@ -186,8 +187,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 2 and 3")
   {
-    const QuadratureFormula<2>& l2 = QuadratureManager::instance().getSquareGaussFormula(2);
-    const QuadratureFormula<2>& l3 = QuadratureManager::instance().getSquareGaussFormula(3);
+    const QuadratureFormula<2>& l2 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(2));
+    const QuadratureFormula<2>& l3 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(3));
 
     REQUIRE(&l2 == &l3);
 
@@ -204,8 +205,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 4 and 5")
   {
-    const QuadratureFormula<2>& l4 = QuadratureManager::instance().getSquareGaussFormula(4);
-    const QuadratureFormula<2>& l5 = QuadratureManager::instance().getSquareGaussFormula(5);
+    const QuadratureFormula<2>& l4 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(4));
+    const QuadratureFormula<2>& l5 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(5));
 
     REQUIRE(&l4 == &l5);
 
@@ -224,8 +225,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 6 and 7")
   {
-    const QuadratureFormula<2>& l6 = QuadratureManager::instance().getSquareGaussFormula(6);
-    const QuadratureFormula<2>& l7 = QuadratureManager::instance().getSquareGaussFormula(7);
+    const QuadratureFormula<2>& l6 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(6));
+    const QuadratureFormula<2>& l7 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(7));
 
     REQUIRE(&l6 == &l7);
 
@@ -246,8 +247,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 8 and 9")
   {
-    const QuadratureFormula<2>& l8 = QuadratureManager::instance().getSquareGaussFormula(8);
-    const QuadratureFormula<2>& l9 = QuadratureManager::instance().getSquareGaussFormula(9);
+    const QuadratureFormula<2>& l8 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(8));
+    const QuadratureFormula<2>& l9 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(9));
 
     REQUIRE(&l8 == &l9);
 
@@ -270,8 +271,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 10 and 11")
   {
-    const QuadratureFormula<2>& l10 = QuadratureManager::instance().getSquareGaussFormula(10);
-    const QuadratureFormula<2>& l11 = QuadratureManager::instance().getSquareGaussFormula(11);
+    const QuadratureFormula<2>& l10 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(10));
+    const QuadratureFormula<2>& l11 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(11));
 
     REQUIRE(&l10 == &l11);
 
@@ -296,8 +297,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 12 and 13")
   {
-    const QuadratureFormula<2>& l12 = QuadratureManager::instance().getSquareGaussFormula(12);
-    const QuadratureFormula<2>& l13 = QuadratureManager::instance().getSquareGaussFormula(13);
+    const QuadratureFormula<2>& l12 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(12));
+    const QuadratureFormula<2>& l13 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(13));
 
     REQUIRE(&l12 == &l13);
 
@@ -324,8 +325,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 14 and 15")
   {
-    const QuadratureFormula<2>& l14 = QuadratureManager::instance().getSquareGaussFormula(14);
-    const QuadratureFormula<2>& l15 = QuadratureManager::instance().getSquareGaussFormula(15);
+    const QuadratureFormula<2>& l14 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(14));
+    const QuadratureFormula<2>& l15 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(15));
 
     REQUIRE(&l14 == &l15);
 
@@ -354,8 +355,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 16 and 17")
   {
-    const QuadratureFormula<2>& l16 = QuadratureManager::instance().getSquareGaussFormula(16);
-    const QuadratureFormula<2>& l17 = QuadratureManager::instance().getSquareGaussFormula(17);
+    const QuadratureFormula<2>& l16 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(16));
+    const QuadratureFormula<2>& l17 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(17));
 
     REQUIRE(&l16 == &l17);
 
@@ -386,8 +387,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 18 and 19")
   {
-    const QuadratureFormula<2>& l18 = QuadratureManager::instance().getSquareGaussFormula(18);
-    const QuadratureFormula<2>& l19 = QuadratureManager::instance().getSquareGaussFormula(19);
+    const QuadratureFormula<2>& l18 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(18));
+    const QuadratureFormula<2>& l19 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(19));
 
     REQUIRE(&l18 == &l19);
 
@@ -420,8 +421,8 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("degree 20 and 21")
   {
-    const QuadratureFormula<2>& l20 = QuadratureManager::instance().getSquareGaussFormula(20);
-    const QuadratureFormula<2>& l21 = QuadratureManager::instance().getSquareGaussFormula(21);
+    const QuadratureFormula<2>& l20 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(20));
+    const QuadratureFormula<2>& l21 = QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(21));
 
     REQUIRE(&l20 == &l21);
 
@@ -457,12 +458,13 @@ TEST_CASE("SquareGaussQuadrature", "[analysis]")
 
   SECTION("max implemented degree")
   {
-    REQUIRE(QuadratureManager::instance().maxSquareGaussDegree() == SquareGaussQuadrature::max_degree);
+    REQUIRE(QuadratureManager::instance().maxSquareDegree(QuadratureType::Gauss) == SquareGaussQuadrature::max_degree);
   }
 
   SECTION("Access functions")
   {
-    const QuadratureFormula<2>& quadrature_formula = QuadratureManager::instance().getSquareGaussFormula(7);
+    const QuadratureFormula<2>& quadrature_formula =
+      QuadratureManager::instance().getSquareFormula(GaussQuadratureDescriptor(7));
 
     auto point_list  = quadrature_formula.pointList();
     auto weight_list = quadrature_formula.weightList();
diff --git a/tests/test_TensorialGaussLegendreQuadrature.cpp b/tests/test_TensorialGaussLegendreQuadrature.cpp
index 0f132c700f6402c48589993cadcf1d73174eb697..b2ac6c80c57009ea16ac8911e0609e59f60cb178 100644
--- a/tests/test_TensorialGaussLegendreQuadrature.cpp
+++ b/tests/test_TensorialGaussLegendreQuadrature.cpp
@@ -2,6 +2,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <analysis/GaussLegendreQuadratureDescriptor.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <analysis/TensorialGaussLegendreQuadrature.hpp>
 #include <utils/Exceptions.hpp>
@@ -159,7 +160,8 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 1")
     {
-      const QuadratureFormula<1>& l1 = QuadratureManager::instance().getLineGaussLegendreFormula(1);
+      const QuadratureFormula<1>& l1 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(1));
 
       REQUIRE(is_symmetric_formula(l1));
 
@@ -174,8 +176,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 2 and 3")
     {
-      const QuadratureFormula<1>& l2 = QuadratureManager::instance().getLineGaussLegendreFormula(2);
-      const QuadratureFormula<1>& l3 = QuadratureManager::instance().getLineGaussLegendreFormula(3);
+      const QuadratureFormula<1>& l2 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(2));
+      const QuadratureFormula<1>& l3 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(3));
 
       REQUIRE(&l2 == &l3);
       REQUIRE(is_symmetric_formula(l3));
@@ -193,8 +197,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 4 and 5")
     {
-      const QuadratureFormula<1>& l4 = QuadratureManager::instance().getLineGaussLegendreFormula(4);
-      const QuadratureFormula<1>& l5 = QuadratureManager::instance().getLineGaussLegendreFormula(5);
+      const QuadratureFormula<1>& l4 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(4));
+      const QuadratureFormula<1>& l5 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(5));
 
       REQUIRE(&l4 == &l5);
       REQUIRE(is_symmetric_formula(l5));
@@ -214,8 +220,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 6 and 7")
     {
-      const QuadratureFormula<1>& l6 = QuadratureManager::instance().getLineGaussLegendreFormula(6);
-      const QuadratureFormula<1>& l7 = QuadratureManager::instance().getLineGaussLegendreFormula(7);
+      const QuadratureFormula<1>& l6 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(6));
+      const QuadratureFormula<1>& l7 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(7));
 
       REQUIRE(&l6 == &l7);
       REQUIRE(is_symmetric_formula(l7));
@@ -237,8 +245,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 8 and 9")
     {
-      const QuadratureFormula<1>& l8 = QuadratureManager::instance().getLineGaussLegendreFormula(8);
-      const QuadratureFormula<1>& l9 = QuadratureManager::instance().getLineGaussLegendreFormula(9);
+      const QuadratureFormula<1>& l8 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(8));
+      const QuadratureFormula<1>& l9 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(9));
 
       REQUIRE(&l8 == &l9);
       REQUIRE(is_symmetric_formula(l9));
@@ -262,8 +272,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 10 and 11")
     {
-      const QuadratureFormula<1>& l10 = QuadratureManager::instance().getLineGaussLegendreFormula(10);
-      const QuadratureFormula<1>& l11 = QuadratureManager::instance().getLineGaussLegendreFormula(11);
+      const QuadratureFormula<1>& l10 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(10));
+      const QuadratureFormula<1>& l11 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(11));
 
       REQUIRE(&l10 == &l11);
       REQUIRE(is_symmetric_formula(l11));
@@ -289,8 +301,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 12 and 13")
     {
-      const QuadratureFormula<1>& l12 = QuadratureManager::instance().getLineGaussLegendreFormula(12);
-      const QuadratureFormula<1>& l13 = QuadratureManager::instance().getLineGaussLegendreFormula(13);
+      const QuadratureFormula<1>& l12 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(12));
+      const QuadratureFormula<1>& l13 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(13));
 
       REQUIRE(&l12 == &l13);
       REQUIRE(is_symmetric_formula(l13));
@@ -318,8 +332,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 14 and 15")
     {
-      const QuadratureFormula<1>& l14 = QuadratureManager::instance().getLineGaussLegendreFormula(14);
-      const QuadratureFormula<1>& l15 = QuadratureManager::instance().getLineGaussLegendreFormula(15);
+      const QuadratureFormula<1>& l14 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(14));
+      const QuadratureFormula<1>& l15 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(15));
 
       REQUIRE(&l14 == &l15);
       REQUIRE(is_symmetric_formula(l15));
@@ -349,8 +365,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 16 and 17")
     {
-      const QuadratureFormula<1>& l16 = QuadratureManager::instance().getLineGaussLegendreFormula(16);
-      const QuadratureFormula<1>& l17 = QuadratureManager::instance().getLineGaussLegendreFormula(17);
+      const QuadratureFormula<1>& l16 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(16));
+      const QuadratureFormula<1>& l17 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(17));
 
       REQUIRE(&l16 == &l17);
       REQUIRE(is_symmetric_formula(l17));
@@ -382,8 +400,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 18 and 19")
     {
-      const QuadratureFormula<1>& l18 = QuadratureManager::instance().getLineGaussLegendreFormula(18);
-      const QuadratureFormula<1>& l19 = QuadratureManager::instance().getLineGaussLegendreFormula(19);
+      const QuadratureFormula<1>& l18 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(18));
+      const QuadratureFormula<1>& l19 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(19));
 
       REQUIRE(&l18 == &l19);
       REQUIRE(is_symmetric_formula(l19));
@@ -417,8 +437,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 20 and 21")
     {
-      const QuadratureFormula<1>& l20 = QuadratureManager::instance().getLineGaussLegendreFormula(20);
-      const QuadratureFormula<1>& l21 = QuadratureManager::instance().getLineGaussLegendreFormula(21);
+      const QuadratureFormula<1>& l20 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(20));
+      const QuadratureFormula<1>& l21 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(21));
 
       REQUIRE(&l20 == &l21);
       REQUIRE(is_symmetric_formula(l21));
@@ -454,8 +476,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 22 and 23")
     {
-      const QuadratureFormula<1>& l22 = QuadratureManager::instance().getLineGaussLegendreFormula(22);
-      const QuadratureFormula<1>& l23 = QuadratureManager::instance().getLineGaussLegendreFormula(23);
+      const QuadratureFormula<1>& l22 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(22));
+      const QuadratureFormula<1>& l23 =
+        QuadratureManager::instance().getLineFormula(GaussLegendreQuadratureDescriptor(23));
 
       REQUIRE(&l22 == &l23);
       REQUIRE(is_symmetric_formula(l23));
@@ -493,7 +517,7 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("max implemented degree")
     {
-      REQUIRE(QuadratureManager::instance().maxGaussLegendreDegree() ==
+      REQUIRE(QuadratureManager::instance().maxLineDegree(QuadratureType::GaussLegendre) ==
               TensorialGaussLegendreQuadrature<1>::max_degree);
     }
   }
@@ -534,8 +558,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 6 and 7")
     {
-      const QuadratureFormula<2>& l6 = QuadratureManager::instance().getSquareGaussLegendreFormula(6);
-      const QuadratureFormula<2>& l7 = QuadratureManager::instance().getSquareGaussLegendreFormula(7);
+      const QuadratureFormula<2>& l6 =
+        QuadratureManager::instance().getSquareFormula(GaussLegendreQuadratureDescriptor(6));
+      const QuadratureFormula<2>& l7 =
+        QuadratureManager::instance().getSquareFormula(GaussLegendreQuadratureDescriptor(7));
 
       REQUIRE(&l6 == &l7);
 
@@ -585,8 +611,10 @@ TEST_CASE("TensorialGaussLegendreQuadrature", "[analysis]")
 
     SECTION("degree 6 and 7")
     {
-      const QuadratureFormula<3>& l6 = QuadratureManager::instance().getCubeGaussLegendreFormula(6);
-      const QuadratureFormula<3>& l7 = QuadratureManager::instance().getCubeGaussLegendreFormula(7);
+      const QuadratureFormula<3>& l6 =
+        QuadratureManager::instance().getCubeFormula(GaussLegendreQuadratureDescriptor(6));
+      const QuadratureFormula<3>& l7 =
+        QuadratureManager::instance().getCubeFormula(GaussLegendreQuadratureDescriptor(7));
 
       REQUIRE(&l6 == &l7);
 
diff --git a/tests/test_TensorialGaussLobattoQuadrature.cpp b/tests/test_TensorialGaussLobattoQuadrature.cpp
index 7744bb123f0e345b5d01211307fdc2be063b2b81..1c08404ecaaf98fedb4dfa841a5ed8d845cfca09 100644
--- a/tests/test_TensorialGaussLobattoQuadrature.cpp
+++ b/tests/test_TensorialGaussLobattoQuadrature.cpp
@@ -2,6 +2,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <analysis/GaussLobattoQuadratureDescriptor.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <analysis/TensorialGaussLobattoQuadrature.hpp>
 #include <utils/Exceptions.hpp>
@@ -119,7 +120,8 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("degree 1")
     {
-      const QuadratureFormula<1>& l1 = QuadratureManager::instance().getLineGaussLobattoFormula(1);
+      const QuadratureFormula<1>& l1 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(1));
 
       REQUIRE(is_symmetric_formula(l1));
 
@@ -134,8 +136,10 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("degree 2 and 3")
     {
-      const QuadratureFormula<1>& l2 = QuadratureManager::instance().getLineGaussLobattoFormula(2);
-      const QuadratureFormula<1>& l3 = QuadratureManager::instance().getLineGaussLobattoFormula(3);
+      const QuadratureFormula<1>& l2 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(2));
+      const QuadratureFormula<1>& l3 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(3));
 
       REQUIRE(&l2 == &l3);
       REQUIRE(is_symmetric_formula(l3));
@@ -153,8 +157,10 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("degree 4 and 5")
     {
-      const QuadratureFormula<1>& l4 = QuadratureManager::instance().getLineGaussLobattoFormula(4);
-      const QuadratureFormula<1>& l5 = QuadratureManager::instance().getLineGaussLobattoFormula(5);
+      const QuadratureFormula<1>& l4 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(4));
+      const QuadratureFormula<1>& l5 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(5));
 
       REQUIRE(&l4 == &l5);
       REQUIRE(is_symmetric_formula(l5));
@@ -174,8 +180,10 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("degree 6 and 7")
     {
-      const QuadratureFormula<1>& l6 = QuadratureManager::instance().getLineGaussLobattoFormula(6);
-      const QuadratureFormula<1>& l7 = QuadratureManager::instance().getLineGaussLobattoFormula(7);
+      const QuadratureFormula<1>& l6 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(6));
+      const QuadratureFormula<1>& l7 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(7));
 
       REQUIRE(&l6 == &l7);
       REQUIRE(is_symmetric_formula(l7));
@@ -197,8 +205,10 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("degree 8 and 9")
     {
-      const QuadratureFormula<1>& l8 = QuadratureManager::instance().getLineGaussLobattoFormula(8);
-      const QuadratureFormula<1>& l9 = QuadratureManager::instance().getLineGaussLobattoFormula(9);
+      const QuadratureFormula<1>& l8 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(8));
+      const QuadratureFormula<1>& l9 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(9));
 
       REQUIRE(&l8 == &l9);
       REQUIRE(is_symmetric_formula(l9));
@@ -222,8 +232,10 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("degree 10 and 11")
     {
-      const QuadratureFormula<1>& l10 = QuadratureManager::instance().getLineGaussLobattoFormula(10);
-      const QuadratureFormula<1>& l11 = QuadratureManager::instance().getLineGaussLobattoFormula(11);
+      const QuadratureFormula<1>& l10 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(10));
+      const QuadratureFormula<1>& l11 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(11));
 
       REQUIRE(&l10 == &l11);
       REQUIRE(is_symmetric_formula(l11));
@@ -249,8 +261,10 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("degree 12 and 13")
     {
-      const QuadratureFormula<1>& l12 = QuadratureManager::instance().getLineGaussLobattoFormula(12);
-      const QuadratureFormula<1>& l13 = QuadratureManager::instance().getLineGaussLobattoFormula(13);
+      const QuadratureFormula<1>& l12 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(12));
+      const QuadratureFormula<1>& l13 =
+        QuadratureManager::instance().getLineFormula(GaussLobattoQuadratureDescriptor(13));
 
       REQUIRE(&l12 == &l13);
       REQUIRE(is_symmetric_formula(l13));
@@ -278,7 +292,8 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("max implemented degree")
     {
-      REQUIRE(QuadratureManager::instance().maxGaussLobattoDegree() == TensorialGaussLobattoQuadrature<1>::max_degree);
+      REQUIRE(QuadratureManager::instance().maxLineDegree(QuadratureType::GaussLobatto) ==
+              TensorialGaussLobattoQuadrature<1>::max_degree);
     }
   }
 
@@ -318,8 +333,10 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("degree 6 and 7")
     {
-      const QuadratureFormula<2>& l6 = QuadratureManager::instance().getSquareGaussLobattoFormula(6);
-      const QuadratureFormula<2>& l7 = QuadratureManager::instance().getSquareGaussLobattoFormula(7);
+      const QuadratureFormula<2>& l6 =
+        QuadratureManager::instance().getSquareFormula(GaussLobattoQuadratureDescriptor(6));
+      const QuadratureFormula<2>& l7 =
+        QuadratureManager::instance().getSquareFormula(GaussLobattoQuadratureDescriptor(7));
 
       REQUIRE(&l6 == &l7);
 
@@ -369,8 +386,10 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
     SECTION("degree 6 and 7")
     {
-      const QuadratureFormula<3>& l6 = QuadratureManager::instance().getCubeGaussLobattoFormula(6);
-      const QuadratureFormula<3>& l7 = QuadratureManager::instance().getCubeGaussLobattoFormula(7);
+      const QuadratureFormula<3>& l6 =
+        QuadratureManager::instance().getCubeFormula(GaussLobattoQuadratureDescriptor(6));
+      const QuadratureFormula<3>& l7 =
+        QuadratureManager::instance().getCubeFormula(GaussLobattoQuadratureDescriptor(7));
 
       REQUIRE(&l6 == &l7);
 
@@ -384,7 +403,8 @@ TEST_CASE("TensorialGaussLobattoQuadrature", "[analysis]")
 
   SECTION("Access functions")
   {
-    const QuadratureFormula<3>& quadrature_formula = QuadratureManager::instance().getCubeGaussLobattoFormula(7);
+    const QuadratureFormula<3>& quadrature_formula =
+      QuadratureManager::instance().getCubeFormula(GaussLobattoQuadratureDescriptor(7));
 
     auto point_list  = quadrature_formula.pointList();
     auto weight_list = quadrature_formula.weightList();
diff --git a/tests/test_TetrahedronGaussQuadrature.cpp b/tests/test_TetrahedronGaussQuadrature.cpp
index de17a655cd21a19eab099f7f5cc06a1d6b37c1ab..00f3eecf101e6e9bbc45ba3866cc06237f922569 100644
--- a/tests/test_TetrahedronGaussQuadrature.cpp
+++ b/tests/test_TetrahedronGaussQuadrature.cpp
@@ -2,6 +2,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <analysis/GaussQuadratureDescriptor.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <analysis/TetrahedronGaussQuadrature.hpp>
 #include <geometry/AffineTransformation.hpp>
@@ -205,7 +206,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 1")
   {
-    const QuadratureFormula<3>& l1 = QuadratureManager::instance().getTetrahedronGaussFormula(1);
+    const QuadratureFormula<3>& l1 = QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(1));
 
     REQUIRE(l1.numberOfPoints() == 1);
 
@@ -218,7 +219,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 2")
   {
-    const QuadratureFormula<3>& l2 = QuadratureManager::instance().getTetrahedronGaussFormula(2);
+    const QuadratureFormula<3>& l2 = QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(2));
 
     REQUIRE(l2.numberOfPoints() == 4);
 
@@ -232,7 +233,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 3")
   {
-    const QuadratureFormula<3>& l3 = QuadratureManager::instance().getTetrahedronGaussFormula(3);
+    const QuadratureFormula<3>& l3 = QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(3));
 
     REQUIRE(l3.numberOfPoints() == 8);
 
@@ -245,7 +246,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 4")
   {
-    const QuadratureFormula<3>& l4 = QuadratureManager::instance().getTetrahedronGaussFormula(4);
+    const QuadratureFormula<3>& l4 = QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(4));
 
     REQUIRE(l4.numberOfPoints() == 14);
 
@@ -261,7 +262,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 5")
   {
-    const QuadratureFormula<3>& l5 = QuadratureManager::instance().getTetrahedronGaussFormula(5);
+    const QuadratureFormula<3>& l5 = QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(5));
 
     REQUIRE(l5.numberOfPoints() == 14);
 
@@ -276,7 +277,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 6")
   {
-    const QuadratureFormula<3>& l6 = QuadratureManager::instance().getTetrahedronGaussFormula(6);
+    const QuadratureFormula<3>& l6 = QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(6));
 
     REQUIRE(l6.numberOfPoints() == 24);
 
@@ -294,7 +295,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 7")
   {
-    const QuadratureFormula<3>& l7 = QuadratureManager::instance().getTetrahedronGaussFormula(7);
+    const QuadratureFormula<3>& l7 = QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(7));
 
     REQUIRE(l7.numberOfPoints() == 35);
 
@@ -313,7 +314,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 8")
   {
-    const QuadratureFormula<3>& l8 = QuadratureManager::instance().getTetrahedronGaussFormula(8);
+    const QuadratureFormula<3>& l8 = QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(8));
 
     REQUIRE(l8.numberOfPoints() == 46);
 
@@ -334,7 +335,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 9")
   {
-    const QuadratureFormula<3>& l9 = QuadratureManager::instance().getTetrahedronGaussFormula(9);
+    const QuadratureFormula<3>& l9 = QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(9));
 
     REQUIRE(l9.numberOfPoints() == 59);
 
@@ -355,7 +356,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 10")
   {
-    const QuadratureFormula<3>& l10 = QuadratureManager::instance().getTetrahedronGaussFormula(10);
+    const QuadratureFormula<3>& l10 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(10));
 
     REQUIRE(l10.numberOfPoints() == 81);
 
@@ -378,7 +380,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 11")
   {
-    const QuadratureFormula<3>& l11 = QuadratureManager::instance().getTetrahedronGaussFormula(11);
+    const QuadratureFormula<3>& l11 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(11));
 
     REQUIRE(l11.numberOfPoints() == 110);
 
@@ -401,7 +404,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 12")
   {
-    const QuadratureFormula<3>& l12 = QuadratureManager::instance().getTetrahedronGaussFormula(12);
+    const QuadratureFormula<3>& l12 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(12));
 
     REQUIRE(l12.numberOfPoints() == 168);
 
@@ -426,7 +430,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 13")
   {
-    const QuadratureFormula<3>& l13 = QuadratureManager::instance().getTetrahedronGaussFormula(13);
+    const QuadratureFormula<3>& l13 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(13));
 
     REQUIRE(l13.numberOfPoints() == 172);
 
@@ -451,7 +456,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 14")
   {
-    const QuadratureFormula<3>& l14 = QuadratureManager::instance().getTetrahedronGaussFormula(14);
+    const QuadratureFormula<3>& l14 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(14));
 
     REQUIRE(l14.numberOfPoints() == 204);
 
@@ -478,7 +484,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 15")
   {
-    const QuadratureFormula<3>& l15 = QuadratureManager::instance().getTetrahedronGaussFormula(15);
+    const QuadratureFormula<3>& l15 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(15));
 
     REQUIRE(l15.numberOfPoints() == 264);
 
@@ -506,7 +513,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 16")
   {
-    const QuadratureFormula<3>& l16 = QuadratureManager::instance().getTetrahedronGaussFormula(16);
+    const QuadratureFormula<3>& l16 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(16));
 
     REQUIRE(l16.numberOfPoints() == 304);
 
@@ -535,7 +543,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 17")
   {
-    const QuadratureFormula<3>& l17 = QuadratureManager::instance().getTetrahedronGaussFormula(17);
+    const QuadratureFormula<3>& l17 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(17));
 
     REQUIRE(l17.numberOfPoints() == 364);
 
@@ -565,7 +574,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 18")
   {
-    const QuadratureFormula<3>& l18 = QuadratureManager::instance().getTetrahedronGaussFormula(18);
+    const QuadratureFormula<3>& l18 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(18));
 
     REQUIRE(l18.numberOfPoints() == 436);
 
@@ -598,7 +608,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 19")
   {
-    const QuadratureFormula<3>& l19 = QuadratureManager::instance().getTetrahedronGaussFormula(19);
+    const QuadratureFormula<3>& l19 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(19));
 
     REQUIRE(l19.numberOfPoints() == 487);
 
@@ -630,7 +641,8 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("degree 20")
   {
-    const QuadratureFormula<3>& l20 = QuadratureManager::instance().getTetrahedronGaussFormula(20);
+    const QuadratureFormula<3>& l20 =
+      QuadratureManager::instance().getTetrahedronFormula(GaussQuadratureDescriptor(20));
 
     REQUIRE(l20.numberOfPoints() == 552);
 
@@ -664,6 +676,7 @@ TEST_CASE("TetrahedronGaussQuadrature", "[analysis]")
 
   SECTION("max implemented degree")
   {
-    REQUIRE(QuadratureManager::instance().maxTetrahedronGaussDegree() == TetrahedronGaussQuadrature::max_degree);
+    REQUIRE(QuadratureManager::instance().maxTetrahedronDegree(QuadratureType::Gauss) ==
+            TetrahedronGaussQuadrature::max_degree);
   }
 }
diff --git a/tests/test_TriangleGaussQuadrature.cpp b/tests/test_TriangleGaussQuadrature.cpp
index 4fa7604ce8b39b7f64097c2291a5d427780595da..879c47b94b3326e96bbefecc40047ea50fb49b71 100644
--- a/tests/test_TriangleGaussQuadrature.cpp
+++ b/tests/test_TriangleGaussQuadrature.cpp
@@ -2,6 +2,7 @@
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers_all.hpp>
 
+#include <analysis/GaussQuadratureDescriptor.hpp>
 #include <analysis/QuadratureManager.hpp>
 #include <analysis/TriangleGaussQuadrature.hpp>
 #include <geometry/AffineTransformation.hpp>
@@ -166,7 +167,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 1")
   {
-    const QuadratureFormula<2>& l1 = QuadratureManager::instance().getTriangleGaussFormula(1);
+    const QuadratureFormula<2>& l1 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(1));
 
     REQUIRE(l1.numberOfPoints() == 1);
 
@@ -179,7 +180,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 2")
   {
-    const QuadratureFormula<2>& l2 = QuadratureManager::instance().getTriangleGaussFormula(2);
+    const QuadratureFormula<2>& l2 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(2));
 
     REQUIRE(l2.numberOfPoints() == 3);
 
@@ -194,8 +195,8 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 3 and 4")
   {
-    const QuadratureFormula<2>& l3 = QuadratureManager::instance().getTriangleGaussFormula(3);
-    const QuadratureFormula<2>& l4 = QuadratureManager::instance().getTriangleGaussFormula(4);
+    const QuadratureFormula<2>& l3 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(3));
+    const QuadratureFormula<2>& l4 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(4));
 
     bool is_same = true;
     is_same &= (l3.numberOfPoints() == l4.numberOfPoints());
@@ -221,7 +222,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 5")
   {
-    const QuadratureFormula<2>& l5 = QuadratureManager::instance().getTriangleGaussFormula(5);
+    const QuadratureFormula<2>& l5 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(5));
 
     REQUIRE(l5.numberOfPoints() == 7);
 
@@ -238,7 +239,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 6")
   {
-    const QuadratureFormula<2>& l6 = QuadratureManager::instance().getTriangleGaussFormula(6);
+    const QuadratureFormula<2>& l6 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(6));
 
     REQUIRE(l6.numberOfPoints() == 12);
 
@@ -256,7 +257,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 7")
   {
-    const QuadratureFormula<2>& l7 = QuadratureManager::instance().getTriangleGaussFormula(7);
+    const QuadratureFormula<2>& l7 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(7));
 
     REQUIRE(l7.numberOfPoints() == 15);
 
@@ -275,7 +276,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 8")
   {
-    const QuadratureFormula<2>& l8 = QuadratureManager::instance().getTriangleGaussFormula(8);
+    const QuadratureFormula<2>& l8 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(8));
 
     REQUIRE(l8.numberOfPoints() == 16);
 
@@ -296,7 +297,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 9")
   {
-    const QuadratureFormula<2>& l9 = QuadratureManager::instance().getTriangleGaussFormula(9);
+    const QuadratureFormula<2>& l9 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(9));
 
     REQUIRE(l9.numberOfPoints() == 19);
 
@@ -317,7 +318,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 10")
   {
-    const QuadratureFormula<2>& l10 = QuadratureManager::instance().getTriangleGaussFormula(10);
+    const QuadratureFormula<2>& l10 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(10));
 
     REQUIRE(l10.numberOfPoints() == 25);
 
@@ -340,7 +341,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 11")
   {
-    const QuadratureFormula<2>& l11 = QuadratureManager::instance().getTriangleGaussFormula(11);
+    const QuadratureFormula<2>& l11 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(11));
 
     REQUIRE(l11.numberOfPoints() == 28);
 
@@ -363,7 +364,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 12")
   {
-    const QuadratureFormula<2>& l12 = QuadratureManager::instance().getTriangleGaussFormula(12);
+    const QuadratureFormula<2>& l12 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(12));
 
     REQUIRE(l12.numberOfPoints() == 33);
 
@@ -388,7 +389,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 13")
   {
-    const QuadratureFormula<2>& l13 = QuadratureManager::instance().getTriangleGaussFormula(13);
+    const QuadratureFormula<2>& l13 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(13));
 
     REQUIRE(l13.numberOfPoints() == 37);
 
@@ -413,7 +414,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 14")
   {
-    const QuadratureFormula<2>& l14 = QuadratureManager::instance().getTriangleGaussFormula(14);
+    const QuadratureFormula<2>& l14 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(14));
 
     REQUIRE(l14.numberOfPoints() == 42);
 
@@ -440,7 +441,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 15")
   {
-    const QuadratureFormula<2>& l15 = QuadratureManager::instance().getTriangleGaussFormula(15);
+    const QuadratureFormula<2>& l15 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(15));
 
     REQUIRE(l15.numberOfPoints() == 49);
 
@@ -467,7 +468,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 16")
   {
-    const QuadratureFormula<2>& l16 = QuadratureManager::instance().getTriangleGaussFormula(16);
+    const QuadratureFormula<2>& l16 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(16));
 
     REQUIRE(l16.numberOfPoints() == 55);
 
@@ -496,7 +497,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 17")
   {
-    const QuadratureFormula<2>& l17 = QuadratureManager::instance().getTriangleGaussFormula(17);
+    const QuadratureFormula<2>& l17 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(17));
 
     REQUIRE(l17.numberOfPoints() == 60);
 
@@ -525,7 +526,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 18")
   {
-    const QuadratureFormula<2>& l18 = QuadratureManager::instance().getTriangleGaussFormula(18);
+    const QuadratureFormula<2>& l18 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(18));
 
     REQUIRE(l18.numberOfPoints() == 67);
 
@@ -556,7 +557,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 19")
   {
-    const QuadratureFormula<2>& l19 = QuadratureManager::instance().getTriangleGaussFormula(19);
+    const QuadratureFormula<2>& l19 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(19));
 
     REQUIRE(l19.numberOfPoints() == 73);
 
@@ -587,7 +588,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("degree 20")
   {
-    const QuadratureFormula<2>& l20 = QuadratureManager::instance().getTriangleGaussFormula(20);
+    const QuadratureFormula<2>& l20 = QuadratureManager::instance().getTriangleFormula(GaussQuadratureDescriptor(20));
 
     REQUIRE(l20.numberOfPoints() == 79);
 
@@ -620,6 +621,7 @@ TEST_CASE("TriangleGaussQuadrature", "[analysis]")
 
   SECTION("max implemented degree")
   {
-    REQUIRE(QuadratureManager::instance().maxTriangleGaussDegree() == TriangleGaussQuadrature::max_degree);
+    REQUIRE(QuadratureManager::instance().maxTriangleDegree(QuadratureType::Gauss) ==
+            TriangleGaussQuadrature::max_degree);
   }
 }