def tapeMeasureToCoordinates(tape, pos): """Interpolate 2D tape measured topography to 2D Cartesian coordinates. Tape and pos value are expected to be sorted along distance to the origin. DEPRECATED will be removed use :py:mod:`pygimli.meshtools.interpolateAlongCurve` instead TODO optional smooth curve with harmfit TODO parametric TODO parametric + Topo: 3d Parameters ---------- tape : [[x,z]] | [RVector3] | R3Vector List of tape measured topography points with measured distance (x) from origin and height (z) pos : iterable Array of query positions along the tape measured profile t[0 .. Returns ------- res : ndarray(N, 2) Same as pos but with interpolated height values. The Distance between pos points and res (along curve) points remains. """ pg.deprecated("tapeMeasureToCoordinates", "interpolateAlongCurve") return interpolateAlongCurve(tape, pos)
def tapeMeasureToCoordinates(tape, pos): """Interpolate 2D tape measured topography to 2D Cartesian coordinates. Tape and pos value are expected to be sorted along distance to the origin. DEPRECATED will be removed use :py:mod:`pygimli.meshtools.interpolateAlongCurve` instead TODO optional smooth curve with harmfit TODO parametric TODO parametric + Topo: 3d Parameters ---------- tape : [[x,z]] | [RVector3] | R3Vector List of tape measured topography points with measured distance (x) from origin and height (z) pos : iterable Array of query positions along the tape measured profile t[0 .. Returns ------- res : ndarray(N, 2) Same as pos but with interpolated height values. The Distance between pos points and res (along curve) points remains. """ pg.deprecated("tapeMeasureToCoordinates", "interpolateAlongCurve") return interpolateAlongCurve(tape, pos)
def randN(n, minVal=0.0, maxVal=1.0): """Create RVector of length n with normally distributed random numbers.""" pg.deprecated('not needed') # 20200515 r = pg.Vector(n) pg.math.randn(r) r *= (maxVal - minVal) r += minVal return r
def plotFirstPicks(ax, data, tt=None, plotva=False, marker='x-'): """Naming convention. drawFOO(ax, ... ).""" pg.deprecated("use drawFirstPicks") return drawFirstPicks(ax=ax, data=data, tt=tt, plotva=plotva, marker=marker)
def plotSpectrum(ax, freq, vals, ylabel=r'$-\phi$ (mrad)', grid=True, marker='+', ylog=True, **kwargs): """Plot some spectrum (redundant). DEPRECATED """ pg.deprecated('drawSpectrum') if 'label' not in kwargs: kwargs['label'] = 'obs' ax.loglog(freq, vals, marker=marker, **kwargs) if ylog: ax.set_yscale('log') ax.set_xlabel('f (Hz)') ax.set_ylabel(ylabel) ax.grid(grid)
def plotSpectrum(ax, freq, vals, ylabel=r'$-\phi$ (mrad)', grid=True, marker='+', ylog=True, **kwargs): """Plot some spectrum (redundant). DEPRECATED """ pg.deprecated('drawSpectrum') if 'label' not in kwargs: kwargs['label'] = 'obs' ax.loglog(freq, vals, marker=marker, **kwargs) if ylog: ax.set_yscale('log') ax.set_xlabel('f (Hz)') ax.set_ylabel(ylabel) ax.grid(grid)
def opt_import(*args, **kwargs): pg.deprecated() return optImport(*args, **kwargs)
def solveFiniteVolume(mesh, a=1.0, b=0.0, f=0.0, fn=0.0, vel=None, u0=0.0, times=None, uL=None, relax=1.0, ws=None, scheme='CDS', **kwargs): r"""Solve partial differential equation with Finite Volumes. This function is a syntactic sugar proxy for using the Finite Volume functionality of the library core to solve elliptic and parabolic partial differential of the following type: .. math:: \frac{\partial u}{\partial t} + \mathbf{v}\cdot\nabla u & = \nabla\cdot(a \nabla u) + b u + f(\mathbf{r},t)\\ u(\mathbf{r}, t) & = u_B \quad\mathbf{r}\in\Gamma_{\text{Dirichlet}}\\ \frac{\partial u(\mathbf{r}, t)}{\partial \mathbf{n}} & = u_{\partial \text{B}} \quad\mathbf{r}\in\Gamma_{\text{Neumann}}\\ u(\mathbf{r}, t=0) & = u_0 \quad\text{with} \quad\mathbf{r}\in\Omega The Domain :math:`\Omega` and the Boundary :math:`\Gamma` are defined through the given mesh with appropriate boundary marker. The solution :math:`u(\mathbf{r}, t)` is given for each cell in the mesh. TODO: * Refactor with solver class and Runga-Kutte solver * non steady boundary conditions Parameters ---------- mesh: :gimliapi:`GIMLI::Mesh` Mesh represents spatial discretization of the calculation domain a: value | array | callable(cell, userData) Stiffness weighting per cell values. b: value | array | callable(cell, userData) Scale for mass values b f: iterable(cell) Load vector fn: iterable(cell) TODO What is fn vel: ndarray (N,dim) | RMatrix(N,dim) Velocity field :math:`\mathbf{v}(\mathbf{r}, t=\text{const}) = \{[v_i]_j,\}` with :math:`i=[1\ldots 3]` for the mesh dimension and :math:`j = [0\ldots N-1]` with N either the amount of cells, nodes, or boundaries. Velocities per boundary are preferred and will be interpolated on demand. u0: value | array | callable(cell, userData) Starting field times: iterable Time steps to calculate for. ws Workspace This can be an empty class that will used as an Workspace to store and cache data. If ws is given: The system matrix is taken from ws or calculated once and stored in ws for further usage. The system matrix is cached in this Workspace as ws.S The LinearSolver with the factorized matrix is cached in this Workspace as ws.solver The rhs vector is only stored in this Workspace as ws.rhs scheme: str [CDS] Finite volume scheme: :py:mod:`pygimli.solver.diffusionConvectionKernel` **kwargs: * bc : Boundary Conditions dictionary, see pg.solver * uB : Dirichlet boundary conditions DEPRECATED * duB : Neumann boundary conditions DEPRECATED Returns ------- u: ndarray(nTimes, nCells) Solution field for all time steps. """ verbose = kwargs.pop('verbose', False) # The Workspace is to hold temporary data or preserve matrix rebuild # swatch = pg.core.Stopwatch(True) sparse = True workspace = pg.solver.WorkSpace() if ws: workspace = ws a = pg.solver.parseArgToArray(a, [mesh.cellCount(), mesh.boundaryCount()]) b = pg.solver.parseArgToArray(b, mesh.cellCount()) f = pg.solver.parseArgToArray(f, mesh.cellCount()) fn = pg.solver.parseArgToArray(fn, mesh.cellCount()) boundsDirichlet = None boundsNeumann = None # BEGIN check for Courant-Friedrichs-Lewy if vel is not None: if isinstance(vel, float): print("Warning! .. velocity is float and no vector field") # we need velocities for boundaries if len(vel) is not mesh.boundaryCount(): if len(vel) == mesh.cellCount(): vel = pg.meshtools.cellDataToNodeData(mesh, vel) if len(vel) == mesh.nodeCount(): vel = pg.meshtools.nodeDataToBoundaryData(mesh, vel) else: print("mesh:", mesh) print("vel:", vel.shape) raise Exception("Cannot determine data format for velocities") if times is not None: pg.solver.checkCFL(times, mesh, np.max(pg.abs(vel))) if not hasattr(workspace, 'S'): boundsDirichlet = [] if 'bc' in kwargs: bct = dict(kwargs['bc']) if 'Dirichlet' in bct: boundsDirichlet += pg.solver.parseArgToBoundaries( bct.pop('Dirichlet'), mesh) if 'Node' in bct: n = bct.pop('Node') boundsDirichlet.append([mesh.node(n[0]), n[1]]) if 'Neumann' in bct: boundsNeumann = pg.solver.parseArgToBoundaries( bct.pop('Neumann'), mesh) if 'uB' in kwargs: pg.deprecated('use new bc dictionary') boundsDirichlet = pg.solver.parseArgToBoundaries( kwargs['uB'], mesh) if 'duB' in kwargs: pg.deprecated('use new bc dictionary') boundsNeumann = pg.solver.parseArgToBoundaries(kwargs['duB'], mesh) workspace.S, workspace.rhsBCScales = diffusionConvectionKernel( mesh=mesh, a=a, b=b, uB=boundsDirichlet, duB=boundsNeumann, # u0=u0, fn=fn, vel=vel, scheme=scheme, sparse=sparse, userData=kwargs.pop('userData', None)) dof = len(workspace.rhsBCScales) workspace.ap = np.zeros(dof) # for nonlinears if uL is not None: for i in range(dof): val = 0.0 if sparse: val = workspace.S.getVal(i, i) / relax workspace.S.setVal(i, i, val) else: val = workspace.S[i, i] / relax workspace.S[i, i] = val workspace.ap[i] = val # print('FVM kernel 2:', swatch.duration(True)) # endif: not hasattr(workspace, 'S'): workspace.rhs = np.zeros(len(workspace.rhsBCScales)) workspace.rhs[0:mesh.cellCount()] = f # * mesh.cellSizes() workspace.rhs += workspace.rhsBCScales # for nonlinear: relax progress with scaled last result if uL is not None: workspace.rhs += (1. - relax) * workspace.ap * uL # print('FVM: Prep:', swatch.duration(True)) if not hasattr(times, '__len__'): if sparse and not hasattr(workspace, 'solver'): Sm = pg.matrix.SparseMatrix(workspace.S) # hold Sm until we have reference counting, # loosing Sm here will kill LinSolver later workspace.Sm = Sm workspace.solver = pg.core.LinSolver(Sm, verbose=verbose) u = None if sparse: u = workspace.solver.solve(workspace.rhs) else: u = np.linalg.solve(workspace.S, workspace.rhs) # print('FVM solve:', swatch.duration(True)) return u[0:mesh.cellCount():1] else: theta = kwargs.pop('theta', 0.5 + 1e-6) if sparse: I = pg.solver.identity(len(workspace.rhs)) else: I = np.diag(np.ones(len(workspace.rhs))) progress = None if verbose: from pygimli.utils import ProgressBar progress = ProgressBar(its=len(times)) print("Solve timesteps with Crank-Nicolson.") return pg.solver.crankNicolson(times, theta, workspace.S, I, f=workspace.rhs, u0=pg.solver.cellValues(mesh, u0), progress=progress)
def plotMatrix(mat, *args, **kwargs): """Naming conventions. Use drawDataMatrix or showDataMatrix""" pg.deprecated("use drawDataMatrix or showMatrix") return showDataMatrix(*args, **kwargs)
def opt_import(*args, **kwargs): pg.deprecated() return optImport(*args, **kwargs)
def _getOffset(data, full=False): """Return vector of offsets (in m) between shot and receiver.""" pg.deprecated('use shotReceiverDistances') # 190429 ?? return shotReceiverDistances(data, full)
def showAmplitudeSpectrum(*args, **kwargs): pg.deprecated('drawAmplitudeSpectrum') return drawAmplitudeSpectrum(*args, **kwargs)
def showPhaseSpectrum(*args, **kwargs): pg.deprecated('drawPhaseSpectrum') return drawPhaseSpectrum(*args, **kwargs)
def createfolders(foldername_list): pg.deprecated("use createFolders") #190520 return createFolders(foldername_list)
import pygimli as pg from ..viewer.mpl import * pg.deprecated("Please use pygimli.viewer.mpl instead of pygimli.mplviewer.", "The latter will be removed in pyGIMLi 1.2.")
def ColeColeRho(f, rho, m, tau, c, a=1): pg.deprecated("Please use modelColeColeRho instead of ColeColeRho.") return modelColeColeRho(f, rho, m, tau, c, a)
def plotVecMatrix(xvec, yvec, vals, full=False, **kwargs): """DEPRECATED for nameing """ pg.deprecated('plotVecMatrix', 'showVecMatrix') return showVecMatrix(xvec, yvec, vals, full, **kwargs)
def opt_import(*args, **kwargs): pg.deprecated() # last vis: 20190903 return optImport(*args, **kwargs)
def ColeColeSigma(f, sigma, m, tau, c, a=1): pg.deprecated("Please use modelColeColeSigma instead of ColeColeSigma.") return modelColeColeSigma(f, sigma, m, tau, c, a)
def DebyeRelaxation(f, tau, m): pg.deprecated("Please use relaxationDebye instead of DebyeRelaxation.") return relaxationDebye(f, tau, m)
def showPhaseSpectrum(*args, **kwargs): pg.deprecated('drawPhaseSpectrum') return drawPhaseSpectrum(*args, **kwargs)
def WarbugRelaxation(f, tau, m): pg.deprecated("Please use relaxationWarbug instead of WarbugRelaxation.") return relaxationWarbug(f, tau, m)
def showAmplitudeSpectrum(*args, **kwargs): pg.deprecated('drawAmplitudeSpectrum') return drawAmplitudeSpectrum(*args, **kwargs)
def ColeColeEpsilon(f, e0, eInf, tau, alpha): pg.deprecated("Use modelColeColeEpsilon instead of ColeColeEpsilon.") return modelColeColeEpsilon(f, e0, eInf, tau, alpha)
def drawDataMatrix(ax, mat, xmap=None, ymap=None, cMin=None, cMax=None, logScale=None, label=None, **kwargs): """Draw previously generated (generateVecMatrix) matrix. Parameters ---------- ax : mpl.axis axis to plot, if not given a new figure is created mat : numpy.array2d matrix to show xmap : dict {i:num} dict (must match A.shape[0]) ymap : iterable vector for x axis (must match A.shape[0]) cMin/cMax : float minimum/maximum color values logScale : bool logarithmic colour scale [min(A)>0] label : string colorbar label """ if xmap is None: xmap = {i: i for i in range(mat.shape[0])} if ymap is None: ymap = {i: i for i in range(mat.shape[1])} if isinstance(mat, np.ma.MaskedArray): mat_ = mat else: mat_ = np.ma.masked_where(mat == 0.0, mat, False) if cMin is None: cMin = np.min(mat_) if cMax is None: cMax = np.max(mat_) if logScale is None: logScale = (cMin > 0.0) if logScale: norm = LogNorm(vmin=cMin, vmax=cMax) else: norm = Normalize(vmin=cMin, vmax=cMax) gci = ax.imshow(mat_, norm=norm, interpolation='nearest') if 'cmap' in kwargs: pg.deprecated('use cMap') # 190422 gci.set_cmap(kwargs.pop('cmap')) if 'cMap' in kwargs: gci.set_cmap(kwargs.pop('cMap')) ax.set_aspect(kwargs.pop('aspect', 1)) ax.grid(True) xt = np.unique(ax.get_xticks().clip(0, len(xmap) - 1)) yt = np.unique(ax.get_xticks().clip(0, len(ymap) - 1)) if kwargs.pop('showally', False): yt = np.arange(len(ymap)) else: yt = np.round(np.linspace(0, len(ymap) - 1, 5)) xx = np.sort([k for k in xmap]) ax.set_xticks(xt) ax.set_xticklabels(['{:g}'.format(round(xx[int(ti)], 2)) for ti in xt]) yy = np.unique([k for k in ymap]) ax.set_yticks(yt) ax.set_yticklabels(['{:g}'.format(round(yy[int(ti)], 2)) for ti in yt]) return gci
def ColeDavidson(f, R, m, tau, a=1): pg.deprecated("Please use modelColeDavidson instead of ColeDavidson.") return modelColeDavidson(f, R, m, tau, a)
def plotDataContainerAsMatrix(*args, **kwargs): "DEPRECATED naming scheme" "" pg.deprecated('plotDataContainerAsMatrix', 'showDataContainerAsMatrix') return showDataContainerAsMatrix(*args, **kwargs)
def ColeColeRhoDouble(f, rho, m1, t1, c1, m2, t2, c2): pg.deprecated("Use modelColeColeRhoDouble instead of ColeColeRhoDouble.") return modelColeColeRhoDouble(f, rho, m1, t1, c1, m2, t2, c2)
def plotVecMatrix(xvec, yvec, vals, full=False, **kwargs): """DEPRECATED for nameing """ pg.deprecated('plotVecMatrix', 'showVecMatrix') return showVecMatrix(xvec, yvec, vals, full, **kwargs)
def linsolve(A, b, verbose=False): """ DEPRECATED wrong name style """ pg.deprecated('linsolve', 'linSolve') return linSolve(A, b, verbose)