def GKtoUTM(ea, no=None, zone=32, gk=None, gkzone=None): """Transform any Gauss-Krueger to UTM autodetect GK zone from offset.""" if gk is None and gkzone is None: if no is None: rr = ea[0][0] else: if isinstance(ea, list) or isinstance(ea, tuple): rr = ea[0] else: rr = ea gkzone = int(floor(rr * 1e-6)) print(gkzone) if gkzone <= 0 or gkzone >= 5: print("cannot detect valid GK zone") pyproj = opt_import('pyproj', 'coordinate transformations') if pyproj is None: return None gk = pyproj.Proj(init="epsg:" + str(31464 + gkzone)) wgs84 = pyproj.Proj(init="epsg:4326") # pure ellipsoid to doubel transform utm = pyproj.Proj(proj='utm', zone=zone, ellps='WGS84') # UTM if no is None: # two-column matrix lon, lat = pyproj.transform(gk, wgs84, ea[0], ea[1]) else: lon, lat = pyproj.transform(gk, wgs84, ea, no) return utm(lon, lat)
def computeInverseRootMatrix(CM, thrsh=0.001, verbose=False): """Compute inverse square root (C^{-0.5} of matrix.""" spl = opt_import('scipy.linalg', 'scipy linear algebra') if spl is None: return None t = time.time() e_vals, e_vecs = spl.eigh(CM) if verbose: print('(C) Calculation time for eigenvalue decomposition:\n%s sec' % (time.time() - t)) t = time.time() A = spl.inv(np.diag(np.sqrt(np.real(e_vals)))) if verbose: print('(C) Calculation time for inv(diag(sqrt)):\n%s sec' % (time.time() - t)) t = time.time() gemm = spl.get_blas_funcs("gemm", [e_vecs, A]) B = gemm(1, e_vecs, A) if verbose: print('(C) Calculation time for dot 1:\n%s sec' % (time.time() - t)) t = time.time() gemm2 = spl.get_blas_funcs("gemm", [B, np.transpose(e_vecs)]) if verbose: print('gemm test:\n%s sec' % (time.time() - t)) CM05 = gemm2(1, B, np.transpose(e_vecs)) if verbose: print('(C) Calculation time for dot 2:\n%s sec' % (time.time() - t)) if thrsh: nModel = len(CM) RCM05 = pg.RSparseMapMatrix(nModel, nModel) for i in range(nModel): for j in range(nModel): if np.abs(CM05[i][j]) > thrsh: RCM05.setVal(i, j, CM05[i][j]) return RCM05 else: return CM05 # not making sense as constraints matrix
def computeR(J, C, alpha=0.5): r"""Return diagional of model resolution matrix. Calculates the formal model resolution matrix deterministically following: .. math:: \mathbf{R_m} = (\mathbf{J}^T\mathbf{D}^T\mathbf{D}\mathbf{J} + \alpha \mathbf{C}^T\mathbf{C})^{-1} \mathbf{J}^T\mathbf{D}^T\mathbf{D}\mathbf{J} .. note:: The current implementation assumes that :math:`\mathbf{D}` is the identitiy matrix, i.e. equal data weights. Parameters ---------- J : array Jacobian matrix. C : array Constraint matrix. alpha : float Regularization strength :math:`\alpha`. """ lin = opt_import("scipy.linalg", "calculate model resolution matrices") if lin: import scipy.sparse as sp from scipy.sparse import coo_matrix, csc_matrix from scipy.sparse.linalg import aslinearoperator, LinearOperator, lsqr JTJ = J.T.dot(J) CM_inv = C.T.dot(C) # Jsharp = lin.solve(JTJ + alpha * CM_inv, J.T) # R = np.diag(Jsharp.dot(J)) RM = lin.solve(JTJ + alpha * CM_inv, JTJ) R = np.diag(RM) return R
def load(self, polyfile): """Read polygon info from XML file (see example.xml).""" ET = opt_import("xml.etree.cElementTree", "read in XML files") self.doc = ET.parse(polyfile) self.parse()
# -*- coding: utf-8 -*- """TODO documentme!. SORT ME. """ from pygimli.io import opt_import json = opt_import("json", "read and write inversion settings") class InversionSettings(dict): """Extends the built-in dict with methods for saving and loading a file.""" def __init__(self, *args, **kwargs): """Constructor. Initialize the settings object by either using a file or sepcifying the settings directly. Works exatly like a dict(), only with extended capabilities like saving and loading to disk. """ try: self.filename = kwargs.pop('filename') except KeyError: print('Creating new settings object.') else: print('Loading settings from: "{}".'.format(self.filename)) finally: super(InversionSettings, self).__init__(*args, **kwargs) if hasattr(self, 'filename'): self.update(InversionSettings.load(self.filename))
""" Methods to calculate the model resolution. """ import numpy as np from pygimli.io import opt_import lin = opt_import("scipy.linalg", "calculate model resolion matrices") if lin: import scipy.sparse as sp from scipy.sparse import coo_matrix, csc_matrix from scipy.sparse.linalg import aslinearoperator, LinearOperator, lsqr def computeR(J, C, alpha=0.5): r"""Return diagional of model resolution matrix. Calculates the formal model resolution matrix deterministically following: .. math:: \mathbf{R_m} = (\mathbf{J}^T\mathbf{D}^T\mathbf{D}\mathbf{J} + \alpha \mathbf{C}^T\mathbf{C})^{-1} \mathbf{J}^T\mathbf{D}^T\mathbf{D}\mathbf{J} .. note:: The current implementation assumes that :math:`\mathbf{D}` is the identitiy matrix, i.e. equal data weights.
def test(target=None, show=False, onlydoctests=False, coverage=False, htmlreport=False, abort=False, verbose=True): """Run docstring examples and additional tests. Examples -------- >>> import pygimli as pg >>> # You can test everything with pg.test() or test an individual function: >>> pg.test("pg.utils.boxprint", verbose=False) >>> # The target argument can also be the function directly >>> from pygimli.utils import boxprint >>> pg.test(boxprint, verbose=False) Parameters ---------- target : function or string, optional Function or method to test. By default everything is tested. show : boolean, optional Show matplotlib windows during test run. They will be closed automatically. onlydoctests : boolean, optional Run test files in ../tests as well. coverage : boolean, optional Create a coverage report. Requires the pytest-cov plugin. htmlreport : str, optional Filename for HTML report such as www.pygimli.org/build_tests.html. Requires pytest-html plugin. abort : boolean, optional Return correct exit code, e.g. abort documentation build when a test fails. """ old_backend = plt.get_backend() if not show: plt.switch_backend("Agg") if target: if isinstance(target, str): # If target is a string, such as "pg.solver.solve" # the code below will overwrite target with the corresponding # imported function, so that doctest works. target = target.replace("pg.", "pygimli.") import importlib mod_name, func_name = target.rsplit('.', 1) mod = importlib.import_module(mod_name) target = getattr(mod, func_name) import doctest doctest.run_docstring_examples(target, globals(), verbose=verbose, optionflags=doctest.ELLIPSIS, name=target.__name__) return try: import pytest except ImportError: raise ImportError("pytest is required to run test suite. " "Try 'sudo pip install pytest'.") cwd = join(realpath(__path__[0]), '..') excluded = [ "gui", "physics/traveltime/example.py", "physics/em/fdemexample.py" ] if onlydoctests: excluded.append("testing") cmd = ([ "-v", "-rsxX", "--color", "yes", "--doctest-modules", "--durations", 5, cwd ]) for directory in excluded: cmd.extend(["--ignore", join(cwd, directory)]) if coverage: pc = opt_import("pytest_cov", "create a code coverage report") if pc: cmd.extend(["--cov", "pygimli"]) cmd.extend(["--cov-report", "term"]) if htmlreport: ph = opt_import("pytest_html", "create a html report") if ph: cmd.extend(["--html", htmlreport]) exitcode = pytest.main(cmd) plt.switch_backend(old_backend) plt.close('all') if abort: sys.exit(exitcode)
#!/usr/bin/env python # -*- coding: utf-8 -*- """Collection of several utility functions.""" import sys from math import floor, sqrt import numpy as np import pygimli as pg from pygimli.io import opt_import coo_matrix = opt_import("scipy.sparse.coo_matrix", "convert sparse matrices to numpy/scipy format.") def sparse2scipy(matrix): """Convert pygimli RSparseMatrix to scipy format. Parameters ---------- matrix : pg.RSpareMatrix Matrix to convert. Returns ------- coo_matrix `matrix` in scipy.sparse.coo_matrix format. """ pass
def test(target=None, show=False, onlydoctests=False, coverage=False, htmlreport=False, abort=False): """Run docstring examples and additional tests. Examples -------- >>> import pygimli as pg >>> from pygimli.utils import boxprint >>> pg.test(boxprint) Parameters ---------- target : function, optional Function or method to test. By default everything is tested. show : boolean, optional Show matplotlib windows during test run. They will be closed automatically. onlydoctests : boolean, optional Run test files in ../tests as well. coverage : boolean, optional Create a coverage report. Requires the pytest-cov plugin. htmlreport : str, optional Filename for HTML report such as www.pygimli.org/build_tests.html. Requires pytest-html plugin. abort : boolean, optional Return correct exit code, e.g. abort documentation build when a test fails. """ old_backend = plt.get_backend() if not show: plt.switch_backend("Agg") if target: import doctest doctest.run_docstring_examples(target, globals()) return try: import pytest except ImportError: raise ImportError("pytest is required to run test suite. " "Try 'sudo pip install pytest'.") cwd = join(realpath(__path__[0]), '..') excluded = [ "gui", "physics/traveltime/example.py", # "physics/em/fdemexample.py" ] if onlydoctests: excluded.append("testing") cmd = ([ "-v", "-rsxX", "--color", "yes", "--doctest-modules", "--durations", 5, cwd ]) for directory in excluded: cmd.extend(["--ignore", join(cwd, directory)]) if coverage: pc = opt_import("pytest_cov", "create a code coverage report") if pc: cmd.extend(["--cov", "pygimli"]) cmd.extend(["--cov-report", "term"]) if htmlreport: ph = opt_import("pytest_html", "create a html report") if ph: cmd.extend(["--html", htmlreport]) exitcode = pytest.main(cmd) plt.switch_backend(old_backend) plt.close('all') if abort: sys.exit(exitcode)
def readHEMData(self, filename, takeevery=1, choosevcp=True): """Read RESOLVE type airborne EM data from .XYZ file.""" self.header = {} keyword = '' i = 0 with open(filename) as f: for i, line in enumerate(f): if line[0] == '/': line = line[1:].strip('\n').replace(',', '').replace('AND', '') try: result = [float(co) for co in line.split()] except: result = line.split() if len(result) == 1: result = result[0] if keyword: if isinstance(keyword, list): for kw, res in zip(keyword, result): self.header[kw] = res else: self.header[keyword] = result keyword = '' else: keyword = result else: break line = f.readline() print(line) # tmp = np.genfromtxt(fname=f, autostrip=True, comments='/', # skip_header=0, dtype=float, names=1, case_sensitive='lower', # missing_values='*', filling_values=-9999, skip_footer=1) tmp = np.genfromtxt(fname=filename, autostrip=True, comments='/', skip_header=i + 1, dtype=float, names=True, case_sensitive='lower', missing_values='*', filling_values=-9999, skip_footer=1) # read properties from header if choosevcp: ivcp = np.nonzero(np.array(self.header['COILGEOMETRY']) == 1)[0] else: ivcp = range(len(self.header['FREQUENCY'])) self.frequencies = np.array(self.header['FREQUENCY'])[ivcp] self.coilSpacing = np.array(self.header['COILSEPERATION'])[ivcp] # read properties from data block names = tmp.dtype.names pyproj = opt_import('pyproj', 'coordinate transformations EM lon,lat values') if 'lon' in names and 'lat' in names and pyproj is not None: utm = pyproj.Proj(proj='utm', zone=32, ellps='WGS84') # projection x, y = utm(tmp['lon'], tmp['lat']) else: x, y = tmp['x'], tmp['y'] self.pos = np.column_stack((x, y))[::takeevery] dx = np.sqrt(np.diff(self.pos[:, 0])**2 + np.diff(self.pos[:, 1])**2) self.x = np.hstack((0., np.cumsum(dx))) self.z = tmp['h_laser'][::takeevery] self.topo = tmp['topo'][::takeevery] IP = np.column_stack([tmp['real_' + str(i + 1)] for i in ivcp]) OP = np.column_stack([tmp['quad_' + str(i + 1)] for i in ivcp]) # better do a decimation or running average here self.IP = IP[::takeevery, :] self.OP = OP[::takeevery, :] self.isActiveFreq = self.frequencies > 0.0 self.activeFreq = np.nonzero(self.isActiveFreq)[0]