changed calls to uploadPoints to use Interpolation, vector3 is called Vector3, removed Vector*.cpp and added code to inline functions

Author: Monica Bugeanu (iMac)

src/cavity/WaveletCavity.cpp

@@ -105,7 +105,7 @@ void WaveletCavity::readCavity(const std::string & filename)
     uploadedDyadic = true;
 }
 
-void WaveletCavity::uploadPoints(int quadLevel, Interpolation *interp)
+void WaveletCavity::uploadPoints(int quadLevel, Interpolation *interp, bool isPWL)
 {
     if (not uploadedDyadic) {
         throw std::runtime_error("Dyadic file must be uploaded first.");
@@ -118,7 +118,7 @@ void WaveletCavity::uploadPoints(int quadLevel, Interpolation *interp)
     Cubature *Q;
     initGaussSquare(&Q, quadLevel + 1);
 
-    nElements_ = nPatches * n * n * Q[quadLevel].nop;
+    nElements_ = nPatches * n * n * Q[quadLevel].noP;
 
     elementCenter_.resize(Eigen::NoChange, nElements_);
     elementNormal_.resize(Eigen::NoChange, nElements_);
@@ -130,14 +130,14 @@ void WaveletCavity::uploadPoints(int quadLevel, Interpolation *interp)
             s.y = h * i2;
             for (int i3=0; i3 < n; ++i3) {
                 s.x = h * i3;
-                for (size_t k = 0; k < Q[quadLevel].nop; k++) {
+                for (size_t k = 0; k < Q[quadLevel].noP; k++) {
                     t = vector2Add(s,vector2SMul(h,Q[quadLevel].xi[k]));
                     point = interp->Chi(t,i1);
                     norm = interp->n_Chi(t,i1);
                     Eigen::Vector3d center(point.x, point.y, point.z);
                     Eigen::Vector3d normal(norm.x,  norm.y,  norm.z);
                     normal.normalize();
-                    double area = h * h * Q[quadLevel].w[k] * vector3Norm(norm);
+                    double area = h * h * Q[quadLevel].weight[k] * vector3Norm(norm);
                     elementCenter_.col(j) = center.transpose();
                     elementNormal_.col(j) = normal.transpose();
                     elementArea_(j) = area;

src/cavity/WaveletCavity.hpp

@@ -39,6 +39,7 @@ extern "C"
 }
 
 #include "Vector3.hpp"
+#include "Interpolation.hpp"
 
 #include "Cavity.hpp"
 #include "CavityData.hpp"
@@ -67,7 +68,7 @@ class WaveletCavity : public Cavity
     }
     virtual ~WaveletCavity() {};
     void readCavity(const std::string & filename);
-    void uploadPoints(int quadLevel, vector3 **** T_, bool isPWL);
+    void uploadPoints(int quadLevel, Interpolation *interp, bool isPWL);
     unsigned int getNPatches() { return nPatches; }
     unsigned int getNPatches() const { return nPatches; }
     unsigned int getNLevels() { return nLevels; }
@@ -86,8 +87,8 @@ class WaveletCavity : public Cavity
     double probeRadius;
     int patchLevel;
     double coarsity;
-    void uploadPointsPWC(int quadLevel, vector3 **** T_);
-    void uploadPointsPWL(int quadLevel, vector3 **** T_);
+    void uploadPointsPWC(int quadLevel, Interpolation *interp);
+    void uploadPointsPWL(int quadLevel, Interpolation *interp);
     std::vector<Eigen::Vector3d> nodePoint;
     std::vector<Eigen::Vector3i> nodeIndex;
     unsigned int nPatches;

src/utils/Vector2.cpp

@@ -20,17 +20,32 @@ class Vector2
 };
 
 // vector addition
-inline Vector2 vector2Add(Vector2 a, Vector2 b);
+inline Vector2 vector2Add(Vector2 a, Vector2 b)
+{
+    return Vector2 (a.x+b.x, a.y+b.y);
+}
 
 // vector subtration
-inline Vector2 vector2Sub(Vector2 a, Vector2 b);
+inline Vector2 vector2Sub(Vector2 a, Vector2 b)
+{
+    return Vector2(a.x-b.x, a.y-b.y);
+}
 
 // multiplication by scalar
-inline Vector2 vector2SMul(double a,Vector2 b);
+inline Vector2 vector2SMul(double a,Vector2 b)
+{
+    return Vector2 (a*b.x, a*b.y);
+}
 
 // scalar product
-inline double vector2Dot(Vector2 a,Vector2 b);
+inline double vector2Dot(Vector2 a,Vector2 b)
+{
+    return(a.x*b.x + a.y*b.y);
+}
 
 // euclidean norm
-inline double vector2Norm(Vector2 a);
+inline double vector2Norm(Vector2 a)
+{
+    return(sqrt(a.x*a.x + a.y*a.y));
+}
 #endif

src/utils/Vector2.hpp

@@ -15,26 +15,47 @@ class Vector3
 
     Vector3 (double xi = 0.0, double yi = 0.0, double zi = 0.0) : x(xi), y(yi), z(zi) {}
 };
-
 // vector addition
-inline Vector3 vector3Add(Vector3 a,Vector3 b);
+inline Vector3 vector3Add(Vector3 a,Vector3 b)
+{
+    return Vector3(a.x+b.x, a.y+b.y, a.z+b.z);
+}
 
 // vector in-place addition
-inline void vector3AddTo(Vector3* a,Vector3 b);
+inline void vector3AddTo(Vector3* a,Vector3 b)
+{
+    a->x += b.x;
+    a->y += b.y;
+    a->z += b.z;
+}
 
 // vector subtration
-inline Vector3 vector3Sub(Vector3 a,Vector3 b);
+inline Vector3 vector3Sub(Vector3 a,Vector3 b)
+{
+    return Vector3(a.x-b.x, a.y-b.y, a.z-b.z);
+}
 
 // cross product
-inline Vector3 vector3Mul(Vector3 a,Vector3 b);
+inline Vector3 vector3Mul(Vector3 a,Vector3 b)
+{
+    return Vector3 (a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x);
+}
 
 // multiplication by scalar
-inline Vector3 vector3SMul(double a,Vector3 b);
+inline Vector3 vector3SMul(double a,Vector3 b)
+{
+    return Vector3(a*b.x, a*b.y, a*b.z);
+}
 
 // scalar product
-inline double vector3Dot(Vector3 a,Vector3 b);
+inline double vector3Dot(Vector3 a,Vector3 b)
+{
+    return(a.x*b.x + a.y*b.y + a.z*b.z);
+}
 
 // euclidean norm
-inline double vector3Norm(Vector3 a);
-
+inline double vector3Norm(Vector3 a)
+{
+    return(sqrt(a.x*a.x + a.y*a.y + a.z*a.z));
+}
 #endif