Work on Example and mesh refinement for MinSIM

This commit is contained in:
D Fournier committed 2016-01-17 13:39:10 -08:00
1 parent c3c96a5bd8
commit 6a7d72bf85
9 files changed
+22458 -127994

No files matched your search

+27 -4
View File
@@ -417,13 +417,14 @@ def read_GOCAD_ts(tsfile):
return vrtx, trgl
def gocad2vtk(gcFile,mesh):
def gocad2vtk(gcFile,mesh,bcflag,inflag):
""""
Function to read gocad polystructure file and output indexes of mesh with in the structure.
"""
import vtk, vtk.util.numpy_support as npsup
print "Reading GOCAD ts file..."
vrtx, trgl = read_GOCAD_ts(gcFile)
# Adjust the index
trgl = trgl - 1
@@ -464,12 +465,34 @@ def gocad2vtk(gcFile,mesh):
extractImpDistRectGridFilt = vtk.vtkExtractGeometry() # Object constructor
extractImpDistRectGridFilt.SetImplicitFunction(ImpDistFunc) #
extractImpDistRectGridFilt.SetInputData(vtkMesh)
extractImpDistRectGridFilt.ExtractBoundaryCellsOn()
extractImpDistRectGridFilt.ExtractInsideOn()
if bcflag is True:
extractImpDistRectGridFilt.ExtractBoundaryCellsOn()
else:
extractImpDistRectGridFilt.ExtractBoundaryCellsOff()
if inflag is True:
extractImpDistRectGridFilt.ExtractInsideOn()
else:
extractImpDistRectGridFilt.ExtractInsideOff()
print "Extracting indices from grid..."
# Executing the pipe
extractImpDistRectGridFilt.Update()
# Get index inside
insideGrid = extractImpDistRectGridFilt.GetOutput()
insideGrid = npsup.vtk_to_numpy(insideGrid.GetCellData().GetArray('Index'))
# Get index surface intersect
extractImpDistRectGridFilt.ExtractBoundaryCellsOn()
extractImpDistRectGridFilt.ExtractInsideOff()
extractImpDistRectGridFilt.Update()
bcGrid = extractImpDistRectGridFilt.GetOutput()
bcGrid = npsup.vtk_to_numpy(bcGrid.GetCellData().GetArray('Index'))
# Return the indexes inside
return npsup.vtk_to_numpy(insideGrid.GetCellData().GetArray('Index'))
return insideGrid, bcGrid
@@ -104,7 +104,7 @@ for ii in range(d_iter):
Utils.writeUBCTensorMesh('Mesh.msh',mesh)
Utils.writeUBCTensorModel('Model.sus',mesh,model)
actv = np.ones(mesh.nC)
#actv = np.ones(mesh.nC)
#%% Forward mode ldata
start_time = time.time()
-76
View File
@@ -1,76 +0,0 @@
import os
home_dir = '.\Test_tria_2_grid'
inpfile = 'PYMAG3C_fwr.inp'
dsep = '\\'
os.chdir(home_dir)
#%%
from SimPEG import np, sp, Utils, mkvc, Maps
import vtk, vtk.util.numpy_support as npsup
import simpegPF as PF
import pylab as plt
## New scripts to be added to basecode
#from fwr_MAG_data import fwr_MAG_data
#from read_MAGfwr_inp import read_MAGfwr_inp
#%%
# Read input file
# Load mesh file
mesh = Utils.meshutils.readUBCTensorMesh('Mesh_2p5m.msh')
# Load GOCAD surf
tsfile = 'Crown.ts'
#[vrtx, trgl] = PF.BaseMag.read_GOCAD_ts(tsfile)
indx = PF.BaseMag.gocad2vtk(tsfile,mesh)
model= np.zeros(mesh.nC)
model[indx]=1
Utils.meshutils.writeUBCTensorModel('VTKout.dat',mesh,model)
# Load model file
#model = Utils.meshutils.readUBCTensorModel(modfile,mesh)
# Load in topofile or create flat surface
#==============================================================================
# if topofile == 'null':
#
# actv = np.ones(mesh.nC)
#
# else:
# topo = np.genfromtxt(topofile,skip_header=1)
# actv = PF.Magnetics.getActiveTopo(mesh,topo,'N')
#
#
# Utils.writeUBCTensorModel('nullcell.dat',mesh,actv)
#
# # Load in observation file
# [B,M,dobs] = PF.BaseMag.readUBCmagObs(obsfile)
#
# rxLoc = dobs[:,0:3]
# #rxLoc[:,2] += 5 # Temporary change for test
# ndata = rxLoc.shape[0]
#==============================================================================
#%% Run forward modeling
# Compute forward model using integral equation
#==============================================================================
# d = PF.Magnetics.Intgrl_Fwr_Data(mesh,B,M,rxLoc,model,actv,'tmi')
#
# # Form data object with coordinates and write to file
# wd = np.zeros((ndata,1))
#
# # Save forward data to file
# PF.Magnetics.writeUBCobs(home_dir + dsep + 'FWR_data.dat',B,M,rxLoc,d,wd)
#==============================================================================
@@ -0,0 +1,139 @@
import os
home_dir = '.\Test_tria_2_grid'
inpfile = 'PYMAG3C_fwr.inp'
dsep = '\\'
os.chdir(home_dir)
#%%
from SimPEG import np, sp, Utils, Mesh
import scipy.interpolate as interpolation
import simpegPF as PF
import pylab as plt
import time as tm
## New scripts to be added to basecode
#from fwr_MAG_data import fwr_MAG_data
#from read_MAGfwr_inp import read_MAGfwr_inp
#%%
chibkg = 0.001
# Read in topo surface
tsfile = 'Topo_Gaussian.ts'
# For now just read both
topofile = 'Gaussian.topo'
topo = np.genfromtxt(topofile,skip_header=1)
# Offset data above topo
zoffset = 2
# Load mesh file
B = np.array(([90.,0.,50000.]))
M = np.array(([90.,0.,315.]))
# Sphere radius
R = 25.
#%% Script starts here
# # Create a grid of observations and offset the z from topo
xr = np.linspace(-99., 99., 40)
yr = np.linspace(-49., 49., 20)
X, Y = np.meshgrid(xr, yr)
F = interpolation.NearestNDInterpolator(topo[:,0:2],topo[:,2])
Z = F(X,Y) + zoffset
rxLoc = np.c_[Utils.mkvc(X.T), Utils.mkvc(Y.T), Utils.mkvc(Z.T)]
ndata = rxLoc.shape[0]
sclx = 100.
dx = 10
nc = int(sclx/dx)
hxind = [(dx, 2*nc)]
hyind = [(dx, nc)]
hzind = [(dx, nc)]
mesh = Mesh.TensorMesh([hxind, hyind, hzind], 'CCN')
# Load GOCAD surf
#[vrtx, trgl] = PF.BaseMag.read_GOCAD_ts(tsfile)
# Find active cells from surface
tin = tm.time()
print "Computing indices with VTK: "
[indx, bc] = PF.BaseMag.gocad2vtk(tsfile,mesh, bcflag = False, inflag = True)
print "VTK operation completed in " + str(tm.time() - tin)
actv = np.zeros(mesh.nC)
actv[indx] = 1
model= np.zeros(mesh.nC)
model[indx]= chibkg
Utils.meshutils.writeUBCTensorModel('VTKout.dat',mesh,model)
Utils.meshutils.writeUBCTensorMesh('Mesh_temp.msh',mesh)
start_time = tm.time()
d = PF.Magnetics.Intgrl_Fwr_Data(mesh,B,M,rxLoc,model,actv,'tmi')
timer = (tm.time() - start_time)
#%% Plot data
plt.figure(1)
ax = plt.subplot()
plt.imshow(np.reshape(d,X.shape), interpolation="bicubic", extent=[xr.min(), xr.max(), yr.min(), yr.max()], origin = 'lower')
plt.colorbar(fraction=0.02)
plt.contour(X,Y, np.reshape(d,X.shape),10)
plt.scatter(X,Y, c=np.reshape(d,X.shape), s=20)
ax.set_title('Forward data')
# Load model file
#model = Utils.meshutils.readUBCTensorModel(modfile,mesh)
# Load in topofile or create flat surface
#==============================================================================
# if topofile == 'null':
#
# actv = np.ones(mesh.nC)
#
# else:
# topo = np.genfromtxt(topofile,skip_header=1)
# actv = PF.Magnetics.getActiveTopo(mesh,topo,'N')
#
#
# Utils.writeUBCTensorModel('nullcell.dat',mesh,actv)
#
# # Load in observation file
# [B,M,dobs] = PF.BaseMag.readUBCmagObs(obsfile)
#
# rxLoc = dobs[:,0:3]
# #rxLoc[:,2] += 5 # Temporary change for test
# ndata = rxLoc.shape[0]
#==============================================================================
#%% Run forward modeling
# Compute forward model using integral equation
#==============================================================================
# d = PF.Magnetics.Intgrl_Fwr_Data(mesh,B,M,rxLoc,model,actv,'tmi')
#
# # Form data object with coordinates and write to file
# wd = np.zeros((ndata,1))
#
# # Save forward data to file
# PF.Magnetics.writeUBCobs(home_dir + dsep + 'FWR_data.dat',B,M,rxLoc,d,wd)
#==============================================================================
File diff suppressed because it is too large. Load diff
@@ -0,0 +1,5 @@
20 10 10
-100.00 -50.00 0.00
10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00
10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00
10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00 10.00
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
@@ -100,7 +100,7 @@
},
{
"cell_type": "code",
"execution_count": 3,
"execution_count": 59,
"metadata": {
"collapsed": false,
"scrolled": true
@@ -117,12 +117,18 @@
"M = np.array([90,0])\n",
"\n",
"# Create a mesh\n",
"hxind = [(5, 20)]\n",
"hyind = [(5, 20)]\n",
"hzind = [(5, 10)]\n",
"dx = 5.\n",
"\n",
"hxind = [(dx,5,-1.3), (dx, 20), (dx,5,1.3)]\n",
"hyind = [(dx,5,-1.3), (dx, 20), (dx,5,1.3)]\n",
"hzind = [(dx,5,-1.3),(5, 10)]\n",
"\n",
"mesh = Mesh.TensorMesh([hxind, hyind, hzind], 'CCC')\n",
"\n",
"# Get index of the center\n",
"midx = int(mesh.nCx/2)\n",
"midy = int(mesh.nCy/2)\n",
"\n",
"# Assume flat topo for now, so all cells are active\n",
"nC = mesh.nC \n",
"actv = np.ones(nC)\n",
@@ -132,11 +138,33 @@
"xr = np.linspace(-20., 20., 20)\n",
"yr = np.linspace(-20., 20., 20)\n",
"X, Y = np.meshgrid(xr, yr)\n",
"Z = np.ones(X.size)*(mesh.vectorNz[-1]+1.) # Let just put the observation flat\n",
"Z = np.ones(X.size)*(mesh.vectorNz[-1]+dx) # Let just put the observation flat\n",
"\n",
"rxLoc = np.c_[Utils.mkvc(X.T), Utils.mkvc(Y.T), Utils.mkvc(Z.T)]\n"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"59.390075000000003"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Z.max()"
]
},
{
"cell_type": "markdown",
"metadata": {},
@@ -172,7 +200,7 @@
},
{
"cell_type": "code",
"execution_count": 4,
"execution_count": 61,
"metadata": {
"collapsed": false
},
@@ -209,7 +237,7 @@
},
{
"cell_type": "code",
"execution_count": 35,
"execution_count": 91,
"metadata": {
"collapsed": false
},
@@ -228,7 +256,9 @@
"Done 60.0 %\n",
"Done 70.0 %\n",
"Done 80.0 %\n",
"Done 90.0 %\n"
"Done 90.0 %\n",
"Done 100% ...distance weighting completed!!\n",
"\n"
]
},
{
@@ -970,7 +1000,7 @@
{
"data": {
"text/html": [
"<img src=\"data:image/png;base64,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 truncated
"<img src=\"data:image/png;base64,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 truncated
],
"text/plain": [
"<IPython.core.display.HTML object>"
@@ -983,11 +1013,11 @@
"source": [
"# Generate a distance weighting\n",
"wr = PF.Magnetics.get_dist_wgt(mesh,rxLoc,3.,np.min(mesh.hx)/4)\n",
"wrMap = PF.BaseMag.WeightMap(mesh, wr**-1)\n",
"wrMap = PF.BaseMag.WeightMap(mesh, wr)\n",
"\n",
"plt.figure()\n",
"ax = subplot()\n",
"mesh.plotSlice(wr, ax = ax, normal = 'Y', ind=10)\n",
"mesh.plotSlice(wr, ax = ax, normal = 'Y', ind=midx)\n",
"title('Distance weighting')\n",
"xlabel('x');ylabel('z')\n",
"plt.gca().set_aspect('equal', adjustable='box')"
@@ -995,7 +1025,7 @@
},
{
"cell_type": "code",
"execution_count": 36,
"execution_count": 92,
"metadata": {
"collapsed": false
},
@@ -1739,7 +1769,7 @@
{
"data": {
"text/html": [
"<img src=\"data:image/png;base64,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 truncated
"<img src=\"data:image/png;base64,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 truncated
],
"text/plain": [
"<IPython.core.display.HTML object>"
@@ -1753,21 +1783,21 @@
"# We can now create a susceptibility model and generate data\n",
"# Lets start with a simple block in half-space\n",
"model = np.zeros((mesh.nCx,mesh.nCy,mesh.nCz))\n",
"model[8:11,8:11,6:9] = 0.01\n",
"model[(midx-2):(midx+2),(midy-2):(midy+2),-6:-2] = 0.01\n",
"model = mkvc(model)\n",
"\n",
"# Create a few models\n",
"figure()\n",
"ax = subplot(211)\n",
"mesh.plotSlice(model, ax = ax, normal = 'Y', ind=10)\n",
"mesh.plotSlice(model, ax = ax, normal = 'Y', ind=midx, grid=True)\n",
"title('A simple block model.')\n",
"xlabel('x');ylabel('y')\n",
"xlabel('x');ylabel('z')\n",
"plt.gca().set_aspect('equal', adjustable='box')\n",
"\n",
"# We can now generate data\n",
"data = F.dot(model) #: this is matrix multiplication!!\n",
"subplot(212)\n",
"imshow(data.reshape(X.shape))\n",
"imshow(data.reshape(X.shape), extent=[xr.min(), xr.max(), yr.min(), yr.max()])\n",
"title('Predicted data.')\n",
"plt.gca().set_aspect('equal', adjustable='box')\n"
]
@@ -1779,7 +1809,7 @@
},
{
"cell_type": "code",
"execution_count": 37,
"execution_count": 93,
"metadata": {
"collapsed": false
},
@@ -1820,7 +1850,7 @@
},
{
"cell_type": "code",
"execution_count": 44,
"execution_count": 97,
"metadata": {
"collapsed": false
},
@@ -1832,17 +1862,20 @@
"survey.pair(prob)\n",
"#survey.makeSyntheticData(data, std=0.01)\n",
"survey.dobs=data\n",
"survey.std = np.ones(len(data))*1e-1\n",
"survey.mtrue = model\n",
"\n",
"reg = Regularization.Tikhonov(mesh, mapping = wrMap)\n",
"\n",
"reg = Regularization.Tikhonov(mesh, mapping=wrMap)\n",
"dmis = DataMisfit.l2_DataMisfit(survey)\n",
"opt = Optimization.ProjectedGNCG(maxIter=35,lower=0.,upper=1.)\n",
"invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta = 1e-2)\n",
"dmis.Wd = np.ones(len(data))*1.\n",
"opt = Optimization.ProjectedGNCG(maxIter=6,lower=0.,upper=1.)\n",
"# opt = Optimization.InexactGaussNewton(maxIter=6)\n",
"invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta = 1e+4)\n",
"beta = Directives.BetaSchedule()\n",
"#betaest = Directives.BetaEstimate_ByEig()\n",
"target = Directives.TargetMisfit()\n",
"inv = Inversion.BaseInversion(invProb, directiveList=[beta, target])\n",
"reg.alpha_s =0.0025\n",
"m0 = np.ones_like(survey.mtrue)*1e-4"
]
},
@@ -1855,7 +1888,7 @@
},
{
"cell_type": "code",
"execution_count": 45,
"execution_count": 98,
"metadata": {
"collapsed": false
},
@@ -1870,18 +1903,14 @@
"=============================== Projected GNCG ===============================\n",
" # beta phi_d phi_m f |proj(x-g)-x| LS Comment \n",
"-----------------------------------------------------------------------------\n",
"SimPEG.l2_DataMisfit is creating default weightings for Wd.\n",
" 0 1.00e-02 3.06e+05 1.89e-04 3.06e+05 3.98e+01 0 \n",
" 1 1.00e-02 5.42e+04 1.86e-04 5.42e+04 3.93e+01 0 \n",
" 2 1.00e-02 2.72e+04 1.78e-04 2.72e+04 3.89e+01 0 Skip BFGS \n",
" 3 1.25e-03 1.98e+04 1.42e-04 1.98e+04 3.81e+01 0 Skip BFGS \n",
" 4 1.25e-03 1.97e+04 1.63e-04 1.97e+04 3.80e+01 3 \n",
" 5 1.25e-03 1.86e+04 5.30e-05 1.86e+04 3.72e+01 0 \n",
"------------------------------------------------------------------\n",
"0 : ft = 1.9170e+04 <= alp*descent = 1.8567e+04\n",
"1 : maxIterLS = 10 <= iterLS = 10\n",
"------------------------- End Linesearch -------------------------\n",
"The linesearch got broken. Boo.\n"
" 0 1.00e+04 5.58e+04 2.22e-07 5.58e+04 8.41e+01 0 \n",
"------------------------- STOP! -------------------------\n",
"1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 5.5847e+03\n",
"1 : |xc-x_last| = 4.1645e-02 <= tolX*(1+|x0|) = 1.0116e-01\n",
"0 : |proj(x-g)-x| = 8.4094e+01 <= tolG = 1.0000e-01\n",
"0 : |proj(x-g)-x| = 8.4094e+01 <= 1e3*eps = 1.0000e-02\n",
"0 : maxIter = 6 <= iter = 1\n",
"------------------------- DONE! -------------------------\n"
]
}
],
@@ -1891,29 +1920,7 @@
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min(mrec)"
]
},
{
"cell_type": "code",
"execution_count": 47,
"execution_count": 99,
"metadata": {
"collapsed": false
},
@@ -2657,7 +2664,7 @@
{
"data": {
"text/html": [
"<img src=\"data:image/png;base64,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 truncated
"<img src=\"data:image/png;base64,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 truncated
],
"text/plain": [
"<IPython.core.display.HTML object>"
@@ -2665,15 +2672,47 @@
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"text/plain": [
"<matplotlib.colorbar.Colorbar instance at 0x000000002CCA78C8>"
]
},
"execution_count": 99,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Here is the recovered susceptibility model\n",
"plt.figure()\n",
"ax = subplot()\n",
"ax = subplot(211)\n",
"mesh.plotSlice(mrec, ax = ax, normal = 'Y', ind=10)\n",
"title('Recovered model.')\n",
"xlabel('x');ylabel('y')\n",
"plt.gca().set_aspect('equal', adjustable='box')"
"plt.gca().set_aspect('equal', adjustable='box')\n",
"\n",
"# Plot predicted data and residual\n",
"pred = F.dot(mrec) #: this is matrix multiplication!!\n",
"\n",
"subplot(234)\n",
"imshow(data.reshape(X.shape))\n",
"title('Predicted data.')\n",
"plt.gca().set_aspect('equal', adjustable='box')\n",
"colorbar()\n",
"\n",
"subplot(235)\n",
"imshow(pred.reshape(X.shape))\n",
"title('Predicted data.')\n",
"plt.gca().set_aspect('equal', adjustable='box')\n",
"colorbar()\n",
"\n",
"subplot(236)\n",
"imshow(data.reshape(X.shape) - pred.reshape(X.shape))\n",
"title('Residual data.')\n",
"plt.gca().set_aspect('equal', adjustable='box')\n",
"colorbar()"
]
},
{