Beispiel #1
0
def _display_function(rootname, argv, verbose, mapkwargs):
    """private"""
    targetfile = "%s/_HerrMet.target" % rootname
    paramfile = "%s/_HerrMet.param" % rootname
    runfile = '%s/_HerrMet.run' % rootname
    pngfile = '%s/_HerrMet.png' % rootname
    #HerrLininitfile = '%s/_HerrLin.init' % rootname

    # ------ Initiate the displayer using the target data if exists
    if "-compact" in argv.keys():  # compact mode
        which_displayer = DepthDispDisplayCompact
    else:
        which_displayer = DepthDispDisplay

    if os.path.exists(targetfile):
        rd = which_displayer(targetfile=targetfile)
        d = makedatacoder(
            targetfile, which=Datacoder_log)  # datacoder based on observations
        dobs, _ = d.target()
    else:
        print "no target file found in %s" % rootname
        rd = which_displayer()

    # ------ Display run results if exist
    if os.path.exists(runfile) and ("-plot" in argv.keys()
                                    or "-pdf" in argv.keys()):

        with RunFile(runfile, verbose=verbose) as rundb:
            s = rundb.select('select MODELID from MODELS limit 1')
            if s is not None:
                # --- display best models
                if "-plot" in argv.keys():

                    assert argv["-plot"] == [] or len(
                        argv["-plot"]) == 4  # unexpected argument number
                    if argv["-plot"] == []:
                        plot_mode, plot_limit, plot_llkmin, plot_step = \
                            default_plot_mode, default_plot_limit, \
                            default_plot_llkmin, default_plot_step
                    elif len(argv['-plot']) == 4:
                        plot_mode, plot_limit, plot_llkmin, plot_step = argv[
                            '-plot']
                    else:
                        raise Exception()

                    print "plot : %s, limit %d, llkmin %f, step %d" % (
                        plot_mode, plot_limit, plot_llkmin, plot_step),
                    if plot_mode == "best":
                        chainids, weights, llks, ms, ds = \
                            rundb.getzip(limit=plot_limit,
                                         llkmin=plot_llkmin,
                                         step=plot_step,
                                         algo="METROPOLIS")
                    elif plot_mode == "last":
                        chainids, weights, llks, ms, ds = \
                            rundb.getlastszip(limit=plot_limit,
                                              llkmin=plot_llkmin,
                                              step=plot_step,
                                              algo="METROPOLIS")
                    else:
                        raise Exception('unexpected plot mode %s' % plot_mode)

                    vmin, vmax = llks.min(), llks.max()
                    # colors = values2colors(llks, vmin=vmin, vmax=vmax, cmap=argv['-cmap'])

                    if "-overdisp" in argv.keys():
                        """note : recomputing dispersion with another frequency array might
                                  result in a completely different dispersion curve in case
                                  of root search failure """
                        waves, types, modes, freqs, _ = ds[0]
                        overwaves, overtypes, overmodes, _, _ = zip(*list(
                            groupbywtm(waves, types, modes, freqs,
                                       np.arange(len(freqs)), None, True)))
                        overfreqs = [
                            freqspace(0.6 * min(freqs), 1.4 * max(freqs), 100,
                                      "plog") for _ in xrange(len(overwaves))
                        ]
                        overwaves, overtypes, overmodes, overfreqs = \
                            igroupbywtm(overwaves, overtypes, overmodes, overfreqs)
                        for llk, (mms, dds) in zip(
                                llks[::-1],
                                overdisp(ms[::-1],
                                         overwaves,
                                         overtypes,
                                         overmodes,
                                         overfreqs,
                                         verbose=verbose,
                                         **mapkwargs)):
                            # rd.plotmodel(color=clr, alpha=1.0, linewidth=3, *mms)
                            rd.addmodel(colorvalue=llk, *mms)
                            try:
                                # rd.plotdisp(color=clr, alpha=1.0, linewidth=3, *dds)
                                rd.adddisp(colorvalue=llk, *dds)
                            except KeyboardInterrupt:
                                raise
                            except Exception as e:
                                print "Error : could not plot dispersion curve (%s)" % str(
                                    e)

                        # cb = makecolorbar(vmin=vmin, vmax=vmax, cmap=argv['-cmap'])
                        # pos = rd.axdisp[-1].get_position()
                        # cax = rd.fig.add_axes((pos.x0, 0.12, pos.width, 0.01))
                        # rd.fig.colorbar(cb, cax=cax, label="log likelyhood", orientation="horizontal")

                    else:
                        "display the dispersion curves as stored in the database"
                        for i in range(len(llks))[::-1]:
                            # rd.plotmodel(color=colors[i], alpha=1.0, linewidth=3, *ms[i])
                            # rd.plotdisp(color=colors[i], alpha=1.0, linewidth=3, *ds[i])
                            rd.addmodel(colorvalue=llks[i], *ms[i])
                            rd.adddisp(colorvalue=llks[i], *ds[i])
                        # cb = makecolorbar(vmin=vmin, vmax=vmax, cmap=argv['-cmap'])
                        # pos = rd.axdisp[-1].get_position()
                        # cax = rd.fig.add_axes((pos.x0, 0.12, pos.width, 0.01))
                        # rd.fig.colorbar(cb, cax=cax, label="log likelyhood", orientation="horizontal")
                        # cax.set_xticklabels(cax.get_xticklabels(), rotation=90., horizontalalignment="center")

                    rd.showdispcoll(vmin=vmin,
                                    vmax=vmax,
                                    cmap=argv['-cmap'],
                                    alpha=1.0,
                                    linewidth=3)
                    rd.showdepthcoll(vmin=vmin,
                                     vmax=vmax,
                                     cmap=argv['-cmap'],
                                     alpha=1.0,
                                     linewidth=3)
                    rd.colorbar(vmin=vmin,
                                vmax=vmax,
                                cmap=argv['-cmap'],
                                label="log likelyhood",
                                orientation="horizontal")
                    print rd.cax.get_position()
                    rd.cax.set_xticklabels(rd.cax.get_xticklabels(),
                                           rotation=90.,
                                           horizontalalignment="center")

                # ---- display posterior pdf
                if "-pdf" in argv.keys():

                    assert argv["-pdf"] == [] or len(
                        argv["-pdf"]) == 4  # unexpected argument number
                    if argv["-pdf"] == []:
                        pdf_mode, pdf_limit, pdf_llkmin, pdf_step = \
                            default_pdf_mode, default_pdf_limit, default_pdf_llkmin, default_pdf_step
                    elif len(argv['-pdf']) == 4:
                        pdf_mode, pdf_limit, pdf_llkmin, pdf_step = argv[
                            '-pdf']
                    else:
                        raise Exception()

                    print "pdf : %s, limit %d, llkmin %f, step %d" % (
                        pdf_mode, pdf_limit, pdf_llkmin, pdf_step),
                    if pdf_mode == "best":
                        chainids, weights, llks, ms, ds = \
                            rundb.getzip(limit=pdf_limit,
                                         llkmin=pdf_llkmin,
                                         step=pdf_step,
                                         algo="METROPOLIS")
                    elif pdf_mode == "last":
                        chainids, weights, llks, ms, ds = \
                            rundb.getlastszip(limit=pdf_limit,
                                              llkmin=pdf_llkmin,
                                              step=pdf_step,
                                              algo="METROPOLIS")
                    else:
                        raise Exception('unexpected pdf mode %s' % pdf_mode)

                    dms = [
                        depthmodel_from_arrays(ztop, vp, vs, rh)
                        for ztop, vp, vs, rh in ms
                    ]

                    # display percentiles of model and data pdfs
                    clr = "b" if "-plot" not in argv.keys() else "k"
                    alp = 1.0 if "-plot" not in argv.keys() else 0.5

                    for p, (vppc, vspc, rhpc, prpc) in \
                            dmstats1(dms,
                                     percentiles=[0.01, 0.16, 0.5, 0.84, 0.99],
                                     Ndepth=100,
                                     Nvalue=100,
                                     weights=weights,
                                     **mapkwargs):
                        try:
                            l = 3 if p == 0.5 else 1
                            for what, where in zip([vppc, vspc, rhpc, prpc], [
                                    rd.axdepth['VP'], rd.axdepth['VS'],
                                    rd.axdepth['RH'], rd.axdepth['PR']
                            ]):
                                if where is not None:
                                    what.show(where,
                                              color=clr,
                                              linewidth=l,
                                              alpha=alp)

                        except KeyboardInterrupt:
                            raise
                        except Exception as e:
                            print "Error", str(e)

                    # display the disp pdf
                    for p, (wpc, tpc, mpc, fpc, vpc) in \
                            dispstats(ds,
                                      percentiles=[0.01, 0.16, 0.5, 0.84, 0.99],
                                      Ndisp=100,
                                      weights=weights,
                                      **mapkwargs):
                        try:
                            l = 3 if p == 0.5 else 1
                            rd.plotdisp(wpc,
                                        tpc,
                                        mpc,
                                        fpc,
                                        vpc,
                                        dvalues=None,
                                        color=clr,
                                        alpha=alp,
                                        linewidth=l)

                        except KeyboardInterrupt:
                            raise
                        except Exception as e:
                            print "Error", str(e)

    # ------
    if os.path.exists(paramfile):
        p, _ = load_paramfile(paramfile)
        showvp, showvs, showrh, showpr = True, True, True, True
        if isinstance(p, Parameterizer_mZVSVPRH):
            showpr = False
        elif isinstance(p, Parameterizer_mZVSPRRH):
            showvp = False
        elif isinstance(p, Parameterizer_mZVSPRzRHvp):
            showvp = showpr = showrh = False
        elif isinstance(p, Parameterizer_mZVSPRzRHz):
            showvp = showpr = showrh = False
        else:
            raise Exception('')

        #
        vplow, vphgh, vslow, vshgh, rhlow, rhhgh, prlow, prhgh = p.boundaries()

        for what, where in zip(\
                [vplow, vphgh, vslow, vshgh, rhlow, rhhgh, prlow, prhgh],
                [rd.axdepth['VP'], rd.axdepth['VP'], rd.axdepth['VS'], rd.axdepth['VS'], rd.axdepth['RH'], rd.axdepth['RH'], rd.axdepth['PR'], rd.axdepth['PR']]):
            if where is not None:
                what.show(where,
                          alpha=1.0,
                          color="k",
                          marker="o--",
                          linewidth=1,
                          markersize=3)
        zmax = 1.1 * p.inv(p.MINF)[0][-1]

        if isinstance(p, Parameterizer_mZVSPRzRHvp):
            rd.axdepth['PR'].plot(p.PRz(np.linspace(0., zmax, 100)),
                                  np.linspace(0., zmax, 100),
                                  "r--",
                                  linewidth=3)
            legendtext(rd.axdepth['PR'], p.PRzName, loc=4)
            legendtext(rd.axdepth['RH'], p.RHvpName, loc=4)
        elif isinstance(p, Parameterizer_mZVSPRzRHz):
            rd.axdepth['PR'].plot(p.PRz(np.linspace(0., zmax, 100)),
                                  np.linspace(0., zmax, 100),
                                  "r--",
                                  linewidth=3)
            rd.axdepth['RH'].plot(p.RHz(np.linspace(0., zmax, 100)),
                                  np.linspace(0., zmax, 100),
                                  "r--",
                                  linewidth=3)
            legendtext(rd.axdepth['PR'], p.PRzName, loc=4)
            legendtext(rd.axdepth['RH'], p.RHzName, loc=4)

        rd.set_zlim(np.array([0, zmax]))
    else:
        print "call option --param to see prior depth boundaries"

    # --------------------
    if "-m96" in argv.keys():  # plot user data on top
        for m96 in argv['-m96']:
            try:
                dm = depthmodel_from_mod96(m96)
                dm.vp.show(rd.axdepth['VP'], "m", linewidth=3, label=m96)
                dm.vs.show(rd.axdepth['VS'], "m", linewidth=3)
                dm.rh.show(rd.axdepth['RH'], "m", linewidth=3)
                dm.pr().show(rd.axdepth['PR'], "m", linewidth=3)
            except KeyboardInterrupt:
                raise
            except:  #Exception as e:
                print 'could not read or display %s (reason : %s)' % (m96,
                                                                      str(e))
            rd.axdepth['VP'].legend(loc=3)
    if "-ritt" in argv.keys():
        a = AsciiFile('/mnt/labex2/home/max/data/boreholes/GRT1/GRT1.logsonic')

        for what, where in zip(
            [a.data['VS'], a.data['VP'], a.data['VP'] / a.data['VS']],
            [rd.axdepth['VS'], rd.axdepth['VP'], rd.axdepth['PR']]):
            if where is not None:
                where.plot(what, a.data['TVD'] / 1000., "m", alpha=0.5)

    # --------------------
    if os.path.exists(targetfile):
        # plot data on top
        rd.plotdisp(d.waves,
                    d.types,
                    d.modes,
                    d.freqs,
                    d.inv(dobs),
                    dvalues=d.dvalues,
                    alpha=.5,
                    color="r",
                    linewidth=2)

        if "-overdisp" in argv.keys():
            rd.set_vlim((0.5 * d.values.min(), 1.5 * d.values.max()))
            rd.set_plim((0.8 / overfreqs.max(), 1.2 / overfreqs.min()))
        else:
            rd.set_vlim((0.8 * d.values.min(), 1.2 * d.values.max()))
            rd.set_plim((0.8 / d.freqs.max(), 1.2 / d.freqs.min()))
    rd.tick()
    rd.grid()
    rd.fig.suptitle(rootname.split('_HerrMet_')[-1])
    if "-ftsz" in argv.keys():
        chftsz(rd.fig, argv["-ftsz"][0])
    else:
        chftsz(rd.fig, default_fontsize)
    if "-png" in argv.keys():
        dpi = argv['-png'][0] if len(argv['-png']) else default_dpi
        if verbose:
            print "writing %s" % pngfile
        rd.fig.savefig(pngfile, dpi=dpi)
    elif "-inline" in argv.keys():
        plt.show()
    else:
        showme()
    plt.close(rd.fig)
Beispiel #2
0
def sker17(ztop, vp, vs, rh, \
    waves, types, modes, freqs,
    dz=0.001, dlogvs=0.01, dlogpr=0.01, dlogrh=0.01, norm=True,
    h = 0.005, dcl = 0.005, dcr = 0.005):
    """sker17 : compute finite difference sensitivity kernels for surface waves dispersion curves 
    input: 
        -> depth model
        ztop, vp, vs, rh  : lists or arrays, see dispersion

        -> required dispersion points
        waves, types, modes, freqs : lists or arrays, see dispersion

        -> sensitivity kernel computation
        dz = depth increment in km
        dlogvs = increment to apply to the logarithm of vs
        dlogpr = increment to apply to the logarithm of vp/vs
        dlogrh = increment to apply to the logarithm of rho
        norm = if True, I divide the sensitivity values by the thickness of each layer
                => this corrects for the difference of sensitivity due to the variable thicknesss

        -> Herrmann's parameters, see CPS documentation
        h, dcl, dcr = passed to dispersion

    output:
        -> yields a tuple (w, t, m, F, DLOGVADZ, DLOGVADLOGVS, DLOGVADLOGPR, DLOGVADLOGRH) for each wave, type and mode
        w      = string, wave letter (L = Love or R = Rayleigh)
        t      = string, type letter (C = phase or U = group)
        m      = int, mode number (0= fundamental)
        F      = array, 1D, frequency array in Hz
        DLOGVADZ  = array, 2D, [normed] sensitivity kernel relative to top depth of each layer (lines) and frequency (columns)
        DLOGVADLOGVS  = array, 2D, [normed] sensitivity kernel relative to Pwave velocity of each layer (lines) and frequency (columns)
        DLOGVADLOGPR  = array, 2D, [normed] sensitivity kernel relative to Swave velocity of each layer (lines) and frequency (columns)
        DLOGVADLOGRH  = array, 2D, [normed] sensitivity kernel relative to density of each layer (lines) and frequency (columns)                
                 note that these arrays might contain nans
    see also :
        sker17_1
        dispersion
    """

    waves, types, modes, freqs = [
        np.asarray(_) for _ in waves, types, modes, freqs
    ]
    nlayer = len(ztop)
    H = np.array(ztop)  # NOT ASARRAY
    H[:-1], H[-1] = H[1:] - H[:-1], np.inf  #layer thickness in km

    model0 = np.concatenate((ztop, np.log(vs), np.log(vp / vs), np.log(rh)))
    dmodel = np.concatenate(
        (dz * np.ones_like(ztop), dlogvs * np.ones_like(vs),
         dlogpr * np.ones_like(vs), dlogrh * np.ones_like(rh)))

    logvalues0 = lognofail(
        dispersion(ztop,
                   vp,
                   vs,
                   rh,
                   waves,
                   types,
                   modes,
                   freqs,
                   h=h,
                   dcl=dcl,
                   dcr=dcr))

    IZ = np.arange(nlayer)
    IVS = np.arange(nlayer, 2 * nlayer)
    IPR = np.arange(2 * nlayer, 3 * nlayer)
    IRH = np.arange(3 * nlayer, 4 * nlayer)
    DVADP = np.zeros((4 * nlayer, len(waves)), float) * np.nan

    # ----
    # parallel
    # ----
    def fun(i, modeli):
        ztopi, logvsi, logpri, logrhi = \
            modeli[IZ], modeli[IVS], modeli[IPR], modeli[IRH]
        n = len(ztopi)
        ilayer = i % n
        if ilayer == n - 1:
            Hi = 1.e50  # thickness of the half-space
        else:
            Hi = ztopi[ilayer + 1] - ztopi[ilayer]

        try:
            logvaluesi = lognofail(
                dispersion(ztopi,
                           np.exp(logvsi + logpri),
                           np.exp(logvsi),
                           np.exp(logrhi),
                           waves,
                           types,
                           modes,
                           freqs,
                           h=h,
                           dcl=dcl,
                           dcr=dcr))
        except CPiSDomainError as err:
            print("error during gradient computation %s" % str(err))
            return i, None
        except:
            raise
        if norm:
            # sensitivity corrected from the layer thicknesses
            DVAVPi = (logvaluesi - logvalues0) / (modeli[i] - model0[i]) / Hi
        else:
            # absolute sensitivity regardless the thickness differences
            DVAVPi = (logvaluesi - logvalues0) / (modeli[i] - model0[i])

        return i, DVAVPi

    # ----
    def gen():
        for i in xrange(1, 4 * len(ztop)):
            modeli = model0.copy()
            modeli[i] += dmodel[i]
            yield Job(i, modeli)

    # ----
    with MapSync(fun, gen()) as ma:
        for _, (i, DVAVPi), _, _ in ma:
            if DVAVPi is None: continue
            DVADP[i, :] = DVAVPi

    for w, t, m, F, Iwtm in groupbywtm(waves, types, modes, freqs,
                                       np.arange(len(waves))):
        DLOGVADZ = DVADP[IZ, :][:, Iwtm]
        DLOGVADLOGPR = DVADP[IPR, :][:, Iwtm]
        DLOGVADLOGVS = DVADP[IVS, :][:, Iwtm]
        DLOGVADLOGRH = DVADP[IRH, :][:, Iwtm]
        DLOGVADZ, DLOGVADLOGVS, DLOGVADLOGPR, DLOGVADLOGRH = \
            [np.ma.masked_where(np.isnan(_), _) for _ in
             [DLOGVADZ, DLOGVADLOGVS, DLOGVADLOGPR, DLOGVADLOGRH]]

        yield w, t, m, F, DLOGVADZ, DLOGVADLOGVS, DLOGVADLOGPR, DLOGVADLOGRH