def empty_run(self, sx, sy, animate=False): sources, refl_fr, trans_fr = self.set_source(sx, sy) sim = mp.Simulation(cell_size=mp.Vector3(sx, sy, self.sz), geometry=[], sources=sources, boundary_layers=self.pml_layers, k_point=self.k, resolution=self.resolution) refl = sim.add_flux(self.fcen, self.df, self.nfreq, refl_fr) trans = sim.add_flux(self.fcen, self.df, self.nfreq, trans_fr) if animate: sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended("ex", mp.at_every(0.6, mp.output_efield_z)), until_after_sources=mp.stop_when_fields_decayed(25, mp.Ey, self.pt, 1e-3)) else: sim.run(until_after_sources=mp.stop_when_fields_decayed(25, mp.Ey, self.pt, 1e-3)) # for normalization run, save flux fields data for reflection plane self.store['straight_refl_data'] = sim.get_flux_data(refl) # save incident power for transmission plane self.store['flux_freqs'] = mp.get_flux_freqs(refl) self.store['straight_tran_flux'] = mp.get_fluxes(trans) self.store['straight_refl_flux'] = mp.get_fluxes(refl)
def runSimulation(cell, geometry, pml_layers, frequency): print("We are running at:", frequency) resolution = simulation.resolution sim = mp.Simulation(cell_size=cell, boundary_layers=pml_layers, geometry=geometry, resolution=resolution, progress_interval=10000, sources=[ mp.Source(mp.ContinuousSource(frequency=frequency), center=mp.Vector3(source.x, source.y, 0), component=mp.Ex) ]) sim.use_output_directory() if (simulation.generatePNG == True): sim.run(mp.to_appended("ez", mp.at_every(1.0, mp.output_efield_z)), until=simulation.simulationTimeSteps) print("After Simulation") # createPNG() # pngToGIF() #deleteH5Files() else: sim.run(until=simulation.simulationTimeSteps) upperPortVolume = mp.Volume(center=mp.Vector3(upperPort.x, upperPort.y, 0), size=mp.Vector3(1, 1, 0)) lowerPortVolume = mp.Volume(center=mp.Vector3(lowerPort.x, lowerPort.y, 0), size=mp.Vector3(1, 1, 0)) lowerPortEnergy = sim.field_energy_in_box(box=lowerPortVolume, d=mp.Ex) upperPortEnergy = sim.field_energy_in_box(box=upperPortVolume, d=mp.Ex) print(lowerPortEnergy, "lowerPortEnergy") print(upperPortEnergy, "upperPortEnergy") return lowerPortEnergy, upperPortEnergy
def main(args): n = 3.4 # index of waveguide w = 1 # width of waveguide r = 1 # inner radius of ring pad = 4 # padding between waveguide and edge of PML dpml = 32 # thickness of PML sr = r + w + pad + dpml # radial size (cell is from 0 to sr) dimensions = mp.CYLINDRICAL cell = mp.Vector3(sr, 0, 0) # in cylindrical coordinates, the phi (angular) dependence of the fields # is given by exp(i m phi), where m is given by: m = args.m geometry = [ mp.Block(center=mp.Vector3(r + (w / 2)), size=mp.Vector3(w, 1e20, 1e20), material=mp.Medium(index=n)) ] pml_layers = [mp.PML(dpml)] resolution = 20 # If we don't want to excite a specific mode symmetry, we can just # put a single point source at some arbitrary place, pointing in some # arbitrary direction. We will only look for TM modes (E out of the plane). fcen = args.fcen # pulse center frequency df = args.df # pulse frequency width sources = [ mp.Source(src=mp.GaussianSource(fcen, fwidth=df), component=mp.Ez, center=mp.Vector3(r + 0.1)) ] # note that the r -> -r mirror symmetry is exploited automatically sim = mp.Simulation(cell_size=cell, geometry=geometry, boundary_layers=pml_layers, resolution=resolution, sources=sources, dimensions=dimensions, m=m) sim.run(mp.after_sources(mp.Harminv(mp.Ez, mp.Vector3(r + 0.1), fcen, df)), until_after_sources=200) # Output fields for one period at the end. (If we output # at a single time, we might accidentally catch the Ez field when it is # almost zero and get a distorted view.) We'll append the fields # to a file to get an r-by-t picture. We'll also output from -sr to -sr # instead of from 0 to sr. sim.run(mp.in_volume( mp.Volume(center=mp.Vector3(), size=mp.Vector3(2 * sr)), mp.at_beginning(mp.output_epsilon), mp.to_appended("ez", mp.at_every(1 / fcen / 20, mp.output_efield_z))), until=1 / fcen)
def main(args): n = 3.4 # index of waveguide w = 1 # width of waveguide r = 1 # inner radius of ring pad = 4 # padding between waveguide and edge of PML dpml = 32 # thickness of PML sr = r + w + pad + dpml # radial size (cell is from 0 to sr) dimensions = mp.CYLINDRICAL cell = mp.Vector3(sr, 0, 0) # in cylindrical coordinates, the phi (angular) dependence of the fields # is given by exp(i m phi), where m is given by: m = args.m geometry = [mp.Block(center=mp.Vector3(r + (w / 2)), size=mp.Vector3(w, mp.inf, mp.inf), material=mp.Medium(index=n))] pml_layers = [mp.PML(dpml)] resolution = 20 # If we don't want to excite a specific mode symmetry, we can just # put a single point source at some arbitrary place, pointing in some # arbitrary direction. We will only look for Ez-polarized modes. fcen = args.fcen # pulse center frequency df = args.df # pulse frequency width sources = [mp.Source(src=mp.GaussianSource(fcen, fwidth=df), component=mp.Ez, center=mp.Vector3(r + 0.1))] # note that the r -> -r mirror symmetry is exploited automatically sim = mp.Simulation(cell_size=cell, geometry=geometry, boundary_layers=pml_layers, resolution=resolution, sources=sources, dimensions=dimensions, m=m) sim.run(mp.after_sources(mp.Harminv(mp.Ez, mp.Vector3(r + 0.1), fcen, df)), until_after_sources=200) # Output fields for one period at the end. (If we output # at a single time, we might accidentally catch the Ez field when it is # almost zero and get a distorted view.) We'll append the fields # to a file to get an r-by-t picture. We'll also output from -sr to -sr # instead of from 0 to sr. sim.run(mp.in_volume(mp.Volume(center=mp.Vector3(), size=mp.Vector3(2 * sr)), mp.at_beginning(mp.output_epsilon), mp.to_appended("ez", mp.at_every(1 / fcen / 20, mp.output_efield_z))), until=1 / fcen)
def simulate_metalens(metalens): # Setup the MEEP objects cell = mp.Vector3(metalens['sim_cell_width'], metalens['sim_cell_height']) # All around the simulation cell pml_layers = [mp.PML(metalens['pml_width'])] # Set up the sources sources = [ mp.Source(src=mp.ContinuousSource(wavelength=metalens['wavelength'], width=metalens['source_width']), component=mp.Ez, center=mp.Vector3(0, metalens['source_coordinate']), size=mp.Vector3(2 * metalens['ws'], 0), amp_func=far_ez_source_amp_func(metalens)) ] # Set up the symmetries syms = [] if metalens['x_mirror_symmetry']: syms.append(mp.Mirror(mp.X)) sim = mp.Simulation(cell_size=cell, boundary_layers=pml_layers, geometry=metalens['geometry'], force_complex_fields=metalens['complex_fields'], symmetries=syms, sources=sources, resolution=metalens['resolution']) start_time = time.time() metalens['run_date'] = ( datetime.datetime.now().strftime("%b %d %Y at %H:%M:%S")) sim.init_sim() # Branch if saving for making an animation if metalens['save_output']: sim.run(mp.to_appended( "ez-{sim_id}".format(**metalens), mp.at_every(metalens['simulation_time'] / 1000., mp.output_efield_z)), until=metalens['simulation_time']) else: sim.run(until=metalens['simulation_time']) # Compute the clock run time and grab the fields metalens['run_time_in_s'] = time.time() - start_time metalens['fields'] = { 'Ez': sim.get_array(component=mp.Ez).transpose(), 'Bx': sim.get_array(component=mp.Bx).transpose(), 'By': sim.get_array(component=mp.By).transpose() } # Dump the result to disk pickle.dump( metalens, open('%smetalens-%s.pkl' % (datadir, metalens['sim_id']), 'wb')) return metalens
center=mp.Vector3(x, y), # It changes position on every loop material=mp.Medium(epsilon=1)) ] pml_layers = [mp.PML(1.0)] resolution = 50 #Generate a source of EMF sources = [ mp.Source(mp.ContinuousSource(frequency=1, end_time=3), component=mp.Ez, center=mp.Vector3(-3, 0), size=mp.Vector3(0, 0)) ] sim = mp.Simulation(cell_size=cell, boundary_layers=pml_layers, geometry=geometry, sources=sources, resolution=resolution) #Start the simulation sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended("ez" + str(x) + str(y), mp.at_every(0.5, mp.output_efield_z)), until=length) #Generate Data and gifs os.system( "h5topng -t 0:" + str(length) + " -R -Zc dkbluered -a yarg -A MeepSimulation-eps-000000.00.h5 MeepSimulation-ez" + str(x) + str(y) + ".h5") os.system("convert MeepSimulation-ez" + str(x) + str(y) + ".t*.png ez" + str(x) + str(y) + ".gif")
src_output = mp.output_efield_y elif src_cmpt == mp.Ez: symmetries = [mp.Mirror(mp.X, phase=+1), mp.Mirror(mp.Y, phase=+1)] src_string = "|Ez|" src_output = mp.output_efield_z #setup the overall simulation sim = mp.Simulation(cell_size=cell, resolution=resolution, sources=sources, symmetries=symmetries, boundary_layers=pml_layers, geometry=geometry) sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended("ez", mp.at_every(0.6, src_output)), until=tau) eps_data = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric) plt.figure() plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary') plt.xlabel("X") plt.ylabel("Y") plt.title("Dielectric Constant") plt.show() x = np.linspace(0, bx * resolution, 100) b = np.ones(100) * resolution o = np.ones(100)
size=mp.Vector3(1, 0, 0), component=mp.Hz, center=mp.Vector3(0.123, 0.0)) sim = mp.Simulation(sources=[s], boundary_layers=[pml_layers], cell_size=cell, geometry=[b,c], resolution=resolution) kx = 0.3 sim.k_point = mp.Vector3(kx) """Harminv mode analysis""" # sim.run(mp.after_sources(mp.Harminv(mp.Hz, mp.Vector3(0.1234), fcen, df)), # until_after_sources=300) # k_interp = 11 # sim.run_k_points(300, mp.interpolate(k_interp, [mp.Vector3(0), mp.Vector3(0.5)])) """Coupling simulation""" sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended("hz", mp.at_every(1/fcen/10, mp.output_hfield_z)), until_after_sources=5/fcen) """Viusalize epsilon""" # eps_data = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric) # # plt.imshow(eps_data.transpose()) # plt.show()
def main(): # Prefix all output files with the command line argument file_prefix = sys.argv[1] # Number of pixels per micron resolution = 150 # Simulation volume (um) cell_x = 2 cell_y = 2 cell_z = 2.5 # Refractive indicies index_si = 3.6 # previously 3.4467 index_sio2 = 1.444 # Durations in units of micron/c duration = round(1.5 * cell_x + 2) num_timesteps = duration * resolution # Absorbing layer on boundary pml = 0.5 # Geometry src_buffer = pml / 16 nbn_buffer = src_buffer nbn_length = cell_x - 2 * pml - src_buffer - nbn_buffer nbn_center_x = (src_buffer + nbn_buffer) / 2 wavelength = 1.55 waveguide_width = 0.750 # 750 nm waveguide_height = 0.110 # 110 nm plane_shift_y = 0 # nbn is 10/8 times thicker than in reality to have enough simulation pixels # so we reduce its absorption by a factor of 5/4 to compensate nbn_thickness_comp = 250 / resolution nbn_thickness = 0.008 * nbn_thickness_comp # Actually 8 nm, but simulating this for 2 grid points nbn_width = 0.100 # 100 nm nbn_spacing = 0.120 # 120 nm # Also compensate the difference in index by the same amount nbn_base_index = 5.23 # Taken from Hu thesis p86 nbn_index = (5.23 - index_si) / nbn_thickness_comp + index_si nbn_base_k = 5.82 # Taken from Hu thesis p86 nbn_k = nbn_base_k / nbn_thickness_comp conductivity = 2 * math.pi * wavelength * nbn_k / nbn_index flux_length = cell_x - 2 * pml - 4 * src_buffer # Generate simulation obejcts cell = mp.Vector3(cell_x, cell_y, cell_z) freq = 1 / wavelength src_pt = mp.Vector3(-cell_x / 2 + pml + src_buffer, 0, 0) output_slice = mp.Volume(center=mp.Vector3(y=(3 * waveguide_height / 4) + plane_shift_y), size=(cell_x, 0, cell_z)) # Log important quantities print('ABSORBING RUN') print('File prefix: {}'.format(file_prefix)) print('Duration: {}'.format(duration)) print('Resolution: {}'.format(resolution)) print('Dimensions: {} um, {} um, {} um'.format(cell_x, cell_y, cell_z)) print('Wavelength: {} um'.format(wavelength)) print('Si thickness: {} um'.format(waveguide_height)) print('NbN thickness: {} um'.format(nbn_thickness)) print('Si index: {}; SiO2 index: {}'.format(index_si, index_sio2)) print('Absorber dimensions: {} um, {} um, {} um'.format( nbn_length, nbn_thickness, nbn_width)) print('Absorber n (base value): {} ({}), k: {} ({})'.format( nbn_index, nbn_base_index, nbn_k, nbn_base_k)) print('Absorber compensation for thickness: {}'.format(nbn_thickness_comp)) print('Flux length: {} um'.format(flux_length)) print('\n\n**********\n\n') default_material = mp.Medium(epsilon=1) # Physical geometry of the simulation geometry = [ mp.Block(mp.Vector3(mp.inf, cell_y, mp.inf), center=mp.Vector3(0, -cell_y / 2 + plane_shift_y, 0), material=mp.Medium(epsilon=index_sio2)), mp.Block(mp.Vector3(mp.inf, waveguide_height, waveguide_width), center=mp.Vector3(0, waveguide_height / 2 + plane_shift_y, 0), material=mp.Medium(epsilon=index_si)) ] # Absorber will only be appended to geometry for the second simulation absorber = [ mp.Block(mp.Vector3(nbn_length, nbn_thickness, nbn_width), center=mp.Vector3( nbn_center_x, waveguide_height + nbn_thickness / nbn_thickness_comp / 2 + plane_shift_y, nbn_spacing / 2), material=mp.Medium(epsilon=nbn_index, D_conductivity=conductivity)), mp.Block(mp.Vector3(nbn_length, nbn_thickness, nbn_width), center=mp.Vector3( nbn_center_x, waveguide_height + nbn_thickness / nbn_thickness_comp / 2 + plane_shift_y, -nbn_spacing / 2), material=mp.Medium(epsilon=nbn_index, D_conductivity=conductivity)), ] # geometry += absorber # Calculate eigenmode source src_max_y = cell_y - 2 * pml src_max_z = cell_z - 2 * pml src_y = src_max_y src_z = src_max_z # min(3 * waveguide_width, src_max_z) src_center_y = 0 # plane_shift_y sources = [ mp.EigenModeSource(src=mp.ContinuousSource(frequency=freq), center=mp.Vector3(-cell_x / 2 + pml + src_buffer, src_center_y, 0), size=mp.Vector3(0, src_y, src_z), eig_match_freq=True, eig_parity=mp.ODD_Z, eig_band=1) ] pml_layers = [mp.PML(pml)] # Pass all simulation parameters to meep sim = mp.Simulation( cell_size=cell, boundary_layers=pml_layers, geometry=geometry, sources=sources, resolution=resolution, # eps_averaging=False, default_material=default_material, symmetries=[mp.Mirror(mp.Z, phase=-1)]) # Create flux monitors to calculate transmission and absorption fr_y = cell_y - 2 * pml fr_z = cell_z - 2 * pml # Reflected flux refl_fr = mp.FluxRegion(center=mp.Vector3( -0.5 * cell_x + pml + 2 * src_buffer, 0, 0), size=mp.Vector3(0, fr_y, fr_z)) refl = sim.add_flux(freq, 0, 1, refl_fr) # Transmitted flux tran_fr = mp.FluxRegion(center=mp.Vector3( 0.5 * cell_x - pml - 2 * src_buffer, 0, 0), size=mp.Vector3(0, fr_y, fr_z)) tran = sim.add_flux(freq, 0, 1, tran_fr) # Run simulation, outputting the epsilon distribution and the fields in the # x-y plane every 0.25 microns/c sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended( "ez_z0", mp.in_volume(output_slice, mp.at_every(2 / resolution, mp.output_efield_z))), until=duration) print('\n\n**********\n\n') sim.fields.synchronize_magnetic_fields() # For normalization run, save flux fields data for reflection plane no_absorber_refl_data = sim.get_flux_data(refl) # Save incident power for transmission plane no_absorber_tran_flux = mp.get_fluxes(tran) print("Flux: {}".format(no_absorber_tran_flux[0])) eps_data = sim.get_array(center=mp.Vector3(z=(nbn_spacing + nbn_width) / 2), size=mp.Vector3(cell_x, cell_y, 0), component=mp.Dielectric) eps_cross_data = sim.get_array(center=mp.Vector3(x=cell_x / 4), size=mp.Vector3(0, cell_y, cell_z), component=mp.Dielectric) max_field = 1.5 # Plot epsilon distribution if mp.am_master(): plt.figure() plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary') plt.axis('off') plt.savefig(file_prefix + '_Eps_A.png', dpi=300) print('Saved ' + file_prefix + '_Eps_A.png') # Plot field on x-y plane ez_data = sim.get_array(center=mp.Vector3(), size=mp.Vector3(cell_x, cell_y, 0), component=mp.Ez) if mp.am_master(): plt.figure() plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary') plt.imshow(ez_data.transpose(), interpolation='spline36', cmap='RdBu', alpha=0.9) plt.axis('off') plt.savefig(file_prefix + '_Ez_A.png', dpi=300) print('Saved ' + file_prefix + '_Ez_A.png') energy_side_data = sim.get_array(center=mp.Vector3(), size=mp.Vector3(cell_x, cell_y, 0), component=mp.EnergyDensity) if mp.am_master(): plt.figure() plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary') plt.imshow(energy_side_data.transpose(), interpolation='spline36', cmap='hot', alpha=0.9) plt.axis('off') plt.savefig(file_prefix + '_Pwr0_A.png', dpi=300) print('Saved ' + file_prefix + '_Pwr0_A.png') # Plot energy density on y-z plane energy_data = sim.get_array(center=mp.Vector3(), size=mp.Vector3(0, cell_y, cell_z), component=mp.EnergyDensity) if mp.am_master(): plt.figure() plt.imshow(eps_cross_data, interpolation='spline36', cmap='binary') plt.imshow(energy_data, interpolation='spline36', cmap='hot', alpha=0.9) plt.axis('off') plt.savefig(file_prefix + '_Pwr1_A.png', dpi=300) print('Saved ' + file_prefix + '_Pwr1_A.png') energy_data = sim.get_array(center=mp.Vector3(x=cell_x / 4), size=mp.Vector3(0, cell_y, cell_z), component=mp.EnergyDensity) if mp.am_master(): plt.figure() plt.imshow(eps_cross_data, interpolation='spline36', cmap='binary') plt.imshow(energy_data, interpolation='spline36', cmap='hot', alpha=0.9) plt.axis('off') plt.savefig(file_prefix + '_Pwr2_A.png', dpi=300) print('Saved ' + file_prefix + '_Pwr2_A.png') # Plot cross-sectional fields at several locations to ensure seeing nonzero fields num_x = 4 num_y = 3 fig, ax = plt.subplots(num_x, num_y) fig.suptitle('Cross Sectional Ez Fields') for i in range(num_x * num_y): monitor_x = i * (cell_x / 4) / (num_x * num_y) ez_cross_data = sim.get_array(center=mp.Vector3(x=monitor_x), size=mp.Vector3(0, cell_y, cell_z), component=mp.Ez) ax_num = i // num_y, i % num_y if mp.am_master(): ax[ax_num].imshow(eps_cross_data, interpolation='spline36', cmap='binary') ax[ax_num].imshow(ez_cross_data, interpolation='spline36', cmap='RdBu', alpha=0.9, norm=ZeroNormalize(vmax=np.max(max_field))) ax[ax_num].axis('off') ax[ax_num].set_title('x = {}'.format( round(cell_x / 4 + i / resolution, 3))) if mp.am_master(): plt.savefig(file_prefix + '_Ez_CS_A.png', dpi=300) print('Saved ' + file_prefix + '_Ez_CS_A.png') fig_e, ax_e = plt.subplots(num_x, num_y) fig_e.suptitle('Cross Sectional Energy Density') for i in range(num_x * num_y): monitor_x = i * (cell_x / 4) / (num_x * num_y) energy_cross_data = sim.get_array(center=mp.Vector3(x=monitor_x), size=mp.Vector3(0, cell_y, cell_z), component=mp.EnergyDensity) ax_num = i // num_y, i % num_y if mp.am_master(): ax_e[ax_num].imshow(eps_cross_data, interpolation='spline36', cmap='binary') ax_e[ax_num].imshow(energy_cross_data, interpolation='spline36', cmap='hot', alpha=0.9) ax_e[ax_num].axis('off') ax_e[ax_num].set_title('x = {}'.format( round(cell_x / 4 + i / resolution, 3))) if mp.am_master(): plt.savefig(file_prefix + '_Pwr_CS_A.png', dpi=300) print('Saved ' + file_prefix + '_Pwr_CS_A.png') print('\n\n**********\n\n') # Reset simulation for absorption run """ sim.reset_meep() geometry += absorber sim = mp.Simulation(cell_size=cell, boundary_layers=pml_layers, geometry=geometry, sources=sources, resolution=resolution, eps_averaging=False, default_material=default_material, symmetries=[mp.Mirror(mp.Z, phase=-1)]) refl = sim.add_flux(freq, 0, 1, refl_fr) tran = sim.add_flux(freq, 0, 1, tran_fr) sim.load_minus_flux_data(refl, no_absorber_refl_data) # Run simulation with absorber sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended("ez_z0", mp.in_volume(output_slice, mp.at_every(0.25, mp.output_efield_z))), until=duration) print('\n\n**********\n\n') # Calculate transmission and absorption absorber_refl_flux = mp.get_fluxes(refl) absorber_tran_flux = mp.get_fluxes(tran) transmittance = absorber_tran_flux[0] / no_absorber_tran_flux[0] reflectance = absorber_refl_flux[0] / no_absorber_tran_flux[0] absorption = 1 - transmittance penetration_depth = - nbn_length / math.log(transmittance) print('Flux: {}'.format(absorber_tran_flux[0])) print("Transmittance: %f" % transmittance) print("Reflectance: %f" % reflectance) print("Absorption: {} over {} um".format(absorption, nbn_length)) print("lambda = {} mm".format(penetration_depth / 1000)) eps_data = sim.get_array(center=mp.Vector3(z=(nbn_spacing + nbn_width) / 2), size=mp.Vector3(cell_x, cell_y, 0), component=mp.Dielectric) max_field = 1 # Plot epsilon distribution with absorber if mp.am_master(): plt.figure() plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary') plt.axis('off') plt.savefig(file_prefix + '_Eps_B.png', dpi=300) print('Saved ' + file_prefix + '_Eps_B.png') # Plot fields in x-y plane with absorber ez_data = sim.get_array(center=mp.Vector3(), size=mp.Vector3(cell_x, cell_y, 0), component=mp.Ez) if mp.am_master(): plt.figure() plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary') plt.imshow(ez_data.transpose(), interpolation='spline36', cmap='RdBu', alpha=0.9) plt.axis('off') plt.savefig(file_prefix + '_Ez_B.png', dpi=300) print('Saved ' + file_prefix + '_Ez_B.png') # Plot field cross sections with absorber eps_cross_data = sim.get_array(center=mp.Vector3(x=cell_x/4), size=mp.Vector3(0, cell_y, cell_z), component=mp.Dielectric) num_x = 4 num_y = 3 fig, ax = plt.subplots(num_x, num_y) fig.suptitle('Cross Sectional Ez Fields') for i in range(num_x * num_y): monitor_x = cell_x/4 + i / resolution ez_cross_data = sim.get_array(center=mp.Vector3(x=monitor_x), size=mp.Vector3(0, cell_y, cell_z), component=mp.Ez) ax_num = i // num_y, i % num_y if mp.am_master(): ax[ax_num].imshow(eps_cross_data, interpolation='spline36', cmap='binary') ax[ax_num].imshow(ez_cross_data, interpolation='spline36', cmap='RdBu', alpha=0.9, norm=ZeroNormalize(vmax=np.max(max_field))) ax[ax_num].axis('off') ax[ax_num].set_title('x = {}'.format(round(cell_x/4 + i / resolution, 3))) if mp.am_master(): plt.savefig(file_prefix + '_Ez_CS_B.png', dpi=300) print('Saved ' + file_prefix + '_Ez_CS_B.png') print('\n\n**********\n\n') """ print('Program finished.')
def main(args): resolution = 20 # pixels/um eps = 13 # epsilon of waveguide cols = 3 # metade da quantidade de colunas no cristal lines = 1 #7 é valor anterior # metade da quantidade de linhas no cristal w = 1.2 # width of the waveguide r = 0.2 # radius of holes N = args.N # number of holes on either side of defect #pad = 1 # padding between last hole and PML dpml = 1 # PML thickness sy = 2 * (dpml + lines) # tamanho da celula em Y (perpend ao guia) #sy = args.sy # size of cell in Y (perpend to wvg) fcen = args.fcen # pulse centger frequency df = args.df # pulse frequency width #sx = 2*(pad + dpml ) + lines # size of cell in X sx = 2 * (dpml + cols) cell = mp.Vector3(sx, sy, 0) blk = mp.Block(size=mp.Vector3(mp.inf, mp.inf, mp.inf), material=mp.Medium(epsilon=eps)) geometry = [blk] for i in range(lines): geometry.append(mp.Cylinder(r, center=mp.Vector3(0, i))) for j in range(cols): geometry.append(mp.Cylinder(r, center=mp.Vector3(i, j))) # j,i))) geometry.append(mp.Cylinder(r, center=mp.Vector3(-i, j))) # j,-i))) geometry.append(mp.Cylinder(r, center=mp.Vector3(i, -j))) # -j,i))) geometry.append(mp.Cylinder(r, center=mp.Vector3( -i, -j))) # -j,-i))) geometry.append( mp.Block(size=mp.Vector3(mp.inf, w, mp.inf), material=mp.Medium(epsilon=eps))) pml_layers = [mp.PML(1.0)] src = [ mp.Source( mp.GaussianSource(fcen, fwidth=df), component=mp.Ey, center=mp.Vector3( -0.5 * sx + dpml ), # fonte na esquerda; para colocar na direita usar 0.5*sx - dpml size=mp.Vector3(0, w)) ] sim = mp.Simulation( cell_size=cell, geometry=geometry, boundary_layers=pml_layers, sources=src, #symmetries=sym, resolution=resolution) freg = mp.FluxRegion( center=mp.Vector3( 0.5 * sx - dpml - 0.5 ), # fluxo na direita; para colocar na esquerda usar -0.5*sx+dpml+0.5 size=mp.Vector3(0, 2 * w)) nfreq = 500 # number of frequencies computed fluxes trans = sim.add_flux(fcen, df, nfreq, freg) # transmitted flux vol = mp.Volume(mp.Vector3(0), size=mp.Vector3(sx)) volTime = mp.Volume(mp.Vector3(((sx) / 2 - dpml), 0), size=mp.Vector3( 0, 1, 0)) # dados para pulso no tempo no final do guia hvals = [] def gethvals(sim): hvals.append( sim.get_array(center=mp.Vector3(), size=cell, component=mp.Hz)) sim.run(mp.at_beginning(mp.output_epsilon), mp.in_volume( volTime, mp.to_appended("TimeVsE2", mp.at_every(0.4, mp.output_dpwr))), mp.in_volume( vol, mp.to_appended("hz-slice", mp.at_every(0.4, gethvals, mp.output_hfield_z))), until=300) sim.display_fluxes( trans) # print flux spectrum - linha realocada, ver abaixo epsilon0 = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric) plt.figure() plt.imshow(epsilon0.transpose(), interpolation='spline36', cmap='RdBu') plt.axis('off') plt.savefig('epsilon.png', format='png') plt.show()
mp.Source(mp.GaussianSource(fcen, df, nfreq), component=mp.Ex, center=mp.Vector3(0, -0.90, 0), size=mp.Vector3(sx - 2.1, 0, 0)) ] symmetries = [mp.Mirror(mp.X), mp.Mirror(mp.Z)] sim = mp.Simulation(cell_size=cell, geometry=geometry, sources=source, resolution=resolution, boundary_layers=pml_layers, filename_prefix='ref_slab') pt = mp.Vector3(0, -0.90, 0) sim.run(mp.dft_ldos(fcen, 0, nfreq), mp.at_beginning(mp.output_epsilon), mp.to_appended("ref_hz", mp.at_every(0.05, mp.output_hfield_z)), until_after_sources=mp.stop_when_fields_decayed(10, mp.Hz, pt, 1e-3)) #sim.run(mp.dft_ldos(fcen,0,nfreq),mp.at_beginning(mp.output_epsilon),mp.at_end(mp.output_efield_x),until=50) eps_data1 = sim.get_array(center=mp.Vector3(0, 0, 0), size=mp.Vector3(sx - 2, sy - 2, sz), component=mp.Dielectric) ex_data1 = sim.get_array(center=mp.Vector3(0, 0, 0), size=mp.Vector3(sx - 2, sy - 2, sz), component=mp.Ex) hz_data1 = sim.get_array(center=mp.Vector3(0, 0, 0), size=mp.Vector3(sx - 2, sy - 2, sz), component=mp.Hz) plt.figure(dpi=160) plt.imshow(eps_data1.transpose(), interpolation='spline36', cmap='binary') plt.imshow(hz_data1.transpose(),
# again define monitors refl = sim.add_flux(cfreq, fwidth, nfreq, refl_fr) tran = sim.add_flux(cfreq, fwidth, nfreq, tran_fr) sim.load_minus_flux_data(refl, straight_refl_data) print("starting main run") if geom: arr = sim.get_epsilon() sim.plot2D() if mp.am_master(): plt.show() exit() sim.run(mp.to_appended( "fields", mp.at_every(0.5 / (cfreq + fwidth * 0.5), mp.output_efield_x, mp.output_efield_y, mp.output_efield_z)), until_after_sources=mp.stop_when_fields_decayed(10, comp, pt, 1e-3)) refl_flux = mp.get_fluxes(refl) tran_flux = mp.get_fluxes(tran) flux_freqs = mp.get_flux_freqs(refl) wl = [] Rs = [] Ts = [] for i in range(nfreq): wl = np.append(wl, 1 / flux_freqs[i]) Rs = np.append(Rs, -refl_flux[i] / straight_tran_flux[i]) Ts = np.append(Ts, tran_flux[i] / straight_tran_flux[i])
for i in range(len(flux_freqsX)): dft_objx = np.append( dft_objx, sim.add_dft_fields([polarisation], flux_freqsX[i], flux_freqsX[i], 1, where=monitor)) dft_obj = sim.add_dft_fields([polarisation], fcen, fcen, 1, where=monitor) sim.use_output_directory('flux-out_1') sim.run(mp.in_volume(monitor, mp.at_beginning(mp.output_epsilon)), mp.in_volume( monitor, mp.to_appended("ez", mp.at_every(time_step, mp.output_efield_x))), until_after_sources=mp.stop_when_fields_decayed( add_time, polarisation, pt, decay)) ''' sim.run(until_after_sources=mp.stop_when_fields_decayed(add_time,polarisation,pt,decay)) ''' #save scattered reflected flux from the surfaces scat_refl_data_t = mp.get_fluxes(refl_t) scat_refl_data_b = mp.get_fluxes(refl_b) scat_refl_data_l = mp.get_fluxes(refl_l) scat_refl_data_r = mp.get_fluxes(refl_r) #trans_flux_structure_abs.dat abs_refl_data_t = mp.get_fluxes(arefl_t) abs_refl_data_b = mp.get_fluxes(arefl_b)
def main(args): resolution = 20 # pixels/um eps = 13 # dielectric constant of waveguide w = 1.2 # width of waveguide r = 0.36 # radius of holes d = 1.4 # defect spacing (ordinary spacing = 1) N = args.N # number of holes on either side of defect sy = args.sy # size of cell in y direction (perpendicular to wvg.) pad = 2 # padding between last hole and PML edge dpml = 1 # PML thickness sx = 2 * (pad + dpml + N) + d - 1 # size of cell in x direction cell = mp.Vector3(sx, sy, 0) blk = mp.Block(size=mp.Vector3(mp.inf, w, mp.inf), material=mp.Medium(epsilon=eps)) geometry = [blk] for i in range(N): geometry.append(mp.Cylinder(r, center=mp.Vector3(d / 2 + i))) geometry.append(mp.Cylinder(r, center=mp.Vector3(-(d / 2 + i)))) pml_layers = [mp.PML(1.0)] fcen = args.fcen # pulse center frequency df = args.df # pulse frequency width src = [ mp.Source(mp.GaussianSource(fcen, fwidth=df), component=mp.Ey, center=mp.Vector3(-0.5 * sx + dpml), size=mp.Vector3(0, w)) ] sym = [mp.Mirror(mp.Y, phase=-1)] sim = mp.Simulation(cell_size=cell, geometry=geometry, boundary_layers=pml_layers, sources=src, symmetries=sym, resolution=resolution) freg = mp.FluxRegion(center=mp.Vector3(0.5 * sx - dpml - 0.5), size=mp.Vector3(0, 2 * w)) nfreq = 500 # number of frequencies at which to compute flux # transmitted flux trans = sim.add_flux(fcen, df, nfreq, freg) vol = mp.Volume(mp.Vector3(0), size=mp.Vector3(sx)) plt.figure(dpi=150) sim.plot2D() #plt.show() plt.savefig('2Dstructure.png') sim.run(mp.at_beginning(mp.output_epsilon), mp.during_sources( mp.in_volume( vol, mp.to_appended("hz-slice", mp.at_every(0.4, mp.output_hfield_z)))), until_after_sources=mp.stop_when_fields_decayed( 50, mp.Ey, mp.Vector3(0.5 * sx - dpml - 0.5), 1e-3)) sim.display_fluxes(trans) # print out the flux spectrum
def main(args): resolution = 20 # pixels/um eps = 13 # dielectric constant of waveguide w = 1.2 # width of waveguide r = 0.36 # radius of holes d = 1.4 # defect spacing (ordinary spacing = 1) N = args.N # number of holes on either side of defect sy = args.sy # size of cell in y direction (perpendicular to wvg.) pad = 2 # padding between last hole and PML edge dpml = 1 # PML thickness sx = 2*(pad+dpml+N)+d-1 # size of cell in x direction cell = mp.Vector3(sx,sy,0) blk = mp.Block(size=mp.Vector3(mp.inf,w,mp.inf), material=mp.Medium(epsilon=eps)) geometry = [blk] for i in range(N): geometry.append(mp.Cylinder(r, center=mp.Vector3(d/2+i))) geometry.append(mp.Cylinder(r, center=mp.Vector3(-(d/2+i)))) fcen = args.fcen # pulse center frequency df = args.df # pulse frequency width nfreq = 500 # number of frequencies at which to compute flux sim = mp.Simulation(cell_size=cell, geometry=geometry, sources=[], boundary_layers=[mp.PML(dpml)], resolution=20) if args.resonant_modes: sim.sources.append(mp.Source(mp.GaussianSource(fcen, fwidth=df), component=mp.Hz, center=mp.Vector3())) sim.symmetries.append(mp.Mirror(mp.Y, phase=-1)) sim.symmetries.append(mp.Mirror(mp.X, phase=-1)) sim.run(mp.at_beginning(mp.output_epsilon), mp.after_sources(mp.Harminv(mp.Hz, mp.Vector3(), fcen, df)), until_after_sources=400) sim.run(mp.at_every(1/fcen/20, mp.output_hfield_z), until=1/fcen) else: sim.sources.append(mp.Source(mp.GaussianSource(fcen, fwidth=df), component=mp.Ey, center=mp.Vector3(-0.5*sx+dpml), size=mp.Vector3(0,w))) sim.symmetries.append(mp.Mirror(mp.Y, phase=-1)) freg = mp.FluxRegion(center=mp.Vector3(0.5*sx-dpml-0.5), size=mp.Vector3(0,2*w)) # transmitted flux trans = sim.add_flux(fcen, df, nfreq, freg) vol = mp.Volume(mp.Vector3(), size=mp.Vector3(sx)) sim.run(mp.at_beginning(mp.output_epsilon), mp.during_sources(mp.in_volume(vol, mp.to_appended("hz-slice", mp.at_every(0.4, mp.output_hfield_z)))), until_after_sources=mp.stop_when_fields_decayed(50, mp.Ey, mp.Vector3(0.5*sx-dpml-0.5), 1e-3)) sim.display_fluxes(trans) # print out the flux spectrum
resolution = 48 sim = mp.Simulation(cell_size=cell, boundary_layers=pml_layers, geometry=geometry, default_material = mp.Medium(index=1), sources=sources, resolution=resolution) sim.use_output_directory("wave_in_bulk") def myhello(thisSim): # print(-0.4*sx+sim.meep_time()*v) if(thisSim.meep_time() > 190): movingSources = [] thisSim.change_sources(movingSources) return sim.run( mp.at_beginning(mp.output_epsilon), mp.to_appended("Hz",mp.at_every(1,mp.output_hfield_z)), myhello, until=runTime) # eps_data = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric) # plt.figure(dpi=100) # plt.imshow(eps_data.transpose(), interpolation='spline36', cmap='binary') # plt.axis('off') # plt.savefig('./wave_in_band_gap/eps.png')
# From the Meep tutorial: plotting permittivity and fields of a bent waveguide from __future__ import division import meep as mp cell = mp.Vector3(16,16,0) geometry = [mp.Block(mp.Vector3(12,1,mp.inf), center=mp.Vector3(-2.5,-3.5), material=mp.Medium(epsilon=12)), mp.Block(mp.Vector3(1,12,mp.inf), center=mp.Vector3(3.5,2), material=mp.Medium(epsilon=12))] pml_layers = [mp.PML(1.0)] resolution = 10 sources = [mp.Source(mp.ContinuousSource(wavelength=2*(11**0.5), width=20), component=mp.Ez, center=mp.Vector3(-7,-3.5), size=mp.Vector3(0,1))] sim = mp.Simulation(cell_size=cell, boundary_layers=pml_layers, geometry=geometry, sources=sources, resolution=resolution) sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended("ez", mp.at_every(0.6, mp.output_efield_z)), until=200)
def simulate_metalens(metalens): # Setup the MEEP objects cell = mp.Vector3(metalens['sim_cell_width'], metalens['sim_cell_height']) # All around the simulation cell pml_layers = [mp.PML(metalens['pml_width'])] # Set up the sources sources = [ mp.Source(src=mp.ContinuousSource(wavelength=metalens['wavelength'], width=metalens['source_width']), component=mp.Ex, amp_func=in_plane_dip_amp_func_Ex(metalens), center=mp.Vector3(0, metalens['source_coord']), size=mp.Vector3(2 * metalens['ws'], 0)), mp.Source(src=mp.ContinuousSource(wavelength=metalens['wavelength'], width=metalens['source_width']), component=mp.Hz, amp_func=in_plane_dip_amp_func_Hz(metalens), center=mp.Vector3(0, metalens['source_coord']), size=mp.Vector3(2 * metalens['ws'], 0)) ] # Set up the symmetries syms = [] if metalens['x_mirror_symmetry'] and (metalens['beta'] == 0 or metalens['beta'] == np.pi / 2): syms.append(mp.Mirror(mp.X)) sim = mp.Simulation(cell_size=cell, boundary_layers=pml_layers, geometry=metalens['geometry'], force_complex_fields=metalens['complex_fields'], symmetries=syms, sources=sources, resolution=metalens['resolution']) start_time = time.time() metalens['run_date'] = ( datetime.datetime.now().strftime("%b %d %Y at %H:%M:%S")) mp.quiet(metalens['quiet']) sim.init_sim() # Branch if saving for making an animation if metalens['save_output']: sim.run(mp.to_appended( "ez-{sim_id}".format(**metalens), mp.at_every(metalens['simulation_time'] / 1000., mp.output_efield_z)), until=metalens['simulation_time']) else: sim.run(until=metalens['simulation_time']) # Compute the clock run time and grab the fields metalens['array_metadata'] = sim.get_array_metadata() metalens['run_time_in_s'] = time.time() - start_time metalens['fields'] = { 'Ex': sim.get_array(component=mp.Ex).transpose(), 'Ey': sim.get_array(component=mp.Ey).transpose(), 'Hz': sim.get_array(component=mp.Hz).transpose() } metalens['eps'] = sim.get_epsilon().transpose() # Dump the result to disk if metalens['log_to_pkl'][0]: if metalens['log_to_pkl'][1] == '': pkl_fname = '%smetalens-%s.pkl' % (datadir, metalens['sim_id']) else: pkl_fname = metalens['log_to_pkl'][1] print(pkl_fname) pickle.dump(metalens, open(pkl_fname, 'wb')) return metalens
size=mp.Vector3(0, 0, 0.8), component=mp.Ez, center=mp.Vector3(-14, 5.)) ] #-14,5.,0.8 #sources = [mp.Source(mp.ContinuousSource(frequency=fcen, width=20), component=mp.Ez, center=mp.Vector3(-14,5.))] sim = mp.Simulation( cell_size=cell, boundary_layers=pml_layers, geometry=geometry, sources=sources, resolution=res) #geometry=geometry, boundary_layers=pml_layers sim.run(mp.at_beginning(mp.output_epsilon), mp.in_volume( mp.Volume(center=mp.Vector3(0, 0, 0), size=mp.Vector3(sx, sy, 0)), mp.to_appended("ez", mp.at_every(0.6, mp.output_efield_z))), mp.in_volume( mp.Volume(center=mp.Vector3(-14, 5., 0), size=mp.Vector3(0, 0, 0)), mp.to_appended("EzTr", mp.at_every(0.6, mp.output_efield_z))), mp.in_volume( mp.Volume(center=mp.Vector3(14., -5., 0), size=mp.Vector3(0, 0, 0)), mp.to_appended("EzR2", mp.at_every(0.6, mp.output_efield_z))), mp.in_volume( mp.Volume(center=mp.Vector3(10., 5., 0), size=mp.Vector3(0, 0, 0)), mp.to_appended("EzR3", mp.at_every(0.6, mp.output_efield_z))), mp.in_volume( mp.Volume(center=mp.Vector3(10., -5., 0), size=mp.Vector3(0, 0, 0)), mp.to_appended("EzR4", mp.at_every(0.6, mp.output_efield_z))), until=5000)
def main(args): resolution = 20 # pixels/um eps = 13 # epsilon of waveguide w = 1.2 # width of the waveguide dpml = 1 # PML thickness largC = 16 # largura da celula altC = 16 # altura da celula sx = largC + dpml sy = altC + dpml fcen = args.fcen # pulse centger frequency df = args.df # pulse frequency width cell = mp.Vector3(sx,sy,0) def epsP(p): valorIm = -0.5 + math.pow(math.cos((p.y)*(2*math.pi/(altC/4))),2) return mp.Medium(epsilon=3, D_conductivity=2*math.pi*fcen*(valorIm)/3) epsP.do_averaging = True blk = mp.Block(size=mp.Vector3(mp.inf,mp.inf,mp.inf), material=mp.Medium(epsilon=eps)) geometry = [blk] # AQUI ESTÁ A LINHA DE TESTE: USAMOS A FUNCAO PARA DEFINIR O EPSILON # geometry.append(mp.Block(size=mp.Vector3(mp.inf,w,mp.inf))) geometry.append(mp.Block(center=mp.Vector3(),size=mp.Vector3(mp.inf,altC,mp.inf),material=epsP)) pml_layers = [mp.PML(1.0)] src = [mp.Source(mp.GaussianSource(fcen, fwidth=df), component=mp.Ey, center=mp.Vector3(-0.5*sx+dpml), # fonte na esquerda; para colocar na direita usar 0.5*sx - dpml size=mp.Vector3(0,w))] sim = mp.Simulation(cell_size=cell, geometry=geometry, boundary_layers=pml_layers, sources=src, #symmetries=sym, resolution=resolution) sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended("hz",mp.at_every(0.4,mp.output_hfield_z)), until=300) epsilon0 = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric) plt.figure() plt.imshow(epsilon0.transpose(), interpolation='spline36', cmap='RdBu') plt.axis('off') plt.savefig('epsilon.png',format='png') plt.show()
sim.symmetries.append(mp.Mirror(mp.Y, phase=-1)) sim.symmetries.append(mp.Mirror(mp.X, phase=-1)) sim.run(mp.at_beginning(mp.output_epsilon), mp.after_sources(mp.Harminv(mp.Hz, mp.Vector3(), fcen, df)), until_after_sources=400) sim.run(mp.at_every(1 / fcen / 20, mp.output_hfield_z), until=1 / fcen) else: sim.sources.append(mp.Source(mp.GaussianSource(fcen, fwidth=df), component=mp.Ey, center=mp.Vector3(-0.5 * sx + dpml), size=mp.Vector3(0, w))) sim.symmetries.append(mp.Mirror(mp.Y, phase=-1)) freg = mp.FluxRegion(center=mp.Vector3(0.5 * sx - dpml - 0.5), size=mp.Vector3(0, 2 * w)) # transmitted flux trans = sim.add_flux(fcen, df, nfreq, freg) vol = mp.Volume(mp.Vector3(), size=mp.Vector3(sx)) sim.run(mp.at_beginning(mp.output_epsilon), mp.during_sources(mp.in_volume(vol, mp.to_appended( "hz-slice", mp.at_every(0.4, mp.output_hfield_z)))), until_after_sources=mp.stop_when_fields_decayed(50, mp.Ey, mp.Vector3(0.5 * sx - dpml - 0.5), 1e-3)) sim.display_fluxes(trans) # print out the flux spectrum
def main(args): # Some parameters to describe the geometry: eps = 13 # dielectric constant of waveguide w = 1.2 # width of waveguide r = 0.36 # radius of holes d = 1.4 # defect spacing (ordinary spacing = 1) N = args.N # number of holes on either side of defect # The cell dimensions sy = args.sy # size of cell in y direction (perpendicular to wvg.) pad = 2 # padding between last hole and PML edge dpml = 1 # PML thickness sx = 2 * (pad + dpml + N) + d - 1 # size of cell in x direction cell = mp.Vector3(sx, sy, 0) blk = mp.Block(size=mp.Vector3(mp.inf, w, mp.inf), material=mp.Medium(epsilon=eps)) geometry = [blk] for i in range(N): geometry.append(mp.Cylinder(r, center=mp.Vector3(d / 2 + i))) geometry.append(mp.Cylinder(r, center=mp.Vector3(-(d / 2 + i)))) fcen = args.fcen # pulse center frequency df = args.df # pulse frequency width nfreq = 500 # number of frequencies at which to compute flux sim = mp.Simulation(cell_size=cell, geometry=geometry, sources=[], boundary_layers=[mp.PML(dpml)], resolution=20) if args.resonant_modes: sim.sources.append( mp.Source(mp.GaussianSource(fcen, fwidth=df), mp.Hz, mp.Vector3())) sim.symmetries.append(mp.Mirror(mp.Y, phase=-1)) sim.symmetries.append(mp.Mirror(mp.X, phase=-1)) sim.run( # mp.at_beginning(mp.output_epsilon), mp.after_sources(mp.Harminv(mp.Hz, mp.Vector3(), fcen, df)), until_after_sources=400) # sim.run(mp.at_every(1 / fcen / 20, mp.output_hfield_z), until=1 / fcen) else: sim.sources.append( mp.Source(mp.GaussianSource(fcen, fwidth=df), mp.Ey, mp.Vector3(dpml + (-0.5 * sx)), size=mp.Vector3(0, w))) sim.symmetries.append(mp.Mirror(mp.Y, phase=-1)) freg = mp.FluxRegion(center=mp.Vector3((0.5 * sx) - dpml - 0.5), size=mp.Vector3(0, 2 * w)) # transmitted flux trans = sim.add_flux(fcen, df, nfreq, freg) vol = mp.Volume(mp.Vector3(), size=mp.Vector3(sx)) sim.run(mp.at_beginning(mp.output_epsilon), mp.during_sources( mp.in_volume( vol, mp.to_appended("hz-slice", mp.at_every(0.4, mp.output_hfield_z)))), until_after_sources=mp.stop_when_fields_decayed( 50, mp.Ey, mp.Vector3((0.5 * sx) - dpml - 0.5, 0), 1e-3)) sim.display_fluxes(trans) # print out the flux spectrum
tran_fr1 = mp.FluxRegion(center=mp.Vector3(0.5*cell_x-dpml,0.5*separation_output,0), size=mp.Vector3(0,1*waveguide_width,0)) tran1 = sim.add_flux(fcen, df, nfreq, tran_fr1) # transmitted flux2 tran_fr2 = mp.FluxRegion(center=mp.Vector3(0.5*cell_x-dpml,-0.5*separation_output,0), size=mp.Vector3(0,1*waveguide_width,0)) tran2 = sim.add_flux(fcen, df, nfreq, tran_fr2) # for normal run, load negated fields to subtract incident from refl. fields sim.load_minus_flux_data(refl, straight_refl_data) # Este comando abajo es interesante pues guarda para el gif y tbn actualiza los valores de tx y rx sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended("ez", mp.at_every(20*0.632, mp.output_efield_z)),# TM: _z, TE: _y until=1500/fcen) # ESte codigo es para obtener los kpoints de cada modo, debe de salir igual al lumerical: # Al poner [1,2,3] dara los valores kpoints: TM0 (8 valores), TE0 (8 valores), TM1 (8 valores) # res = sim.get_eigenmode_coefficients(tran, # [1,2,3], # Calculará los valores kpoints # eig_parity=mp.NO_PARITY,#mp.EVEN_Y+mp.ODD_Z if rot_angle == 0 else mp.ODD_Z, # direction=mp.NO_DIRECTION, # kpoint_func=lambda f,n: kpoint) mmi_refl_flux = mp.get_fluxes(refl) mmi_tran1_flux = mp.get_fluxes(tran1) mmi_tran2_flux = mp.get_fluxes(tran2)
def run_simulation(save_prefix, tip_radius=0.007, cone_height=0.364, trunk_radius=0.275, n_tip=3.694, k_tip=0.0, fcen=1.25, waves=7.5, theta_deg=10, sample=20, sx=0.8, sy=1.5, sz=1.0, dpml=0.1, res=1000, res_factor=0.2, X_1=-0.2, X_2=0.2, Y_1=-0.2, Y_2=0.2, Z_1=-0.2, Z_2=0.2, x_mon_rat=1.0, y_mon_rat=1.0, z_mon_rat=1.0): #Interpolate to next resolution step for high-res region dx = 1 / res X_1 = np.floor(X_1 / dx) * dx X_2 = np.ceil(X_2 / dx) * dx Y_1 = np.floor(Y_1 / dx) * dx Y_2 = np.ceil(Y_2 / dx) * dx Z_1 = np.floor(Z_1 / dx) * dx Z_2 = np.ceil(Z_2 / dx) * dx #Dump all the settings to a file: settings_file = h5py.File( Path(sys.argv[0]).stem + '-' + save_prefix + '_settings.h5', 'w') settings_file.create_dataset('tip_radius', data=tip_radius) settings_file.create_dataset('cone_height', data=cone_height) settings_file.create_dataset('trunk_radius', data=trunk_radius) settings_file.create_dataset('n_tip', data=n_tip) settings_file.create_dataset('k_tip', data=k_tip) settings_file.create_dataset('fcen', data=fcen) settings_file.create_dataset('waves', data=waves) settings_file.create_dataset('theta_deg', data=theta_deg) settings_file.create_dataset('sample', data=sample) settings_file.create_dataset('sx', data=sx) settings_file.create_dataset('sy', data=sy) settings_file.create_dataset('sz', data=sz) settings_file.create_dataset('dpml', data=dpml) settings_file.create_dataset('res', data=res) settings_file.create_dataset('res_factor', data=res_factor) settings_file.create_dataset('X_1', data=X_1) settings_file.create_dataset('X_2', data=X_2) settings_file.create_dataset('Y_1', data=Y_1) settings_file.create_dataset('Y_2', data=Y_2) settings_file.create_dataset('Z_1', data=Z_1) settings_file.create_dataset('Z_2', data=Z_2) settings_file.create_dataset('x_mon_rat', data=x_mon_rat) settings_file.create_dataset('y_mon_rat', data=y_mon_rat) settings_file.create_dataset('z_mon_rat', data=z_mon_rat) settings_file.close() #Convert theta to radians theta = theta_deg * np.pi / 180 eps_tip = calc_eps_r(n_tip, k_tip) sig_d_tip = calc_sig_d(n_tip, k_tip, fcen) #Create the cell size sX = 2 * dpml + sx sY = 2 * dpml + sy sZ = 2 * dpml + sz #Monitor sizes x_mon = sx * x_mon_rat y_mon = sx * y_mon_rat z_mon = sx * z_mon_rat #Calculate values in prime-space: sx_prime = sx * res_factor + (X_2 - X_1) * (1 - res_factor) sy_prime = sy * res_factor + (Y_2 - Y_1) * (1 - res_factor) sz_prime = sz * res_factor + (Z_2 - Z_1) * (1 - res_factor) dpml_prime = dpml * res_factor sX_prime = 2 * dpml_prime + sx_prime sY_prime = 2 * dpml_prime + sy_prime sZ_prime = 2 * dpml_prime + sz_prime x_mon_prime = (x_mon/2.0 > X_2)*((x_mon/2.0 - X_2)*res_factor + X_2) +\ (x_mon/2.0)*(x_mon/2.0 <= X_2) -\ (-1*x_mon/2.0 < X_1)*((-1*x_mon/2.0 - X_1)*res_factor + X_1) -\ (-1*x_mon/2.0)*(-1*x_mon/2.0 >= X_1) y_mon_prime = (y_mon/2.0 > Y_2)*((y_mon/2.0 - Y_2)*res_factor + Y_2) +\ (y_mon/2.0)*(y_mon/2.0 <= Y_2) -\ (-1*y_mon/2.0 < Y_1)*((-1*y_mon/2.0 - Y_1)*res_factor + Y_1) -\ (-1*y_mon/2.0)*(-1*y_mon/2.0 >= Y_1) z_mon_prime = (z_mon/2.0 > Z_2)*((z_mon/2.0 - Z_2)*res_factor + Z_2) +\ (z_mon/2.0)*(z_mon/2.0 <= Z_2) -\ (-1*z_mon/2.0 < Z_1)*((-1*z_mon/2.0 - Z_1)*res_factor + Z_1) -\ (-1*z_mon/2.0)*(-1*z_mon/2.0 >= Z_1) cell = mp.Vector3(sX_prime, sY_prime, sZ_prime) tip = [ mp.Cylinder(radius=trunk_radius, center=mp.Vector3( 0.0, -1 * sY / 4.0 - cone_height / 2.0 - tip_radius, 0.0), height=(sY / 2.0 - cone_height), axis=mp.Vector3(0.0, 1.0, 0.0)), mp.Cone(center=mp.Vector3(0, -1 * cone_height / 2 - tip_radius, 0), height=cone_height, radius=trunk_radius, radius2=tip_radius, axis=mp.Vector3(0, 1, 0)), mp.Sphere(center=mp.Vector3(0, -1 * tip_radius, 0), radius=tip_radius) ] def mat_func(r_prime): r_x = r_prime.x r_y = r_prime.y r_z = r_prime.z x_fac = 1 y_fac = 1 z_fac = 1 if (r_prime.x < X_1): x_fac = res_factor r_x = X_1 + (r_prime.x - X_1) / res_factor elif (r_prime.x > X_2): x_fac = res_factor r_x = X_2 + (r_prime.x - X_2) / res_factor if (r_prime.y < Y_1): y_fac = res_factor r_y = Y_1 + (r_prime.y - Y_1) / res_factor elif (r_prime.y > Y_2): y_fac = res_factor r_y = Y_2 + (r_prime.y - Y_2) / res_factor if (r_prime.z < Z_1): z_fac = res_factor r_z = Z_1 + (r_prime.z - Z_1) / res_factor elif (r_prime.z > Z_2): z_fac = res_factor r_z = Z_2 + (r_prime.z - Z_2) / res_factor r = mp.Vector3(r_x, r_y, r_z) J = np.matrix([[x_fac, 0, 0], [0, y_fac, 0], [0, 0, z_fac]]) #Loop through all objects inside of tip and see if point is inside. # if yes -- then set eps_point to tip eps # if no -- then leave it as air eps_point = 1.0 for kk in range(len(tip)): if (mp.is_point_in_object(r, tip[kk])): eps_point = eps_tip eps_transform = eps_point * J * J.transpose() / np.linalg.det(J) mu_transform = J * J.transpose() / np.linalg.det(J) eps_diag = eps_transform.diagonal() mu_diag = mu_transform.diagonal() mat = mp.Medium(epsilon_diag=mp.Vector3(eps_diag[0, 0], eps_diag[0, 1], eps_diag[0, 2]), mu_diag=mp.Vector3(mu_diag[0, 0], mu_diag[0, 1], mu_diag[0, 2]), D_conductivity=sig_d_tip) return mat #Create source amplitude function: ky = fcen * np.sin(theta) ky_prime = ky * sY / sY_prime def my_amp_func_y(r_prime): r_y = r_prime.y y_fac = 1 / res_factor if ((r_prime.x >= X_1) and (r_prime.x <= X_2)): x_fac = 1.0 / res_factor else: x_fac = 1.0 if (r_prime.y < Y_1): y_fac = 1.0 r_y = Y_1 + (r_prime.y - Y_1) / res_factor elif (r_prime.y > Y_2): y_fac = 1.0 r_y = Y_2 + (r_prime.y - Y_2) / res_factor if ((r_prime.z >= Z_1) and (r_prime.z <= Z_2)): z_fac = 1.0 / res_factor else: z_fac = 1.0 J = np.matrix([[x_fac, 0, 0], [0, y_fac, 0], [0, 0, z_fac]]) transform = J / np.linalg.det(J) phase_factor = np.exp(-1 * 2 * 1j * np.pi * ky * r_y) amp_factor = transform.diagonal()[0, 1] return amp_factor * phase_factor def my_amp_func_z(r_prime): r_y = r_prime.y y_fac = 1.0 / res_factor if ((r_prime.x >= X_1) and (r_prime.x <= X_2)): x_fac = 1.0 / res_factor else: x_fac = 1.0 if (r_prime.y < Y_1): y_fac = 1.0 r_y = Y_1 + (r_prime.y - Y_1) / res_factor elif (r_prime.y > Y_2): y_fac = 1.0 r_y = Y_2 + (r_prime.y - Y_2) / res_factor if ((r_prime.z >= Z_1) and (r_prime.z <= Z_2)): z_fac = 1.0 / res_factor else: z_fac = 1.0 J = np.matrix([[x_fac, 0, 0], [0, y_fac, 0], [0, 0, z_fac]]) transform = J / np.linalg.det(J) phase_factor = np.exp(-1 * 2 * 1j * np.pi * ky * r_y) amp_factor = transform.diagonal()[0, 2] return amp_factor * phase_factor #Create PMLs pml_layers = [ mp.PML(thickness=dpml_prime, direction=mp.X), mp.PML(thickness=dpml_prime, direction=mp.Y), mp.PML(thickness=dpml_prime, direction=mp.Z) ] symmetry = [mp.Mirror(direction=mp.X)] #Sources Ey_source = mp.Source(mp.ContinuousSource(frequency=fcen), component=mp.Ey, center=mp.Vector3(0, 0, -1 * sz_prime * 0.5), size=mp.Vector3(sX_prime, sY_prime, 0), amp_func=my_amp_func_y, amplitude=np.cos(theta)) Ez_source = mp.Source(mp.ContinuousSource(frequency=fcen), component=mp.Ez, center=mp.Vector3(0, 0, -1 * sz_prime * 0.5), size=mp.Vector3(sX_prime, sY_prime, 0), amp_func=my_amp_func_z, amplitude=np.sin(theta)) sources = [Ey_source, Ez_source] monitor_xy = mp.Volume(center=mp.Vector3(0, 0, 0), size=mp.Vector3(x_mon_prime, y_mon_prime, 0)) monitor_yz = mp.Volume(center=mp.Vector3(0, 0, 0), size=mp.Vector3(0, y_mon_prime, z_mon_prime)) #Now make the simulation sim = mp.Simulation( cell_size=cell, boundary_layers=pml_layers, geometry=[], sources=sources, resolution=res, symmetries=symmetry, dimensions=3, k_point=mp.Vector3(0, -1 * ky_prime, 0), material_function=mat_func, extra_materials=[mp.Medium(epsilon=eps_tip, mu=4, D_conductivity=1)], verbose=True) sim.run(mp.in_volume( monitor_xy, mp.to_appended(save_prefix + "E_xy", mp.at_every(1 / fcen / sample, mp.output_efield))), mp.in_volume( monitor_yz, mp.to_appended( save_prefix + "E_yz", mp.at_every(1 / fcen / sample, mp.output_efield))), until=waves / fcen)
temp = time() if time_is_after_source: sim.run(*to_do_while_running, until_after_source=run_time) else: sim.run(*to_do_while_running, until=run_time) enlapsed.append(time() - temp) #%% SAVE DATA! vs.savetxt(file("Lines.txt"), results_line, footer=parameters, overwrite=True) del results_line, results_plane #%% OPTION 3: SAVE FULL FIELD ################################################ to_do_while_running = [mp.to_appended("Ez", mp.at_beginning(mp.output_efield_z), mp.at_every(period_line, mp.output_efield_z))] #%% INITIALIZE sim.reset_meep() sim = mp.Simulation(resolution=resolution, cell_size=cell_size, boundary_layers=boundary_layers, sources=sources, symmetries=symmetries, filename_prefix="") sim.use_output_directory(path) sim.init_sim()
def main(args): """ Args: * **fields** (boolean): If true, outputs the fields at the relevant waveguide cross-sections (top-down and side-view) * **output_directory** (string): Name of the output directory (for storing the fields) * **eps_input_file** (string): Name of the hdf5 file that defines the geometry through prisms * **input_pol** (string): Either "TE", or "TM", corresponding to the desired input mode. Defaults to "TE" * **res** (int): Resolution of the MEEP simulation * **nfreq** (int): The number of wavelength points to record in the transmission/reflection spectra * **input_direction** (1 or -1): Direction of propagation for the input eigenmode. If +1, goes in +x, else if -1, goes in -x. Defaults to +1. * **dpml** (float): Length (in microns) of the perfectly-matched layer (PML) at simulation boundaries. Defaults to 0.5 um. * **wl_center** (float): Center wavelength (in microns) * **wl_span** (float): Wavelength span (determines the pulse width) * **port_vcenter** (float): Vertical center of the waveguide * **port_height** (float): Height of the port cross-section (flux plane) * **port_width** (float): Width of the port cross-section (flux plane) * **source_offset** (float): Offset (in x-direction) between reflection monitor and source. Defaults to 0.1 um. * **center_x** (float): x-coordinate of the center of the simulation region * **center_y** (float): y-coordinate of the center of the simulation region * **center_z** (float): z-coordinate of the center of the simulation region * **sx** (float): Size of the simulation region in x-direction * **sx** (float): Size of the simulation region in y-direction * **sz** (float): Size of the simulation region in z-direction * **port_coords** (list): List of the port coordinates (variable length), in the format [x1, y1, x2, y2, x3, y3, ...] (*must* be even) """ #Boolean inputs fields = args.fields #String inputs output_directory = args.output_directory eps_input_file = args.eps_input_file input_pol = args.input_pol #Int inputs res = args.res nfreq = args.nfreq input_direction = args.input_direction #Float inputs dpml = args.dpml wl_center = args.wl_center wl_span = args.wl_span port_vcenter = args.port_vcenter port_height = args.port_height port_width = args.port_width source_offset = args.source_offset center_x, center_y, center_z = args.center_x, args.center_y, args.center_z sx, sy, sz = args.sx, args.sy, args.sz #List of floats port_coords = [float(x) for x in args.port_coords[0].split(" ")] ports = [(port_coords[2 * i], port_coords[2 * i + 1]) for i in range(int(len(port_coords) / 2))] if input_pol == "TE": parity = mp.ODD_Z elif input_pol == "TM": parity = mp.EVEN_Z else: raise ValueError( "Warning! Improper value of 'input_pol' was passed to mcts.py (input_pol given =" + str(input_pol) + ")") if len(port_coords) % 2 != 0: raise ValueError( "Warning! Improper port_coords was passed to `meep_compute_transmission_spectra`. Must be even number of port_coords in [x1, y1, x2, y2, ..] format." ) # Setup the simulation geometries prism_objects = get_prism_objects(eps_input_file) geometry = [] for p in prism_objects: # print('vertices='+str(p['vlist'])) # print('axis = '+str(mp.Vector3(0,1,0))) # print('height = '+str(p['height'])) print('material = ' + str(p['eps'])) # print('\n') geometry.append( mp.Prism(p['vlist'], axis=mp.Vector3(0, 1, 0), height=p['height'], material=mp.Medium(epsilon=p['eps']))) # Setup the simulation sources fmax = 1.0 / (wl_center - 0.5 * wl_span) fmin = 1.0 / (wl_center + 0.5 * wl_span) fcen = (fmax + fmin) / 2.0 df = fmax - fmin if abs(abs(input_direction) - 1) > 1E-6: print(input_direction) raise ValueError("Warning! input_direction is not +1 or -1.") # Use first port in 'ports' as the location of the eigenmode source sources = [ mp.EigenModeSource( src=mp.GaussianSource(fcen, fwidth=df, cutoff=30), component=mp.ALL_COMPONENTS, size=mp.Vector3(0, 3 * float(port_height), 3 * float(port_width)), center=mp.Vector3(ports[0][0] + source_offset - center_x, float(port_vcenter) - center_y, ports[0][1] - center_z), eig_match_freq=True, eig_parity=parity, eig_kpoint=mp.Vector3(float(input_direction) * wl_center, 0, 0), eig_resolution=2 * res if res > 16 else 32, ) ] # Setup the simulation sim = mp.Simulation(cell_size=mp.Vector3(sx, sy, sz), boundary_layers=[mp.PML(dpml)], geometry=geometry, sources=sources, dimensions=3, resolution=res, filename_prefix=False) """ Add power flux monitors """ print("ADDING FLUX MONITORS") flux_plane_objects = [] for port in ports: flux_region = mp.FluxRegion(size=mp.Vector3(0, float(port_height), float(port_width)), center=mp.Vector3( float(port[0]) - center_x, float(port_vcenter) - center_y, float(port[1]) - center_z)) fpo = sim.add_flux(fcen, df, nfreq, flux_region) flux_plane_objects.append(fpo) sim.use_output_directory(str(output_directory)) """ Run the simulation """ """ Monitor the amplitude in the center of the structure """ decay_pt = mp.Vector3(0, port_vcenter, 0) sv = mp.Volume(size=mp.Vector3(sx, sy, 0), center=mp.Vector3(0, 0, 0)) tv = mp.Volume(size=mp.Vector3(sx, 0, sz), center=mp.Vector3(0, port_vcenter, 0)) print("RUNNING SIMULATION") if fields: sim.run(mp.at_beginning(mp.output_epsilon), mp.at_beginning( mp.with_prefix(str("sideview-"), mp.in_volume(sv, mp.output_epsilon))), mp.at_beginning( mp.with_prefix(str("topview-"), mp.in_volume(tv, mp.output_epsilon))), mp.at_every( 1.0, mp.to_appended(str("ez-sideview"), mp.in_volume(sv, mp.output_efield_z))), mp.at_every( 1.0, mp.to_appended(str("ez-topview"), mp.in_volume(tv, mp.output_efield_z))), until_after_sources=mp.stop_when_fields_decayed( 20, mp.Ez, decay_pt, 1e-4)) else: sim.run(until_after_sources=mp.stop_when_fields_decayed( 20, mp.Ez, decay_pt, 1e-4)) sim.display_fluxes(*flux_plane_objects) print("FINISHED SIMULATION")
sources=[src], resolution=10, symmetries=[mp.Mirror(mp.Y)], boundary_layers=[mp.PML(dpml)], filename_prefix=prefix + "-" + label(w)) path_i = os.path.join(path, label(w)) if not os.path.isdir(path_i): sav.new_dir(path_i) os.chdir(path_i) path_freqs.append(path_i) sim.run(mp.at_beginning(mp.output_epsilon), mp.after_sources( mp.to_appended("Ez", mp.at_every(1 / fcen / 20, mp.output_efield_z))), until_after_sources=1 / fcen) end = [end, time()] del i, w, path_i # Output fields for one period at the end. # (If we output at a single time, we might accidentally catch # the Ez field when it is almost zero and get a distorted view.) print("Enlapsed time 2: {:.2f}".format(end[1] - start[1])) #%% PLOTS :P # General parameters nframes_step = 1
def generate_model(params, args): cell = mp.Vector3(params.cell_width, params.cell_height, 0) spheres = mplib.geo2D_spherical_pc(params.ps_n, params.si_n, params.ps_thickness, params.si_thickness, params.cell_height, params.num_layers, params.cell_width/2-200, params.sph_radius, params.sph_spacing, params.offset, params.xoffset) thin_film = mplib.geo2D_thin_film(params.ps_n, params.ps_thickness, params.cell_height, params.cell_width/2-100) pc_ideal = mplib.geo2D_photonic_crystal(params.ps_n, params.other_n, params.ps_thickness, params.cell_height, params.si_thickness, params.si_n, 5, params.cell_width/2-200, 50) geometry = pc_ideal if args.background: geometry = [] ## Gaussian source source_pos = -1*params.cell_width/2 + params.dpml+5 sources = [mp.Source(mp.GaussianSource(frequency=params.freq, fwidth=params.df), mp.Ez, center=mp.Vector3(source_pos,0,0), size=mp.Vector3(0,params.cell_height,0))] pml_layers = [mp.PML(params.dpml, direction=mp.X)] sim = mp.Simulation(cell_size = cell, boundary_layers = pml_layers, geometry = geometry, filename_prefix=args.filename, sources = sources, k_point = mp.Vector3(0,0,0), resolution = params.resolution) freg_trans = mp.FluxRegion(center = mp.Vector3(0.5*params.cell_width - params.dpml - 1,0,0), size = mp.Vector3(0, params.cell_height, 0)) freg_ref = mp.FluxRegion(center = mp.Vector3(source_pos + 10, 0, 0), size = mp.Vector3(0, params.cell_height), weight=1.0) trans_flux = sim.add_flux(params.freq, params.df , 500, freg_trans) ref_flux = sim.add_flux(params.freq, params.df, 500, freg_ref) vol = mp.Volume(mp.Vector3(0), size = mp.Vector3(params.cell_width,0,0)) if not args.reflectflux: sim.load_minus_flux("pulse_bg_flux_{:d}".format(params.wavelength),ref_flux) if args.outdir: print("Output directory: {:s}".format(args.outdir)) sim.use_output_directory(args.outdir) if args.geometry: sim.run(mp.at_beginning(mp.output_epsilon), until=1) else: sim.run(mp.at_beginning(mp.output_epsilon), mp.to_appended("ez", mp.at_every(params.dt, mp.output_efield_z)), #mp.to_appended("ep", mp.at_every(params.dt, mp.output_dpwr)), mp.in_volume(vol, mp.to_appended("ez_slice", mp.at_every(params.dt, mp.output_efield_z))), until=params.time) if args.reflectflux: sim.save_flux("pulse_bg_flux_{:d}".format(params.wavelength),ref_flux) #sim.save_flux("bg_flux_other", trans_flux) sim.display_fluxes(trans_flux, ref_flux)
component=mp.Ez, center=mp.Vector3(-7, -3.5), size=mp.Vector3(0, 1)) ] resolution = 10 sim = mp.Simulation(cell_size=cell, boundary_layers=pml_layers, geometry=geometry, sources=sources, resolution=resolution) sim.run(mp.at_beginning(mp.output_epsilon), mp.at_beginning(mp.output_mu), mp.to_appended("ez", mp.at_every(0.6, mp.output_efield_z)), until=200) """Post-processing""" # plot the epsilon and mu values eps_data = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Dielectric) mu_data = sim.get_array(center=mp.Vector3(), size=cell, component=mp.Permeability) fig, axs = plt.subplots(2, 2) axs[0, 0].imshow(eps_data.transpose(), cmap='binary') axs[0, 1].imshow(mu_data.transpose(), cmap='binary')
arefl_up = sim.add_flux(fcen, df, nfreq, refl_fr_up) arefl_dw = sim.add_flux(fcen, df, nfreq, refl_fr_dw) # for normal run, load negated fields to subtract incident from refl. fields sim.load_minus_flux_data(refl_t, straight_refl_data_t) sim.load_minus_flux_data(refl_b, straight_refl_data_b) sim.load_minus_flux_data(refl_l, straight_refl_data_l) sim.load_minus_flux_data(refl_r, straight_refl_data_r) sim.load_minus_flux_data(refl_up, straight_refl_data_up) sim.load_minus_flux_data(refl_dw, straight_refl_data_dw) sim.use_output_directory('flux-sph_1') sim.run(mp.in_volume(monitor2D, mp.at_beginning(mp.output_epsilon)), mp.in_volume(monitor2D, mp.to_appended("ez", mp.at_every(time_step, mp.output_efield_x))), until_after_sources=mp.stop_when_fields_decayed(add_time,axis,pt,decay)) #get reflected flux from the surfaces scat_refl_data_t = mp.get_fluxes(refl_t) scat_refl_data_b = mp.get_fluxes(refl_b) scat_refl_data_l = mp.get_fluxes(refl_l) scat_refl_data_r = mp.get_fluxes(refl_r) scat_refl_data_up = mp.get_fluxes(refl_up) scat_refl_data_dw = mp.get_fluxes(refl_dw) #get absorbed fluxes from the surfaces abs_refl_data_t = mp.get_fluxes(arefl_t) abs_refl_data_b = mp.get_fluxes(arefl_b) abs_refl_data_l = mp.get_fluxes(arefl_l)