Exemple #1
0
    def run_all(self, time_after_sources=150, nfreq_ldos=200):
        self.time_after_sources = time_after_sources
        self.nfreq_ldos = nfreq_ldos

        self.harminv_instance = mp.Harminv(
            mp.Er, mp.Vector3(0, 0, self.source_position + self.shift),
            self.fcen, self.df)

        self.ldos_instance = mp.Ldos(self.fcen, self.df, self.nfreq_ldos)

        self._sim.run(mp.after_sources(self.harminv_instance),
                      mp.dft_ldos(ldos=self.ldos_instance),
                      until_after_sources=self.time_after_sources)

        self.ldos_results = np.transpose(
            np.array([self.ldos_instance.freqs(), self._sim.ldos_data]))

        self.q_results = []
        for mode in self.harminv_instance.modes:
            self.q_results.append(
                [1000 / mode.freq, mode.decay, mode.Q,
                 abs(mode.amp)])
        self.q_results = np.array(self.q_results)

        self.print_qs()
        self.plot_power()
        self.plot_ldos()
        self.plot_er_field()
Exemple #2
0
    def test_ldos_user_object(self):
        ldos = mp.Ldos(self.fcen, 0, 1)
        self.sim.run(mp.dft_ldos(ldos=ldos),
                     until_after_sources=mp.stop_when_fields_decayed(
                         50, mp.Ez, mp.Vector3(), 1e-6))

        self.assertAlmostEqual(self.sim.ldos_data[0], 1.011459560620368)
        self.assertEqual(len(mp.get_ldos_freqs(ldos)), 1)
Exemple #3
0
    def test_ldos_user_object(self):
        ldos = mp.Ldos(self.fcen, 0, 1)
        self.sim.run(mp.dft_ldos(ldos=ldos),
                     until_after_sources=mp.stop_when_fields_decayed(
                         50, mp.Ez, mp.Vector3(), 1e-6))

        self.assertAlmostEqual(self.sim.ldos_data[0], 1.011459560620368)
        freqs = ldos.freqs()
        self.assertEqual(ldos.freq_min, freqs[0] * 2 * math.pi)
        self.assertEqual(ldos.nfreq, 1)
        self.assertEqual(ldos.dfreq, 0)
Exemple #4
0
    def get_ldos(self, time_after_sources=150, nfreq_ldos=200):
        self.nfreq_ldos = nfreq_ldos

        self.time_after_sources = time_after_sources
        self.ldos_instance = mp.Ldos(self.fcen, self.df, self.nfreq_ldos)

        self._sim.run(mp.dft_ldos(ldos=self.ldos_instance),
                      until_after_sources=self.time_after_sources)

        self.ldos_results = np.transpose(
            np.array([self.ldos_instance.freqs(), self._sim.ldos_data]))

        maximum = max(self.ldos_results[:, 1])
        index = np.where(self.ldos_results[:, 1] == maximum)
        mode_wvl = 1000 / self.ldos_results[index, 0]

        self.mode_wvl = mode_wvl
Exemple #5
0
    def cavity_ldos(self, sz):
        sxy = self.L + 2 * self.dpml
        cell_size = mp.Vector3(sxy, sxy, sz)

        boundary_layers = [
            mp.PML(self.dpml, direction=mp.X),
            mp.PML(self.dpml, direction=mp.Y)
        ]

        sim = mp.Simulation(resolution=self.resolution,
                            cell_size=cell_size,
                            boundary_layers=boundary_layers,
                            sources=self.sources,
                            symmetries=self.symmetries,
                            default_material=mp.Medium(index=self.n))

        sim.run(mp.dft_ldos(ldos=mp.Ldos(self.fcen, 0, 1)),
                until_after_sources=mp.stop_when_fields_decayed(
                    20, mp.Ex, mp.Vector3(), 1e-6))

        return sim.ldos_data[0]
Exemple #6
0
 def test_invalid_dft_ldos(self):
     with self.assertRaises(TypeError):
         self.sim.run(mp.dft_ldos(mp.Ldos(self.fcen, 0, 1)), until=200)