def simulate(synmodel, ab2=None, mn2=None, errPerc=3.): """Forward calculation with optional noise Simulates a synthetic data set of a vertical electric sounding and appends gaussian distributed noise. Block only for now. Parameters ---------- ab2: array_like Vector of distances between the point of the sounding and the current electrodes. mn2: array_like [ab2/3] Vector of distances between the point of the sounding and the potential electrodes. errPerc: float [3.] Percentage Value for the gaussian noise. Default are 3 %. """ thk = synmodel[0] res = synmodel[1] if mn2 is None: mn2 = ab2 / 3 FOP = pg.DC1dModelling(len(res), ab2, mn2) syndata = FOP.response(thk + res) syndata = syndata * (pg.randn(len(syndata)) * errPerc / 100. + 1.) return syndata
def __init__(self, nlay, ab2, mn2, freq, coilspacing, verbose=False): """Init number of layers, AB/2, MN/2, frequencies & coil spacing.""" pg.ModellingBase.__init__(self, verbose) self.nlay_ = nlay self.fDC_ = pg.DC1dModelling(nlay, ab2, mn2, verbose) self.fEM_ = pg.FDEM1dModelling(nlay, freq, coilspacing, verbose) self.mesh_ = pg.createMesh1DBlock(nlay) self.setMesh(self.mesh_)
def response_mt(self, par, i=0): if self.am is not None and self.bm is not None: nLayer = (len(par) + 1) // 2 fop = pg.DC1dModelling(nLayer, self.am, self.bm, self.an, self.bn) else: raise Exception("I have no data basis .. " "don't know what to calculate.") return fop.response(par)
def createFOP(self): """Creates the forward operator instance.""" if self.type == 'block': self.FOP = pg.DC1dModelling(self.Z, self.ab2, self.mn2) mesh1D = pg.createMesh1DBlock(self.Z) if self.type == 'smooth': self.FOP = pg.DC1dRhoModelling(self.Z, self.ab2, self.mn2) mesh1D = pg.createMesh1D(nCells=len(self.Z) + 1) self.FOP.setMesh(mesh1D) self.applyModelTrans()
import numpy as np import matplotlib.pyplot as plt import pygimli as pg from pygimli.mplviewer import drawModel1D ############################################################################### # some definitions before (model, data and error) nlay = 4 # number of layers lam = 200. # (initial) regularization parameter errPerc = 10. # relative error of 3 percent ab2 = np.logspace(-1, 2, 50) # AB/2 distance (current electrodes) mn2 = ab2 / 3. # MN/2 distance (potential electrodes) ############################################################################### # initialize the forward modelling operator f = pg.DC1dModelling(nlay, ab2, mn2) ############################################################################### # other ways are by specifying a Data Container or am/an/bm/bn distances synres = [100., 500., 20., 800.] # synthetic resistivity synthk = [0.5, 3.5, 6.] # synthetic thickness (nlay-th layer is infinite) ############################################################################### # the forward operator can be called by f.response(model) or simply f(model) rhoa = f(synthk + synres) rhoa = rhoa * (pg.randn(len(rhoa)) * errPerc / 100. + 1.) ############################################################################### # create some transformations used for inversion transThk = pg.RTransLog() # log-transform ensures thk>0 transRho = pg.RTransLogLU(1, 1000) # lower and upper bound transRhoa = pg.RTransLog() # log transformation for data ############################################################################### # set model transformation for thickness and resistivity
############################################################################### # We import numpy numerics, mpl plotting, pygimli and the 1D plotting function import numpy as np import matplotlib.pyplot as plt import pygimli as pg from pygimli.mplviewer import drawModel1D ############################################################################### ############################################################################### # initialize the forward modelling operator and compute synthetic noisy data synres = [100., 500., 20., 800.] # synthetic resistivity synthk = [4, 6, 10] # synthetic thickness (lay layer is infinite) ab2 = np.logspace(-1, 2, 25) # 0.1 to 100 in 25 steps (8 points per decade) fBlock = pg.DC1dModelling(len(synres), ab2, ab2 / 3) rhoa = fBlock(synthk + synres) # The data are noisified using a errPerc = 3. # relative error of 3 percent rhoa = rhoa * (pg.randn(len(rhoa)) * errPerc / 100. + 1.) ############################################################################### # The forward operator can be called by f.response(model) or simply f(model) thk = np.logspace(-0.5, 0.5, 30) f = pg.DC1dRhoModelling(thk, ab2, ab2 / 3) ############################################################################### # Create some transformations used for inversion transRho = pg.RTransLogLU(1, 1000) # lower and upper bound transRhoa = pg.RTransLog() # log transformation also for data ############################################################################### # Set up inversion inv = pg.RInversion(rhoa, f, transRhoa, transRho, False) # data vector, f, ...
invEM = g.RInversion(dataEM, fEM, transEM, verbose) modelEM = g.RVector(nlay * 2 - 1, 50.) invEM.setModel(modelEM) invEM.setAbsoluteError(noiseEM) invEM.setLambda(lamEM) invEM.setMarquardtScheme(0.9) modelEM = invEM.run() respEM = invEM.response() # DC forward operator and synthetic data ab2 = g.RVector(20, 3.) na = len(ab2) mn2 = g.RVector(na, 1.0) for i in range(na - 1): ab2[i + 1] = ab2[i] * 1.3 fDC = g.DC1dModelling(nlay, ab2, mn2) dataDC = fDC(model) for i in range(len(dataDC)): dataDC[i] *= 1. + P.randn(1)[0] * noiseDC / 100. fDC.region(0).setTransModel(transThk) fDC.region(1).setTransModel(transRes) # independent DC inversion invDC = g.RInversion(dataDC, fDC, transRhoa, verbose) modelDC = g.RVector(nlay * 2 - 1, 20.) invDC.setModel(modelDC) invDC.setRelativeError(noiseDC / 100.) invDC.setLambda(lamDC) invDC.setMarquardtScheme(0.9) modelDC = invDC.run() respDC = invDC.response()
def __init__(self, nlay, K, z, t, ab2, mn2, verbose=False): self.nlay_ = nlay mesh = pg.createMesh1DBlock(nlay, 3) # 3 paramaters: thk,wc,t2,res pg.ModellingBase.__init__(self, mesh) self.fMRS = MRS1dBlockQTModelling(nlay, K, z, t) self.fVES = pg.DC1dModelling(nlay, ab2, mn2)
def runEMO(self, nlay=5, pop_size=100, max_generations=100): """ Run evolutionary multi-objective optimization (EMO) Run EMO using inspyred for now fixed to NSGA-II algorithm after Deb (2002) TODO (cite correctly) (non-dominated sorting genetic algorithm) """ import inspyred def genMods(individual): """generate MRS and VES models from unit vector""" model = individual * (self.lUB - self.lLB) + self.lLB # model = pg.asvector(individual) * (self.lUB - self.lLB) + self.lLB if self.logpar: model = pg.exp(model) modMRS = model(0, nlay * 3 - 1) modVES = pg.cat(model(0, nlay - 1), model(nlay * 3 - 1, nlay * 4 - 1)) return modMRS, modVES def mygenerate(random, args): """generate a random vector of model size""" return [random.random() for i in range(nlay * 4 - 1)] @inspyred.ec.evaluators.evaluator def datafit(individual, args): """return data fits for MRS and VES as Pareto object""" modMRS, modVES = genMods(individual) MRSmisfit = (self.data - self.f(modMRS)) / self.error VESmisfit = (np.log(self.rhoa) - np.log(self.fVES(modVES))) / np.log(1.02) return inspyred.ec.emo.Pareto( [np.mean(MRSmisfit**2), np.mean(VESmisfit**2)]) self.createFOP(nlay) self.fVES = pg.DC1dModelling(nlay, self.ab2, self.mn2) lowerBound = pg.cat( pg.cat(pg.RVector(nlay - 1, self.lowerBound[0]), pg.RVector(nlay, self.lowerBound[1])), pg.cat(pg.RVector(nlay, self.lowerBound[2]), pg.RVector(nlay, self.lowerBound[3]))) upperBound = pg.cat( pg.cat(pg.RVector(nlay - 1, self.upperBound[0]), pg.RVector(nlay, self.upperBound[1])), pg.cat(pg.RVector(nlay, self.upperBound[2]), pg.RVector(nlay, self.upperBound[3]))) if self.logpar: self.lLB, self.lUB = pg.log(lowerBound), pg.log( upperBound) # ready mapping functions else: self.lLB, self.lUB = lowerBound, upperBound rand = random.Random() rand.seed(int(time.time())) ea = inspyred.ec.emo.NSGA2(rand) ea.variator = [ inspyred.ec.variators.blend_crossover, inspyred.ec.variators.gaussian_mutation ] ea.terminator = inspyred.ec.terminators.generation_termination ea.observer = [ inspyred.ec.observers.stats_observer, inspyred.ec.observers.file_observer ] self.pop = ea.evolve(evaluator=datafit, generator=mygenerate, maximize=False, bounder=inspyred.ec.Bounder(0., 1.), pop_size=pop_size, max_generations=max_generations)