rename curvedsurfacegrid to curvedgrid

dune/curvedsurfacegrid/geometries/sphere.hh → dune/curvedgrid/geometries/sphere.hh

-#ifndef DUNE_CURVEDSURFACEGRID_SPHERE_GRIDFUNCTION_HH
-#define DUNE_CURVEDSURFACEGRID_SPHERE_GRIDFUNCTION_HH
+#ifndef DUNE_CURVEDGRID_SPHERE_GRIDFUNCTION_HH
+#define DUNE_CURVEDGRID_SPHERE_GRIDFUNCTION_HH
 
 #include <cmath>
 
 #include <dune/common/fmatrix.hh>
 #include <dune/common/fvector.hh>
-#include <dune/curvedsurfacegrid/gridfunctions/analyticgridfunction.hh>
+#include <dune/curvedgrid/gridfunctions/analyticgridfunction.hh>
 
 namespace Dune {
 
@@ -72,4 +72,4 @@ auto sphereGridFunction (T radius)
 
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_SPHERE_GRIDFUNCTION_HH
+#endif // DUNE_CURVEDGRID_SPHERE_GRIDFUNCTION_HH

dune/curvedsurfacegrid/geometries/torus.hh → dune/curvedgrid/geometries/torus.hh

-#ifndef DUNE_CURVEDSURFACEGRID_TORUS_GRIDFUNCTION_HH
-#define DUNE_CURVEDSURFACEGRID_TORUS_GRIDFUNCTION_HH
+#ifndef DUNE_CURVEDGRID_TORUS_GRIDFUNCTION_HH
+#define DUNE_CURVEDGRID_TORUS_GRIDFUNCTION_HH
 
 #include <cassert>
 #include <cmath>
@@ -7,7 +7,7 @@
 #include <type_traits>
 
 #include <dune/common/math.hh>
-#include <dune/curvedsurfacegrid/gridfunctions/analyticgridfunction.hh>
+#include <dune/curvedgrid/gridfunctions/analyticgridfunction.hh>
 
 namespace Dune {
 
@@ -103,4 +103,4 @@ auto torusGridFunction (T R, T r)
 
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_TORUS_GRIDFUNCTION_HH
+#endif // DUNE_CURVEDGRID_TORUS_GRIDFUNCTION_HH

dune/curvedsurfacegrid/geometry.hh → dune/curvedgrid/geometry.hh

-#ifndef DUNE_CURVEDSURFACEGRID_GEOMETRY_HH
-#define DUNE_CURVEDSURFACEGRID_GEOMETRY_HH
+#ifndef DUNE_CURVEDGRID_GEOMETRY_HH
+#define DUNE_CURVEDGRID_GEOMETRY_HH
 
 #include <cassert>
 #include <functional>
@@ -226,4 +226,4 @@ public:
 } // end namespace Curved
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_GEOMETRY_HH
+#endif // DUNE_CURVEDGRID_GEOMETRY_HH

dune/curvedsurfacegrid/grid.hh → dune/curvedgrid/grid.hh

-#ifndef DUNE_CURVEDSURFACEGRID_GRID_HH
-#define DUNE_CURVEDSURFACEGRID_GRID_HH
+#ifndef DUNE_CURVEDGRID_GRID_HH
+#define DUNE_CURVEDGRID_GRID_HH
 
 #include <dune/common/deprecated.hh>
 #include <dune/common/shared_ptr.hh>
-#include <dune/curvedsurfacegrid/concepts.hh>
-#include <dune/curvedsurfacegrid/gridfamily.hh>
-#include <dune/curvedsurfacegrid/backuprestore.hh>
-#include <dune/curvedsurfacegrid/datahandle.hh>
-#include <dune/curvedsurfacegrid/gridfunctions/analyticgridfunction.hh>
-#include <dune/curvedsurfacegrid/gridfunctions/gridfunction.hh>
+#include <dune/curvedgrid/concepts.hh>
+#include <dune/curvedgrid/gridfamily.hh>
+#include <dune/curvedgrid/backuprestore.hh>
+#include <dune/curvedgrid/datahandle.hh>
+#include <dune/curvedgrid/gridfunctions/analyticgridfunction.hh>
+#include <dune/curvedgrid/gridfunctions/gridfunction.hh>
 #include <dune/grid/common/grid.hh>
 #include <dune/grid/geometrygrid/identity.hh>
 #include <dune/grid/geometrygrid/persistentcontainer.hh>
@@ -18,7 +18,7 @@ namespace Dune {
 namespace Impl {
 
 template <class GridFunction, bool useInterpolation>
-struct CurvedSurfaceGridBase
+struct CurvedGridBase
 {
   using HG = GridOf_t<GridFunction>;
 
@@ -31,17 +31,17 @@ struct CurvedSurfaceGridBase
 } // end namespace Impl
 
 template <class GridFunction, bool useInterpolation>
-using CurvedSurfaceGridBase = typename Impl::CurvedSurfaceGridBase<GridFunction,useInterpolation>::type;
+using CurvedGridBase = typename Impl::CurvedGridBase<GridFunction,useInterpolation>::type;
 
 
-// CurvedSurfaceGrid
+// CurvedGrid
 // -----------------
 
-/** \class CurvedSurfaceGrid
+/** \class CurvedGrid
  *  \brief grid wrapper replacing the geometries
  *  \ingroup CurvedGeo
  *
- *  CurvedSurfaceGrid wraps another DUNE grid and replaces its geometry by an implementation
+ *  CurvedGrid wraps another DUNE grid and replaces its geometry by an implementation
  *  of a CurvedGeometry.
  *
  *  \tparam GF     GridViewFunction defined on a (flat) hostgrid
@@ -50,36 +50,36 @@ using CurvedSurfaceGridBase = typename Impl::CurvedSurfaceGridBase<GridFunction,
  *  \nosubgrouping
  */
 template <class GF, bool useInterpolation = false>
-class CurvedSurfaceGrid;
+class CurvedGrid;
 
-/// \brief Generator for CurvedSurfaceGrid from a grid-functions
+/// \brief Generator for CurvedGrid from a grid-functions
 template <class HostGrid, class GF, bool useInterpolation = false,
   std::enable_if_t<Concept::isGridFunction<GF, HostGrid>(), int> = 0>
-auto curvedSurfaceGrid (HostGrid& hostGrid, GF&& gridFunction, int order = -1)
+auto curvedGrid (HostGrid& hostGrid, GF&& gridFunction, int order = -1)
 {
   static_assert(std::is_same<HostGrid, GridOf_t<std::decay_t<GF>>>::value, "GridFunction must be defined on the HostGrid");
-  return CurvedSurfaceGrid<std::decay_t<GF>,useInterpolation>{hostGrid, std::forward<GF>(gridFunction), order};
+  return CurvedGrid<std::decay_t<GF>,useInterpolation>{hostGrid, std::forward<GF>(gridFunction), order};
 }
 
-/// \brief Generator for CurvedSurfaceGrid from a callable
+/// \brief Generator for CurvedGrid from a callable
 template <class HostGrid, class F, bool useInterpolation = false,
   std::enable_if_t<not Concept::isGridFunction<F, HostGrid>(), int> = 0>
-auto curvedSurfaceGrid (HostGrid& hostGrid, F&& callable, int order = -1)
+auto curvedGrid (HostGrid& hostGrid, F&& callable, int order = -1)
 {
   using GlobalCoordinate = typename GridEntitySet<HostGrid,0>::GlobalCoordinate;
   static_assert(Concept::isCallable<F, GlobalCoordinate>(), "Function must be callable");
   auto gridFct = analyticGridFunction<HostGrid>(std::forward<F>(callable));
-  return CurvedSurfaceGrid<decltype(gridFct),useInterpolation>{hostGrid, std::move(gridFct), order};
+  return CurvedGrid<decltype(gridFct),useInterpolation>{hostGrid, std::move(gridFct), order};
 }
 
 
 template <class GF, bool useInterpolation>
-class CurvedSurfaceGrid
-    : public CurvedSurfaceGridBase<GF,useInterpolation>
-    , public Curved::BackupRestoreFacilities<CurvedSurfaceGrid<GF,useInterpolation>>
+class CurvedGrid
+    : public CurvedGridBase<GF,useInterpolation>
+    , public Curved::BackupRestoreFacilities<CurvedGrid<GF,useInterpolation>>
 {
-  using Self = CurvedSurfaceGrid;
-  using Super = CurvedSurfaceGridBase<GF,useInterpolation>;
+  using Self = CurvedGrid;
+  using Super = CurvedGridBase<GF,useInterpolation>;
 
   // friend declarations
   template <class, class> friend class Curved::IdSet;
@@ -219,7 +219,7 @@ public:
    */
   template <class GF_,
     std::enable_if_t<std::is_same<GF,std::decay_t<GF_>>::value, int> = 0>
-  CurvedSurfaceGrid (HostGrid& hostGrid, GF_&& gridFunction, int order = -1)
+  CurvedGrid (HostGrid& hostGrid, GF_&& gridFunction, int order = -1)
     : hostGrid_(hostGrid)
     , gridFunction_(wrap_or_move(std::forward<GF_>(gridFunction)))
     , levelIndexSets_(hostGrid_.maxLevel()+1, nullptr)
@@ -230,12 +230,12 @@ public:
 
   template <class F_,
     std::enable_if_t<std::is_same<GF,AnalyticGridFunction<HostGrid,std::decay_t<F_>>>::value, int> = 0>
-  CurvedSurfaceGrid (HostGrid& hostGrid, F_&& callable, int order = -1)
-    : CurvedSurfaceGrid(hostGrid, analyticGridFunction<HostGrid>(std::forward<F_>(callable)), order)
+  CurvedGrid (HostGrid& hostGrid, F_&& callable, int order = -1)
+    : CurvedGrid(hostGrid, analyticGridFunction<HostGrid>(std::forward<F_>(callable)), order)
   {}
 
   /// \brief destructor
-  ~CurvedSurfaceGrid ()
+  ~CurvedGrid ()
   {
     for (unsigned int i = 0; i < levelIndexSets_.size(); ++i)
     {
@@ -561,25 +561,25 @@ private:
   int order_; // polynomial order of local geometry interpolation
 };
 
-/// \brief Deduction guide for CurvedSurfaceGrid from a grid-functions or callables if
+/// \brief Deduction guide for CurvedGrid from a grid-functions or callables if
 /// the local-function of the grid-function should be used directly as geometry parametrization
 template <class HostGrid, class GF>
-CurvedSurfaceGrid (HostGrid& hostGrid, GF&& gridFunction)
-  -> CurvedSurfaceGrid<GridFunctionOf_t<HostGrid,std::decay_t<GF>>, false>;
+CurvedGrid (HostGrid& hostGrid, GF&& gridFunction)
+  -> CurvedGrid<GridFunctionOf_t<HostGrid,std::decay_t<GF>>, false>;
 
-/// \brief Deduction guide for CurvedSurfaceGrid from a grid-functions or callables if
+/// \brief Deduction guide for CurvedGrid from a grid-functions or callables if
 /// interpolation should be used
 template <class HostGrid, class GF>
-CurvedSurfaceGrid (HostGrid& hostGrid, GF&& gridFunction, int order)
-  -> CurvedSurfaceGrid<GridFunctionOf_t<HostGrid,std::decay_t<GF>>, true>;
+CurvedGrid (HostGrid& hostGrid, GF&& gridFunction, int order)
+  -> CurvedGrid<GridFunctionOf_t<HostGrid,std::decay_t<GF>>, true>;
 
 
-// CurvedSurfaceGrid::Codim
+// CurvedGrid::Codim
 // ------------------------
 
 template <class GridFunction, bool useInterpolation>
 template <int codim>
-struct CurvedSurfaceGrid<GridFunction,useInterpolation>::Codim
+struct CurvedGrid<GridFunction,useInterpolation>::Codim
   : public Super::template Codim<codim>
 {
   /** \name Entity types
@@ -653,4 +653,4 @@ struct CurvedSurfaceGrid<GridFunction,useInterpolation>::Codim
 
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_GRID_HH
+#endif // DUNE_CURVEDGRID_GRID_HH

dune/curvedsurfacegrid/gridfamily.hh → dune/curvedgrid/gridfamily.hh

-#ifndef DUNE_CURVEDSURFACEGRID_GRIDFAMILY_HH
-#define DUNE_CURVEDSURFACEGRID_GRIDFAMILY_HH
+#ifndef DUNE_CURVEDGRID_GRIDFAMILY_HH
+#define DUNE_CURVEDGRID_GRIDFAMILY_HH
 
 #include <type_traits>
 
 #include <dune/grid/common/grid.hh>
-#include <dune/curvedsurfacegrid/capabilities.hh>
-#include <dune/curvedsurfacegrid/entity.hh>
-#include <dune/curvedsurfacegrid/entityseed.hh>
-#include <dune/curvedsurfacegrid/geometry.hh>
-#include <dune/curvedsurfacegrid/gridview.hh>
-#include <dune/curvedsurfacegrid/intersection.hh>
-#include <dune/curvedsurfacegrid/intersectioniterator.hh>
-#include <dune/curvedsurfacegrid/iterator.hh>
-#include <dune/curvedsurfacegrid/idset.hh>
-#include <dune/curvedsurfacegrid/indexsets.hh>
-#include <dune/curvedsurfacegrid/localgeometrywrapper.hh>
-#include <dune/curvedsurfacegrid/gridfunctions/gridfunction.hh>
+#include <dune/curvedgrid/capabilities.hh>
+#include <dune/curvedgrid/entity.hh>
+#include <dune/curvedgrid/entityseed.hh>
+#include <dune/curvedgrid/geometry.hh>
+#include <dune/curvedgrid/gridview.hh>
+#include <dune/curvedgrid/intersection.hh>
+#include <dune/curvedgrid/intersectioniterator.hh>
+#include <dune/curvedgrid/iterator.hh>
+#include <dune/curvedgrid/idset.hh>
+#include <dune/curvedgrid/indexsets.hh>
+#include <dune/curvedgrid/localgeometrywrapper.hh>
+#include <dune/curvedgrid/gridfunctions/gridfunction.hh>
 
 namespace Dune {
 
-/** \brief namespace containing the implementations of CurvedSurfaceGrid
+/** \brief namespace containing the implementations of CurvedGrid
  *  \ingroup CurvedGeo
  */
 namespace Curved {
@@ -41,7 +41,7 @@ struct GridFamily
 {
   struct Traits
   {
-    using Grid = CurvedSurfaceGrid<GF,useInterpolation>;
+    using Grid = CurvedGrid<GF,useInterpolation>;
     using HostGrid = GridOf_t<GF>;
 
     using GridFunction = GF;
@@ -129,4 +129,4 @@ struct GridFamily
 } // end namespace Curved
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_GRIDFAMILY_HH
+#endif // DUNE_CURVEDGRID_GRIDFAMILY_HH

dune/curvedsurfacegrid/gridfunctions/analyticdiscretefunction.hh → dune/curvedgrid/gridfunctions/analyticdiscretefunction.hh

-#ifndef DUNE_CURVEDSURFACEGRID_ANALYTIC_DISCRETEFUNCTION_HH
-#define DUNE_CURVEDSURFACEGRID_ANALYTIC_DISCRETEFUNCTION_HH
+#ifndef DUNE_CURVEDGRID_ANALYTIC_DISCRETEFUNCTION_HH
+#define DUNE_CURVEDGRID_ANALYTIC_DISCRETEFUNCTION_HH
 
 #include <optional>
 #include <type_traits>
@@ -10,8 +10,8 @@
 #endif
 
 #include <dune/common/typeutilities.hh>
-#include <dune/curvedsurfacegrid/gridfunctions/discretegridviewfunction.hh>
-#include <dune/curvedsurfacegrid/gridfunctions/gridentityset.hh>
+#include <dune/curvedgrid/gridfunctions/discretegridviewfunction.hh>
+#include <dune/curvedgrid/gridfunctions/gridentityset.hh>
 #include <dune/localfunctions/lagrange/lfecache.hh>
 
 namespace Dune {
@@ -274,4 +274,4 @@ private:
 
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_ANALYTIC_DISCRETEFUNCTION_HH
+#endif // DUNE_CURVEDGRID_ANALYTIC_DISCRETEFUNCTION_HH

dune/curvedsurfacegrid/gridfunctions/analyticgridfunction.hh → dune/curvedgrid/gridfunctions/analyticgridfunction.hh

-#ifndef DUNE_CURVEDSURFACEGRID_ANALYTIC_GRIDFUNCTION_HH
-#define DUNE_CURVEDSURFACEGRID_ANALYTIC_GRIDFUNCTION_HH
+#ifndef DUNE_CURVEDGRID_ANALYTIC_GRIDFUNCTION_HH
+#define DUNE_CURVEDGRID_ANALYTIC_GRIDFUNCTION_HH
 
 #include <optional>
 #include <type_traits>
@@ -205,4 +205,4 @@ auto derivative (const AnalyticGridFunction<Grid,F>& t)
 
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_ANALYTIC_GRIDFUNCTION_HH
+#endif // DUNE_CURVEDGRID_ANALYTIC_GRIDFUNCTION_HH

dune/curvedsurfacegrid/gridfunctions/discretegridviewfunction.hh → dune/curvedgrid/gridfunctions/discretegridviewfunction.hh

-#ifndef DUNE_CURVEDSURFACEGRID_DISCRETE_GRIDVIEWFUNCTION_HH
-#define DUNE_CURVEDSURFACEGRID_DISCRETE_GRIDVIEWFUNCTION_HH
+#ifndef DUNE_CURVEDGRID_DISCRETE_GRIDVIEWFUNCTION_HH
+#define DUNE_CURVEDGRID_DISCRETE_GRIDVIEWFUNCTION_HH
 
 #include <array>
 #include <optional>
@@ -299,4 +299,4 @@ private:
 
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_DISCRETE_GRIDVIEWFUNCTION_HH
+#endif // DUNE_CURVEDGRID_DISCRETE_GRIDVIEWFUNCTION_HH

dune/curvedsurfacegrid/gridfunctions/gridentityset.hh → dune/curvedgrid/gridfunctions/gridentityset.hh

-#ifndef DUNE_CURVEDSURFACEGRID_GRID_ENTITYSET_HH
-#define DUNE_CURVEDSURFACEGRID_GRID_ENTITYSET_HH
+#ifndef DUNE_CURVEDGRID_GRID_ENTITYSET_HH
+#define DUNE_CURVEDGRID_GRID_ENTITYSET_HH
 
 namespace Dune {
 
@@ -29,4 +29,4 @@ public:
 
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_GRID_ENTITYSET_HH
+#endif // DUNE_CURVEDGRID_GRID_ENTITYSET_HH

dune/curvedsurfacegrid/gridfunctions/gridfunction.hh → dune/curvedgrid/gridfunctions/gridfunction.hh

-#ifndef DUNE_CURVEDSURFACEGRID_GRIDFUNCTION_HH
-#define DUNE_CURVEDSURFACEGRID_GRIDFUNCTION_HH
+#ifndef DUNE_CURVEDGRID_GRIDFUNCTION_HH
+#define DUNE_CURVEDGRID_GRIDFUNCTION_HH
 
 #include <type_traits>
 
 #include <dune/common/typeutilities.hh>
-#include <dune/curvedsurfacegrid/concepts.hh>
-#include <dune/curvedsurfacegrid/gridfunctions/analyticgridfunction.hh>
+#include <dune/curvedgrid/concepts.hh>
+#include <dune/curvedgrid/gridfunctions/analyticgridfunction.hh>
 
 namespace Dune {
 namespace Impl {
@@ -50,4 +50,4 @@ using GridFunctionOf_t
 
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_GRIDFUNCTION_HH
+#endif // DUNE_CURVEDGRID_GRIDFUNCTION_HH

dune/curvedsurfacegrid/gridfunctions/normalgridviewfunction.hh → dune/curvedgrid/gridfunctions/normalgridviewfunction.hh

-#ifndef DUNE_CURVEDSURFACEGRID_NORMAL_GRIDVIEWFUNCTION_HH
-#define DUNE_CURVEDSURFACEGRID_NORMAL_GRIDVIEWFUNCTION_HH
+#ifndef DUNE_CURVEDGRID_NORMAL_GRIDVIEWFUNCTION_HH
+#define DUNE_CURVEDGRID_NORMAL_GRIDVIEWFUNCTION_HH
 
 #include <array>
 #include <vector>
@@ -205,4 +205,4 @@ private:
 
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_NORMAL_GRIDVIEWFUNCTION_HH
+#endif // DUNE_CURVEDGRID_NORMAL_GRIDVIEWFUNCTION_HH

dune/curvedsurfacegrid/gridview.hh → dune/curvedgrid/gridview.hh

-#ifndef DUNE_CURVEDSURFACEGRID_GRIDVIEW_HH
-#define DUNE_CURVEDSURFACEGRID_GRIDVIEW_HH
+#ifndef DUNE_CURVEDGRID_GRIDVIEW_HH
+#define DUNE_CURVEDGRID_GRIDVIEW_HH
 
 #include <cassert>
 #include <utility>
 
-#include <dune/curvedsurfacegrid/datahandle.hh>
-#include <dune/curvedsurfacegrid/declaration.hh>
-#include <dune/curvedsurfacegrid/indexsets.hh>
-#include <dune/curvedsurfacegrid/intersection.hh>
-#include <dune/curvedsurfacegrid/intersectioniterator.hh>
-#include <dune/curvedsurfacegrid/iterator.hh>
+#include <dune/curvedgrid/datahandle.hh>
+#include <dune/curvedgrid/declaration.hh>
+#include <dune/curvedgrid/indexsets.hh>
+#include <dune/curvedgrid/intersection.hh>
+#include <dune/curvedgrid/intersectioniterator.hh>
+#include <dune/curvedgrid/iterator.hh>
 #include <dune/grid/common/gridview.hh>
 
 namespace Dune {
@@ -39,7 +39,7 @@ class GridViewTraits
 
 public:
   using GridViewImp = GridView<HostGridView, GridFunction, useInterpolation>;
-  using Grid = Dune::CurvedSurfaceGrid<GridFunction, useInterpolation>;
+  using Grid = Dune::CurvedGrid<GridFunction, useInterpolation>;
   using IndexSet = Curved::IndexSet<const Grid, typename HostGridView::IndexSet>;
 
   using Intersection = Dune::Intersection<const Grid, Curved::Intersection<const Grid, HostIntersection>>;
@@ -243,4 +243,4 @@ private:
 } // end namespace Curved
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_GRIDVIEW_HH
+#endif // DUNE_CURVEDGRID_GRIDVIEW_HH

dune/curvedsurfacegrid/idset.hh → dune/curvedgrid/idset.hh

-#ifndef DUNE_CURVEDSURFACEGRID_IDSET_HH
-#define DUNE_CURVEDSURFACEGRID_IDSET_HH
+#ifndef DUNE_CURVEDGRID_IDSET_HH
+#define DUNE_CURVEDGRID_IDSET_HH
 
 #include <type_traits>
 
@@ -72,4 +72,4 @@ private:
 } // end namespace Curved
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_IDSET_HH
+#endif // DUNE_CURVEDGRID_IDSET_HH

dune/curvedsurfacegrid/indexsets.hh → dune/curvedgrid/indexsets.hh

-#ifndef DUNE_CURVEDSURFACEGRID_INDEXSETS_HH
-#define DUNE_CURVEDSURFACEGRID_INDEXSETS_HH
+#ifndef DUNE_CURVEDGRID_INDEXSETS_HH
+#define DUNE_CURVEDGRID_INDEXSETS_HH
 
 #include <type_traits>
 #include <vector>
@@ -97,4 +97,4 @@ private:
 } // end namespace Curved
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_INDEXSETS_HH
+#endif // DUNE_CURVEDGRID_INDEXSETS_HH

dune/curvedsurfacegrid/intersection.hh → dune/curvedgrid/intersection.hh

-#ifndef DUNE_CURVEDSURFACEGRID_INTERSECTION_HH
-#define DUNE_CURVEDSURFACEGRID_INTERSECTION_HH
+#ifndef DUNE_CURVEDGRID_INTERSECTION_HH
+#define DUNE_CURVEDGRID_INTERSECTION_HH
 
 #include <optional>
 #include <type_traits>
@@ -183,4 +183,4 @@ private:
 } // end namespace Curved
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_INTERSECTION_HH
+#endif // DUNE_CURVEDGRID_INTERSECTION_HH

dune/curvedsurfacegrid/intersectioniterator.hh → dune/curvedgrid/intersectioniterator.hh

-#ifndef DUNE_CURVEDSURFACEGRID_INTERSECTIONITERATOR_HH
-#define DUNE_CURVEDSURFACEGRID_INTERSECTIONITERATOR_HH
+#ifndef DUNE_CURVEDGRID_INTERSECTIONITERATOR_HH
+#define DUNE_CURVEDGRID_INTERSECTIONITERATOR_HH
 
-#include <dune/curvedsurfacegrid/intersection.hh>
+#include <dune/curvedgrid/intersection.hh>
 
 namespace Dune {
 namespace Curved {
@@ -54,4 +54,4 @@ private:
 } // end namespace Curved
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_INTERSECTIONITERATOR_HH
+#endif // DUNE_CURVEDGRID_INTERSECTIONITERATOR_HH

dune/curvedsurfacegrid/iterator.hh → dune/curvedgrid/iterator.hh

-#ifndef DUNE_CURVEDSURFACEGRID_ITERATOR_HH
-#define DUNE_CURVEDSURFACEGRID_ITERATOR_HH
+#ifndef DUNE_CURVEDGRID_ITERATOR_HH
+#define DUNE_CURVEDGRID_ITERATOR_HH
 
 #include <cassert>
 #include <type_traits>
 #include <utility>
 
-#include <dune/curvedsurfacegrid/entity.hh>
+#include <dune/curvedgrid/entity.hh>
 #include <dune/geometry/referenceelements.hh>
 
 namespace Dune {
@@ -156,4 +156,4 @@ private:
 } // end namespace Curved
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_ITERATOR_HH
+#endif // DUNE_CURVEDGRID_ITERATOR_HH

dune/curvedsurfacegrid/localgeometrywrapper.hh → dune/curvedgrid/localgeometrywrapper.hh

-#ifndef DUNE_CURVEDSURFACEGRID_LOCALGEOMETRYWRAPPER_HH
-#define DUNE_CURVEDSURFACEGRID_LOCALGEOMETRYWRAPPER_HH
+#ifndef DUNE_CURVEDGRID_LOCALGEOMETRYWRAPPER_HH
+#define DUNE_CURVEDGRID_LOCALGEOMETRYWRAPPER_HH
 
 #include <functional>
 #include <utility>
@@ -37,4 +37,4 @@ struct LocalGeometryWrapper
 } // end namespace Curved
 } // end namespace Dune
 
-#endif // DUNE_CURVEDSURFACEGRID_LOCALGEOMETRYWRAPPER_HH
+#endif // DUNE_CURVEDGRID_LOCALGEOMETRYWRAPPER_HH