def run_tdse_sims( amplitudes=np.array([0.3, 0.5]) * atomic_electric_field, number_of_cycleses=(6, 12), omegas=np.array([0.2]) * atomic_angular_frequency, r_bound=100 * bohr_radius, mask_inner=75 * bohr_radius, mask_outer=100 * bohr_radius, r_points=500, l_points=300, ): mesh_identifier = f"R={r_bound / bohr_radius:3f}_Nr={r_points}_L={l_points}" specs = [] for amplitude, number_of_cycles, omega in itertools.product( amplitudes, number_of_cycleses, omegas ): pulse = BauerGaussianPulse( amplitude=amplitude, number_of_cycles=number_of_cycles, omega=omega ) pulse_identifier = get_pulse_identifier(pulse) times = np.linspace(-pulse.pulse_center, pulse.pulse_center * 3, 1000) si.vis.xy_plot( f"field__{pulse_identifier}", times, pulse.get_electric_field_amplitude(times), pulse.get_electric_field_envelope(times) * pulse.amplitude, x_unit="fsec", y_unit="atomic_electric_field", **PLOT_KWARGS, ) specs.append( ion.SphericalHarmonicSpecification( f"tdse__{mesh_identifier}__{pulse_identifier}", r_bound=r_bound, r_points=r_points, l_points=l_points, time_initial=times[0], time_final=times[-1], time_step=1 * asec, electric_potential=pulse, mask=potentials.RadialCosineMask( inner_radius=mask_inner, outer_radius=mask_outer ), use_numeric_eigenstates=True, numeric_eigenstate_max_energy=20 * eV, numeric_eigenstate_max_angular_momentum=5, checkpoints=True, checkpoint_dir=SIM_LIB, checkpoint_every=datetime.timedelta(minutes=1), ) ) return si.utils.multi_map(run, specs, processes=2), mesh_identifier
def get_tdse_spec(pulse, times): spec = ion.SphericalHarmonicSpecification( pulse_identifier(pulse), r_bound=100 * u.bohr_radius, r_points=500, l_bound=200, time_initial=times[0], time_final=times[-1], electric_potential=pulse, store_energy_expectation_value=True, store_electric_dipole_moment_expectation_value=True, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=20 * u.eV, numeric_eigenstate_max_angular_momentum=3, electric_potential_dc_correction=True, checkpoints=True, checkpoint_every=datetime.timedelta(minutes=1), checkpoint_dir=SIM_LIB, ) return spec
mask=ion.RadialCosineMask( inner_radius=0.9 * r_bound * bohr_radius, outer_radius=r_bound * bohr_radius, ), store_data_every=10, snapshot_type=ion.SphericalHarmonicSnapshot, snapshot_times=[(t_bound + (n * 100)) * asec for n in range(100)], snapshot_kwargs=dict( plane_wave_overlap__max_wavenumber=60 * per_nm, plane_wave_overlap__wavenumber_points=200, plane_wave_overlap__theta_points=100, ), ) sim = ion.SphericalHarmonicSpecification( f"R={r_bound}_amp={amp}_phase={phase / pi:3f}pi_tB={t_bound}_tE={t_extra}", **spec_kwargs, ).to_sim() OUT_DIR = os.path.join(OUT_DIR, sim.name) print(sim.info()) sim.run() sim.save(target_dir=OUT_DIR) print(sim.info()) # sim.mesh.plot_g(target_dir = OUT_DIR) # sim.mesh.plot_g(target_dir = OUT_DIR, name_postfix = '_25', plot_limit = 25 * bohr_radius) for log in (True, False): si.vis.xy_plot( f"norm_vs_time__log={log}",
initial_state=ion.HydrogenBoundState(1, 0), time_initial=-t_bound * asec, time_final=(t_bound + t_extra) * asec, time_step=1 * asec, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=50 * eV, numeric_eigenstate_max_angular_momentum=5, electric_potential=efield, electric_potential_dc_correction=True, mask=ion.RadialCosineMask(inner_radius=0.8 * bound * bohr_radius, outer_radius=bound * bohr_radius), store_data_every=-1, ) sim = ion.SphericalHarmonicSpecification( f"PWTest_amp={amp}aef_phase={phase / pi:3f}pi__tB={t_bound}pw__tE={t_extra}asec", **spec_kwargs, ).to_sim() sim.run() print(sim.info()) # sim.mesh.plot_g(target_dir = OUT_DIR) # sim.mesh.plot_g(target_dir = OUT_DIR, name_postfix = '_25', plot_limit = 25 * bohr_radius) # # plot_kwargs = dict( # target_dir = OUT_DIR, # bound_state_max_n = 4, # ) # # sim.plot_wavefunction_vs_time(**plot_kwargs, name_postfix = '__no_grouping') # sim.plot_wavefunction_vs_time(**plot_kwargs, name_postfix = '__no_grouping__collapsed_l',
time_final=time_bound * pw, time_step=1 * asec, mask=ion.RadialCosineMask( inner_radius=(r_bound * 0.8) * bohr_radius, outer_radius=r_bound * bohr_radius, ), use_numeric_eigenstates=True, numeric_eigenstate_max_energy=10 * eV, numeric_eigenstate_max_angular_momentum=10, electric_potential_dc_correction=True, store_data_every=20, ) specs = [ ion.SphericalHarmonicSpecification( "cosine", electric_potential=cosine_pulse, **shared_kwargs ), ion.SphericalHarmonicSpecification( "sine", electric_potential=sine_pulse, **shared_kwargs ), ] cosine_sim = specs[0].clone().to_sim() times = cosine_sim.times print(specs) rand_pulses = [] for i in range(num_random_pulses): rand_pulses.append( ion.GenericElectricPotential.from_pulse(
ion.SphericalHarmonicSpecification( # fr'cep={phase / pi:3f}pi', f"pw={pulse_width / asec:3f}as_flu={fluence / Jcm2:3f}jcm2_cep={phase / pi:3f}pi", r_bound=100 * bohr_radius, r_points=400, l_bound=100, time_initial=-10 * pulse_width, time_final=10 * pulse_width, time_step=1 * asec, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=30 * eV, numeric_eigenstate_max_angular_momentum=10, electric_potential=pulse, electric_potential_dc_correction=True, initial_state=initial_state, # animators = [ # ion.animators.PolarAnimator( # postfix = '__g_wavefunction', # axman_wavefunction = ion.animators.SphericalHarmonicPhiSliceMeshAxis( # which = 'g', # colormap = plt.get_cmap('richardson'), # norm = si.vis.RichardsonNormalization(), # plot_limit = 30 * bohr_radius, # ), # axman_lower_right = ion.animators.ElectricPotentialPlotAxis( # show_electric_field = True, # show_vector_potential = False, # show_y_label = False, # show_ticks_right = True, # ), # axman_upper_right = ion.animators.WavefunctionStackplotAxis(states = [initial_state]), # axman_colorbar = None, # target_dir = OUT_DIR, # fig_dpi_scale = 2, # length = 30, # fps = 30, # ), # ] ))
spec_kwargs = dict( r_bound=bound * bohr_radius, r_points=bound * ppbr, l_bound=30, initial_state=state_a, time_initial=0 * asec, time_step=dt * asec, mask=ion.RadialCosineMask(inner_radius=0.8 * bound * bohr_radius, outer_radius=bound * bohr_radius), use_numeric_eigenstates=True, numeric_eigenstate_max_energy=20 * eV, numeric_eigenstate_max_angular_momentum=10, store_data_every=10, ) dummy = ion.SphericalHarmonicSpecification("dummy", **spec_kwargs).to_sim() state_a = dummy.mesh.analytic_to_numeric[state_a] state_b = dummy.mesh.analytic_to_numeric[state_b] dipole_moment = np.abs( dummy.mesh.z_dipole_moment_inner_product(b=state_b)) # print(f'calculated dipole moment between {state_a} and {state_b} is {dipole_moment / (proton_charge * bohr_radius)}') # print(np.sqrt(2) * (2 ** 7) / (3 ** 5)) specs = [] for amplitude, cycle, gauge in itertools.product( amplitudes, cycles, gauges): electric_field = ion.SineWave.from_photon_energy(
FILE_NAME = os.path.splitext(os.path.basename(__file__))[0] OUT_DIR = os.path.join(os.getcwd(), "out", FILE_NAME) if __name__ == "__main__": with si.utils.LogManager("simulacra", "ionization", stdout_logs=True, stdout_level=logging.DEBUG) as logger: bound = 100 points_per_bohr_radius = 4 sim = ion.SphericalHarmonicSpecification( "test", r_bound=bound * bohr_radius, r_points=bound * points_per_bohr_radius, l_bound=50, initial_state=ion.HydrogenBoundState(1, 0), use_numeric_eigenstates=True, numeric_eigenstate_max_energy=10 * eV, numeric_eigenstate_max_angular_momentum=5, ).to_sim() print(sim.info()) print() # for wavenumber, v in sim.mesh.analytic_to_numeric.items(): # print(f'{wavenumber} -> {v}') print() a_state = ion.HydrogenBoundState(1, 0) print(a_state) print(sim.mesh.get_g_for_state(a_state))
numeric_eigenstate_max_energy=50 * eV, numeric_eigenstate_max_angular_momentum=20, electric_potential=efield, electric_potential_dc_correction=True, mask=ion.RadialCosineMask(inner_radius=0.8 * bound * bohr_radius, outer_radius=bound * bohr_radius), store_norm_by_l=True, store_data_every=store_every, animators=ani, snapshot_times=[10 * pw * asec], snapshot_indices=[-1], snapshot_type=ion.SphericalHarmonicSnapshot, ) sim = ion.SphericalHarmonicSpecification( "SumOfSines__flu={}jcm2__{}at{}x{}__data_rate={}".format( flu, bound, points_per_bohr_radius, l_bound, store_every), **spec_kwargs).to_sim() print(sim.info()) sim.run() print(sim.info()) # path = sim.save(target_dir = OUT_DIR, save_mesh = True) # sim = si.Simulation.load(path) sim.mesh.plot_g2(target_dir=OUT_DIR) sim.mesh.plot_g2(target_dir=OUT_DIR, name_postfix="_25", plot_limit=50 * bohr_radius) plot_kwargs = dict(target_dir=OUT_DIR, bound_state_max_n=4)
points_per_bohr_radius = 4 spec_kwargs = { "r_bound": bound * bohr_radius, "r_points": bound * points_per_bohr_radius, "l_bound": 100, "initial_state": ion.HydrogenBoundState(1, 0), "time_initial": -1000 * asec, "time_final": 1000 * asec, "time_step": 1 * asec, "test_states": test_states, } OUT_DIR = os.path.join( OUT_DIR, "bound={}_ppbr={}".format(bound, points_per_bohr_radius)) sim = ion.SphericalHarmonicSpecification("eig", **spec_kwargs).to_sim() with si.utils.LogManager( "simulacra", "ionization", stdout_logs=True, stdout_level=logging.DEBUG, file_logs=True, file_mode="w", file_dir=OUT_DIR, file_name="log", ) as logger: # CONSTRUCT EIGENBASIS numerical_basis = {}
use_numeric_eigenstates=True, numeric_eigenstate_max_energy=200 * eV, numeric_eigenstate_max_angular_momentum=50, electric_potential=ion.SineWave.from_photon_energy( rydberg + 5 * eV, amplitude=0.5 * atomic_electric_field), mask=ion.RadialCosineMask(inner_radius=0.8 * bound * bohr_radius, outer_radius=bound * bohr_radius), ) analytic_test_states = [ ion.HydrogenBoundState(n, l) for n in range(6) for l in range(n) ] sims = [ ion.SphericalHarmonicSpecification("dt={}as_every{}".format( dt, store_every), store_data_every=store_every, **spec_kwargs).to_sim() ] for sim in sims: sim.run() sim.save(target_dir=OUT_DIR, save_mesh=False) plot_kwargs = dict(target_dir=OUT_DIR, img_format="pdf", bound_state_max_n=4) sim.plot_wavefunction_vs_time(**plot_kwargs, name_postfix="__no_grouping") sim.plot_wavefunction_vs_time(
def make_plot(args): pulse_type, pw, flu, cep = args t_bound = T_BOUND_MAP[pulse_type] p_bound = P_BOUND_MAP[pulse_type] times = np.linspace(-t_bound * pw, t_bound * pw, 1e4) window = ion.potentials.LogisticWindow( window_time=p_bound * pw, window_width=0.2 * pw ) pulse = pulse_type(pulse_width=pw, fluence=flu, phase=cep, window=window) corrected_pulse = ion.DC_correct_electric_potential(pulse, times) efield = corrected_pulse.get_electric_field_amplitude(times) afield = corrected_pulse.get_vector_potential_amplitude_numeric_cumulative(times) starts = range(0, len(times), 50)[50:-50] sliced_times = list(times[start:] for start in starts) sliced_alphas = list( (proton_charge / electron_mass) * integ.cumtrapz( y=integ.cumtrapz(y=efield[start:], x=times[start:], initial=0), x=times[start:], initial=0, ) for start in starts ) identifier = f"{pulse_type.__name__}__pw={pw / asec:0f}as_flu={flu / Jcm2:2f}jcm2_cep={cep / pi:2f}pi" spec = ion.SphericalHarmonicSpecification( identifier, r_bound=250 * bohr_radius, r_points=250 * 4, l_bound=500, time_initial=times[0], time_final=times[-1], use_numeric_eigenstates=True, numeric_eigenstate_max_energy=10 * eV, numeric_eigenstate_max_angular_momentum=5, electric_potential=pulse, electric_potential_dc_correction=True, mask=ion.RadialCosineMask( inner_radius=225 * bohr_radius, outer_radius=250 * bohr_radius ), checkpoints=True, checkpoint_every=50, checkpoint_dir=SIM_LIB, ) sim = si.utils.find_or_init_sim(spec, search_dir=SIM_LIB) if sim.status != si.Status.FINISHED: sim.run_simulation() sim.save(target_dir=SIM_LIB) si.vis.xxyy_plot( identifier, [times, times, sim.times, *sliced_times], [ efield / atomic_electric_field, afield * (proton_charge / atomic_momentum), sim.radial_position_expectation_value_vs_time / bohr_radius, *(alpha / bohr_radius for alpha in sliced_alphas), ], line_labels=[ rf"$ {ion.vis.LATEX_EFIELD}(t) $", rf"$ e \, {ion.LATEX_AFIELD}(t) $", rf"$ \left\langle r(t) \right\rangle $", rf"$ \alpha(t) $", ], line_kwargs=[ None, None, None, *({"color": "black", "alpha": 0.5} for _ in starts), ], x_label=r"Time $t$", x_unit="asec", # y_label = r'Field Amplitude (a.u.) / Distance ($a_0$)', title=rf"$ \tau = {pw / asec:0f} \, \mathrm{{as}}, \; H = {flu / Jcm2:2f} \, \mathrm{{J/cm^2}}, \; \varphi = {cep / pi:2f}\pi $", **PLOT_KWARGS, )
axman_lower_right=deepcopy(axman_lower_right), axman_upper_right=animation.animators. WavefunctionStackplotAxis(states=[initial_state]), **animator_kwargs, ), ] specs.append( ion.SphericalHarmonicSpecification( name, electric_potential=efield, time_initial=-t_bound * pw, time_final=t_bound * pw, time_step=dt * asec, r_points=r_points, r_bound=r_bound * bohr_radius, l_bound=l_bound, initial_state=initial_state, mask=mask, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=50 * eV, numeric_eigenstate_max_angular_momentum=20, animators=deepcopy(animators), electric_potential_dc_correction=True, store_data_every=5, )) si.utils.multi_map(run, specs, processes=4) print(timer)
number_of_cycles=10) shared_kwargs = dict( electric_potential=pulse, time_initial=-time_bound * pulse.pulse_width, time_final=time_bound * pulse.pulse_width, # electric_potential_dc_correction = True, ) tdse_spec = ion.SphericalHarmonicSpecification( "tdse", r_bound=100 * bohr_radius, r_points=500, l_bound=100, time_step=1 * asec, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=20 * eV, numeric_eigenstate_max_angular_momentum=20, mask=potentials.RadialCosineMask(inner_radius=75 * bohr_radius, outer_radius=100 * bohr_radius), **shared_kwargs, ) ide_spec = ide.IntegroDifferentialEquationSpecification( "ide", time_step=0.5 * asec, kernel=ide. LengthGaugeHydrogenKernelWithContinuumContinuumInteraction(), **shared_kwargs, )
def compare_quasistatic_to_tdse(intensity, photon_energy): dummy = ion.SineWave.from_photon_energy(0.5 * eV) time_initial = 0 time_final = 8 * dummy.period_carrier time_front = 1 * dummy.period_carrier time_plateau = 5 * dummy.period_carrier efield = ion.SineWave.from_photon_energy_and_intensity( photon_energy, intensity) efield.window = ion.potentials.SmoothedTrapezoidalWindow( time_front=time_front, time_plateau=time_plateau) r_bound = 100 r_points = 4 * r_bound l_bound = 400 dt = 4 store = 5 h = hash(( intensity, photon_energy, time_initial, time_final, time_front, time_plateau, r_bound, r_points, l_bound, dt, store, )) title = f"P={intensity / atomic_intensity:5f}_E={photon_energy / eV:1f}_R={r_bound}_Rp={r_points}_L={l_bound}_dt={dt}_sde={store}" spec = ion.SphericalHarmonicSpecification( f"tdse_{h}", r_bound=r_bound * bohr_radius, r_points=r_points, l_bound=l_bound, internal_potential=ion.SoftCoulomb(softening_distance=0.05 * bohr_radius), time_initial=time_initial, time_final=time_final, time_step=dt * asec, electric_potential=efield, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=20 * eV, numeric_eigenstate_max_angular_momentum=5, store_data_every=store, checkpoints=True, checkpoint_dir=SIM_LIB, checkpoint_every=50, mask=ion.RadialCosineMask(0.9 * r_bound * bohr_radius, r_bound * bohr_radius), ) sim = si.utils.find_or_init_sim(spec, search_dir=SIM_LIB) sim.info().log() if not sim.status == si.Status.FINISHED: sim.run_simulation(progress_bar=True) sim.info().log() sim.save(target_dir=SIM_LIB) sim.plot_wavefunction_vs_time(**PLOT_KWARGS) times = np.linspace(time_initial, time_final, 1e3) si.vis.xy_plot( title + "__efield_vs_time", times, efield.get_electric_field_amplitude(times), x_label=r"Time $t$", x_unit="asec", y_label=fr"$ {ion.vis.LATEX_EFIELD}(t) $)", y_unit="atomic_electric_field", **PLOT_KWARGS, ) tunneling_rate_vs_time = instantaneous_tunneling_rate( efield.get_electric_field_amplitude(times), sim.spec.initial_state.energy) si.vis.xy_plot( title + "__tunneling_rate_vs_time", times, tunneling_rate_vs_time * asec, x_label=r"Time $t$", x_unit="asec", y_label=r"Tunneling Rate ($\mathrm{as}^{-1}$)", **PLOT_KWARGS, ) wavefunction_remaining = np.empty_like(times) wavefunction_remaining[0] = 1 for ii, tunneling_rate in enumerate(tunneling_rate_vs_time[:-1]): wavefunction_remaining[ii + 1] = wavefunction_remaining[ii] * ( 1 - (tunneling_rate * np.abs(times[ii + 1] - times[ii]))) cycle_avg_rate = averaged_tunneling_rate(efield.amplitude) cycle_avg_norm_remaining_plat = np.exp(-cycle_avg_rate * time_plateau) cycle_avg_norm_remaining_all = np.exp(-cycle_avg_rate * (time_plateau + (2 * time_front))) for log in (True, False): si.vis.xxyy_plot( title + f"__comparison__log={log}", (sim.data_times, sim.data_times, sim.data_times, times), ( sim.norm_vs_time, sim.total_bound_state_overlap_vs_time, sim.state_overlaps_vs_time[sim.spec.initial_state], wavefunction_remaining, ), line_labels=( "TDSE Norm", "TDSE Bound States", "TDSE Initial State", "Tunneling", ), x_label=r"Time $t$", x_unit="fsec", y_label="Remaining Wavefunction", y_log_axis=log, hlines=[ cycle_avg_norm_remaining_plat, cycle_avg_norm_remaining_all ], hline_kwargs=[{ "linestyle": "--" }, { "linestyle": ":" }], **PLOT_KWARGS, )
ion.LineSpecification( prefix + "__fsw_len", internal_potential=internal_potential, initial_state=fsw_initial_state, evolution_gauge="LEN", **shared_kwargs, ), # ion.LineSpecification( # prefix + '__line_vel', # internal_potential = internal_potential, # initial_state = ion.FiniteSquareWellState.from_potential(internal_potential, mass = test_mass), # evolution_gauge = 'VEL', # **shared_kwargs, # ), ion.SphericalHarmonicSpecification(prefix + "__hyd_len", evolution_gauge="LEN", **shared_kwargs), # ion.SphericalHarmonicSpecification( # prefix + '__hyd_vel', # evolution_gauge = 'VEL', # **shared_kwargs, # ), ide.IntegroDifferentialEquationSpecification( prefix + "__ide_len", integral_prefactor=ide.gaussian_prefactor_LEN( test_width, test_charge), kernel=ide.gaussian_kernel_LEN, kernel_kwargs={ "tau_alpha": ide.gaussian_tau_alpha_LEN(test_width, test_mass) },
for l in range(test_states_l_points) ] # test_states += coulomb_states logger.info("Warning: using {} test states".format(len(test_states))) # SET UP SIM sim = ion.SphericalHarmonicSpecification( identifier, r_bound=space_bound, r_points=r_points, l_bound=l_bound, # time_initial = - time_bound, time_final = time_bound, time_step = dt, time_initial=0, time_final=electric_field.period_carrier * 20, time_step=dt, internal_potential=ion.Coulomb(), electric_potential=electric_field, initial_state=initial_state, test_states=test_states, mask=mask, ).to_sim() sim.info().log() sim.run() sim.info().log() sim.plot_wavefunction_vs_time(target_dir=OUT_DIR) overlap_by_energy = {s.energy: 0 for s in coulomb_states}
) as logger: bound = 70 points_per_bohr_radius = 4 spec_kwargs = dict( r_bound=bound * bohr_radius, r_points=bound * points_per_bohr_radius, l_bound=70, initial_state=ion.HydrogenBoundState(1, 0), time_initial=0 * asec, time_final=500 * asec, time_step=1 * asec, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=200 * eV, numeric_eigenstate_max_angular_momentum=50, electric_potential=ion.SineWave.from_photon_energy( rydberg + 5 * eV, amplitude=0.5 * atomic_electric_field), mask=ion.RadialCosineMask(inner_radius=0.8 * bound * bohr_radius, outer_radius=bound * bohr_radius), out_dir=OUT_DIR, ) every = [1, 5, 10, 100, 600] specs = [ ion.SphericalHarmonicSpecification("eig_{}".format(e), store_data_every=e, **spec_kwargs) for e in every ] si.utils.multi_map(run, specs, processes=2)
fluence=flu, phase=cep, number_of_cycles=n_cycles, number_of_pulse_widths=3, window=ion.potentials.LogisticWindow( window_time=pulse_time_bound * pw, window_width=0.2 * pw), ) specs.append( ion.SphericalHarmonicSpecification( f"{pulse_type.__name__}__Nc={n_cycles}_pw={pw / asec:3f}as_flu={flu / Jcm2:3f}jcm2_cep={cep / pi:3f}pi__R={r_bound / bohr_radius:3f}br_ppbr={r_points_per_br}_L={l_bound}_dt={dt / asec:3f}as", r_bound=r_bound, r_points=r_points_per_br * r_bound / bohr_radius, l_bound=l_bound, time_step=dt, time_initial=-sim_time_bound * pw, time_final=(sim_time_bound + extra_end_time) * pw, mask=ion.RadialCosineMask(0.8 * r_bound, r_bound), electric_potential=pulse, electric_potential_dc_correction=True, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=20 * eV, numeric_eigenstate_max_angular_momentum=20, checkpoints=True, checkpoint_dir=SIM_LIB, checkpoint_every=datetime.timedelta(minutes=1), store_radial_probability_current=True, )) si.utils.multi_map(run_spec, specs, processes=4)
with si.utils.LogManager( "simulacra", "ionization", stdout_logs=True, stdout_level=logging.DEBUG, file_logs=False, file_mode="w", file_dir=OUT_DIR, file_name="log", ) as logger: bound = 100 points_per_bohr_radius = 4 l_max = 10 energy = 20 sim = ion.SphericalHarmonicSpecification( "eig", r_bound=bound * bohr_radius, r_points=bound * points_per_bohr_radius, l_bound=50, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=energy * eV, numeric_eigenstate_max_angular_momentum=l_max, ).to_sim() print("max?:", ((bound * points_per_bohr_radius) - 2) * (l_max + 1)) print("total:", len(sim.spec.test_states)) bound = len(list(sim.bound_states)) free = len(list(sim.free_states)) print("{} free + {} bound = {} total".format(free, bound, free + bound))
r_points=100 * 10, l_bound=500, use_numeric_eigenstates=False, numeric_eigenstate_max_energy=20 * u.eV, numeric_eigenstate_max_angular_momentum=10, store_data_every=10, checkpoints=True, checkpoint_dir=SIM_LIB, checkpoint_every=datetime.timedelta(minutes=1), ) specs = [ ion.SphericalHarmonicSpecification( "uncorrected_cos", electric_potential=uncorrected_cos_pulse, electric_potential_dc_correction=False, electric_potential_fluence_correction=False, **spec_kwargs, ), ion.SphericalHarmonicSpecification( "uncorrected_sin", electric_potential=uncorrected_sin_pulse, electric_potential_dc_correction=False, electric_potential_fluence_correction=False, **spec_kwargs, ), ion.SphericalHarmonicSpecification( "dc_corrected_cos", electric_potential=uncorrected_cos_pulse, electric_potential_dc_correction=True, electric_potential_fluence_correction=False,
points_per_bohr_radius = 4 spec_kwargs = { "r_bound": bound * bohr_radius, "r_points": bound * points_per_bohr_radius, "l_bound": 100, "initial_state": ion.HydrogenBoundState(1, 0), "time_initial": 0 * asec, "time_final": 200 * asec, "time_step": 1 * asec, } OUT_DIR = os.path.join( OUT_DIR, "bound={}_ppbr={}".format(bound, points_per_bohr_radius) ) sim = ion.SphericalHarmonicSpecification("eig", **spec_kwargs).to_sim() with si.utils.LogManager( "simulacra", "ionization", stdout_logs=True, stdout_level=logging.INFO, file_logs=True, file_mode="w", file_dir=OUT_DIR, file_name="log", ) as logger: for l in range(l_bound): logger.info("working on l = {}".format(l)) h = sim.mesh._get_internal_hamiltonian_matrix_operator_single_l(l=l) with si.utils.BlockTimer() as t:
end_time=300 * asec, amplitude=1 * atomic_electric_field, ) base_spec_kwargs = dict( r_bound=50 * bohr_radius, r_points=200, l_bound=50, time_initial=0 * asec, time_final=400 * asec, use_numeric_eigenstates=True, electric_potential=efield, electric_potential_dc_correction=True, ) specs = [] for name, dt in zip( (".5as", "1as", "5as", "dense_center"), (0.5 * asec, 1 * asec, 5 * asec, dense_center), ): specs.append( ion.SphericalHarmonicSpecification( name, time_step=dt, **base_spec_kwargs ) ) results = si.utils.multi_map(run_spec, specs) for r in sorted(results, key=lambda r: r.running_time): print(r.running_time, r.name)
pulse_widths = [290, 310, 390, 410] # pulse_widths = [50, 100, 200, 400, 600, 800] t_step = 2 * asec mask = ion.RadialCosineMask(inner_radius=100 * bohr_radius, outer_radius=150 * bohr_radius) specs = [] for phase in ("cos", "sin"): for pw in pulse_widths: sinc = ion.potentials.SincPulse.from_amplitude_density( pulse_width=pw * asec, amplitude_density=source.amplitude_omega, phase=phase, ) specs.append( ion.SphericalHarmonicSpecification( "pw={}asec_phase={}".format(pw, phase), r_bound=150 * bohr_radius, r_points=600, l_bound=100, electric_potential=sinc, mask=mask, time_initial=-15 * pw * asec, time_final=15 * pw * asec, time_step=t_step, )) si.utils.multi_map(run, specs)
animators = [ src.ionization.animators.SphericalHarmonicAnimator( postfix="_nm", target_dir=OUT_DIR, distance_unit="nm"), src.ionization.animators.SphericalHarmonicAnimator( postfix="_br", target_dir=OUT_DIR, distance_unit="bohr_radius"), ] specs.append( ion.SphericalHarmonicSpecification( "sph_harm", time_initial=t_init * asec, time_final=t_final * asec, time_step=dt * asec, r_bound=bound * bohr_radius, r_points=radial_points, l_bound=angular_points, initial_state=initial_state, electric_potential=e_field, mask=mask, animators=animators, )) ####### mass = electron_mass pot = ion.HarmonicOscillator.from_energy_spacing_and_mass( energy_spacing=1 * eV, mass=mass) init = ion.QHOState.from_potential( pot, mass, n=1) + ion.QHOState.from_potential(pot, mass, n=2)
# target_dir = OUT_DIR, # axman_wavefunction = ion.animators.SphericalHarmonicPhiSliceMeshAxis( # norm = si.vis.AbsoluteRenormalize(), # ), # ) # ] ) specs = [] for gauge in ("LEN", "VEL"): for r_points, l_bound in itertools.product([200, 201], [30, 31]): specs.append( ion.SphericalHarmonicSpecification( f"{gauge}__R={r_points}_L={l_bound}", r_points=r_points, l_bound=l_bound, evolution_gauge=gauge, **spec_base, )) results = si.utils.multi_map(run_sim, specs, processes=3) si.vis.xxyy_plot( "dipole_moment", (r.data_times for r in results), (r.electric_dipole_moment_expectation_value_vs_time for r in results), line_labels=(r.name for r in results), line_kwargs=({ "linestyle": "-" }, {
axman_lower_right=deepcopy(epot_axman), axman_upper_right=deepcopy(wavefunction_axman), axman_colorbar=None, fig_dpi_scale=2, **anim_kwargs, ), ] sim = ion.SphericalHarmonicSpecification( "sph_harm", time_initial=0 * asec, time_final=100 * asec, r_bound=50 * bohr_radius, l_bound=20, r_points=200, electric_potential=ion.potentials.Rectangle( start_time=25 * asec, end_time=75 * asec, amplitude=1 * atomic_electric_field, ), # test_states = (ion.HydrogenBoundState(n, l) for n in range(5) for l in range(n)), use_numeric_eigenstates=True, numeric_eigenstate_max_energy=10 * eV, numeric_eigenstate_max_angular_momentum=5, animators=animators, ).to_sim() sim.info().log() sim.run() sim.info().log()
for r_points, time_step in it.product(r_points_list, time_step_list): spec_name = [prefix] + [ "{}x{}".format(r_points, l_bound), "dt={}as".format(time_step), ] specs.append( ion.SphericalHarmonicSpecification( "__".join(spec_name), r_bound=r_bound * bohr_radius, r_points=int(r_points), l_bound=l_bound, time_step=time_step * asec, time_initial=-t_bound * asec, time_final=t_bound * asec, electric_potential=electric_potential, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=10 * eV, numeric_eigenstate_max_angular_momentum=0, store_data_every=0, dr=r_bound / r_points, dt=time_step, )) sims = si.utils.multi_map(run_spec, specs, processes=6) # with open(os.path.join(OUT_DIR, 'ref_info.txt'), mode = 'w') as f: # print(sims[0].info(), file = f) # r_points_per_br_set = set(sim.spec.r_points_per_br for sim in sims) # time_steps_set = set(sim.spec.dt for sim in sims)
plot_limit=30 * bohr_radius, ), src.ionization.animators.SphericalHarmonicAnimator( postfix="100", target_dir=OUT_DIR, plot_limit=100 * bohr_radius, ), ] spec = ion.SphericalHarmonicSpecification( prefix + "harm_CN_4", time_initial=t_init, time_final=t_final, time_step=dt, r_bound=bound * bohr_radius, r_points=bound * 4, l_bound=angular_points, initial_state=state, internal_potential=internal_potential, electric_potential=e_field, animators=animators, mask=mask, evolution_method="CN", ) specs.append(spec) spec = ion.SphericalHarmonicSpecification( prefix + "harm_SO_4", time_initial=t_init, time_final=t_final, time_step=dt, r_bound=bound * bohr_radius,
pulse = ion.potentials.SincPulse( pulse_width=pw, fluence=1 * Jcm2, window=ion.potentials.LogisticWindow(window_time=30 * pw, window_width=0.2 * pw), ) sim = ion.SphericalHarmonicSpecification( "very_long_pulse", r_bound=200 * bohr_radius, r_points=1000, l_bound=400, mask=ion.RadialCosineMask(inner_radius=80 * bohr_radius, outer_radius=100 * bohr_radius), time_initial=-32 * pw, time_final=32 * pw, time_step=dt, electric_potential=pulse, use_numeric_eigenstates=True, numeric_eigenstate_max_energy=10 * eV, numeric_eigenstate_max_angular_momentum=10, electric_potential_dc_correction=True, store_data_every=20, ).to_sim() sim.info().log() si.vis.xy_plot( "efield_vs_time", sim.times, sim.spec.electric_potential.get_electric_field_amplitude(