Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/Point2DTests.cs
===================================================================
diff -u
--- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/Point2DTests.cs	(revision 0)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/Point2DTests.cs	(revision 5065)
@@ -0,0 +1,53 @@
+// Copyright (C) Stichting Deltares 2024. All rights reserved.
+// 
+// This file is part of the Dam Engine.
+// 
+// The Dam Engine is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+// 
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+// 
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <http://www.gnu.org/licenses/>.
+// 
+// All names, logos, and references to "Deltares" are registered trademarks of
+// Stichting Deltares and remain full property of Stichting Deltares at all times.
+// All rights reserved.
+
+using Deltares.DamEngine.Data.Geometry;
+using Deltares.Geo.Common.Standard;
+using NUnit.Framework;
+
+namespace Deltares.DamEngine.Data.Tests.Geometry;
+
+[TestFixture]
+public class Point2DTests
+{
+    [TestFixture]
+    public class GivenPoint2D
+    {
+        private static readonly Point2D point2D = new Point2D(1.0, 2.0) { Name = "Point 2D" };
+
+        [TestFixture]
+        public class WhenCloned : GivenPoint2D
+        {
+            private static readonly Point2D clonedPoint2D = point2D.Clone();
+
+            [Test]
+            public void ThenCopyOfPointIsReturned()
+            {
+                Assert.Multiple(() =>
+                {
+                    Assert.That(clonedPoint2D, Is.Not.EqualTo(point2D));
+                    Assert.That(clonedPoint2D.Name, Is.EqualTo(point2D.Name));
+                    Assert.That(clonedPoint2D.LocationEquals(point2D), Is.True);
+                });
+            }
+        }
+    }
+}
\ No newline at end of file
Index: DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryDataTests.cs
===================================================================
diff -u -r5063 -r5065
--- DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryDataTests.cs	(.../GeometryDataTests.cs)	(revision 5063)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data.Tests/Geometry/GeometryDataTests.cs	(.../GeometryDataTests.cs)	(revision 5065)
@@ -385,4 +385,160 @@
         geometryModel.RegenerateGeometry();
         return geometryModel;
     }
+
+    [TestFixture]
+    public class GivenGeometryData
+    {
+        private static readonly GeometryData originalGeometryData = CreateGeometryData();
+
+        [TestFixture]
+        public class WhenCloned : GivenGeometryData
+        {
+            private readonly GeometryData clonedGeometryData = originalGeometryData.Clone();
+
+            [Test]
+            public void ThenBaseDataIsCopied()
+            {
+                Assert.That(clonedGeometryData, Is.Not.EqualTo(originalGeometryData));
+                Assert.Multiple(() =>
+                {
+                    Assert.That(clonedGeometryData.Left, Is.EqualTo(originalGeometryData.Left));
+                    Assert.That(clonedGeometryData.Right, Is.EqualTo(originalGeometryData.Right));
+                    Assert.That(clonedGeometryData.Bottom, Is.EqualTo(originalGeometryData.Bottom));
+                });
+            }
+
+            [Test]
+            public void ThenPointsAreCopied()
+            {
+                Assert.That(clonedGeometryData.Points, Has.Count.EqualTo(originalGeometryData.Points.Count));
+                Assert.That(clonedGeometryData.Points, Has.Count.GreaterThan(0));
+                Assert.That(clonedGeometryData.Points[0], Is.Not.EqualTo(originalGeometryData.Points[0]));
+                Assert.That(clonedGeometryData.Points[0].X, Is.EqualTo(originalGeometryData.Points[0].X));
+            }
+
+            [Test]
+            public void ThenNewlyEffectedPointsAreCopied()
+            {
+                Assert.That(clonedGeometryData.NewlyEffectedPoints, Has.Count.EqualTo(originalGeometryData.NewlyEffectedPoints.Count));
+                Assert.That(clonedGeometryData.NewlyEffectedPoints, Has.Count.GreaterThan(0));
+                Assert.That(clonedGeometryData.NewlyEffectedPoints[0], Is.Not.EqualTo(originalGeometryData.NewlyEffectedPoints[0]));
+                Assert.That(clonedGeometryData.NewlyEffectedPoints[0].X, Is.EqualTo(originalGeometryData.NewlyEffectedPoints[0].X));
+            }
+
+            [Test]
+            public void ThenCurvesAreCopied()
+            {
+                Assert.That(clonedGeometryData.Curves, Has.Count.EqualTo(originalGeometryData.Curves.Count));
+                Assert.That(clonedGeometryData.Curves, Has.Count.GreaterThan(0));
+                Assert.That(clonedGeometryData.Curves[0], Is.Not.EqualTo(originalGeometryData.Curves[0]));
+                Assert.That(clonedGeometryData.Curves[0].HeadPoint.X, Is.EqualTo(originalGeometryData.Curves[0].HeadPoint.X));
+            }
+
+            [Test]
+            public void ThenAllPointsAreCopied()
+            {
+                Assert.Multiple(() =>
+                {
+                    Assert.That(originalGeometryData.Curves[0].HeadPoint, Is.EqualTo(originalGeometryData.Points[0]));
+                    Assert.That(clonedGeometryData.Curves[0].HeadPoint, Is.Not.EqualTo(clonedGeometryData.Points[0]));
+                });
+            }
+
+            [Test]
+            public void AfterRegeneratePointsAreLinked()
+            {
+                GeometryData data = originalGeometryData.Clone();
+                data.RegenerateGeometry();
+                Assert.Multiple(() =>
+                {
+                    Assert.That(originalGeometryData.Curves[0].HeadPoint, Is.EqualTo(originalGeometryData.Points[0]));
+                    Assert.That(data.Curves[0].HeadPoint, Is.EqualTo(data.Points[0]));
+                });
+            }
+            
+            [Test]
+            public void ThenNewlyEffectedCurvesAreCopied()
+            {
+                Assert.That(clonedGeometryData.NewlyEffectedCurves, Has.Count.EqualTo(originalGeometryData.NewlyEffectedCurves.Count));
+                Assert.That(clonedGeometryData.NewlyEffectedCurves, Has.Count.GreaterThan(0));
+                Assert.That(clonedGeometryData.NewlyEffectedCurves[0], Is.Not.EqualTo(originalGeometryData.NewlyEffectedCurves[0]));
+                Assert.That(clonedGeometryData.NewlyEffectedCurves[0].HeadPoint.X, Is.EqualTo(originalGeometryData.NewlyEffectedCurves[0].HeadPoint.X));
+            }
+
+            [Test]
+            public void ThenLoopsAreCopied()
+            {
+                Assert.That(clonedGeometryData.Loops, Has.Count.EqualTo(originalGeometryData.Loops.Count));
+                Assert.That(clonedGeometryData.Loops, Has.Count.GreaterThan(0));
+                Assert.That(clonedGeometryData.Loops[0], Is.Not.EqualTo(originalGeometryData.Loops[0]));
+                Assert.That(clonedGeometryData.Loops[0].CurveList, Has.Count.GreaterThan(0));
+                Assert.That(clonedGeometryData.Loops[0].CurveList, Has.Count.EqualTo(originalGeometryData.Loops[0].CurveList.Count));
+            }
+
+            [Test]
+            public void ThenSurfacesAreCopied()
+            {
+                Assert.That(clonedGeometryData.Surfaces, Has.Count.EqualTo(originalGeometryData.Surfaces.Count));
+                Assert.That(clonedGeometryData.Surfaces, Has.Count.GreaterThan(0));
+                Assert.That(clonedGeometryData.Surfaces[0], Is.Not.EqualTo(originalGeometryData.Surfaces[0]));
+                Assert.That(clonedGeometryData.Surfaces[0].OuterLoop.CurveList, Has.Count.GreaterThan(0));
+                Assert.That(clonedGeometryData.Surfaces[0].OuterLoop.CurveList, Has.Count.EqualTo(originalGeometryData.Surfaces[0].OuterLoop.CurveList.Count));
+            }
+
+            [Test]
+            public void WhenModified_ThenGeometryDataAreNotEqual()
+            {
+                ModifyGeometryData(clonedGeometryData);
+                Assert.Multiple(() =>
+                {
+                    Assert.That(clonedGeometryData.Left, Is.Not.EqualTo(originalGeometryData.Left));
+                    Assert.That(clonedGeometryData.Right, Is.Not.EqualTo(originalGeometryData.Right));
+                    Assert.That(clonedGeometryData.Bottom, Is.Not.EqualTo(originalGeometryData.Bottom));
+                    Assert.That(clonedGeometryData.Points, Has.Count.Not.EqualTo(originalGeometryData.Points.Count));
+                    Assert.That(clonedGeometryData.NewlyEffectedPoints, Has.Count.Not.EqualTo(originalGeometryData.NewlyEffectedPoints.Count));
+                    Assert.That(clonedGeometryData.Curves, Has.Count.Not.EqualTo(originalGeometryData.Curves.Count));
+                    Assert.That(clonedGeometryData.NewlyEffectedCurves, Has.Count.Not.EqualTo(originalGeometryData.NewlyEffectedCurves.Count));
+                    Assert.That(clonedGeometryData.Loops, Has.Count.Not.EqualTo(originalGeometryData.Loops.Count));
+                    Assert.That(clonedGeometryData.Surfaces, Has.Count.Not.EqualTo(originalGeometryData.Surfaces.Count));
+                });
+            }
+        }
+
+        private static GeometryData CreateGeometryData()
+        {
+            var geometryData = new GeometryData
+            {
+                Left = -10.0,
+                Right = 10.0,
+                Bottom = -10.0
+            };
+            geometryData.Points.Add(new Point2D(0.1, 1.1));
+            geometryData.Points.Add(new Point2D(0.2, 1.2));
+            geometryData.NewlyEffectedPoints.Add(new Point2D(0.3, 1.3));
+            geometryData.NewlyEffectedPoints.Add(new Point2D(0.4, 1.4));
+            geometryData.Curves.Add(new GeometryCurve(geometryData.Points[0], geometryData.Points[1]));
+            geometryData.NewlyEffectedCurves.Add(new GeometryCurve(geometryData.NewlyEffectedPoints[0], geometryData.NewlyEffectedPoints[1]));
+            var loop = new GeometryLoop();
+            loop.CurveList.Add(new GeometryCurve(new Point2D(1.0, 2.0), new Point2D(3.0, 4.0)));
+            geometryData.Loops.Add(loop);
+            geometryData.Surfaces.Add(new GeometrySurface(loop));
+            return geometryData;
+        }
+
+        private static void ModifyGeometryData(GeometryData geometryData)
+        {
+            geometryData.Left = geometryData.Left + 1;
+            geometryData.Right = geometryData.Right + 1;
+            geometryData.Bottom = geometryData.Bottom + 1;
+            geometryData.Points.Add(new Point2D(10.0, 20.0));
+            geometryData.NewlyEffectedPoints.Add(new Point2D(30.0, 40.0));
+            geometryData.Curves.Add(new GeometryCurve(geometryData.Points[1], geometryData.Points[2]));
+            geometryData.NewlyEffectedCurves.Add(new GeometryCurve(geometryData.NewlyEffectedPoints[1], geometryData.NewlyEffectedPoints[2]));
+            var loop = new GeometryLoop();
+            loop.CurveList.Add(new GeometryCurve(new Point2D(5.0, 6.0), new Point2D(7.0, 8.0)));
+            geometryData.Loops.Add(loop);
+            geometryData.Surfaces.Add(new GeometrySurface());
+        }
+    }
 }
\ No newline at end of file
Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryCurve.cs
===================================================================
diff -u -r5028 -r5065
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryCurve.cs	(.../GeometryCurve.cs)	(revision 5028)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryCurve.cs	(.../GeometryCurve.cs)	(revision 5065)
@@ -240,4 +240,25 @@
         SurfaceAtRight = aCurve.SurfaceAtRight;
         SurfaceAtLeft = aCurve.SurfaceAtLeft;
     }
+    
+    /// <summary>
+    /// Clones the curve.
+    /// </summary>
+    /// <returns>Returns a clone</returns>
+    public GeometryCurve Clone()
+    {
+        var curve = new GeometryCurve(headPoint.Clone(), endPoint.Clone())
+        {
+            Name = Name
+        };
+        if (SurfaceAtLeft != null)
+        {
+            curve.SurfaceAtLeft = SurfaceAtLeft.Clone();
+        }
+        if (SurfaceAtRight != null)
+        {
+            curve.SurfaceAtRight = SurfaceAtRight.Clone();
+        }
+        return curve;
+    }
 }
\ No newline at end of file
Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/Point2D.cs
===================================================================
diff -u -r5028 -r5065
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/Point2D.cs	(.../Point2D.cs)	(revision 5028)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/Point2D.cs	(.../Point2D.cs)	(revision 5065)
@@ -137,4 +137,13 @@
     {
         return new Point2D(aPoint2.X + aPoint1.X, aPoint2.Z + aPoint1.Z);
     }
+
+    /// <summary>
+    /// Clones the 2D point.
+    /// </summary>
+    /// <returns>Returns a clone</returns>
+    public Point2D Clone()
+    {
+        return new Point2D { X = this.X, Z = this.Z, Name = this.Name};
+    }
 }
\ No newline at end of file
Index: DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs
===================================================================
diff -u -r5064 -r5065
--- DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs	(.../GeometryData.cs)	(revision 5064)
+++ DamEngine/trunk/src/Deltares.DamEngine.Data/Geometry/GeometryData.cs	(.../GeometryData.cs)	(revision 5065)
@@ -1290,4 +1290,43 @@
                 aCurveList.Add(curve);
         }
     }
+
+    /// <summary>
+    /// Clones the geometry data.
+    /// </summary>
+    /// <returns>Returns a clone</returns>
+    public new GeometryData Clone()
+    {
+        var clonedGeometryData = new GeometryData
+        {
+            Left = this.Left,
+            Right = this.Right,
+            Bottom = this.Bottom
+        };
+        foreach (Point2D point in this.Points)
+        {
+            clonedGeometryData.Points.Add(point.Clone());
+        }
+        foreach (Point2D point in this.NewlyEffectedPoints)
+        {
+            clonedGeometryData.NewlyEffectedPoints.Add(point.Clone());
+        }
+        foreach (GeometryCurve curve in this.Curves)
+        {
+            clonedGeometryData.Curves.Add(curve.Clone());
+        }
+        foreach (GeometryCurve curve in this.NewlyEffectedCurves)
+        {
+            clonedGeometryData.NewlyEffectedCurves.Add(curve.Clone());
+        }
+        foreach (GeometryLoop loop in this.Loops)
+        {
+            clonedGeometryData.Loops.Add(loop.Clone());
+        }
+        foreach (GeometrySurface surface in this.Surfaces)
+        {
+            clonedGeometryData.Surfaces.Add(surface.Clone());
+        }
+        return clonedGeometryData;
+    }    
 }
\ No newline at end of file