A few minor changes towards annalytic solution convergence.

examples/ResampleWithDataset.cpp

 int main(int argc, char**argv) {
 
 
-    std::cout << "Mesh processing routine\n";
+    std::cout << "Mesh boundary assigment 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();
+    vtkUnstructuredGrid* uGrid;// = vtkUnstructuredGrid::New();
 
     std::string fn = argv[1];
     if(fn.substr(fn.find_last_of(".") + 1) == "vtk") {
         Stencil->SetFileName(argv[2]);
         Stencil->Update();
 
-    vtkUnstructuredGrid* output = vtkUnstructuredGrid::New();
 
     vtkProbeFilter* Resample = vtkProbeFilter::New();
         //Resample->SetSourceData( uGrid );
     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();
 
+    Writer->Delete();
+    Resample->Delete();
+    //Reader->Delete();
+    Stencil->Delete();
+
     //std::cout << *Stencil << std::endl;
 
 }

examples/VTKEdgeGsphere.cpp

         } else if (std::string(argv[3]) == "gravity") {
             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] );
+                phi->InsertTuple1( in, mass * (( 3*(R*R) - raddist*raddist )/(2*(R*R*R))) ); // (1./3.)*point[2] );
+                //phi->InsertTuple1( in,  (2*PI/3)*(3*R*R-raddist*raddist)  ); // (1./3.)*point[2] );
             } else {
                 //phi->InsertTuple1( in, 0);
                 //double costheta = point[2]/raddist ;

examples/borehole/sphere.geo

  */
 
 radius = 2.25;     // Radius of the damn thing
-lc = radius;     //  0.25;   // Target element size
+lc = 15*radius;     //  0.25;   // Target element size
 
 // Total Solution Space
-Box = 10*radius; // The down side of potential
+Box = 100*radius; // The down side of potential
 X0 = -Box;
 X1 =  Box;
 Y0 = -Box;
 Z0 = -Box;
 Z1 =  Box;
 
-cellSize=lc/5; ///10;
+cellSize=radius/10; ///10;
 dd = 0 ; //  1e-5; //cellSize; // .01;
 pio2=Pi/2;
 

examples/borehole/sphereBox.geo

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

src/FEM4EllipticPDE.cpp

 	// ====================  LIFECYCLE     =======================
 
 	FEM4EllipticPDE::FEM4EllipticPDE(const std::string&name) :
-			LemmaObject(name), BndryH(1), BndrySigma(1),
+			LemmaObject(name), BndryH(1000), BndrySigma(1000),
             vtkSigma(NULL), vtkG(NULL), vtkGrid(NULL), gFcn3(NULL) {
 	}
 
 
         //Eigen::BiCGSTAB<Eigen::SparseMatrix<Real> > cg(A);
         cg.setMaxIterations(3000);
+        cg.setTolerance(1e-28);
 
-        std::cout <<"          rows\tcols\n";
+        std::cout << "  rows\tcols\n";
         std::cout << "A: "  << A.rows() << "\t" << A.cols() << std::endl;
         std::cout << "g: "  << g.rows() << "\t" << g.cols() << std::endl;
 
 
             for (int ii=0; ii<4; ++ii) {
                 for (int jj=0; jj<4; ++jj) {
+                    /* homogeneous Dirichlet boundary */
                     if (jj == ii) {
                         // Apply Homogeneous Dirichlet Boundary conditions
                         Real bb = vtkGrid->GetPointData()->GetScalars("vtkValidPointMask")->GetTuple(ID[ii])[0];
             //}
             //TODO this seems wrong!
             //avg /= 4.;
-                //g(ID[ii]) +=  (V) * ( vtkGrid->GetPointData()->GetScalars("G")->GetTuple(ID[ii])[0] )  ;
-                g(ID[ii]) += PI* (V) * avg;
+                g(ID[ii]) +=  (V/4.) * ( vtkGrid->GetPointData()->GetScalars("G")->GetTuple(ID[ii])[0] )  ;
+                //g(ID[ii]) +=  V/4*avg;
                   //g(ID[ii]) +=  6.67 *(V/4.) * avg;
             }
             //g(ID[0]) +=  (V/4.) * avg;