Пример #1
0
    def test_EM1DFDfwd_VMD_ComplexCond(self):

        if self.prob.ispaired:
            self.prob.unpair()
        if self.survey.ispaired:
            self.survey.unpair()

        self.prob = EM1D(self.mesh1D,
                         sigmaMap=Maps.IdentityMap(self.mesh1D),
                         chi=np.zeros(self.survey.n_layer),
                         eta=self.eta,
                         tau=self.tau,
                         c=self.c,
                         jacSwitch=False)
        self.prob.pair(self.survey)
        self.prob.survey.src_type = 'VMD'
        sig_half = 0.01
        m_1D = np.ones(self.prob.survey.n_layer) * sig_half
        Hz = self.prob.forward(m_1D)
        sigCole = EM1DAnalytics.ColeCole(self.survey.frequency, sig_half,
                                         self.eta, self.tau, self.c)
        Hzanal = EM1DAnalytics.Hzanal(sigCole, self.prob.survey.frequency,
                                      self.prob.survey.offset, 'secondary')

        if self.showIt is True:

            plt.loglog(self.prob.survey.frequency, abs(Hz.real), 'b')
            plt.loglog(self.prob.survey.frequency, abs(Hzanal.real), 'b*')
            plt.loglog(self.prob.survey.frequency, abs(Hz.imag), 'r')
            plt.loglog(self.prob.survey.frequency, abs(Hzanal.imag), 'r*')
            plt.show()

        err = np.linalg.norm(Hz - Hzanal) / np.linalg.norm(Hzanal)
        self.assertTrue(err < 1e-5)
        print("EM1DFD-VMD for complex conductivity works")
Пример #2
0
    def test_EM1DTDfwd_CirLoop_ComplexCond(self):

        if self.prob.ispaired:
            self.prob.unpair()
        if self.survey.ispaired:
            self.survey.unpair()

        self.prob = EM1D(self.mesh1D,
                         sigmaMap=self.expmap,
                         jacSwitch=False,
                         chi=self.chi,
                         eta=self.eta,
                         tau=self.tau,
                         c=self.c)
        self.prob.pair(self.survey)

        BzTD = self.prob.survey.dpred(self.m_1D)

        w_, _, omega_int = setFrequency(self.survey.time)
        sigCole = EM1DAnalytics.ColeCole(omega_int / (2 * np.pi),
                                         self.sig_half, self.eta[0],
                                         self.tau[0], self.c[0])

        Bzanal = EM1DAnalytics.BzAnalCircTCole(self.survey.a, self.survey.time,
                                               sigCole)

        if self.showIt is True:

            plt.loglog(self.survey.time, (BzTD), 'b')
            plt.loglog(self.survey.time, (Bzanal), 'b*')
            plt.show()

        err = np.linalg.norm(BzTD - Bzanal) / np.linalg.norm(Bzanal)
        print('Bz error = ', err)
        self.assertTrue(err < 1e-2)

        self.survey.rx_type = 'dBzdt'
        dBzdtTD = self.survey.dpred(self.m_1D)
        dBzdtanal = EM1DAnalytics.dBzdtAnalCircTCole(self.survey.a,
                                                     self.survey.time, sigCole)

        if self.showIt is True:

            plt.loglog(self.survey.time, -dBzdtTD, 'b')
            plt.loglog(self.survey.time, -dBzdtanal, 'b*')
            plt.show()

        err = np.linalg.norm(dBzdtTD - dBzdtanal) / np.linalg.norm(dBzdtanal)
        print('dBzdt error = ', err)
        self.assertTrue(err < 1e-2)
        print("EM1DTD-CirculurLoop for Complex conductivity works")
Пример #3
0
    def setUp(self):

        nearthick = np.logspace(-1, 1, 5)
        deepthick = np.logspace(1, 2, 10)
        hx = np.r_[nearthick, deepthick]
        mesh1D = Mesh.TensorMesh([hx], [0.])
        depth = -mesh1D.gridN[:-1]
        LocSigZ = -mesh1D.gridCC

        # Triangular waveform
        time_input_currents = np.r_[0., 5.5 * 1e-4, 1.1 * 1e-3]
        input_currents = np.r_[0., 1., 0.]

        TDsurvey = EM1DSurveyTD(rx_location=np.array([0., 0., 100. + 1e-5]),
                                src_location=np.array([0., 0., 100. + 1e-5]),
                                topo=np.r_[0., 0., 100.],
                                depth=depth,
                                field_type='secondary',
                                rx_type='Bz',
                                wave_type='general',
                                time_input_currents=time_input_currents,
                                input_currents=input_currents,
                                n_pulse=2,
                                base_frequency=25.,
                                time=np.logspace(-5, -2, 31),
                                src_type='CircularLoop',
                                I=1e0,
                                a=2e1)

        sig_half = 1e-4
        chi_half = 0.

        expmap = Maps.ExpMap(mesh1D)
        m_1D = np.log(np.ones(TDsurvey.n_layer) * sig_half)
        chi = np.zeros(TDsurvey.n_layer)

        prob = EM1D(mesh1D, sigmaMap=expmap, jacSwitch=False, chi=chi)
        prob.pair(TDsurvey)

        self.survey = TDsurvey
        self.prob = prob
        self.mesh1D = mesh1D
        self.showIt = False
        self.chi = chi
        self.m_1D = m_1D
        self.sig_half = sig_half
        self.expmap = expmap
Пример #4
0
    def setUp(self):

        nearthick = np.logspace(-1, 1, 5)
        deepthick = np.logspace(1, 2, 10)
        hx = np.r_[nearthick, deepthick]
        mesh1D = Mesh.TensorMesh([hx], [0.])
        depth = -mesh1D.gridN[:-1]
        LocSigZ = -mesh1D.gridCC

        TDsurvey = EM1DSurveyTD(rx_location=np.array([0., 0., 100. + 1e-5]),
                                src_location=np.array([0., 0., 100. + 1e-5]),
                                topo=np.r_[0., 0., 100.],
                                depth=depth,
                                field_type='secondary',
                                rx_type='Bz',
                                wave_type='stepoff',
                                time=np.logspace(-5, -2, 64),
                                src_type='CircularLoop',
                                I=1e0,
                                a=1e1)

        sig_half = 1e-2
        chi_half = 0.

        expmap = Maps.ExpMap(mesh1D)
        tau = 1e-3 * np.ones(TDsurvey.n_layer)
        eta = 2e-1 * np.ones(TDsurvey.n_layer)
        c = 1. * np.ones(TDsurvey.n_layer)
        m_1D = np.log(np.ones(TDsurvey.n_layer) * sig_half)
        chi = np.zeros(TDsurvey.n_layer)

        prob = EM1D(mesh1D, sigmaMap=expmap, jacSwitch=False, chi=chi)
        prob.pair(TDsurvey)

        self.survey = TDsurvey
        self.prob = prob
        self.mesh1D = mesh1D
        self.showIt = False
        self.tau = tau
        self.eta = eta
        self.c = c
        self.chi = chi
        self.m_1D = m_1D
        self.sig_half = sig_half
        self.expmap = expmap
Пример #5
0
    def setUp(self):

        nearthick = np.logspace(-1, 1, 5)
        deepthick = np.logspace(1, 2, 10)
        hx = np.r_[nearthick, deepthick]
        mesh1D = Mesh.TensorMesh([hx], [0.])
        depth = -mesh1D.gridN[:-1]
        nlay = depth.size
        topo = np.r_[0., 0., 100.]

        FDsurvey = EM1DSurveyFD(rx_location=np.array([0., 0., 100. + 1e-5]),
                                src_location=np.array([0., 0., 100. + 1e-5]),
                                field_type='secondary',
                                depth=depth,
                                topo=topo,
                                frequency=np.logspace(1, 8, 61),
                                offset=10. * np.ones(61))

        sig_half = 1e-2
        chi_half = 0.

        expmap = Maps.ExpMap(mesh1D)
        tau = 1e-3
        eta = 2e-1
        c = 1.

        m_1D = np.log(np.ones(nlay) * sig_half)
        FDsurvey.rx_type = 'Hz'

        prob = EM1D(mesh1D, sigmaMap=expmap, jacSwitch=False)
        prob.pair(FDsurvey)
        prob.chi = np.zeros(FDsurvey.n_layer)

        self.survey = FDsurvey
        self.prob = prob
        self.mesh1D = mesh1D
        self.showIt = False
        self.tau = tau
        self.eta = eta
        self.c = c
    def setUp(self):

        nearthick = np.logspace(-1, 1, 2)
        deepthick = np.logspace(1, 2, 5)
        hx = np.r_[nearthick, deepthick]
        mesh1D = Mesh.TensorMesh([hx], [0.])
        depth = -mesh1D.gridN[:-1]
        n_layer = depth.size

        FDsurvey = EM1DSurveyFD(
            rx_location=np.array([0., 0., 100.+50.]),
            src_location=np.array([0., 0., 100.+50.]),
            field_type='secondary',
            topo=np.r_[0., 0., 100.],
            depth=depth,
            frequency=np.logspace(2, 4, 10),
            src_type='CircularLoop'
        )

        sig_half = 1e-1
        chi_half = 0.

        expmap = Maps.ExpMap(mesh1D)
        tau = 1e-3
        eta = 2e-1
        c = 1.

        m_1D = np.log(np.ones(n_layer)*sig_half)
        FDsurvey.rxType = 'Hz'

        prob = EM1D(mesh1D, sigmaMap=expmap)
        prob.pair(FDsurvey)
        prob.chi = np.zeros(FDsurvey.n_layer)

        self.survey = FDsurvey
        self.prob = prob
        self.mesh1D = mesh1D
        self.showIt = False
Пример #7
0
    def setUp(self):

        wave_HM = skytem_HM_2015()
        wave_LM = skytem_LM_2015()
        time_HM = wave_HM.time_gate_center[0::2]
        time_LM = wave_LM.time_gate_center[0::2]

        hz = get_vertical_discretization_time(np.unique(np.r_[time_HM,
                                                              time_LM]),
                                              facter_tmax=0.5,
                                              factor_tmin=10.)
        mesh1D = set_mesh_1d(hz)
        depth = -mesh1D.gridN[:-1]
        LocSigZ = -mesh1D.gridCC

        time_input_currents_HM = wave_HM.current_times[-7:]
        input_currents_HM = wave_HM.currents[-7:]
        time_input_currents_LM = wave_LM.current_times[-13:]
        input_currents_LM = wave_LM.currents[-13:]

        TDsurvey = EM1DSurveyTD(
            rx_location=np.array([0., 0., 100.]),
            src_location=np.array([0., 0., 100.]),
            topo=np.r_[0., 0., 100.],
            depth=depth,
            rx_type='dBzdt',
            wave_type='general',
            src_type='CircularLoop',
            a=13.,
            I=1.,
            time=time_HM,
            time_input_currents=time_input_currents_HM,
            input_currents=input_currents_HM,
            n_pulse=2,
            base_frequency=25.,
            use_lowpass_filter=False,
            high_cut_frequency=7e4,
            moment_type='dual',
            time_dual_moment=time_HM,
            time_input_currents_dual_moment=time_input_currents_LM,
            input_currents_dual_moment=input_currents_LM,
            base_frequency_dual_moment=210,
        )

        sig_half = 1e-2
        chi_half = 0.

        expmap = Maps.ExpMap(mesh1D)
        m_1D = np.log(np.ones(TDsurvey.n_layer) * sig_half)
        chi = np.zeros(TDsurvey.n_layer)

        prob = EM1D(mesh1D, sigmaMap=expmap, chi=chi)
        prob.pair(TDsurvey)

        self.survey = TDsurvey
        self.prob = prob
        self.mesh1D = mesh1D
        self.showIt = False
        self.chi = chi
        self.m_1D = m_1D
        self.sig_half = sig_half
        self.expmap = expmap