ocm.z1_layer = z1_thickness
    ocm.write_model_file()
    
    #--> write occam1d startup file
    ocs = occam1d.Startup()
    ocs.data_fn = data_tm_fn
    ocs.model_fn = ocm.model_fn
    ocs.save_path = ocd.save_path
    ocs.max_iter = max_iter
    ocs.rough_type = 4
    ocs.debug_level = 2
    ocs.min_max_bounds = (-3, 4) 
    ocs.write_startup_file()
    
    #--> run occam1d
    occam1d.Run(ocs.startup_fn, occam_path=opath, mode='TM')
    
    #--> write occam1d startup file
    ocs = occam1d.Startup()
    ocs.data_fn = data_te_fn
    ocs.model_fn = ocm.model_fn
    ocs.save_path = ocd.save_path
    ocs.max_iter = max_iter
    ocs.rough_type = 4
    ocs.debug_level = 2
    ocs.min_max_bounds = (-3, 5)
    ocs.write_startup_file()
    occam1d.Run(ocs.startup_fn, occam_path=opath, mode='TE')

if plot == 'y':
    try:
            # --> write occam1d model file
            ocm = occam1d.Model()
            ocm.save_path = ocd.save_path
            ocm.write_model_file(model_depth=mdm.grid_z[1:])

            # --> write occam1d startup file
            ocs = occam1d.Startup()
            ocs.data_fn = data_tm_fn
            ocs.model_fn = ocm.model_fn
            ocs.save_path = ocd.save_path
            ocs.max_iter = iter_num + 1
            ocs.write_startup_file()

            # --> run occam1d
            occam1d.Run(ocs.startup_fn, occam_path=opath, mode="Det")

            try:
                iter_fn = os.path.join(ocd.save_path,
                                       "Det_{0}.iter".format(iter_num))
                resp_fn = os.path.join(ocd.save_path,
                                       "Det_{0}.resp".format(iter_num))
                ocm.read_iter_file(iter_fn)
                oned_res_arr[dd]["station"] = mt_obj.station
                oned_res_arr[dd]["grid_east"] = mt_obj.grid_east
                oned_res_arr[dd]["grid_north"] = mt_obj.grid_north
                oned_res_arr[dd]["grid_elev"] = mt_obj.grid_elev

                # need to find elevation
                depth_index = np.where(mdm.grid_z == mt_obj.grid_elev)[0][0]
                depth_res = np.repeat(fill_res, depth_index)
예제 #3
0
    
    for mmode in ['TE', 'TM']:
        sv_path = os.path.join(save_path, e1.station, mmode)
        ocd.write_data_file(edi_file=edi, res_err=res_err, phase_err=phase_err, 
                            mode=mmode, save_path=sv_path)

        #--> write model file
        ocm.save_path = sv_path
        ocm.write_model_file()
        
        #--> write startup file
        ocs.save_path = sv_path
        ocs.data_fn = ocd.data_fn
        ocs.model_fn = ocm.model_fn
        ocs.max_iter = max_iter
        ocs.write_startup_file()

        #--> run occam1d
        occam1d.Run(startup_fn=ocs.startup_fn, occam_path=occam_path, 
                    mode=mmode) 
        
        try:            
            ocm.read_iter_file(os.path.join(sv_path, mmode+'_5.iter'))
            log_fid.write('    --> {0} Mode RMS = {1:.2f}\n'.format(mmode, 
                          float(ocm.itdict['Misfit Value'])))
        except IOError:
            log_fid.write('    *** {0} Mode DID NOT RUN PROPERLY CHECK FILES\n'.format(mmode))

log_fid.close()
        
m_obj = modem.Model()
m_obj.read_model_file(mfn)

ocm = occam1d.Model()
ocm.write_model_file(save_path=sv_dir, model_depth=m_obj.grid_z)

### make startup file
ocs = occam1d.Startup()
ocs.start_rho = median_rho.mean()
ocs.data_fn = ocd.data_fn
ocs.model_fn = ocm.model_fn
ocs.save_path = sv_dir
ocs.max_iter = 10
ocs.write_startup_file()

occam1d.Run(ocs.startup_fn, occam_path=occam1d_path, mode='Det')

m_ocm = occam1d.Model()
m_ocm.read_iter_file(os.path.join(sv_dir, 'Det_5.iter'), ocm.model_fn)

res_1d = np.zeros_like(m_obj.res_model)
res_1d[:, :, :] = 10**signal.medfilt(m_ocm.model_res[3:, 1], kernel_size=7)
res_1d[np.where(m_obj.res_model > 1E10)] = 1E12

m_obj.res_model = res_1d
m_obj.write_model_file(model_fn_basename='mp_sm1d_topo.rho')
m_obj.write_vtk_file(vtk_fn_basename='mp_sm1d_topo')

#fig = plt.figure()
#
#ax = fig.add_subplot(1, 1, 1)
예제 #5
0
    def apply(self):
        """
        Apply.

        Returns
        -------
        None.

        """
        parm = {}

        parm['tdepth'] = tonumber(self.targetdepth.text())
        parm['nlayers'] = tonumber(self.nlayers.text())
        parm['blayer'] = tonumber(self.bottomlayer.text())
        parm['alayer'] = tonumber(self.airlayer.text())
        parm['z1layer'] = tonumber(self.z1layer.text())
        parm['miter'] = tonumber(self.maxiter.text())
        parm['trms'] = tonumber(self.targetrms.text())
        parm['rerr'] = tonumber(self.errres.text(), 'data')
        parm['perr'] = tonumber(self.errphase.text(), 'data')
        parm['perrflr'] = tonumber(self.errfloorphase.text())
        parm['rerrflr'] = tonumber(self.errfloorres.text())

        if -999 in parm.values():
            return

        mode = self.combomode.currentText()
        i = self.combobox1.currentText()
        edi_file = self.data[i].fn

        save_path = edi_file[:-4] + '-' + mode

        if os.path.exists(save_path):
            r = glob.glob(save_path + r'\*')
            for i in r:
                os.remove(i)
        else:
            os.makedirs(save_path)

        d1 = occam1d.Data()
        d1.write_data_file(edi_file=edi_file,
                           mode=mode,
                           save_path=save_path,
                           res_err=parm['rerr'],
                           phase_err=parm['perr'],
                           res_errorfloor=parm['rerrflr'],
                           phase_errorfloor=parm['perrflr'],
                           remove_outofquadrant=True)

        m1 = occam1d.Model(target_depth=parm['tdepth'],
                           n_layers=parm['nlayers'],
                           bottom_layer=parm['blayer'],
                           z1_layer=parm['z1layer'],
                           air_layer_height=parm['alayer'])
        m1.write_model_file(save_path=d1.save_path)

        s1 = occam1d.Startup(data_fn=d1.data_fn,
                             model_fn=m1.model_fn,
                             max_iter=parm['miter'],
                             target_rms=parm['trms'])

        s1.write_startup_file()

        self.mmc.figure.clear()
        self.mmc.figure.set_facecolor('r')
        self.mmc.figure.suptitle('Busy, please wait...', fontsize=14, y=0.5)
        #        ax = self.mmc.figure.gca()
        #        ax.text(0.5, 0.5, 'Busy, please wait...')
        self.mmc.figure.canvas.draw()
        QtWidgets.QApplication.processEvents()

        occam_path = os.path.dirname(__file__)[:-2] + r'\bin\occam1d.exe'

        occam1d.Run(s1.startup_fn, occam_path, mode='TE')

        self.mmc.figure.set_facecolor('w')

        allfiles = glob.glob(save_path + r'\*.resp')
        self.hs_profnum.setMaximum(len(allfiles))
        self.hs_profnum.setMinimum(1)

        self.change_band()
    ocm.z1_layer = z1_thickness
    ocm.write_model_file()

    # --> write occam1d startup file
    ocs = occam1d.Startup()
    ocs.data_fn = data_tm_fn
    ocs.model_fn = ocm.model_fn
    ocs.save_path = ocd.save_path
    ocs.max_iter = max_iter
    ocs.rough_type = 4
    ocs.debug_level = 2
    ocs.min_max_bounds = (-3, 4)
    ocs.write_startup_file()

    # --> run occam1d
    occam1d.Run(ocs.startup_fn, occam_path=opath, mode="TM")

    # --> write occam1d startup file
    ocs = occam1d.Startup()
    ocs.data_fn = data_te_fn
    ocs.model_fn = ocm.model_fn
    ocs.save_path = ocd.save_path
    ocs.max_iter = max_iter
    ocs.rough_type = 4
    ocs.debug_level = 2
    ocs.min_max_bounds = (-3, 5)
    ocs.write_startup_file()
    occam1d.Run(ocs.startup_fn, occam_path=opath, mode="TE")

if plot == "y":
    try:
예제 #7
0
def modelling(datadir):
    """ modelling """
    edi_file = os.path.join(datadir, r"synth02.edi")
    save_path = os.path.join(datadir, 'TM')

    allfiles = glob.glob(save_path + '\\*.*')
    for i in allfiles:
        os.remove(i)
    try:
        os.remove(save_path + '\\Model1D')
        os.remove(save_path + '\\OccamStartup1D')
    except:
        pass

    d1 = occam1d.Data()
    d1.write_data_file(edi_file=edi_file,
                       mode='TE',
                       save_path=save_path,
                       res_err='data',
                       phase_err='data',
                       res_errorfloor=4.,
                       phase_errorfloor=2.,
                       remove_outofquadrant=True)

    m1 = occam1d.Model(target_depth=40000,
                       n_layers=100,
                       bottom_layer=100000,
                       z1_layer=10)
    m1.write_model_file(save_path=d1.save_path)

    #--> make a startup file
    s1 = occam1d.Startup(data_fn=d1.data_fn,
                         model_fn=m1.model_fn,
                         max_iter=200,
                         target_rms=1.0)

    s1.write_startup_file()

    #--> run occam1d from python
    occam_path = r"C:\Work\Programming\pygmi\pygmi\bin\occam1d.exe"
    occam1d.Run(s1.startup_fn, occam_path, mode='TM')

    #--plot the L2 curve
    #    l2 = occam1d.PlotL2(d1.save_path, m1.model_fn,
    #                        fig_dpi=100,
    #                        fig_size=(2,2)
    #                        )

    #--> see that iteration 7 is the optimum model to plot

    iterfn = os.path.join(save_path, 'TM_005.iter')
    respfn = os.path.join(save_path, 'TM_005.resp')

    p1 = occam1d.Plot1DResponse(
        data_te_fn=d1.data_fn,
        model_fn=m1.model_fn,
        iter_te_fn=iterfn,
        resp_te_fn=respfn,
        #                                depth_limits=(0,20),
        fig_dpi=100,
        fig_size=(2, 2))

    oc1m = occam1d.Model(model_fn=m1.model_fn)

    allfiles = glob.glob(save_path + '\*.iter')

    roughness = []
    rms = []
    for iterfn in allfiles:
        oc1m.read_iter_file(iterfn)
        roughness.append(float(oc1m.itdict['Roughness Value']))
        rms.append(float(oc1m.itdict['Misfit Value']))

    roughness.pop(0)
    rms.pop(0)

    plt.plot(roughness, rms)
    plt.xlabel('Roughness')
    plt.ylabel('RMS')
    plt.show()
    plt.plot(rms)
    plt.xlabel('Iteration')
    plt.ylabel('RMS')
    plt.show()

    iterfn = os.path.join(save_path, 'TM_005.iter')
    respfn = os.path.join(save_path, 'TM_005.resp')

    oc1m.read_iter_file(iterfn)

    oc1d = occam1d.Data(data_fn=d1.data_fn)
    oc1d.read_resp_file(respfn)

    depths = []
    res = []

    for i, val in enumerate(oc1m.model_res[:, 1]):
        if i == 0:
            continue
        if i > 1:
            depths.append(-oc1m.model_depth[i - 1])
            res.append(val)

        depths.append(-oc1m.model_depth[i])
        res.append(val)

    plt.plot(res, depths)

    plt.xlabel('Res')
    plt.ylabel('Depth')

    plt.show()

    plt.plot(1 / oc1d.freq, oc1d.data['resxy'][0], 'bs')
    plt.plot(1 / oc1d.freq, oc1d.data['resxy'][2], 'r')
    plt.xscale('log')
    plt.yscale('log')
    plt.grid(True)
    plt.show()

    plt.plot(1 / oc1d.freq, oc1d.data['phasexy'][0], 'bs')
    plt.plot(1 / oc1d.freq, oc1d.data['phasexy'][2], 'r')
    plt.xscale('log')
    plt.yscale('log')
    plt.grid(True)
    plt.show()

    breakpoint()