Original+sub mesh+shifted

AnalyticalGeometricShape.cpp

@@ -0,0 +1,27 @@
+// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
+// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
+// reserved. See files LICENSE and NOTICE for details.
+//
+// This file is part of CEED, a collection of benchmarks, miniapps, software
+// libraries and APIs for efficient high-order finite element and spectral
+// element discretizations for exascale applications. For more information and
+// source code availability see http://github.com/ceed.
+//
+// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,
+// a collaborative effort of two U.S. Department of Energy organizations (Office
+// of Science and the National Nuclear Security Administration) responsible for
+// the planning and preparation of a capable exascale ecosystem, including
+// software, applications, hardware, advanced system engineering and early
+// testbed platforms, in support of the nation's exascale computing imperative.
+
+#include "AnalyticalGeometricShape.hpp"
+
+namespace mfem
+{
+
+  AnalyticalGeometricShape::AnalyticalGeometricShape(Mesh *mesh): mesh(mesh){
+
+}
+  AnalyticalGeometricShape::~AnalyticalGeometricShape(){
+  }
+}

AnalyticalGeometricShape.hpp

@@ -0,0 +1,43 @@
+// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
+// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
+// reserved. See files LICENSE and NOTICE for details.
+//
+// This file is part of CEED, a collection of benchmarks, miniapps, software
+// libraries and APIs for efficient high-order finite element and spectral
+// element discretizations for exascale applications. For more information and
+// source code availability see http://github.com/ceed.
+//
+// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,
+// a collaborative effort of two U.S. Department of Energy organizations (Office
+// of Science and the National Nuclear Security Administration) responsible for
+// the planning and preparation of a capable exascale ecosystem, including
+// software, applications, hardware, advanced system engineering and early
+// testbed platforms, in support of the nation's exascale computing imperative.
+
+#ifndef MFEM_ANALYTICAL_GEOMETRIC_SHAPE
+#define MFEM_ANALYTICAL_GEOMETRIC_SHAPE
+
+#include "mfem.hpp"
+
+namespace mfem{
+
+  class AnalyticalGeometricShape{
+
+  protected:
+    Mesh *mesh;
+
+public:
+    /// Element type related to shifted boundaries (not interfaces).
+   /// For more than 1 level-set, we set the marker to CUT+level_set_index
+   /// to discern between different level-sets.
+    enum SBElementType {OUTSIDE = 0, INSIDE = 1, CUT = 2};
+
+    AnalyticalGeometricShape(Mesh* mesh);
+    virtual void SetupElementStatus(GridFunction& alpha) = 0;
+
+    virtual void ComputeDistanceAndNormal(const Vector& x_ip, Vector& dist, Vector& tn) const = 0;
+
+  virtual  ~AnalyticalGeometricShape();
+  };
+}
+#endif // MFEM_LAGHOS

AnalyticalSurface.cpp

@@ -0,0 +1,70 @@
+// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
+// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
+// reserved. See files LICENSE and NOTICE for details.
+//
+// This file is part of CEED, a collection of benchmarks, miniapps, software
+// libraries and APIs for efficient high-order finite element and spectral
+// element discretizations for exascale applications. For more information and
+// source code availability see http://github.com/ceed.
+//
+// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,
+// a collaborative effort of two U.S. Department of Energy organizations (Office
+// of Science and the National Nuclear Security Administration) responsible for
+// the planning and preparation of a capable exascale ecosystem, including
+// software, applications, hardware, advanced system engineering and early
+// testbed platforms, in support of the nation's exascale computing imperative.
+
+#include "AnalyticalSurface.hpp"
+
+namespace mfem
+{
+
+  AnalyticalSurface::AnalyticalSurface(int geometryType, Mesh *mesh):
+    geometryType(geometryType),
+    mesh(mesh),
+    L2FEC_0(0, mesh->Dimension()),
+    L2_fes_0(mesh, &L2FEC_0),
+    geometry(NULL)
+  {
+    alpha.SetSpace(&L2_fes_0),
+    alpha = 0.0;
+
+    switch (geometryType)
+      {
+      case 1: geometry = new Line(mesh); break;
+      case 2: geometry = new Circle(mesh); break;
+      default:
+	out << "Unknown geometry type: " << geometryType << '\n';
+	break;
+      }
+  }
+
+  AnalyticalSurface::~AnalyticalSurface()
+  {
+    delete geometry;
+  }
+
+  void AnalyticalSurface::SetupElementStatus()
+  {
+    geometry->SetupElementStatus(alpha);
+  }
+  void AnalyticalSurface::ResetData()
+  {
+    alpha = 0.0;
+  }
+
+  GridFunction& AnalyticalSurface::GetAlpha()
+  {
+    return alpha;
+  }
+  AnalyticalGeometricShape& AnalyticalSurface::GetAnalyticalGeometricShape()
+  {
+    return *geometry;
+  }
+
+  void AnalyticalSurface::ComputeDistanceAndNormal(const Vector& x_ip, Vector& dist, Vector& tn) const
+  {
+    geometry->ComputeDistanceAndNormal(x_ip, dist, tn);
+  }
+
+}

AnalyticalSurface.hpp

@@ -0,0 +1,50 @@
+// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
+// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
+// reserved. See files LICENSE and NOTICE for details.
+//
+// This file is part of CEED, a collection of benchmarks, miniapps, software
+// libraries and APIs for efficient high-order finite element and spectral
+// element discretizations for exascale applications. For more information and
+// source code availability see http://github.com/ceed.
+//
+// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,
+// a collaborative effort of two U.S. Department of Energy organizations (Office
+// of Science and the National Nuclear Security Administration) responsible for
+// the planning and preparation of a capable exascale ecosystem, including
+// software, applications, hardware, advanced system engineering and early
+// testbed platforms, in support of the nation's exascale computing imperative.
+
+#ifndef MFEM_ANALYTICAL_SURFACE
+#define MFEM_ANALYTICAL_SURFACE
+
+#include "mfem.hpp"
+#include "general/forall.hpp"
+#include "linalg/dtensor.hpp"
+#include "Line.hpp"
+#include "Circle.hpp"
+
+namespace mfem
+{
+
+  class AnalyticalSurface
+  {
+
+  protected:
+    int geometryType;
+    GridFunction alpha;
+    AnalyticalGeometricShape *geometry;
+    Mesh *mesh;
+    L2_FECollection L2FEC_0;
+    FiniteElementSpace L2_fes_0;
+
+  public:
+  AnalyticalSurface(int geometryType, Mesh *mesh);
+  void SetupElementStatus();
+  void ResetData();
+  GridFunction& GetAlpha();
+  AnalyticalGeometricShape& GetAnalyticalGeometricShape();
+  void ComputeDistanceAndNormal(const Vector& x_ip, Vector& dist, Vector& tn) const;
+  ~AnalyticalSurface();
+  };
+}
+#endif // MFEM_LAGHOS

Circle.cpp

@@ -0,0 +1,108 @@
+// Copyright (c) 2017, Lawrence Livermore National Security, OALLC. Produced at
+// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
+// reserved. See files LICENSE and NOTICE for details.
+//
+// This file is part of CEED, a collection of benchmarks, miniapps, software
+// libraries and APIs for efficient high-order finite element and spectral
+// element discretizations for exascale applications. For more information and
+// source code availability see http://github.com/ceed.
+//
+// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,
+// a collaborative effort of two U.S. Department of Energy organizations (Office
+// of Science and the National Nuclear Security Administration) responsible for
+// the planning and preparation of a capable exascale ecosystem, including
+// software, applications, hardware, advanced system engineering and early
+// testbed platforms, in support of the nation's exascale computing imperative.
+
+
+#include "Circle.hpp"
+
+namespace mfem{
+
+  Circle::Circle(Mesh* mesh): AnalyticalGeometricShape(mesh), radius(0.2), center(2)
+ {
+   center(0) = 0.5;
+   center(1) = 0.5;
+  }
+
+  Circle::~Circle()
+  {}
+
+  void Circle::SetupElementStatus(GridFunction& alpha)
+  {
+    const int max_elem_attr = (mesh->attributes).Max();
+    int activeCount = 0;
+    int inactiveCount = 0;
+    int cutCount = 0;
+    IntegrationRules IntRulesLo(0, Quadrature1D::GaussLobatto);
+    alpha = 0.0;
+    auto fes = alpha.FESpace();
+    const IntegrationRule &ir = IntRulesLo.Get(fes->GetFE(0)->GetGeomType(), 20);
+    const int NE = fes->GetNE(), nqp = ir.GetNPoints();
+    // Check elements on the current MPI rank
+    for (int e = 0; e < NE; e++)
+      {
+	ElementTransformation *Tr = fes->GetElementTransformation(e);
+	int count = 0;
+	for (int q = 0; q < nqp; q++)
+	  {
+	    const IntegrationPoint &ip = ir.IntPoint(q);
+	    Tr->SetIntPoint(&ip);
+	    Vector x(3);
+	    Tr->Transform(ip,x);
+
+	    double radiusOfPt = pow(pow(x(0)-center(0),2.0)+pow(x(1)-center(1),2.0),0.5);
+	    if ( radiusOfPt >= radius)
+	      {
+		count++;
+	      }
+	  }
+	if (count == nqp)
+	  {
+	    activeCount++;
+	    alpha(e) = 1.0;
+	  }
+	else if (count > 0 && count < nqp)
+	  {
+	    cutCount++;
+	    alpha(e) = 0.5;
+	    //  mesh->SetAttribute(e, max_elem_attr+1);
+	  }
+	else if (count == 0)
+	  {
+	    inactiveCount++;
+	    alpha(e) = 0.0;
+	    //	    mesh->SetAttribute(e, max_elem_attr+1);
+	  }
+      }
+    // mesh->SetAttributes();
+    // std::cout << " active elemSta " << activeCount << " cut " << cutCount << " inacive " << inactiveCount <<  std::endl;
+  }
+
+  void Circle::ComputeDistanceAndNormal(const Vector& x_ip, Vector& dist, Vector& tn) const
+  {
+    dist.SetSize(2);
+    dist = 0.0;
+    tn.SetSize(2);
+    tn = 0.0;
+
+    double r = sqrt(pow(x_ip(0)-center(0),2.0)+pow(x_ip(1)-center(1),2.0));
+    if (r > radius)
+      {
+	dist(0) = ((x_ip(0)-center(0))/r)*(radius-r);
+	dist(1) = ((x_ip(1)-center(1))/r)*(radius-r);
+	double normD = sqrt(dist(0) * dist(0) + dist(1) * dist(1));
+	if (normD > 0.0)
+	  {
+	    tn(0) = dist(0) / normD;
+	    tn(1) = dist(1) / normD;	
+	  }
+      }
+    else
+      {
+	dist = 0.0;
+	tn(0) = (center(0) - x_ip(0)) / radius;
+	tn(1) = (center(1) - x_ip(1)) / radius;		
+      }
+  }
+}

Circle.hpp

@@ -0,0 +1,41 @@
+// Copyright (c) 2017, Lawrence Livermore National Security, LLC. Produced at
+// the Lawrence Livermore National Laboratory. LLNL-CODE-734707. All Rights
+// reserved. See files LICENSE and NOTICE for details.
+//
+// This file is part of CEED, a collection of benchmarks, miniapps, software
+// libraries and APIs for efficient high-order finite element and spectral
+// element discretizations for exascale applications. For more information and
+// source code availability see http://github.com/ceed.
+//
+// The CEED research is supported by the Exascale Computing Project 17-SC-20-SC,
+// a collaborative effort of two U.S. Department of Energy organizations (Office
+// of Science and the National Nuclear Security Administration) responsible for
+// the planning and preparation of a capable exascale ecosystem, including
+// software, applications, hardware, advanced system engineering and early
+// testbed platforms, in support of the nation's exascale computing imperative.
+#ifndef MFEM_CIRCLE
+#define MFEM_CIRCLE
+
+#include "AnalyticalGeometricShape.hpp"
+
+namespace mfem
+{
+  class Circle : public AnalyticalGeometricShape{
+
+  protected:
+    double radius;
+    Vector center;
+
+  public: 
+
+    Circle(Mesh *mesh);
+    ~Circle();
+
+    void SetupElementStatus(GridFunction& alpha);
+    void ComputeDistanceAndNormal(const Vector& x_ip, Vector& dist, Vector& tn) const;
+  };
+
+}
+
+#endif // MFEM_LAGHOS
+