Element-to-Vertex (EToV) connectivity table creation.

include/Nodes1DProvisioner.hpp

@@ -9,16 +9,22 @@ using namespace blitz;
 
 class Nodes1DProvisioner {
 
+    static const int NumFacePoints;
+    static const int NumFaces;
+
     double Min_x;
     double Max_x;
     int NumElements;
     int NOrder;
+    int NumLocalPoints;
 
     Array<double, 2> * xGrid;
     Array<double, 1> * rGrid;
 
     Array<double, 2> * V;
     Array<double, 2> * Dr;
+    Array<double, 2> * Lift;
+    Array<double, 2> * EToV;
 
     SparseMatrixConverter * MatrixConverter;
     EigenSolver * EigSolver;
@@ -37,6 +43,7 @@ class Nodes1DProvisioner {
     Array<double, 1> & get_rGrid();
     Array<double, 2> & get_Dr();
     Array<double, 2> & get_V();
+    Array<double, 2> & get_EToV();
 
     // these can be moved to a helper (polynomials) class or made private within this class.
     void computeJacobiPolynomial(Array<double,1> const & x, const double alpha, const double beta, const int N, Array<double,1> & p);

src/Nodes1DProvisioner.cpp

@@ -5,6 +5,9 @@
 using namespace std;
 using namespace blitz;
 
+const int Nodes1DProvisioner::NumFacePoints = 1;
+const int Nodes1DProvisioner::NumFaces = 2;
+
 /**
  * Constructor. Takes order of polynomials, number of elements, and dimensions of the domain.
  * Assumes equally-spaced elements.
@@ -18,8 +21,13 @@ Nodes1DProvisioner::Nodes1DProvisioner(int _NOrder, int _NumElements, double _xm
     EigSolver = &eigenSolver;
     LinSolver = &directSolver;
 
-    rGrid = new Array<double, 1>(NOrder+1);
-    xGrid = new Array<double, 2>(NOrder+1, NumElements);
+    // This is true in 1D only.
+    NumLocalPoints = NOrder + 1;
+
+    rGrid = new Array<double, 1>(NumLocalPoints);
+    xGrid = new Array<double, 2>(NumLocalPoints, NumElements);
+    Lift = new Array<double, 2>(NumLocalPoints, NumFacePoints*NumFaces);
+    EToV = new Array<double, 2>(NumElements, NumFaces);
 }
 
 /**
@@ -43,6 +51,14 @@ void Nodes1DProvisioner::buildNodes() {
     for (int k=0; k < NumElements; k++) {
         x(Range::all(), k) = Min_x + width*(k + 0.5*(r+1.));
     }
+
+    Array<double, 2> & E2V = *EToV;
+
+    // Create Element-to-Vertex connectivity table.
+    for (int k=0; k < NumElements; k++) {
+        E2V(k, 0) = k+1;
+        E2V(k, 1) = k+2;
+    }
 }
 
 /**
@@ -125,6 +141,12 @@ Array<double, 1> & Nodes1DProvisioner::get_rGrid() {
     return *rGrid;
 }
 
+/**
+ * Get reference to Element-to-Vertex connectivity table.
+ */
+Array<double, 2> & Nodes1DProvisioner::get_EToV() {
+    return *EToV;
+}
 
 /**
  * Get reference to differentiation matrix Dr on the standard element.
@@ -141,7 +163,7 @@ Array<double, 2> & Nodes1DProvisioner::get_V() {
 }
 
 /**
- * Destructoructor
+ * Destructor.
  */
 Nodes1DProvisioner::~Nodes1DProvisioner() {
 }

src/main.cpp

@@ -44,13 +44,14 @@ int main(int argc, char **argv) {
   cout << DVr << endl;
   cout << nodes1DProvisioner.get_Dr() << endl;
 
-  cout << nodes1DProvisioner.get_xGrid() << endl;
+  Array<double,2> x = nodes1DProvisioner.get_xGrid();
+
+  cout << x << endl;
 
   Array<double,2> J(N+1, K);
   Array<double,2> rx(N+1, K);
+
   nodes1DProvisioner.computeJacobian(J, rx);
-  cout << J << endl;
-  cout << rx << endl;
 
   return 0;
 }

src/test/Nodes1DProvisionerTests.cpp

@@ -250,6 +250,22 @@ namespace Nodes1DProvisionerTests {
             Assert::That(sqrt(sum(res(ii)*res(ii))), IsLessThan(epsf));
         }
 
+        It(Should_Build_Element_To_Vertex_Connectivity) {
+            Nodes1DProvisioner & nodes1D = *nodes1DProvisioner;
+
+            nodes1D.buildNodes();
+
+            Array<double, 2> EToV = nodes1D.get_EToV();
+
+            cout << "EToV: " << EToV << endl;
+
+            Assert::That(EToV(0,0), Equals(1)); Assert::That(EToV(0,1), Equals(2));
+            Assert::That(EToV(1,0), Equals(2)); Assert::That(EToV(1,1), Equals(3));
+            Assert::That(EToV(2,0), Equals(3)); Assert::That(EToV(2,1), Equals(4));
+            Assert::That(EToV(3,0), Equals(4)); Assert::That(EToV(3,1), Equals(5));
+            Assert::That(EToV(4,0), Equals(5)); Assert::That(EToV(4,1), Equals(6));
+        }
+
         It(Should_Compute_Jacobian) {
             Nodes1DProvisioner & nodes1D = *nodes1DProvisioner;