Include tree.pxd in source distribution

• from #102

• commits from: @cgohlke

• review from: @jcapriot, @lheagy

• Include tree.pxd in source distribution

Minor update: plotGrid - linestyle

• from pr #101
• ".-" is no longer valid for a linestyle input in matplotlib, it should instead be "-." (however, a solid line looks better anyways for the 1d).

TreeMesh Re-write

• originally from pr #94
• commits from: @jcapriot
• review from: @rowanc1, @fourndo, @lheagy

New Implementation of the TreeMesh

At this point consider this branch as EXPERIMENTAL. There are many possible unsafe operations that could arise, so be careful (which will need to be enforced at a later time). The code is certainly not completely up to format standards, but at this point, just wanted to get a pull request going and allow anyone who wants to use it to test it out to find any bugs.

There are many changes to the TreeMesh implementation within this pull request, However it is mostly feature complete compared to the previous implementation with regards to the public members of the class.

It was mostly rewritten in a way that made the construction of the mesh and construction of the operators all done in c++/cython, which resulted in dramatic speedups. As a reference, the 97 nosetests on the tree in the previous implementation took 238.476s on my personal computer. This implementation took 20.281s.

The basic idea is that each object, (node, edge, etc.) is aware of the structure of the TreeMesh as each is a cpp class that contains references to other objects.

A few key differences:

• All tree construction is balanced (no need to call tree.balance, or pass balance=True to functions)

• tree.refine should only be called once (at this point) as it "finalizes" the tree. It might be good to add a flag to the tree initialization that would allow incremental additions (similar to scipy.spatial.ConvexHull) and then require a finalization operation to be done before any other operations.

• Interpolation is "lazy" 2nd order now for all E, CC, and F interpolation, meaning we triangulate the grid points to interpolate. Interpolating without triangulation on the TreeMesh is still a point of research. This is not as fast as it could be, but still faster than previously.

• Both face and edge operations are defined for 2D, (basically a re-ording of x-edges -> y-faces)

• Do not expect any ordering for the faces, edges, and nodes. They are whatever they have decided to be.

• Do not expect any of the private members of the class to have remained consistent between implementations.

• There are many other changes which should hopefully be apparent as you look through the code.

Big things that still need to be implemented

• Serialization, (do not expect to pickle this object and have it work, however with construction being much faster, this shouldn't slow down anyone too much while it is being worked on).

• PlotImage and PlotSlice.

There are also many areas that this code could be extended to handle different types of underlying meshs, as well as support for differing sizes of axes, but as I said before, the initial goal of this pull request is to mimic the behavior of the current implementation.

Other than that, I hope this speeds up the operations for those who need them.

Update

• Serialization should be implemented now (the TreeMesh is pickle-able)
• PlotImage and PlotSlice are also implemented.
• It also now support differing dimensions of the underlying TensorMesh
• Interpolation is now NOT triangulated, so do there is no longer 2nd order convergence of the non-node interpolation matrices.
• the refine and insert_cells function now have a finalize keyword arg that can be set to false if you want to do multiple steps of tree building

pypi deploys

• from pr #97
• update pypi credentials
• update appveyor and travis to auto-deploy to pypi on tags
  • includes upload of wheel files from appveyor

3D cyl mesh

• originally from pr: #36
• commits from: @lheagy
• review from: @rowanc1

3D Cyl Mesh

First implementation of a 3D cylindrical mesh. We discretize in r, theta and z.

Operators

• edgeCurl
• faceDiv
• aveF2CC
• aveF2CCV
• aveE2CC
• aveE2CCV

are all implemented and tested for second order convergence

Examples

There are some examples running this code in http://github.com/lheagy/casingResearch

• added a simple example that plots a 3D cyl mesh

Plotting

• add plot capabilities for plotSlice (and I think two slices through the mesh for plotGrid())

Testing

• basic elements like the grids, counting of things.
• operator tests for mimetic properties

Other updates

Cell Grad Stencils are properties

• cell grad stencils are properties rather than methods. This pr will need to be followed by an update in the SimPEG regularization (addressed in simpeg/simpeg#699)

minor updates

• plotting now uses the C0, C1, ... colors in matplotlib
• added *.ipynb to .gitignore

plotSlice upgrades

• from pr #92
• commits from @micmitch
• review from @lheagy

upgrades in plotSlice

• Added range_x, range_y, and sample_grid input arguments to plotSlice function.

stream thresholds

• from pr #91
• make the stream_threshold compatible with plotslice

VTK updates

Just a few small changes for vtk mesh IO in python 3

• from pr #89
• commits from @jcapriot
• review from @lheagy

Tree mesh cell grad

Cell grad operators for TreeMesh inversion

• from pr #72

• commits from: @fourndo, @micmitch, @sgkang, @lheagy

• review from: @rowanc1, @lheagy, @jiajiasun

• First pass implementation for stencil operators
  Initial implementation without hanging faces
  

• Second implementation with hanging faces
  

Smoother gradients on Octree change.

• Create gradient operators with dimensions for PDE problems.
• Add unit tests for operators. Thanks @micmitch and @sgkang

Solve DC problem in mine tunnels.
Tree mesh examples will follow shortly on SimPEG ... stay tuned.

aveCCV2F

• commits from @sgkang
• review from @rowanc1, @lheagy
• originally from pr #88 and discussed in issue #87

create aveCCV2F, which averages a cell centered vector to faces and is useful for self-potential problems