Added preprocessing routine.

examples/CMakeLists.txt

@@ -16,9 +16,12 @@ target_link_libraries( VTKEdgeG  "lemmacore" "fem4ellipticpde")
 add_executable( VTKEdgeGsphere VTKEdgeGsphere.cpp  )
 target_link_libraries( VTKEdgeGsphere  "lemmacore" "fem4ellipticpde")
 
+add_executable( ResampleWithDataset ResampleWithDataset.cpp  )
+target_link_libraries( ResampleWithDataset  "lemmacore" "fem4ellipticpde")
+
 #INSTALL_TARGETS( "${CMAKE_INSTALL_PREFIX}/share/FEM4EllipticPDE/"
 INSTALL_TARGETS( "/share/FEM4EllipticPDE/"
-	FEM4EllipticPDE_bhmag FEM4EllipticPDE merge VTKDC VTKEdgeG VTKEdgeGsphere
+	FEM4EllipticPDE_bhmag FEM4EllipticPDE merge VTKDC VTKEdgeG VTKEdgeGsphere ResampleWithDataset
 )
 
 install( DIRECTORY "borehole"

examples/ResampleWithDataset.cpp

@@ -0,0 +1,95 @@
+/* This file is part of Lemma, a geophysical modelling and inversion API.
+ * More information is available at http://lemmasoftware.org
+ */
+
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ */
+
+/**
+ * @file
+ * @date      01/27/2016 01:24:24 PM
+ * @version   $Id$
+ * @author    Trevor Irons (ti)
+ * @email     tirons@egi.utah.edu
+ * @copyright Copyright (c) 2016, University of Utah
+ * @copyright Copyright (c) 2016, Trevor Irons & Lemma Software, LLC
+ */
+
+#include <vtkProbeFilter.h>
+#include <vtkSTLReader.h>
+#include <vtkUnstructuredGrid.h>
+#include <vtkUnstructuredGridReader.h>
+#include <vtkUnstructuredGridWriter.h>
+#include <vtkGenericDataObjectReader.h>
+#include <vtkXMLUnstructuredGridReader.h>
+#include <vtkXMLUnstructuredGridWriter.h>
+#include <vtkDoubleArray.h>
+#include <vtkPointData.h>
+#include <cmath>
+#include <Eigen/Core>
+
+
+int main(int argc, char**argv) {
+
+
+    std::cout << "Mesh processing routine\n";
+    if (argc<4) {
+        std::cout << "usage:\n" << "./ResampleWithDataset  inMesh.vtu  boundaries.stl  outG.vtu" << std::endl;
+        exit(EXIT_SUCCESS);
+    }
+
+    vtkUnstructuredGrid* uGrid = vtkUnstructuredGrid::New();
+
+    std::string fn = argv[1];
+    if(fn.substr(fn.find_last_of(".") + 1) == "vtk") {
+        vtkGenericDataObjectReader* Reader = vtkGenericDataObjectReader::New();
+            Reader->SetFileName(argv[1]);
+            Reader->Update();
+        if(Reader->IsFileUnstructuredGrid()) {
+            std::cout << "Found Unstructured grid legacy file" << std::endl;
+            uGrid = Reader->GetUnstructuredGridOutput();
+        } else {
+            std::cerr << "Unknown legacy format";
+            exit(EXIT_FAILURE);
+        }
+
+    } else {
+
+        vtkXMLUnstructuredGridReader* Reader = vtkXMLUnstructuredGridReader::New();
+            std::cout << "Reading" << argv[1] << std::endl;
+            Reader->SetFileName(argv[1]);
+            Reader->Update();
+            uGrid = Reader->GetOutput();
+    }
+        int nc = uGrid->GetNumberOfCells()  ;
+        int nn = uGrid->GetNumberOfPoints()  ;
+
+    std::cout << "Processing grid with nodes=" << nn << "\t cells=" << nc << "\n";
+
+    vtkSTLReader* Stencil = vtkSTLReader::New();
+        Stencil->SetFileName(argv[2]);
+        Stencil->Update();
+
+    vtkUnstructuredGrid* output = vtkUnstructuredGrid::New();
+
+    vtkProbeFilter* Resample = vtkProbeFilter::New();
+        //Resample->SetSourceData( uGrid );
+        //Resample->SetInputData( Stencil->GetOutput() );
+        Resample->SetInputData( uGrid );
+        Resample->SetSourceData( Stencil->GetOutput() );
+        Resample->SpatialMatchOn();
+        Resample->Update();
+
+    std::cout << *Resample << std::endl;
+
+    vtkXMLUnstructuredGridWriter* Writer = vtkXMLUnstructuredGridWriter::New();
+        //Resample->Probe(uGrid, Stencil->GetOutput(), output);
+        Writer->SetInputData( Resample->GetOutput() );
+        Writer->SetFileName( argv[3] );
+        Writer->Write();
+
+    //std::cout << *Stencil << std::endl;
+
+}

examples/VTKEdgeGsphere.cpp

@@ -143,7 +143,7 @@ int main(int argc, char**argv) {
                 phi->InsertTuple1( in, (1./3.) * (R*R*R) * (costheta / (raddist*raddist))  );
             }
         } else if (std::string(argv[3]) == "gravity") {
-            double mass = 4./3. * PI * (R*R*R);
+            double mass = 4./3. * PI * (R*R*R); // volume * density (1)
             if (raddist < R) {
                 phi->InsertTuple1( in, mass * ( 3*(R*R) - raddist*raddist )/(2*(R*R*R)) ); // (1./3.)*point[2] );
             } else {

examples/borehole/sphere.geo

@@ -7,25 +7,11 @@
  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
  */
 
-/**
- * @file
- * @date      08/08/2014 12:19:20 PM
- * @version   $Id$
- * @author    Trevor Irons (ti)
- * @email     Trevor.Irons@xri-geo.com
- * @copyright Copyright (c) 2014, XRI Geophysics, LLC
- * @copyright Copyright (c) 2014, Trevor Irons
- */
-
-
-D0 = 10;          // Top of magnet
-D1 = 11;          // Bottom of magnet
 radius = 2.25;     // Radius of the damn thing
-
-lc = radius;   //  0.25;   // Target element size
+lc = radius;     //  0.25;   // Target element size
 
 // Total Solution Space
-Box = 30*radius; // The down side of potential
+Box = 10*radius; // The down side of potential
 X0 = -Box;
 X1 =  Box;
 Y0 = -Box;
@@ -33,7 +19,7 @@ Y1 =  Box;
 Z0 = -Box;
 Z1 =  Box;
 
-cellSize=lc; //300;
+cellSize=lc/5; ///10;
 dd = 0 ; //  1e-5; //cellSize; // .01;
 pio2=Pi/2;
 
@@ -60,8 +46,6 @@ Plane Surface(125) = {lv+4};
 //v = newv;
 v[] = Extrude {0, 0, Z1-Z0} { Surface{125}; };
 
-
-
 // Calculate offset effect
 theta = Asin(dd/radius);
 rr = radius * Cos(theta);
@@ -131,13 +115,28 @@ Surface{t6[0]} In Volume{v[1]};
 ///////////////////////////////////////////////
 // Attractor Field
 
-Field[1] = Attractor;
-Field[1].NodesList = {p}; //0, p0+1, p0+2, p0+3, p0+4, p, p+1, p+2, p+3, p+4};
-
-//Field[2] = MathEval;
-//Field[2].F = Sprintf("(2.25 - F1)^2 + %g", cellSize*10 );  // WORKS
-//Field[2].F = Sprintf("(%g - F1)^2 + %g", radius, 2*cellSize );
-//Background Field = 2;
+// Field[1] = Attractor;
+// Field[1].NodesList = {p}; //0, p0+1, p0+2, p0+3, p0+4, p, p+1, p+2, p+3, p+4};
+//
+// Field[2] = MathEval;
+// Field[2].F = Sprintf("(2.25 - F1)^1.01 + %g", radius/10 );  // WORKS
+//
+// Field[3] = MathEval;
+// Field[3].F = Sprintf("(12.25 - F1)^1.01 + %g", radius/5 );  // WORKS
+//
+// Field[4] = MathEval;
+// Field[4].F = Sprintf("(22.25 - F1)^1.01 + %g", radius );  // WORKS
+//
+// Field[5] = MathEval;
+// Field[5].F = Sprintf("(42.25 - F1)^1.01 + %g", radius*5 );  // WORKS
+//
+// //Field[2].F = Sprintf("(%g - F1)^2 + %g", radius, 2*cellSize );
+// //Background Field = 2;
+//
+// // Finally, let's use the minimum of all the fields as the background mesh field
+// Field[7] = Min;
+// Field[7].FieldsList = {2, 3, 4, 5};
+// Background Field = 7;
 
 // Don't extend the elements sizes from the boundary inside the domain
 //Mesh.CharacteristicLengthExtendFromBoundary = 0;

examples/borehole/sphere.sh

@@ -1,7 +1,14 @@
 #!/usr/bin/env bash
 gmsh  -3 -format vtk -o sphere.vtk  sphere.geo 
 gmsh  -2 -format stl -o sphereBox.stl  sphereBox.geo 
-paraview --state=boundarySphere.pvsm 
+//paraview --state=boundarySphere.pvsm 
+../ResampleWithDataset  sphere.vtk  sphereBox.stl  MergedSphere.vtu 
+
+
+../VTKEdgeGsphere MergedSphere.vtu   2.25  gravity  sphereGrav.vtu
+../FEM4EllipticPDE_bhmag  sphereGrav.vtu  sphereGrav.vtu   sphereOutGrav.vtu 
+
+paraview --state=sliceGravSphere3.pvsm
 
 #IMPORTANT! 
 #   Select ResampleWithDataset1

examples/borehole/sphereBox.geo

@@ -11,10 +11,10 @@ D0 = 10;          // Top of magnet
 D1 = 11;          // Bottom of magnet
 radius = 2.25;     // Radius of the damn thing
 
-lc = radius;   //  0.25;   // Target element size
+lc = 1*radius;   //  0.25;   // Target element size
 
 // Total Solution Space
-Box = 30*radius; // The down side of potential
+Box = 10*radius; // The down side of potential
 X0 = -Box;
 X1 =  Box;
 Y0 = -Box;

src/FEM4EllipticPDE.cpp

@@ -297,7 +297,7 @@ namespace Lemma {
                 C(ii, 3) =  pts[2] ;
             }
 
-            Eigen::Matrix<Real, 4, 4> Phi = C.inverse(); // nabla \phi
+            Eigen::Matrix<Real, 4, 4> GradPhi = C.inverse(); // nabla \phi
             Real V = (1./6.) * C.determinant();          // volume of tetrahedra
 
             vtkIdList* Ids = vtkGrid->GetCell(ic)->GetPointIds();
@@ -322,17 +322,16 @@ namespace Lemma {
             for (int ii=0; ii<4; ++ii) {
                 for (int jj=0; jj<4; ++jj) {
                     if (jj == ii) {
-                        // I apply boundary to Stiffness matrix, it's common to take the other approach and apply to the load vector and then
-                        //   solve for the boundaries? Is one better? This seems to work, which is nice.
-                        //Real bdry = V*(1./(BndryH*BndryH))*BndrySigma*bndryCnt( ID[ii] ); // + sum;
+                        // Apply Homogeneous Dirichlet Boundary conditions
                         Real bb = vtkGrid->GetPointData()->GetScalars("vtkValidPointMask")->GetTuple(ID[ii])[0];
-                        Real bdry = V*(1./(BndryH*BndryH))*BndrySigma*bb; // + sum;
-                        coeffs.push_back( Eigen::Triplet<Real> ( ID[ii], ID[jj], bdry +  Phi.col(ii).tail<3>().dot(Phi.col(jj).tail<3>() ) * V * sigma_bar ) );
+                        Real bdry = (1./(BndryH*BndryH))*BndrySigma*bb; // + sum;
+                        //Real bdry = GradPhi.col(ii).tail<3>().dot(GradPhi.col(ii).tail<3>())*BndrySigma*bb; // + sum;
+                        coeffs.push_back( Eigen::Triplet<Real> ( ID[ii], ID[jj], bdry + GradPhi.col(ii).tail<3>().dot(GradPhi.col(jj).tail<3>() ) * V * sigma_bar ) );
                     } else {
-                        coeffs.push_back( Eigen::Triplet<Real> ( ID[ii], ID[jj],         Phi.col(ii).tail<3>().dot(Phi.col(jj).tail<3>() ) * V * sigma_bar ) );
+                        coeffs.push_back( Eigen::Triplet<Real> ( ID[ii], ID[jj],        GradPhi.col(ii).tail<3>().dot(GradPhi.col(jj).tail<3>() ) * V * sigma_bar ) );
                     }
                     // Stiffness matrix no longer contains boundary conditions...
-                    //coeffs.push_back( Eigen::Triplet<Real> ( ID[ii], ID[jj], Phi.col(ii).tail<3>().dot(Phi.col(jj).tail<3>() ) * V * sigma_bar ) );
+                    //coeffs.push_back( Eigen::Triplet<Real> ( ID[ii], ID[jj], GradPhi.col(ii).tail<3>().dot(GradPhi.col(jj).tail<3>() ) * V * sigma_bar ) );
                 }
             }
             std::cout <<  "\r" << (int)(1e2*((float)(ic) / (float)(vtkGrid->GetNumberOfCells()))) << std::flush ;
@@ -354,7 +353,7 @@ namespace Lemma {
             Eigen::Matrix<Real, 4, 4> C = Eigen::Matrix<Real, 4, 4>::Zero() ;
             for (int ii=0; ii<4; ++ii) {
                 double* pts =  vtkGrid->GetCell(ic)->GetPoints()->GetPoint(ii); //[ipc] ;
-                C(ii, 0) = 1;
+                C(ii, 0) =  1;
                 C(ii, 1) =  pts[0];
                 C(ii, 2) =  pts[1];
                 C(ii, 3) =  pts[2];
@@ -386,9 +385,11 @@ namespace Lemma {
             //}
             //TODO this seems wrong!
             //avg /= 4.;
-                //g(ID[ii]) +=  (V/4.) * ( vtkGrid->GetPointData()->GetScalars("G")->GetTuple(ID[ii])[0] )  ;
-                g(ID[ii]) +=  (V/4.) * avg;
+                //g(ID[ii]) +=  (V) * ( vtkGrid->GetPointData()->GetScalars("G")->GetTuple(ID[ii])[0] )  ;
+                g(ID[ii]) += PI* (V) * avg;
+                  //g(ID[ii]) +=  6.67 *(V/4.) * avg;
             }
+            //g(ID[0]) +=  (V/4.) * avg;
         }
 
     }