Boundary specification now coded

CMakeLists.txt

 
 	# Linking
 	target_link_libraries(emschur3d ${VTK_LIBRARIES})
-if ( SUPERLU_FOUND )
-	target_link_libraries(emschur3d ${SUPERLU_LIBRARIES})
-endif()
-if ( PASTIX_FOUND )
-	target_link_libraries(emschur3d ${PASTIX_LIBRARIES})
-	target_link_libraries(emschur3d "blas" "metis" "scotch" "scotchmetis" "scotcherr" "scotcherrexit" "hwloc")
-endif()
-if ( UMFPACK_FOUND )
-	target_link_libraries(emschur3d ${UMFPACK_LIBRARIES})
-endif()
+
+	if ( SUPERLU_FOUND )
+		target_link_libraries(emschur3d ${SUPERLU_LIBRARIES})
+	endif()
+	if ( PASTIX_FOUND )
+		target_link_libraries(emschur3d ${PASTIX_LIBRARIES})
+		target_link_libraries(emschur3d "blas" "metis" "scotch" "scotchmetis" "scotcherr" "scotcherrexit" "hwloc")
+	endif()
+	if ( UMFPACK_FOUND )
+		target_link_libraries(emschur3d ${UMFPACK_LIBRARIES})
+	endif()
 
 	# Testing
 	if (LEMMA_ENABLE_TESTING)

config/EMSchur3DConfig.h.in

 /**
  * @file
  * @date      01/08/2018 04:01:30 PM
- * @version   $Id$
  * @author    Trevor Irons (ti)
  * @email     tirons@egi.utah.edu
  * @copyright Copyright (c) 2018, University of Utah

examples/CMakeLists.txt

 install ( DIRECTORY grd  DESTINATION ${CMAKE_INSTALL_PREFIX}/share/EMSchur3D/ ) 
 install ( DIRECTORY src  DESTINATION ${CMAKE_INSTALL_PREFIX}/share/EMSchur3D/ ) 
 install ( FILES block.sh  DESTINATION ${CMAKE_INSTALL_PREFIX}/share/EMSchur3D/ ) 
+install ( FILES block.py  DESTINATION ${CMAKE_INSTALL_PREFIX}/share/EMSchur3D/ ) 
 
 INSTALL_TARGETS( "/share/EMSchur3D/"
     EMSchur3D

examples/block.py

+import numpy as np
+import pprint
+
+def calcH( oxx, nxx, dxx, pad ):
+    """Calculates grid spacing along a dimension, if padding cells are requested those are incorporated too"""
+    pp = 1.1 # fixed padding expansion factor 
+    if not pad:
+        px = np.arange(oxx-dxx/2, oxx-dxx/2+(nxx+1)*dxx, dxx)
+        hx = dxx*np.ones(nxx)
+        return hx, px 
+    else:
+        hx = np.zeros( nxx )
+        for ip in range(0,pad):
+            hx[ip] = dxx*pp**(pad-ip)      
+        hx[pad:nxx-pad] = dxx
+        ip = 1 
+        for ii in range (nxx-pad, nxx):
+            hx[ii] = dxx*pp**ip
+            ip += 1  
+
+        px = np.zeros( nxx + 1 )  # interfaces 
+        px[0] = oxx - (dxx*pp**pad)/2
+        for i, h in enumerate(hx):
+            px[i+1] = px[i]+h
+
+        return hx, px
+
+def writeH(fout, h, p):
+    ix = 0
+    rx,rxm1 = 0,0
+    while (ix < len(h)):
+        fout.write ("%6.2f" %( h[ix]) )
+        ix += 1
+        rx += 1 
+        if rx > 4:
+            fout.write(" //") # [%i:%i]\n" %(rxm1,ix-1))
+            #fout.write( (p[rxm1:ix-1]) )
+            for pp in p[rxm1:ix+1]:
+                fout.write(" %6.2f" %(pp))
+            fout.write("\n")
+            rxm1 += rx
+            rx = 0
+        else: 
+            fout.write(" ")
+
+def writeGRD(fout, args):
+    
+    fout.write( "%i\t%i\t%i\t// nx ny nz\n" %(args.nx[0],args.ny[0],args.nz[0]) )
+    fout.write( "%f\t%f\t%f\t// ox oy oz\n" %(args.ox[0],args.oy[0],args.oz[0]) )
+
+    fout.write("\n// hx\n")
+    hx,px = calcH( args.ox[0], args.nx[0], args.dx[0], args.pad )
+    writeH(fout, hx, px)
+    
+    fout.write("\n// hy\n")
+    hy,py = calcH( args.oy[0], args.ny[0], args.dy[0], args.pad )
+    writeH(fout, hy, py)
+    
+    fout.write("\n// hz\n")
+    hz,pz = calcH( args.oz[0], args.nz[0], args.dz[0], args.pad )
+    writeH(fout, hz, pz)
+
+    fout.write("\n\n")
+    #fout.write( "// vim: set tabstop=4 expandtab:\n")
+    fout.write( "// vim: set filetype=cpp:\n")
+
+    return px,py,pz
+
+def writeMOD(fout, args, px, py, pz):
+    sigma = np.zeros( (args.nx[0], args.ny[0], args.nz[0]) )  
+    sigma[:,:,pz[1:]>0] = 0.05
+    xlo = np.where( px[0:-1] >= args.bxlo[0] )[0][0] 
+    xhi = np.where( px[1:] <= args.bxhi[0] )[0][-1] + 1
+    ylo = np.where( py[0:-1] >= args.bylo[0] )[0][0] 
+    yhi = np.where( py[1:] <= args.byhi[0] )[0][-1] + 1
+    zlo = np.where( pz[0:-1] >= args.bzlo[0] )[0][0] 
+    zhi = np.where( pz[1:] <= args.bzhi[0] )[0][-1] + 1
+    sigma[xlo:xhi, ylo:yhi, zlo:zhi] = .1
+    for val in np.ravel(sigma, order='C'):
+        fout.write("%f\n" %(val) )
+
+def str2bool(v):
+    if v.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif v.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value expected.')
+ 
+import argparse
+
+PAD = 0
+
+parser = argparse.ArgumentParser(description='Set up test EMSchur3D block problem.')
+
+parser.add_argument('nx', metavar='nx', type=int, nargs=1, 
+                   help='number of cells in x')
+
+parser.add_argument('ny', metavar='ny', type=int, nargs=1, 
+                   help='number of cells in y')
+
+parser.add_argument('nz', metavar='nz', type=int, nargs=1, 
+                   help='number of cells in z')
+
+parser.add_argument('ox', metavar='ox', type=float, nargs=1, 
+                   help='offset of grid in x')
+
+parser.add_argument('oy', metavar='oy', type=float, nargs=1, 
+                   help='offset of grid in y')
+
+parser.add_argument('oz', metavar='oz', type=float, nargs=1, 
+                   help='offset of grid in z')
+
+parser.add_argument('dx', metavar='dx', type=int, nargs=1, 
+                   help='minimum spacing in x')
+
+parser.add_argument('dy', metavar='dy', type=int, nargs=1, 
+                   help='minimum spacing in y')
+
+parser.add_argument('dz', metavar='dz', type=int, nargs=1, 
+                   help='minimum spacing in z')
+
+parser.add_argument('bxlo', metavar='bxlo', type=float, nargs=1, 
+                   help='low end of block cell location in x')
+
+parser.add_argument('bxhi', metavar='bxhi', type=float, nargs=1, 
+                   help='high end of block cell location in x')
+
+parser.add_argument('bylo', metavar='bylo', type=float, nargs=1, 
+                   help='low end of block cell location in y')
+
+parser.add_argument('byhi', metavar='byhi', type=float, nargs=1, 
+                   help='high end of block cell location in y')
+
+parser.add_argument('bzlo', metavar='bzlo', type=float, nargs=1, 
+                   help='low end of block cell location in z')
+
+parser.add_argument('bzhi', metavar='bzhi', type=float, nargs=1, 
+                   help='high end of block cell location in z')
+
+parser.add_argument("--pad", type=int, nargs='?',
+                        const=True, default=PAD, 
+                        help="Activate this number of padding cells with 10%% growth factor.")
+
+args = parser.parse_args()
+
+fout = open("example.grd", 'w')
+px,py,pz = writeGRD(fout, args)
+fout.close()
+
+mout = open("example.mod", 'w')
+writeMOD(mout, args, px, py, pz)
+
+#print(args.nx)
+#print(args.accumulate(args.nx))
+#print(args.accumulate(args.ny))

include/EMSchur3D.h

 
         VectorXcr ADiv = D*A;  // ADiv == RHS == D C^I Se
         //VectorXcr Error = ((Cc.selfadjointView<Eigen::Lower>()*A).array() - Se.array());
+        VectorXcr Error = ((Cvec[iw]*A).array() - Se.array());
+/*
 #if LOWER==1
         std::cout << "Using Eigen::Lower to calculate Error" << std::endl;
         VectorXcr Error = ((Cvec[iw].selfadjointView<Eigen::Lower>()*A).array() - Se.array());
         std::cout << "Using Eigen::Upper to calculate Error" << std::endl;
         VectorXcr Error = ((Cvec[iw].selfadjointView<Eigen::Upper>()*A).array() - Se.array());
 #endif
+*/
         logio << "|| Div(A) || = " << ADiv.norm()
               << "\tInital solution error="<<   Error.norm()  // Iteritive info
 //              << "\tSolver reported error="<<   CSolver[iw].error()  // Iteritive info
         // Solve for Phi
         logio << "Solving for Phi " << std::flush;
         timer.begin();
-        tol = 1e-20;
+        tol = 1e-30;
         int success(2);
 
         success = implicitbicgstab(D, idx, ms, ADiv, Phi, CSolver[iw], max_it, tol, errorn, iter_done, logio);
 
         // Report error of solutions
         //Error = ((Cc.selfadjointView<Eigen::Lower>()*A).array() + E.array() - Se.array());
+/*
 #if LOWER==1
         std::cout << "Using Eigen::Lower to calculate Error" << std::endl;
         Error = ((Cvec[iw].selfadjointView<Eigen::Lower>()*A).array() + E.array() - Se.array());
         std::cout << "Using Eigen::Upper to calculate Error" << std::endl;
         Error = ((Cvec[iw].selfadjointView<Eigen::Upper>()*A).array() + E.array() - Se.array());
 #endif
+*/
+        Error = ((Cvec[iw]*A).array() + E.array() - Se.array());
         //      << "\tSolver reported error="<<   CSolver[iw].error()  // Iteritive info
         //      << "\ttime " << timer.end() / 60. << " [m]   "
         //      <<  CSolver[iw].iterations() << "  iterations"
             jsw_timer timer;
             timer.begin();
 
-            CSolver[iw].isSymmetric(true);
+            //CSolver[iw].isSymmetric(true);
             //CSolver[iw].setPivotThreshold(0.0); // OK for symmetric complex systems with real and imaginary positive definite parts.
-            //                                  // but our imaginary part is negative definite
+            //                                    // but our imaginary part is negative definite
             //http://www.ams.org/journals/mcom/1998-67-224/S0025-5718-98-00978-8/S0025-5718-98-00978-8.pdf
 
             /*  Complex system */
             std::cout << "SparseLU pattern analyzing C_" << iw << ",";
             std::cout.flush();
-            CSolver[iw].analyzePattern( Cvec[iw].selfadjointView< Eigen::Lower>() );
+            //CSolver[iw].analyzePattern( Cvec[iw].selfadjointView< Eigen::Lower>() );
+            CSolver[iw].analyzePattern( Cvec[iw] );
             std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
 
             // factorize
             timer.begin();
             std::cout << "SparseLU factorising C_" << iw << ", ";
             std::cout.flush();
-            CSolver[iw].factorize( Cvec[iw].selfadjointView< Eigen::Lower>() );
+            //CSolver[iw].factorize( Cvec[iw].selfadjointView< Eigen::Lower>() );
+            CSolver[iw].factorize( Cvec[iw] ); //.selfadjointView< Eigen::Lower>() );
             std::cout << " done in " << timer.end() / 60. << " [m]" << std::endl;
         }
     }

include/EMSchur3DBase.h

 
 namespace Lemma {
 
-#define UPPER 0  // LOWER WAS 0
+// Pardiso likes LOWER for Sym problem
+#define UPPER 1  // LOWER WAS 0
 #define LOWER 1  // 1=true, 0=false
 
 enum SOLVER{ SPARSELU, SimplicialLLT, SimplicialLDLT, BiCGStab, SparseQR };
     /** Marker for air cells */
     std::vector<int> idx;
 
+    /** Dirichlet on low X */
+    bool DirichletXLO = true;
+    //bool DirichletXLO = false;
+
+    bool DirichletXHI = true;
+    //bool DirichletXHI = false;
+
+    bool DirichletYLO = true;
+    //bool DirichletYLO = false;
+
+    bool DirichletYHI = true;
+    //bool DirichletYHI = false;
+
+//    bool DirichletZLO = true;
+    bool DirichletZLO = false;
+
+    bool DirichletZHI = true;
+//    bool DirichletZHI = false;
+
     private:
 
         static constexpr auto CName = "EMSchur3DBase";

src/EMSchur3DBase.cpp

 //
 //   Organisation:  University of Utah
 //
-//          Email:  tirons@egi.utah.edu
+//          Email:  Trevor.Irons@utah.edu
 //
 // ===========================================================================
 
   @file
   @author   Trevor Irons
   @date     09/20/2013
-  @version  $Id$
-  THis is a port of the procedural code developed at School of Mines
  **/
 
 #include "EMSchur3DBase.h"
 typedef Eigen::Triplet<Lemma::Complex> Tc;
 typedef Eigen::Triplet<Lemma::Real> Tr;
 
-// Moved to header 
+// Moved to header
 //#define UPPER 0  // LOWER WAS 0
 //#define LOWER 1  // 1=true, 0=false
 
+//#define FINITEVOLUME 1
+#define FINITEDIFFERENCE 1
+
 namespace Lemma {
 
 
         for (int ix=0; ix<nx+1; ++ix) {
 
             // Calculate 1/2 step values on staggered grid
-            Real alo_ihz2(0);
-            Real ahi_ihz2(0);
+            Real hzlo(0);
+            Real hzhi(0);
             if (iz == 0) {
-                ahi_ihz2 = std::pow(.5*hz[iz+1] + .5*hz[iz], -2);
-                alo_ihz2 = std::pow(.5*hz[iz+1] + .5*hz[iz], -2);
+                hzlo = .5*hz[iz+1] + .5*hz[iz];                   // assume same grid spacing for boundary
+                hzhi = .5*hz[iz+1] + .5*hz[iz];
             } else if (iz == nz-1) {
-                alo_ihz2 = std::pow(.5*hz[iz-1] + .5*hz[iz], -2);
-                ahi_ihz2 = std::pow(.5*hz[iz-1] + .5*hz[iz], -2);
+                hzlo = .5*hz[iz-1] + .5*hz[iz];
+                hzhi = .5*hz[iz-1] + .5*hz[iz];                   // assume same grid spacing for boundary
             } else {
-                alo_ihz2 = std::pow(.5*hz[iz-1] + .5*hz[iz], -2);
-                ahi_ihz2 = std::pow(.5*hz[iz+1] + .5*hz[iz], -2);
+                hzlo = .5*hz[iz-1] + .5*hz[iz  ];
+                hzhi = .5*hz[iz  ] + .5*hz[iz+1];
             }
+            Real scz = 2./(hzlo+hzhi);
 
-            Real alo_ihy2(0);  // half step low jump in y
-            Real ahi_ihy2(0);  // half step high jump in y
+            // Calculate 1/2 step values on staggered grid
+            Real hylo(0);
+            Real hyhi(0);
             if (iy == 0) {
-                ahi_ihy2 = std::pow(.5*hy[iy+1] + .5*hy[iy], -2);
-                alo_ihy2 = std::pow(.5*hy[iy+1] + .5*hy[iy], -2);
+                hylo = .5*hy[iy+1] + .5*hy[iy];                   // assume same grid spacing for boundary
+                hyhi = .5*hy[iy+1] + .5*hy[iy];
             } else if (iy == ny-1) {
-                alo_ihy2 = std::pow(.5*hy[iy-1] + .5*hy[iy], -2);
-                ahi_ihy2 = std::pow(.5*hy[iy-1] + .5*hy[iy], -2);
+                hylo = .5*hy[iy-1] + .5*hy[iy];
+                hyhi = .5*hy[iy-1] + .5*hy[iy];                   // assume same grid spacing for boundary
             } else {
-                alo_ihy2 = std::pow(.5*hy[iy-1] + .5*hy[iy], -2);
-                ahi_ihy2 = std::pow(.5*hy[iy+1] + .5*hy[iy], -2);
+                hylo = .5*hy[iy-1] + .5*hy[iy  ];
+                hyhi = .5*hy[iy  ] + .5*hy[iy+1];
             }
+            Real scy = 2./(hylo+hyhi);
 
             /////////////////////////////////////////////////////////////////////////
             // Diagonal entry
             //hsig += Complex(0, omega*EPSILON0);
 
             Real Sum(0);
-            if (ix == 0) {
-                // Dirichlet bdry condition on A
-                // Sum = alo_ihy2+ahi_ihy2 + alo_ihz2+ahi_ihz2 + 2.*ihx2[ix  ];
-                // Neumann bdry
-                Sum = alo_ihy2+ahi_ihy2 + alo_ihz2+ahi_ihz2 + ihx2[ix  ];
-            } else if (ix == nx) {
-                // Dirichlet bdry condition on A
-                // Sum = alo_ihy2+ahi_ihy2 + alo_ihz2+ahi_ihz2 + 2.*ihx2[ix-1];
-                // Neumann bdry
-                Sum = alo_ihy2+ahi_ihy2 + alo_ihz2+ahi_ihz2 + ihx2[ix-1];
+            Real scx(0);
+            if (ix == 0) { // x- bdry
+                scx = 2./(hx[ix]+hx[ix]);
+                if (DirichletXLO) {
+                    /* Dirichlet bdry condition on A */
+                    Sum = scz/hzlo + scz/hzhi + scy/hylo + scy/hyhi + 2.*scx/hx[ix];
+                } else {
+                    /* Neumann bdry */
+                    Sum = scz/hzlo + scz/hzhi + scy/hylo + scy/hyhi + scx/hx[ix];
+                }
+            } else if (ix == nx) {  // x+ bdry
+                scx = 2./(hx[ix-1]+hx[ix-1]);
+                if (DirichletXHI) {
+                    /* Dirichlet bdry condition on A */
+                    Sum = scz/hzlo + scz/hzhi + scy/hylo + scy/hyhi + 2.*scx/hx[ix-1];
+                } else {
+                    /* Neumann bdry */
+                    Sum = scz/hzlo + scz/hzhi + scy/hylo + scy/hyhi + scx/hx[ix-1];
+                }
             } else {
-                Sum = alo_ihy2+ahi_ihy2 + alo_ihz2+ahi_ihz2 + ihx2[ix] + ihx2[ix-1];
+                scx = 2./(hx[ix]+hx[ix-1]);
+                Sum = scz/hzlo + scz/hzhi + scy/hylo + scy/hyhi + scx/hx[ix] + scx/hx[ix-1];
             }
 
             /////////////////////////////////////////
             // minus side off diagonal terms
 #if LOWER
             // Third Off Diagonal
-            if (iz!=0)         Cvec[iw].insert(ir, ic-ny*(nx+1)) = Complex(-ahi_ihz2, 0);
+            if (iz!=0)         Cvec[iw].insert(ir, ic-ny*(nx+1)) = Complex(-scz/hzlo, 0);
 
             // Second Off Diagonal
-            if (iy!=0)         Cvec[iw].insert(ir, ic-(nx+1)) = Complex(-ahi_ihy2, 0);
+            if (iy!=0)         Cvec[iw].insert(ir, ic-(nx+1)) = Complex(-scy/hylo, 0);
 
             // First  Off Diagonal
-            if (ix!=0)         Cvec[iw].insert(ir, ic-1) = Complex(-ihx2[ix-1], 0);
+            if (ix!=0)         Cvec[iw].insert(ir, ic-1) = Complex(-scx/hx[ix-1], 0);
 #endif
             ////////////////////////////////////////////
             // Diagonal Term
             // plus side off diagonal terms
 #if UPPER
             // First Off Diagonal
-            if (ix!=nx)         Cvec[iw].insert(ir, ic+1) = Complex(-ihx2[ix], 0);
+            if (ix!=nx)         Cvec[iw].insert(ir, ic+1) = Complex(-scx/hx[ix], 0);
 
             // Second Off Diagonal
-            if (iy!=ny-1)       Cvec[iw].insert(ir, ic+(nx+1)) = Complex(-ahi_ihy2, 0);
+            if (iy!=ny-1)       Cvec[iw].insert(ir, ic+(nx+1)) = Complex(-scy/hyhi, 0);
 
             // Third Off Diagonal
-            if (iz!=nz-1)       Cvec[iw].insert(ir, ic+ny*(nx+1)) = Complex(-ahi_ihz2, 0);
+            if (iz!=nz-1)       Cvec[iw].insert(ir, ic+ny*(nx+1)) = Complex(-scz/hzhi, 0);
 #endif
             ++ir;
             ++ic;
         for (int ix=0; ix<nx;   ++ix) {
 
             // Calculate 1/2 step values on staggered grid
-            Real alo_ihz2(0);
-            Real ahi_ihz2(0);
-            if (iz == 0) {
-                ahi_ihz2 = std::pow(.5*hz[iz+1] + .5*hz[iz], -2);
-                alo_ihz2 = std::pow(.5*hz[iz+1] + .5*hz[iz], -2);
-            } else if (iz == nz-1) {
-                alo_ihz2 = std::pow(.5*hz[iz-1] + .5*hz[iz], -2);
-                ahi_ihz2 = std::pow(.5*hz[iz-1] + .5*hz[iz], -2);
+            Real hxlo(0);
+            Real hxhi(0);
+            if (ix == 0) {
+                hxlo = .5*hx[ix+1] + .5*hx[ix];                   // assume same grid spacing for boundary
+                hxhi = .5*hx[ix+1] + .5*hx[ix];
+            } else if (ix == nx-1) {
+                hxlo = .5*hx[ix-1] + .5*hx[ix];
+                hxhi = .5*hx[ix-1] + .5*hx[ix];                   // assume same grid spacing for boundary
             } else {
-                alo_ihz2 = std::pow(.5*hz[iz-1] + .5*hz[iz], -2);
-                ahi_ihz2 = std::pow(.5*hz[iz+1] + .5*hz[iz], -2);
+                hxlo = .5*hx[ix-1] + .5*hx[ix  ];
+                hxhi = .5*hx[ix  ] + .5*hx[ix+1];
             }
+            Real scx = 2./(hxlo+hxhi);
 
             // Calculate 1/2 step values on staggered grid
-            Real alo_ihx2(0);
-            Real ahi_ihx2(0);
-            if (ix == 0) {
-                ahi_ihx2 = std::pow(.5*hx[ix+1] + .5*hx[ix], -2);
-                alo_ihx2 = std::pow(.5*hx[ix+1] + .5*hx[ix], -2);
-            } else if (ix == nx-1) {
-                alo_ihx2 = std::pow(.5*hx[ix-1] + .5*hx[ix], -2);
-                ahi_ihx2 = std::pow(.5*hx[ix-1] + .5*hx[ix], -2);
+            Real hzlo(0);
+            Real hzhi(0);
+            if (iz == 0) {
+                hzlo = .5*hz[iz+1] + .5*hz[iz];                   // assume same grid spacing for boundary
+                hzhi = .5*hz[iz+1] + .5*hz[iz];
+            } else if (iz == nz-1) {
+                hzlo = .5*hz[iz-1] + .5*hz[iz];
+                hzhi = .5*hz[iz-1] + .5*hz[iz];                   // assume same grid spacing for boundary
             } else {
-                alo_ihx2 = std::pow(.5*hx[ix-1] + .5*hx[ix], -2);
-                ahi_ihx2 = std::pow(.5*hx[ix+1] + .5*hx[ix], -2);
+                hzlo = .5*hz[iz-1] + .5*hz[iz  ];
+                hzhi = .5*hz[iz  ] + .5*hz[iz+1];
             }
+            Real scz = 2./(hzlo+hzhi);
 
             // Harmonically average sigmay
             if (iy == 0) {
             //hsig += Complex(0, omega*EPSILON0);
 
             Real Sum(0);
-            if (iy == 0) {
-                // Dirichlet bdry condition on A
-                //Sum = alo_ihx2+ahi_ihx2 + alo_ihz2+ahi_ihz2 + 2.*ihy2[iy  ];
-                // Neumann bdry
-                Sum = alo_ihx2+ahi_ihx2 + alo_ihz2+ahi_ihz2 + ihy2[iy  ];
-            } else if (iy == ny) {
-                // Dirichlet bdry condition on A
-                //Sum = alo_ihx2+ahi_ihx2 + alo_ihz2+ahi_ihz2 + 2.*ihy2[iy-1];
-                // Neumann bdry
-                Sum = alo_ihx2+ahi_ihx2 + alo_ihz2+ahi_ihz2 + ihy2[iy-1];
+            Real scy(0);
+            if (iy == 0) {  // y- bdry
+                scy = 2./(hy[iy]+hy[iy]);
+                if (DirichletYLO) {
+                    /* Dirichlet bdry condition on A */
+                    Sum = scz/hzlo + scz/hzhi + scx/hxlo + scx/hxhi + 2.*scy/hy[iy];
+                } else {
+                    /* Neumann bdry */
+                    Sum = scz/hzlo + scz/hzhi + scx/hxlo + scx/hxhi + scy/hy[iy];
+                }
+            } else if (iy == ny) {  // y+ bdry
+                scy = 2./(hy[iy-1]+hy[iy-1]);
+                if (DirichletYHI) {
+                    /* Dirichlet bdry condition on A */
+                    Sum = scz/hzlo + scz/hzhi + scx/hxlo + scx/hxhi + 2.*scy/hy[iy-1];
+                } else {
+                    /* Neumann bdry */
+                    Sum = scz/hzlo + scz/hzhi + scx/hxlo + scx/hxhi + scy/hy[iy-1];
+                }
             } else {
-                Sum = alo_ihx2+ahi_ihx2 + alo_ihz2+ahi_ihz2 + ihy2[iy] + ihy2[iy-1];
+                scy = 2./(hy[iy]+hy[iy-1]);
+                Sum = scz/hzlo + scz/hzhi + scx/hxlo + scx/hxhi + scy/hy[iy-1] + scy/hy[iy];
             }
 #if LOWER
             // Third Off Diagonal
-            if (iz!=0)              Cvec[iw].insert(ir,ic-(ny+1)*(nx)) = Complex(-ahi_ihz2, 0);
+            if (iz!=0)              Cvec[iw].insert(ir,ic-(ny+1)*(nx)) = Complex(-scz/hzlo, 0);
 
             // Second Off Diagonal
-            if (iy!=0)              Cvec[iw].insert(ir,ic-(nx)) = Complex(-ihy2[iy-1], 0);
+            if (iy!=0)              Cvec[iw].insert(ir,ic-(nx)) = Complex(-scy/hy[iy-1], 0);
 
             // First Off Diagonal
-            if (ix!=0)              Cvec[iw].insert(ir,ic-1) = Complex(-ahi_ihx2, 0);
+            if (ix!=0)              Cvec[iw].insert(ir,ic-1) = Complex(-scx/hxlo, 0);
 #endif
             // Diagonal Term
             Cvec[iw].insert(ir,ic) =       Complex(Sum, 0) + Complex(0,1)*omega*MU0*hsig;
             //CMMvec[iw].insert(ir,ic) =  1./ Complex(Sum, omega*MU0*hsig);
 #if UPPER
             // First Off Diagonal
-            if (ix!=nx-1)           Cvec[iw].insert(ir,ic+1) = Complex(-ahi_ihx2, 0);
+            if (ix!=nx-1)           Cvec[iw].insert(ir,ic+1) = Complex(-scx/hxhi, 0);
 
             // Second Off Diagonal
-            if (iy!=ny)             Cvec[iw].insert(ir,ic+(nx)) = Complex(-ihy2[iy], 0);
+            if (iy!=ny)             Cvec[iw].insert(ir,ic+(nx)) = Complex(-scy/hy[iy], 0);
 
             // Third Off Diagonal
-            if (iz!=nz-1)           Cvec[iw].insert(ir,ic+(ny+1)*(nx)) = Complex(-ahi_ihz2, 0);
+            if (iz!=nz-1)           Cvec[iw].insert(ir,ic+(ny+1)*(nx)) = Complex(-scz/hzhi, 0);
 #endif
             ++ir;
             ++ic;
         for (int ix=0; ix<nx;   ++ix) {
 
             // Calculate 1/2 step values on staggered grid
-            Real alo_ihx2(0);
-            Real ahi_ihx2(0);
-            if (ix == 0) {
-                ahi_ihx2 = std::pow(.5*hx[ix+1] + .5*hx[ix], -2);
-                alo_ihx2 = std::pow(.5*hx[ix+1] + .5*hx[ix], -2);
-            } else if (ix == nx-1) {
-                alo_ihx2 = std::pow(.5*hx[ix-1] + .5*hx[ix], -2);
-                ahi_ihx2 = std::pow(.5*hx[ix-1] + .5*hx[ix], -2);
+            Real hylo(0);
+            Real hyhi(0);
+            if (iy == 0) {
+                hylo = .5*hy[iy+1] + .5*hy[iy];                   // assume same grid spacing for boundary
+                hyhi = .5*hy[iy+1] + .5*hy[iy];
+            } else if (iy == ny-1) {
+                hylo = .5*hy[iy-1] + .5*hy[iy];
+                hyhi = .5*hy[iy-1] + .5*hy[iy];                   // assume same grid spacing for boundary
             } else {
-                alo_ihx2 = std::pow(.5*hx[ix-1] + .5*hx[ix], -2);
-                ahi_ihx2 = std::pow(.5*hx[ix+1] + .5*hx[ix], -2);
+                hylo = .5*hy[iy-1] + .5*hy[iy  ];
+                hyhi = .5*hy[iy  ] + .5*hy[iy+1];
             }
+            Real scy = 2./(hylo+hyhi);
 
             // Calculate 1/2 step values on staggered grid
-            Real alo_ihy2(0);
-            Real ahi_ihy2(0);
-            if (iy == 0) {
-                ahi_ihy2 = std::pow(.5*hy[iy+1] + .5*hy[iy], -2);
-                alo_ihy2 = std::pow(.5*hy[iy+1] + .5*hy[iy], -2);
-            } else if (iy == ny-1) {
-                alo_ihy2 = std::pow(.5*hy[iy-1] + .5*hy[iy], -2);
-                ahi_ihy2 = std::pow(.5*hy[iy-1] + .5*hy[iy], -2);
+            Real hxlo(0);
+            Real hxhi(0);
+            if (ix == 0) {
+                hxlo = .5*hx[ix+1] + .5*hx[ix];                   // assume same grid spacing for boundary
+                hxhi = .5*hx[ix+1] + .5*hx[ix];
+            } else if (ix == nx-1) {
+                hxlo = .5*hx[ix-1] + .5*hx[ix];
+                hxhi = .5*hx[ix-1] + .5*hx[ix];                   // assume same grid spacing for boundary
             } else {
-                alo_ihy2 = std::pow(.5*hy[iy-1] + .5*hy[iy], -2);
-                ahi_ihy2 = std::pow(.5*hy[iy+1] + .5*hy[iy], -2);
+                hxlo = .5*hx[ix-1] + .5*hx[ix  ];
+                hxhi = .5*hx[ix  ] + .5*hx[ix+1];
             }
+            Real scx = 2./(hxlo+hxhi);
 
             // Harmonically average sigmaz
             if (iz==0) {
             //hsig += Complex(0, omega*EPSILON0);
 
             Real Sum(0);
-            if (iz == 0) {
-                // Dirichlet bdry condition on A
-                //Sum = alo_ihx2 + ahi_ihx2 + alo_ihy2 + ahi_ihy2 + 2.*ihz2[iz  ];
-                // Neumann bdry
-                Sum = alo_ihx2 + ahi_ihx2 + alo_ihy2 + ahi_ihy2 + ihz2[iz  ];
-            } else if (iz == nz) {
-                // Dirichlet bdry condition on A
-                Sum = alo_ihx2 + ahi_ihx2 + alo_ihy2 + ahi_ihy2 + 2.*ihz2[iz-1];
-                // Neumann bdry
-                //Sum = alo_ihx2 + ahi_ihx2 + alo_ihy2 + ahi_ihy2 + ihz2[iz-1];
+            Real scz(0);
+            if (iz == 0) { // z- bdry
+                scz = 2./(hz[iz]+hz[iz]);
+                if (DirichletZLO) {
+                    /* Dirichlet bdry condition on A */
+                    Sum = scx/hxlo + scx/hxhi + scy/hylo + scy/hyhi + 2.*scz/hz[iz];
+                } else {
+                    // Neumann bdry
+                    Sum = scx/hxlo + scx/hxhi + scy/hylo + scy/hyhi + scz/hz[iz];
+                }
+            } else if (iz == nz) { // z+ bdry
+                scz = 2./(hz[iz-1]+hz[iz-1]);
+                if (DirichletZHI) {
+                    // Dirichlet bdry condition on A
+                    Sum = scx/hxlo + scx/hxhi + scy/hylo + scy/hyhi + 2.*scz/hz[iz-1];
+                } else {
+                    // Neumann bdry
+                    //Sum = alo_ihx2 + ahi_ihx2 + alo_ihy2 + ahi_ihy2 + ihz2[iz-1];
+                    Sum = scx/hxlo + scx/hxhi + scy/hylo + scy/hyhi + scz/hz[iz-1];
+                }
             } else {
-                Sum = alo_ihx2 + ahi_ihx2 + alo_ihy2 + ahi_ihy2 + ihz2[iz] + ihz2[iz-1];
+                scz = 2./(hz[iz]+hz[iz-1]);
+                Sum = scx/hxlo + scx/hxhi + scy/hylo + scy/hyhi + scz/hz[iz-1] + scz/hz[iz];
             }
 #if LOWER
             // Third Off Diagonal
-            if (iz!=0)             Cvec[iw].insert(ir,ic-ny*(nx)) = Complex(-ihz2[iz-1], 0);
+            if (iz!=0)             Cvec[iw].insert(ir,ic-ny*(nx)) = Complex(-scz/hz[iz-1], 0);
 
             // Second Off Diagonal
-            if (iy!=0)           Cvec[iw].insert(ir,ic-(nx)) = Complex(-ahi_ihy2, 0);
+            if (iy!=0)           Cvec[iw].insert(ir,ic-(nx)) = Complex(-scy/hylo, 0);
 
             // First Off Diagonal
-            if (ix!=0)           Cvec[iw].insert(ir,ic-1) = Complex(-ahi_ihx2, 0);
+            if (ix!=0)           Cvec[iw].insert(ir,ic-1) = Complex(-scx/hxlo, 0);
 #endif
             // Diagonal Term
             Cvec[iw].insert(ir,ic) =       Complex(Sum, 0) + Complex(0,1)*omega*MU0*hsig;
             //CMMvec[iw].insert(ir,ic) =  1. / Complex(Sum, omega*MU0*hsig);
 #if UPPER
             // First Off Diagonal
-            if (ix!=nx-1)           Cvec[iw].insert(ir,ic+1) = Complex(-ahi_ihx2, 0);
+            if (ix!=nx-1)           Cvec[iw].insert(ir,ic+1) = Complex(-scx/hx[ix], 0);
 
             // Second Off Diagonal
-            if (iy!=ny-1)           Cvec[iw].insert(ir,ic+(nx)) = Complex(-ahi_ihy2, 0);
+            if (iy!=ny-1)           Cvec[iw].insert(ir,ic+(nx)) = Complex(-scy/hy[iy], 0);
 
             // Third Off Diagonal
-            if (iz!=nz)             Cvec[iw].insert(ir,ic+ny*(nx)) = Complex(-ihz2[iz], 0);
+            if (iz!=nz)             Cvec[iw].insert(ir,ic+ny*(nx)) = Complex(-scz/hz[iz], 0);
 #endif
             ++ir;
             ++ic;
             for (int ix=0; ix<nx; ++ix) {
                 //D.insert(ir, ic-1) = Complex(-ihx[ix], 0);
                 //D.insert(ir, ic  ) = Complex( ihx[ix], 0);
-                triplets.push_back( Tc(ir, ic-1, Complex(-ihx[ix], 0)) );
-                triplets.push_back( Tc(ir, ic  , Complex( ihx[ix], 0)) );
+#ifdef FINITEDIFFERENCE
+                //triplets.push_back( Tc(ir, ic-1, Complex(-sc*ihx[ix], 0)) );
+                //triplets.push_back( Tc(ir, ic  , Complex( sc*ihx[ix], 0)) );
+                triplets.push_back( Tc(ir, ic-1, Complex(-1.0/hx[ix], 0)) );
+                triplets.push_back( Tc(ir, ic  , Complex( 1.0/hx[ix], 0)) );
+#elif FINITEVOLUME
+                triplets.push_back( Tc(ir, ic-1, Complex(-1, 0)) );
+                triplets.push_back( Tc(ir, ic  , Complex( 1, 0)) );
+#endif
                 ++ir;
                 ++ic;
             }
             for (int ix=0; ix<nx; ++ix) {
                 //D.insert(ir, ic   ) = Complex(-ihy[iy], 0);
                 //D.insert(ir, ic+nx) = Complex( ihy[iy], 0);
-                triplets.push_back( Tc(ir, ic   , Complex(-ihy[iy], 0)) );
-                triplets.push_back( Tc(ir, ic+nx, Complex( ihy[iy], 0)) );
+#ifdef FINITEDIFFERENCE
+                //triplets.push_back( Tc(ir, ic   , Complex(-sc*ihy[iy], 0)) );
+                //triplets.push_back( Tc(ir, ic+nx, Complex( sc*ihy[iy], 0)) );
+                triplets.push_back( Tc(ir, ic   , Complex(-1.0/hy[iy], 0)) );
+                triplets.push_back( Tc(ir, ic+nx, Complex( 1.0/hy[iy], 0)) );
+#elif FINITEVOLUME
+                triplets.push_back( Tc(ir, ic   , Complex(-1, 0)) );
+                triplets.push_back( Tc(ir, ic+nx, Complex( 1, 0)) );
+#endif
                 ++ir;
                 ++ic;
             }
         for (int ix=0; ix<nx; ++ix) {
             //D.insert(ir, ic      ) = Complex(-ihz[iz], 0);
             //D.insert(ir, ic+nx*ny) = Complex( ihz[iz], 0);
-            triplets.push_back( Tc(ir, ic      , Complex(-ihz[iz], 0)) );
-            triplets.push_back( Tc(ir, ic+nx*ny, Complex( ihz[iz], 0)) );
+#ifdef FINITEDIFFERENCE
+            //triplets.push_back( Tc(ir, ic      , Complex(-sc*ihz[iz], 0)) );
+            //triplets.push_back( Tc(ir, ic+nx*ny, Complex( sc*ihz[iz], 0)) );
+            triplets.push_back( Tc(ir, ic      , Complex(-1.0/hz[iz], 0)) );
+            triplets.push_back( Tc(ir, ic+nx*ny, Complex( 1.0/hz[iz], 0)) );
+#elif FINITEVOLUME
+            triplets.push_back( Tc(ir, ic      , Complex(-1, 0)) );
+            triplets.push_back( Tc(ir, ic+nx*ny, Complex( 1, 0)) );
+#endif
             ++ir;
             ++ic;
         }