From 1aab6aaee59c18e3fe04f9d626c482ff0c527841 Mon Sep 17 00:00:00 2001 From: Rowan Cockett Date: Thu, 12 Feb 2015 11:39:13 -0800 Subject: [PATCH 1/2] move analytics to utils. --- simpegMT/Analytics/MT1Danalytic.py | 101 ------------------ simpegMT/Analytics/MT1Dsolutions.py | 43 -------- simpegMT/Utils/MT1Danalytic.py | 153 ++++++++++++++-------------- simpegMT/Utils/MT1Dsolutions.py | 65 ++++++------ 4 files changed, 110 insertions(+), 252 deletions(-) delete mode 100644 simpegMT/Analytics/MT1Danalytic.py delete mode 100644 simpegMT/Analytics/MT1Dsolutions.py diff --git a/simpegMT/Analytics/MT1Danalytic.py b/simpegMT/Analytics/MT1Danalytic.py deleted file mode 100644 index 66db5df5..00000000 --- a/simpegMT/Analytics/MT1Danalytic.py +++ /dev/null @@ -1,101 +0,0 @@ -# Analytic solution of EM fields due to a plane wave - -import numpy as np, SimPEG as simpeg - -def getEHfields(m1d,sigma,freq,zd): - '''Analytic solution for MT 1D layered earth. Returns E and H fields. - - :param SimPEG.mesh, object m1d: Mesh object with the 1D spatial information. - :param numpy.array, vector sigma: Physical property of conductivity corresponding with the mesh. - :param float, freq: Frequency to calculate data at. - :param numpy array, vector zd: location to calculate EH fields at - - Assumes a halfspace with the same conductive as the last cell below. - - ''' - # Note add an error check for the mesh and sigma are the same size. - # Need make the solution e^-iwt dependent - - # Constants: Assume constant - mu = 4*np.pi*1e-7*np.ones((m1d.nC+1)) - eps = 8.85*1e-12*np.ones((m1d.nC+1)) - # Angular freq - w = 2*np.pi*freq - # Add the halfspace value to the property - sig = np.concatenate((np.array([sigma[0]]),sigma)) - # Calculate the wave number - k = np.sqrt(eps*mu*w**2-1j*mu*sig*w) - - # Initiate the propagation matrix, in the order down up. - UDp = np.zeros((2,m1d.nC+1),dtype=complex) - UDp[1,0] = 1 # Set the wave amplitude as 1 into the half-space at the bottom of the mesh - # Loop over all the layers, starting at the bottom layer - for lnr, h in enumerate(m1d.hx): # lnr-number of layer, h-thickness of the layer - # Calculate - yp1 = k[lnr]/(w*mu[lnr]) # Admittance of the layer below the current layer - zp = (w*mu[lnr+1])/k[lnr+1] # Impedance in the current layer - # Build the propagation matrix - - # Convert fields to down/up going components in layer below current layer - Pj1 = np.array([[1,1],[yp1,-yp1]]) - # Convert fields to down/up going components in current layer - Pjinv = 1./2*np.array([[1,zp],[1,-zp]]) - # Propagate down and up components through the current layer - elamh = np.array([[np.exp(-1j*k[lnr+1]*h),0],[0,np.exp(1j*k[lnr+1]*h)]]) - - # The down and up component in current layer. - UDp[:,lnr+1] = elamh.dot(Pjinv.dot(Pj1)).dot(UDp[:,lnr]) - - # Calculate the fields - Ed = np.zeros((zd.size,),dtype=complex) - Eu = np.zeros((zd.size,),dtype=complex) - Hd = np.zeros((zd.size,),dtype=complex) - Hu = np.zeros((zd.size,),dtype=complex) - - # Loop over the layers and calculate the fields - for ki,mui,epsi,dlow,dup,Up,Dp in zip(k[1::],mu[1::],eps[1::],m1d.vectorNx[:-1],m1d.vectorNx[1::],UDp[0,1::],UDp[1,1::]): - dind = np.logical_and(dup >= zd, zd > dlow) - Ed[dind] = Dp*np.exp(-1j*ki*(dup-zd[dind])) - Eu[dind] = Up*np.exp(1j*ki*(dup-zd[dind])) - Hd[dind] = (ki/(w*mui))*Dp*np.exp(-1j*ki*(dup-zd[dind])) - Hu[dind] = -(ki/(w*mui))*Up*np.exp(1j*ki*(dup-zd[dind])) - - # Return return the fields - return Ed, Eu, Hd, Hu - -def getImpedance(m1d,sigma,freq): - """Analytic solution for MT 1D layered earth. Returns the impedance at the surface. - - :param SimPEG.mesh, object m1d: Mesh object with the 1D spatial information. - :param numpy.array, vector sigma: Physical property corresponding with the mesh. - :param numpy.array, vector freq: Frequencies to calculate data at. - - - """ - - # Define constants - mu0 = 4*np.pi*1e-7 - eps0 = 8.85e-12 - - # Initiate the impedances - Z1d = np.empty(len(freq) , dtype='complex') - h = m1d.hx #vectorNx[:-1] - # Start the process - for nrFr, fr in enumerate(freq): - om = 2*np.pi*fr - Zall = np.empty(len(h)+1,dtype='complex') - # Calculate the impedance for the bottom layer - Zall[0] = (mu0*om)/np.sqrt(mu0*eps0*(om)**2 - 1j*mu0*sigma[0]*om) - - for nr,hi in enumerate(h): - # Calculate the wave number - # print nr,sigma[nr] - k = np.sqrt(mu0*eps0*om**2 - 1j*mu0*sigma[nr]*om) - Z = (mu0*om)/k - - Zall[nr+1] = Z *((Zall[nr] + Z*np.tanh(1j*k*hi))/(Z + Zall[nr]*np.tanh(1j*k*hi))) - - #pdb.set_trace() - Z1d[nrFr] = Zall[-1] - - return Z1d \ No newline at end of file diff --git a/simpegMT/Analytics/MT1Dsolutions.py b/simpegMT/Analytics/MT1Dsolutions.py deleted file mode 100644 index a2900240..00000000 --- a/simpegMT/Analytics/MT1Dsolutions.py +++ /dev/null @@ -1,43 +0,0 @@ -import numpy as np, SimPEG as simpeg -from MT1Danalytic import getEHfields -from scipy.constants import mu_0 - -def get1DEfields(m1d,sigma,freq,sourceAmp=1.0): - """Function to get 1D electrical fields""" - - # Get the gradient - G = m1d.nodalGrad - # Mass matrices - # Magnetic permeability - Mmu = simpeg.Utils.sdiag(m1d.vol*(1.0/mu_0)) - # Conductivity - Msig = m1d.getFaceInnerProduct(sigma) - # Set up the solution matrix - A = G.T*Mmu*G - 1j*2.*np.pi*freq*Msig - # Define the inner part of the solution matrix - Aii = A[1:-1,1:-1] - # Define the outer part of the solution matrix - Aio = A[1:-1,[0,-1]] - - # Set the boundary conditions - Ed_low, Eu_low, Hd_low, Hu_low = getEHfields(m1d,sigma,freq,np.array([m1d.vectorNx[0]])) - Etot_low = Ed_low + Eu_low - ## Note: need to use conjugate of the analytic solution. It is derived with e^iwt - bc = np.r_[Etot_low.conj(),sourceAmp] - # The right hand side - rhs = -Aio*bc - # Solve the system - Aii_inv = simpeg.Solver(Aii) - eii = Aii_inv*rhs - # Assign the boundary conditions - e = np.r_[bc[0],eii,bc[1]] - # Return the electrical fields - return e - - -if __name__ == '__main__': - - hz = [(100.,18)] - M = simpeg.Mesh.TensorMesh([hz],'C') - sig = np.zeros(M.nC) + 1e-8 - sig[M.vectorCCx<=0] = sigHalf \ No newline at end of file diff --git a/simpegMT/Utils/MT1Danalytic.py b/simpegMT/Utils/MT1Danalytic.py index f5605125..02406fc4 100644 --- a/simpegMT/Utils/MT1Danalytic.py +++ b/simpegMT/Utils/MT1Danalytic.py @@ -3,98 +3,99 @@ import numpy as np, SimPEG as simpeg def getEHfields(m1d,sigma,freq,zd): - '''Analytic solution for MT 1D layered earth. Returns E and H fields. + '''Analytic solution for MT 1D layered earth. Returns E and H fields. - :param SimPEG.mesh, object m1d: Mesh object with the 1D spatial information. - :param numpy.array, vector sigma: Physical property of conductivity corresponding with the mesh. - :param float, freq: Frequency to calculate data at. - :param numpy array, vector zd: location to calculate EH fields at + :param SimPEG.mesh, object m1d: Mesh object with the 1D spatial information. + :param numpy.array, vector sigma: Physical property of conductivity corresponding with the mesh. + :param float, freq: Frequency to calculate data at. + :param numpy array, vector zd: location to calculate EH fields at - Assumes a halfspace with the same conductive as the last cell below. + Assumes a halfspace with the same conductive as the last cell below. - ''' - # Note add an error check for the mesh. + ''' + # Note add an error check for the mesh and sigma are the same size. + # Need make the solution e^-iwt dependent - # Constants: Assume constant - mu = 4*np.pi*1e-7*np.ones((m1d.nC+1)) - eps = 8.85*1e-12*np.ones((m1d.nC+1)) - # Angular freq - w = 2*np.pi*freq - # Add the halfspace value to the property - sig = np.concatenate((np.array([sigma[0]]),sigma)) - # Calculate the wave number - k = np.sqrt(eps*mu*w**2-1j*mu*sig*w) + # Constants: Assume constant + mu = 4*np.pi*1e-7*np.ones((m1d.nC+1)) + eps = 8.85*1e-12*np.ones((m1d.nC+1)) + # Angular freq + w = 2*np.pi*freq + # Add the halfspace value to the property + sig = np.concatenate((np.array([sigma[0]]),sigma)) + # Calculate the wave number + k = np.sqrt(eps*mu*w**2-1j*mu*sig*w) - # Initiate the propagation matrix, in the order down up. - UDp = np.zeros((2,m1d.nC+1),dtype=complex) - UDp[1,0] = 1 # Set the wave amplitude as 1 into the half-space at the bottom of the mesh - # Loop over all the layers, starting at the bottom layer - for lnr, h in enumerate(m1d.hx): # lnr-number of layer, h-thickness of the layer - # Calculate - yp1 = k[lnr]/(w*mu[lnr]) # Admittance of the layer below the current layer - zp = (w*mu[lnr+1])/k[lnr+1] # Impedance in the current layer - # Build the propagation matrix - - # Convert fields to down/up going components in layer below current layer - Pj1 = np.array([[1,1],[yp1,-yp1]]) - # Convert fields to down/up going components in current layer - Pjinv = 1./2*np.array([[1,zp],[1,-zp]]) - # Propagate down and up components through the current layer - elamh = np.array([[np.exp(-1j*k[lnr+1]*h),0],[0,np.exp(1j*k[lnr+1]*h)]]) + # Initiate the propagation matrix, in the order down up. + UDp = np.zeros((2,m1d.nC+1),dtype=complex) + UDp[1,0] = 1 # Set the wave amplitude as 1 into the half-space at the bottom of the mesh + # Loop over all the layers, starting at the bottom layer + for lnr, h in enumerate(m1d.hx): # lnr-number of layer, h-thickness of the layer + # Calculate + yp1 = k[lnr]/(w*mu[lnr]) # Admittance of the layer below the current layer + zp = (w*mu[lnr+1])/k[lnr+1] # Impedance in the current layer + # Build the propagation matrix - # The down and up component in current layer. - UDp[:,lnr+1] = elamh.dot(Pjinv.dot(Pj1)).dot(UDp[:,lnr]) + # Convert fields to down/up going components in layer below current layer + Pj1 = np.array([[1,1],[yp1,-yp1]]) + # Convert fields to down/up going components in current layer + Pjinv = 1./2*np.array([[1,zp],[1,-zp]]) + # Propagate down and up components through the current layer + elamh = np.array([[np.exp(-1j*k[lnr+1]*h),0],[0,np.exp(1j*k[lnr+1]*h)]]) - # Calculate the fields - Ed = np.zeros((zd.size,),dtype=complex) - Eu = np.zeros((zd.size,),dtype=complex) - Hd = np.zeros((zd.size,),dtype=complex) - Hu = np.zeros((zd.size,),dtype=complex) + # The down and up component in current layer. + UDp[:,lnr+1] = elamh.dot(Pjinv.dot(Pj1)).dot(UDp[:,lnr]) - # Loop over the layers and calculate the fields - for ki,mui,epsi,dlow,dup,Up,Dp in zip(k[1::],mu[1::],eps[1::],m1d.vectorNx[:-1],m1d.vectorNx[1::],UDp[0,1::],UDp[1,1::]): - dind = np.logical_and(dup >= zd, zd > dlow) - Ed[dind] = Dp*np.exp(-1j*ki*(dup-zd[dind])) - Eu[dind] = Up*np.exp(1j*ki*(dup-zd[dind])) - Hd[dind] = (ki/(w*mui))*Dp*np.exp(-1j*ki*(dup-zd[dind])) - Hu[dind] = -(ki/(w*mui))*Up*np.exp(1j*ki*(dup-zd[dind])) + # Calculate the fields + Ed = np.zeros((zd.size,),dtype=complex) + Eu = np.zeros((zd.size,),dtype=complex) + Hd = np.zeros((zd.size,),dtype=complex) + Hu = np.zeros((zd.size,),dtype=complex) - # Return return the fields - return Ed, Eu, Hd, Hu + # Loop over the layers and calculate the fields + for ki,mui,epsi,dlow,dup,Up,Dp in zip(k[1::],mu[1::],eps[1::],m1d.vectorNx[:-1],m1d.vectorNx[1::],UDp[0,1::],UDp[1,1::]): + dind = np.logical_and(dup >= zd, zd > dlow) + Ed[dind] = Dp*np.exp(-1j*ki*(dup-zd[dind])) + Eu[dind] = Up*np.exp(1j*ki*(dup-zd[dind])) + Hd[dind] = (ki/(w*mui))*Dp*np.exp(-1j*ki*(dup-zd[dind])) + Hu[dind] = -(ki/(w*mui))*Up*np.exp(1j*ki*(dup-zd[dind])) + + # Return return the fields + return Ed, Eu, Hd, Hu def getImpedance(m1d,sigma,freq): - """Analytic solution for MT 1D layered earth. Returns the impedance at the surface. + """Analytic solution for MT 1D layered earth. Returns the impedance at the surface. - :param SimPEG.mesh, object m1d: Mesh object with the 1D spatial information. - :param numpy.array, vector sigma: Physical property corresponding with the mesh. - :param numpy.array, vector freq: Frequencies to calculate data at. + :param SimPEG.mesh, object m1d: Mesh object with the 1D spatial information. + :param numpy.array, vector sigma: Physical property corresponding with the mesh. + :param numpy.array, vector freq: Frequencies to calculate data at. - """ + """ - # Define constants - mu0 = 4*np.pi*1e-7 - eps0 = 8.85e-12 + # Define constants + mu0 = 4*np.pi*1e-7 + eps0 = 8.85e-12 - # Initiate the impedances - Z1d = np.empty(len(freq) , dtype='complex') - h = m1d.hx #vectorNx[:-1] - # Start the process - for nrFr, fr in enumerate(freq): - om = 2*np.pi*fr - Zall = np.empty(len(h)+1,dtype='complex') - # Calculate the impedance for the bottom layer - Zall[0] = (mu0*om)/np.sqrt(mu0*eps0*(om)**2 - 1j*mu0*sigma[0]*om) + # Initiate the impedances + Z1d = np.empty(len(freq) , dtype='complex') + h = m1d.hx #vectorNx[:-1] + # Start the process + for nrFr, fr in enumerate(freq): + om = 2*np.pi*fr + Zall = np.empty(len(h)+1,dtype='complex') + # Calculate the impedance for the bottom layer + Zall[0] = (mu0*om)/np.sqrt(mu0*eps0*(om)**2 - 1j*mu0*sigma[0]*om) - for nr,hi in enumerate(h): - # Calculate the wave number - # print nr,sigma[nr] - k = np.sqrt(mu0*eps0*om**2 - 1j*mu0*sigma[nr]*om) - Z = (mu0*om)/k - - Zall[nr+1] = Z *((Zall[nr] + Z*np.tanh(1j*k*hi))/(Z + Zall[nr]*np.tanh(1j*k*hi))) + for nr,hi in enumerate(h): + # Calculate the wave number + # print nr,sigma[nr] + k = np.sqrt(mu0*eps0*om**2 - 1j*mu0*sigma[nr]*om) + Z = (mu0*om)/k - #pdb.set_trace() - Z1d[nrFr] = Zall[-1] + Zall[nr+1] = Z *((Zall[nr] + Z*np.tanh(1j*k*hi))/(Z + Zall[nr]*np.tanh(1j*k*hi))) - return Z1d \ No newline at end of file + #pdb.set_trace() + Z1d[nrFr] = Zall[-1] + + return Z1d diff --git a/simpegMT/Utils/MT1Dsolutions.py b/simpegMT/Utils/MT1Dsolutions.py index 3b1149b8..fd3347d5 100644 --- a/simpegMT/Utils/MT1Dsolutions.py +++ b/simpegMT/Utils/MT1Dsolutions.py @@ -3,40 +3,41 @@ from MT1Danalytic import getEHfields from scipy.constants import mu_0 def get1DEfields(m1d,sigma,freq,sourceAmp=1.0): - """Function to get 1D electrical fields""" - - # Get the gradient - G = m1d.nodalGrad - # Mass matrices - # Magnetic permeability - Mmu = simpeg.Utils.sdiag(m1d.vol*(1.0/mu_0)) - # Conductivity - Msig = m1d.getFaceInnerProduct(sigma) - # Set up the solution matrix - A = G.T*Mmu*G - 1j*2.*np.pi*freq*Msig - # Define the inner part of the solution matrix - Aii = A[1:-1,1:-1] - # Define the outer part of the solution matrix - Aio = A[1:-1,[0,-1]] + """Function to get 1D electrical fields""" - # Set the boundary conditions - Ed_low, Eu_low, Hd_low, Hu_low = getEHfields(m1d,sigma,freq,np.array([m1d.vectorNx[0]])) - Etot_low = Ed_low + Eu_low - bc = np.r_[Etot_low,sourceAmp] - # The right hand side - rhs = -Aio*bc - # Solve the system - Aii_inv = simpeg.Solver(Aii) - eii = Aii_inv*rhs - # Assign the boundary conditions - e = np.r_[bc[0],eii,bc[1]] - # Return the electrical fields - return e + # Get the gradient + G = m1d.nodalGrad + # Mass matrices + # Magnetic permeability + Mmu = simpeg.Utils.sdiag(m1d.vol*(1.0/mu_0)) + # Conductivity + Msig = m1d.getFaceInnerProduct(sigma) + # Set up the solution matrix + A = G.T*Mmu*G - 1j*2.*np.pi*freq*Msig + # Define the inner part of the solution matrix + Aii = A[1:-1,1:-1] + # Define the outer part of the solution matrix + Aio = A[1:-1,[0,-1]] + + # Set the boundary conditions + Ed_low, Eu_low, Hd_low, Hu_low = getEHfields(m1d,sigma,freq,np.array([m1d.vectorNx[0]])) + Etot_low = Ed_low + Eu_low + ## Note: need to use conjugate of the analytic solution. It is derived with e^iwt + bc = np.r_[Etot_low.conj(),sourceAmp] + # The right hand side + rhs = -Aio*bc + # Solve the system + Aii_inv = simpeg.Solver(Aii) + eii = Aii_inv*rhs + # Assign the boundary conditions + e = np.r_[bc[0],eii,bc[1]] + # Return the electrical fields + return e if __name__ == '__main__': - hz = [(100.,18)] - M = simpeg.Mesh.TensorMesh([hz],'C') - sig = np.zeros(M.nC) + 1e-8 - sig[M.vectorCCx<=0] = sigHalf \ No newline at end of file + hz = [(100.,18)] + M = simpeg.Mesh.TensorMesh([hz],'C') + sig = np.zeros(M.nC) + 1e-8 + sig[M.vectorCCx<=0] = sigHalf From bae79ecb25f83c51f0bc4bbda72a45d908c112e5 Mon Sep 17 00:00:00 2001 From: Rowan Cockett Date: Thu, 12 Feb 2015 11:40:13 -0800 Subject: [PATCH 2/2] delete analytics folder. --- simpegMT/Analytics/MT1Danalytic.pyc | Bin 3435 -> 0 bytes simpegMT/Analytics/MT1Dsolutions.pyc | Bin 1471 -> 0 bytes simpegMT/Analytics/__init__.py | 1 - simpegMT/Analytics/__init__.pyc | Bin 161 -> 0 bytes simpegMT/Utils/__init__.py | 2 +- 5 files changed, 1 insertion(+), 2 deletions(-) delete mode 100644 simpegMT/Analytics/MT1Danalytic.pyc delete mode 100644 simpegMT/Analytics/MT1Dsolutions.pyc delete mode 100644 simpegMT/Analytics/__init__.py delete mode 100644 simpegMT/Analytics/__init__.pyc diff --git a/simpegMT/Analytics/MT1Danalytic.pyc b/simpegMT/Analytics/MT1Danalytic.pyc deleted file mode 100644 index 91ddc2b12ecaa0cb55f0982a38fed8fba4070621..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3435 zcmd5X@N0F>VXtFcAJI=g3 z)9ZMx9U&C>4JaJAaNx)RaYNz^;?9L%zyTs6&hS;W*Bb{1ksIrop6=@Es_N?MugZld zW2K?&hqXHG{%m~T$D7Teaq(Cb5UpFizD?@|a&7tq!~t>((ivp7o3jI0;{S!;jXHN< z!aIuh3f}C`g2>WD8y1xzpv+yHx@aM=KvNGv&mnT04xE9GA(;VN7t3=q8W7qbbzxzV zs!fX^2ZM&qoxCX1L(~Pw02U6hl%r+$kQo+*RGwzmL&92QhQ3h{;|`NP1YuS_%yxFs z9;U_Zw=F#^j3rjIboW*3j!k)q@)7DndWot~2A$k1SMpKX8}eqWWy2)>Nlz z;TG_Z(g=EZ*t&6YOKe(&odaLMkTIS!ojzkZKfEi88Ar(NnFB`FIznZLgR6M0@eY_^ zu-Lqhsjqy3x)ZbklMYKe&KBWe3cNAO&!@1t#9psr;u$JS#mwU7FLax&DpI#V8)MXf zA$!i9+;#r}Q%9aZb@cgDW!g?HJ%%-{?+}@(Sh0D4(Kyn(`{;$0H)N_^Rq`EbyYMySVQKpua6S-el*&btfhIw(ED17Ek4Zh5RAOC0Sxf$}3L4bhLIxjku7J4`xrPMSKMGinR6U{~fh zLuWy)wmO+#$HF9y6ED>r6*p8pj@))#`&&N7^*BwvECI=nnrcrco7UIR2x3Q{QH|8w zTu@ihw!Ns{Q94$TU2g}D_LS>rM>)E`NX%0E&Dy~pgSajm*uQ+a=O)O2qb_Gz8#X9M zwVa@V?bp4&ahVf({atv<$;3~AlWA4=fT%nLfG*WA>4p|3YUon+p~F_Wts z^P*{W!;iM4=LJsK5|(A7YPl_=6*F2fqx-%{3){xEUXq!Piztv8w{3iX%Y0x99|0oX zoyC`=$xfk{`5}(_`r6svZO_hLUz=ZYcJKaN(h)y3J-xhQZZ!u;_7+PSKW!biC+*Yr z8--I=$)2%~Stkch*{|C-3)c!KEcq*ZVV$&I!{2%9okE>Y>M&kD#w&QUkKjJkBAjJ* z%Zyxr8HEMYY(5ZF4?s{CX?mi+e zD@F(f1grcPVMy(LVW=orD@3DAsGxf2;(=M^F&BwdISc7A!#<6Yym!aZWFuf$0DS$f5=u~5-8UvewgD}w@ zxzT|a)%c`pC2klKD z(lDPm6!N+g1VRRI3BdZb6TE~CTYqu%;QuIq9@lz7av9@n1`Ul&T0?+|VY_NgS})u0 z+10{XYusKd9ID&oXw+ Iv^~7|H?c(OjQ{`u diff --git a/simpegMT/Analytics/MT1Dsolutions.pyc b/simpegMT/Analytics/MT1Dsolutions.pyc deleted file mode 100644 index a09951665243eeb14ff2dd56cc4798966470cc62..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1471 zcmb7DO>Y}F5Pi$lw`5DP)y4+gLO^rSDT#reiXgEeD|QbG0@*!OD6rV>QZkkOP?wYw z1-mD=x1#@`hyI-Yjb3{R&>zqaXO+0=tqXBD91b~;?~UBQc3OYF{{1Sz_N&l*LPP&X zCZwN(2$(tVeSw+FzCct#T*a&k$L6_+YKZHY)oEQpSjCSHW(~+D!Wv!)WWOTpU_rqa zq>E)6%MN7AM#3g;>Eazo2g_Z^9W1-JrFaYXXFbS!kYp*khp>%T4xS{8>~gq6DAnKe zy%;*=nl_n*G~2rtjUez()Es>NG|)I57v7Kv97q6aq^ZHbPHv zV5<0}Pk@Rl$7;wOi?1N3f@K|f6@BvhVI8J{Ws_EdMh*Rgf_CdD8Tm=vIdg%-qVe%w z&C<3I;JqeH%T}XObeX-j&BZ&G&qHF30NhsaT?Iu8MH@v2#SU^h)5iT`mru}o7r9$r z*hSt%JMW@j^!Sam)!=8`Lr%XQZS1{2*5xYs9w?u{AI@EZyN`Sym&1l->;akQ>m)EL zO$H_%5bJ~Evw@6cU@{f>(V&#z1L+$&@UQRPv+WK}l$DNER5sy1i8vW{DQcQzk~H+A z^UM!TjaFL4E4d(TfNzY7G%wA?`xDE`-3|tvO zHd*nsQd3%3wE;iN{0*^A_t1;d?8O^S$viH7nMOA<8`>V?TJdpMR#%JIH@3aznf!q< z>vWw3@-$v?y>m{V#A{BPXtm(*DThy$+RiCg8HZk!zAoMM2lwJGdQnC#%CSier`Y#= zAMicdwKlfJ>0VDIHyo2x!#-RN$$*Xig1nN<$iA5j(b`I^AFej0 zLwQ8x@!7c4*7Br}$e_}6KNDT?Kpcr9_e-bc?2ESOIxX?JU=BSm_Eq9}Tg|^cQG0ZX zfs7Vk{rvckUpC{Xtp3pA|2S=E1!Q`Yb-db4Z6}l}sQBghd}_sJY!50yuBbv^E^QrR>J7FNl diff --git a/simpegMT/Analytics/__init__.py b/simpegMT/Analytics/__init__.py deleted file mode 100644 index 92f785d8..00000000 --- a/simpegMT/Analytics/__init__.py +++ /dev/null @@ -1 +0,0 @@ -from MT1Dsolutions import * # Add the names of the functions diff --git a/simpegMT/Analytics/__init__.pyc b/simpegMT/Analytics/__init__.pyc deleted file mode 100644 index da509dadc3c41d94fc096248d813508ddd2a7de8..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 161 zcmZSn%*(~B!WELt00m4y+5w1*`G7