diff --git a/abel/__init__.py b/abel/__init__.py index 1a1d007f..2af08860 100644 --- a/abel/__init__.py +++ b/abel/__init__.py @@ -21,7 +21,8 @@ from .classes.interstage.interstage import Interstage from .classes.rf_accelerator.rf_accelerator import RFAccelerator, RFAcceleratorInitializationException from .classes.bds.bds import BeamDeliverySystem -from .classes.spectrometer.spectrometer import Spectrometer +from .classes.spectrometer import Spectrometer +from .classes.spectrometer.quad_imaging import SpectrometerQuadImaging from .classes.damping_ring.damping_ring import DampingRing from .classes.combiner_ring.combiner_ring import CombinerRing from .classes.turnaround.turnaround import Turnaround @@ -30,9 +31,12 @@ from .classes.beamline.impl.linac.linac import Linac from .classes.beamline.impl.linac.impl.plasma_linac import PlasmaLinac from .classes.beamline.impl.linac.impl.conventional_linac import ConventionalLinac -from .classes.beamline.impl.experiment.experiment import Experiment -from .classes.beamline.impl.experiment.impl.experiment_pwfa import ExperimentPWFA -from .classes.beamline.impl.experiment.impl.experiment_apl import ExperimentAPL + +from .classes.beamline.impl.experiment import Experiment +from .classes.beamline.impl.experiment.pwfa import ExperimentPWFA +from .classes.beamline.impl.experiment.pwfa.preset.flashforward import FLASHForward +from .classes.beamline.impl.experiment.pwfa.preset.facet2 import FACET2 +from .classes.beamline.impl.experiment.apl import ExperimentAPL from .classes.collider.collider import Collider @@ -40,6 +44,7 @@ from .classes.source.impl.source_trapezoid import SourceTrapezoid from .classes.source.impl.source_combiner import SourceCombiner from .classes.source.impl.source_from_file import SourceFromFile +from .classes.source.impl.source_from_profile import SourceFromProfile from .classes.source.impl.source_flattop import SourceFlatTop from .classes.source.impl.source_capsule import SourceCapsule from .classes.stage.impl.stage_basic import StageBasic @@ -67,8 +72,9 @@ from .classes.transfer_line.impl.transfer_line_basic import TransferLineBasic from .classes.bds.impl.bds_basic import BeamDeliverySystemBasic from .classes.bds.impl.bds_fbt import BeamDeliverySystemFlatBeamTransformer -from .classes.spectrometer.impl.spectrometer_facet_ocelot import SpectrometerFacetOcelot -from .classes.spectrometer.impl.spectrometer_basic_clear import SpectrometerBasicCLEAR +from .classes.spectrometer.quad_imaging.preset.facet2 import SpectrometerFACET2 +#from .classes.spectrometer.impl.spectrometer_facet_ocelot import SpectrometerFacetOcelot +#from .classes.spectrometer.impl.spectrometer_basic_clear import SpectrometerBasicCLEAR from .classes.ip.impl.ip_basic import InteractionPointBasic from .classes.ip.impl.ip_guineapig import InteractionPointGuineaPig diff --git a/abel/apis/hipace/hipace_api.py b/abel/apis/hipace/hipace_api.py index 0760ed0c..e65c20c2 100644 --- a/abel/apis/hipace/hipace_api.py +++ b/abel/apis/hipace/hipace_api.py @@ -29,6 +29,8 @@ def hipace_write_inputs(filename_input, filename_beam, filename_driver, plasma_d # driver-only mode if driver_only: beam_components = 'driver' + elif filename_driver is None: + beam_components = 'beam' else: beam_components = 'driver beam' @@ -159,12 +161,18 @@ def hipace_run(filename_job_script, num_steps, runfolder=None, quiet=False): # when finished, load the beam and driver filename = os.path.join(runfolder, "diags/hdf5/openpmd_{:06}.h5".format(int(num_steps))) - + + # attempt to load the beam try: beam = Beam.load(filename, beam_name='beam') except: beam = None - driver = Beam.load(filename, beam_name='driver') + + # attempt to load the driver + try: + driver = Beam.load(filename, beam_name='driver') + except: + driver = None return beam, driver diff --git a/abel/classes/beam.py b/abel/classes/beam.py index 1b9a107f..a30816b7 100644 --- a/abel/classes/beam.py +++ b/abel/classes/beam.py @@ -19,7 +19,7 @@ class Beam(): - def __init__(self, phasespace=None, num_particles=1000, num_bunches_in_train=1, bunch_separation=0.0): + def __init__(self, phasespace=None, num_particles=1000, num_bunches_in_train=1, bunch_separation=0.0, location=0.0, particle_mass=SI.m_e): # check the inputs if num_particles < 1 or not isinstance(num_particles, int): @@ -41,7 +41,10 @@ def __init__(self, phasespace=None, num_particles=1000, num_bunches_in_train=1, self.trackable_number = -1 # will increase to 0 after first tracking element self.stage_number = 0 - self.location = 0 + self.location = location + + # particle mass + self.particle_mass = particle_mass # reset phase space @@ -1685,8 +1688,7 @@ def plot_transverse_profile(self): ax.set_title('Transverse profile') cb = fig.colorbar(p) cb.ax.set_ylabel('Charge density (pC/um^2)') - - + # TODO: unfinished! # def plot_bunch_pattern(self): diff --git a/abel/classes/beamline/impl/experiment/__init__.py b/abel/classes/beamline/impl/experiment/__init__.py new file mode 100644 index 00000000..326602bc --- /dev/null +++ b/abel/classes/beamline/impl/experiment/__init__.py @@ -0,0 +1,84 @@ +from abc import abstractmethod +from abel.CONFIG import CONFIG +from abel.classes.beamline.beamline import Beamline +from abel.classes.beamline.impl.linac.linac import Linac +from abel.classes.source.source import Source +from abel.classes.spectrometer import Spectrometer +import numpy as np + +class Experiment(Beamline): + + def __init__(self, linac=None, test_device=None, spectrometer=None, num_bunches_in_train=1, bunch_separation=0, rep_rate_trains=10): + super().__init__(num_bunches_in_train, bunch_separation, rep_rate_trains) + + self.linac = linac + self.test_device = test_device + self.spectrometer = spectrometer + + + + # assemble the trackables + def assemble_trackables(self): + + self.trackables = [] + + # add the linac/source + assert(isinstance(self.linac, Linac) or isinstance(self.linac, Source)) + self.trackables.append(self.linac) + + # add the experimental test device + self.trackables.append(self.test_device) + + # add the spectrometer (if it exists + if self.spectrometer is not None: + assert(isinstance(self.spectrometer, Spectrometer)) + self.trackables.append(self.spectrometer) + + # set the bunch train pattern etc. + super().assemble_trackables() + + + def energy_usage(self): + return 0 + + def get_nom_beam_power(self): + return 0 + + def get_cost_breakdown(): + return ('Experiment', 0) + + + # plot the spectrometer screen + def plot_spectrometer_screen(self, xlims=None, ylims=None): + + from matplotlib import pyplot as plt + + # load phase space + beam = self.final_beam + + # make screen projection + xbins, ybins = None, None + num_bins = round(np.sqrt(len(beam))/2) + if xlims is not None: + xbins = np.linspace(min(xlims), max(xlims), num_bins) + if ylims is not None: + ybins = np.linspace(min(ylims), max(ylims), num_bins) + dQdxdy, xedges, yedges = beam.density_transverse(hbins=xbins, vbins=ybins) + + # prepare figure + fig, ax = plt.subplots(1, 1) + fig.set_figwidth(6) + fig.set_figheight(9) + + # plot spectrometer image + c0 = ax.pcolor(xedges*1e3, yedges * 1e3, abs(dQdxdy) * 1e3, cmap=CONFIG.default_cmap, shading='auto') + + # make plot + ax.set_xlabel('x (mm)') + ax.set_ylabel('y (mm)') + ax.set_title('Spectrometer screen (shot ' + str(self.shot+1) + ')') + ax.grid(False, which='major') + cbar0 = fig.colorbar(c0, ax=ax, pad = 0.015*fig.get_figwidth()) + cbar0.ax.set_ylabel('Charge density (nC ' r'$\mathrm{mm^{-2})}$') + ax.set_ylim(min(yedges * 1e3), max(yedges * 1e3)) + \ No newline at end of file diff --git a/abel/classes/beamline/impl/experiment/impl/experiment_apl.py b/abel/classes/beamline/impl/experiment/apl/__init__.py similarity index 59% rename from abel/classes/beamline/impl/experiment/impl/experiment_apl.py rename to abel/classes/beamline/impl/experiment/apl/__init__.py index 37093190..c20084c9 100644 --- a/abel/classes/beamline/impl/experiment/impl/experiment_apl.py +++ b/abel/classes/beamline/impl/experiment/apl/__init__.py @@ -1,4 +1,4 @@ -from abel.classes.beamline.impl.experiment.experiment import Experiment +from abel.classes.beamline.impl.experiment import Experiment from abel.classes.plasma_lens.plasma_lens import PlasmaLens class ExperimentAPL(Experiment): @@ -6,16 +6,16 @@ class ExperimentAPL(Experiment): def __init__(self, linac=None, plasma_lens=None, spectrometer=None): self.plasma_lens = plasma_lens - super().__init__(linac=linac, component=plasma_lens, spectrometer=spectrometer) + super().__init__(linac=linac, test_device=plasma_lens, spectrometer=spectrometer) # assemble the trackables def assemble_trackables(self): # check element classes, then assemble - if self.component is None: - self.component = self.plasma_lens - assert(isinstance(self.component, PlasmaLens)) + if self.test_device is None: + self.test_device = self.plasma_lens + assert(isinstance(self.test_device, PlasmaLens)) # run beamline constructor super().assemble_trackables() diff --git a/abel/classes/beamline/impl/experiment/experiment.py b/abel/classes/beamline/impl/experiment/experiment.py deleted file mode 100644 index d68337d5..00000000 --- a/abel/classes/beamline/impl/experiment/experiment.py +++ /dev/null @@ -1,119 +0,0 @@ -from abc import abstractmethod -from abel.CONFIG import CONFIG -from abel.classes.beamline.beamline import Beamline -from abel.classes.beamline.impl.linac.linac import Linac -from abel.classes.source.source import Source -from abel.classes.spectrometer.spectrometer import Spectrometer -import numpy as np - -class Experiment(Beamline): - - def __init__(self, linac=None, component=None, spectrometer=None, num_bunches_in_train=1, bunch_separation=0, rep_rate_trains=10): - super().__init__(num_bunches_in_train, bunch_separation, rep_rate_trains) - - self.linac = linac - self.component = component - self.spectrometer = spectrometer - - - - # assemble the trackables - def assemble_trackables(self): - - self.trackables = [] - - # add the linac/source - assert(isinstance(self.linac, Linac) or isinstance(self.linac, Source)) - self.trackables.append(self.linac) - - # add the experimental component - self.trackables.append(self.component) - - # add the spectrometer (if it exists - if self.spectrometer is not None: - assert(isinstance(self.spectrometer, Spectrometer)) - self.trackables.append(self.spectrometer) - - # set the bunch train pattern etc. - super().assemble_trackables() - - - def energy_usage(self): - return 0 - - def get_nom_beam_power(self): - return 0 - - def get_cost_breakdown(): - return ('Experiment', 0) - - # density plots - def plot_spectrometer_screen(self, xlims=None, ylims=None, E_calib = False, diverg = None, plot_m12 = False, savefig = None): - - from matplotlib import pyplot as plt - import warnings - - # load phase space - beam = self.final_beam - - # make screen projection - xbins, ybins = None, None - num_bins = round(np.sqrt(len(beam))/2) - if xlims is not None: - xbins = np.linspace(min(xlims), max(xlims), num_bins) - if ylims is not None: - ybins = np.linspace(min(ylims), max(ylims), num_bins) - dQdxdy, xedges, yedges = beam.density_transverse(hbins=xbins, vbins=ybins) - - # prepare figure - fig, ax = plt.subplots(2, 1, gridspec_kw={'height_ratios': [2, 1]}) - fig.set_figwidth(8) - fig.set_figheight(8) - - # current profile - c0 = ax[0].pcolor(xedges*1e3, yedges * 1e3, abs(dQdxdy) * 1e3, cmap=CONFIG.default_cmap, shading='auto') - - # make plot - ax[0].set_xlabel('x (mm)') - ax[0].set_ylabel('y (mm)') - ax[0].set_title('Spectrometer screen (shot ' + str(self.shot+1) + ')') - ax[0].grid(False, which='major') - cbar0 = fig.colorbar(c0, ax=ax[0], pad = 0.015*fig.get_figwidth()) - cbar0.ax.set_ylabel('Charge density (nC ' r'$\mathrm{mm^{-2})}$') - ax[0].set_ylim(min(yedges * 1e3), max(yedges * 1e3)) - - # calculate energy axis (E = E0*Dy/y) - Dy_img = self.spectrometer.get_dispersion(energy=self.spectrometer.img_energy) - E_times_Dy = self.spectrometer.img_energy*Dy_img - - # add imaging energies - y_img = -E_times_Dy/self.spectrometer.img_energy - y_img_y = -E_times_Dy/self.spectrometer.img_energy_y - ax[0].axhline(y_img*1e3, color = 'black', linestyle = '--', linewidth = 1, label = 'Imaging energy x (GeV)') - ax[0].axhline(y_img_y*1e3, color = 'black', linestyle = ':', linewidth = 1, label = 'Imaging energy y (GeV)') - - # add energy axis - warnings.simplefilter('ignore', category=RuntimeWarning) - ax2 = ax[0].secondary_yaxis('right', functions=(lambda y: -E_times_Dy/(y/1e3)/1e9, lambda y: -E_times_Dy/(y/1e3)/1e9)) - ax2.set_ylabel('Energy (GeV)') - - if diverg is not None: - energies = -E_times_Dy/yedges - m12s = self.spectrometer.get_m12(energies) - x_pos = m12s*diverg - x_neg = -m12s*diverg - ax[0].plot(x_pos*1e3, yedges*1e3, color = 'orange', label = str(diverg*1e3) + ' mrad butterfly', alpha = 0.7) - ax[0].plot(x_neg*1e3, yedges*1e3, color = 'orange', alpha = 0.7) - ax[1].plot(energies/1e9, m12s) - ax[1].set_ylabel(r'$\mathrm{m_{12}}$') - ax[1].set_xlabel('E (GeV)') - ax[1].grid(False, which='major') - - ax[0].set_xlim(min(xedges*1e3), max(xedges*1e3)) - ax[0].legend(loc = 'center right', fontsize = 6) - - if plot_m12 == False: - fig.delaxes(ax[1]) - if savefig is not None: - plt.savefig(str(savefig), dpi = 700) - \ No newline at end of file diff --git a/abel/classes/beamline/impl/experiment/impl/experiment_pwfa.py b/abel/classes/beamline/impl/experiment/impl/experiment_pwfa.py deleted file mode 100644 index e6247a3d..00000000 --- a/abel/classes/beamline/impl/experiment/impl/experiment_pwfa.py +++ /dev/null @@ -1,119 +0,0 @@ -from abel.classes.beamline.impl.experiment.experiment import Experiment -from abel.classes.stage.stage import Stage -import numpy as np -from abel.utilities.plasma_physics import wave_breaking_field, beta_matched -import scipy.constants as SI - - -class ExperimentPWFA(Experiment): - - def __init__(self, linac=None, stage=None, spectrometer=None): - self.stage = stage - - super().__init__(linac=linac, component=stage, spectrometer=spectrometer) - - - # assemble the trackables - def assemble_trackables(self): - - # check element classes, then assemble - if self.component is None: - self.component = self.stage - assert(isinstance(self.component, Stage)) - - # run beamline constructor - super().assemble_trackables() - - # Lebedev eta_t - def eta_t(self): - transverse_normalised = self.get_initial_normalised_deflecting() - focusing_normalised = self.stage.get_normalised_initial_focusing() - eta_t = transverse_normalised/focusing_normalised - analytical_eta = transverse_normalised/self.stage.analytical_focusing() - - return abs(eta_t), abs(analytical_eta) - - # initial normalised deflecting force - def get_initial_normalised_deflecting(self): - transverse_normalised = self.stage.get_transverse_sliced()/self.get_beam(1).x_offset() - return transverse_normalised - - # betatron phase advance - def betatron_phase_advance(self): - phase_advance = np.sqrt(2)*(np.sqrt(self.get_beam(-2).gamma()) - np.sqrt(self.get_beam(-3).gamma())) * wave_breaking_field(self.stage.plasma_density)/(abs(self.get_rms_accel_initial())) - return phase_advance - - - def rms_amplitude_flat(self, etabetatron_adv): - rms_amplitude_A0 = np.exp((etabetatron_adv)**2 /(60 + 2.2*((etabetatron_adv)**1.57))) - return rms_amplitude_A0 - - # plot instability evolution - def plot_instability(self): - - from matplotlib import pyplot as plt - - # Frst compute initial and final point on plot from ABEL - # Get betatron advance - phase_advance = self.betatron_phase_advance() - - amplitude_initial = np.sqrt(np.mean(self.get_beam(-3).gammas()*(self.get_beam(-3).xs()**2/beta_matched(self.stage.plasma_density, self.get_beam(-3).Es()) + beta_matched(self.stage.plasma_density, self.get_beam(-3).Es()) * self.get_beam(-3).xps()**2))) - - amplitude_final = np.sqrt(np.mean(self.get_beam(-2).gammas()*(self.get_beam(-2).xs()**2/beta_matched(self.stage.plasma_density, self.get_beam(-2).Es()) + beta_matched(self.stage.plasma_density, self.get_beam(-2).Es()) * self.get_beam(-2).xps()**2))) - - eta_t, analytical_eta = self.eta_t() - advances, amplitudes = self.stage.get_amplitudes() - advances = advances/self.get_rms_accel_initial() - amplitudes_LEBEDEV = self.rms_amplitude_flat(eta_t*advances) - ABEL_x = np.array((0, phase_advance*eta_t)) - ABEL_amp = np.array((1, amplitude_final/amplitude_initial)) - amplitudes = amplitudes/amplitudes[0] - - # Plot expected figure from HiPACE++ and predicted from LEBEDEV - plt.plot(advances*eta_t, amplitudes, label = 'HiPACE++', color = 'green') - plt.plot(advances*eta_t, amplitudes_LEBEDEV, label = 'Lebedev', color = 'grey') - plt.scatter(ABEL_x, ABEL_amp, label = 'ABEL endpoints', color = 'r') - y_ticks = [1, 2, 3, 4, 5, 6, 7, 8, 9] - plt.yscale('log') - plt.yticks(y_ticks, [str(val) for val in y_ticks]) - plt.xlabel(r'$\mu \eta_{t}$') - plt.ylabel(r'$A/A_{0}$') - plt.grid(True, which='both', ls='--', lw=0.5) - plt.legend() - - - def get_rms_accel_initial(self): - field = (self.get_beam(2).energy() - self.get_beam(1).energy())/(self.stage.length) - return field - - def spectrometer_energy_cal(self, xlims=None, ylims=None, plot_figure = False): - - from matplotlib import pyplot as plt - from scipy.stats import linregress - - shots = range(self.num_shots) - y_mean = np.zeros(len(shots)) - Bs = np.zeros(len(shots)) - Es = np.zeros(len(shots)) - for id, shot in enumerate(shots): - beam = self[shot].final_beam - xbins, ybins = None, None - num_bins = round(np.sqrt(len(beam))/2) - if xlims is not None: - xbins = np.linspace(min(xlims), max(xlims), num_bins) - if ylims is not None: - ybins = np.linspace(min(ylims), max(ylims), num_bins) - dQdxdy, xedges, yedges = beam.density_transverse(hbins=xbins, vbins=ybins) - dQdxdy = abs(dQdxdy) - proj_y = np.sum(dQdxdy, axis = 1)*1e3 - y_mean[id] = yedges[np.argmax(proj_y)] - Bs[id] = self[shot].spectrometer.dipole_field - Es[id] = beam.energy() - slope, intercept, r_value, p_value, std_err = linregress(Bs/Es, y_mean) - if plot_figure == True: - plt.plot(Bs/Es*1e9, (slope*Bs/Es + intercept)*1e3) - plt.ylabel('y (mm)') - plt.xlabel(r'B/E'' (T/GeV)') - plt.scatter(Bs/Es*1e9, y_mean*1e3) - - return slope, intercept \ No newline at end of file diff --git a/abel/classes/beamline/impl/experiment/pwfa/__init__.py b/abel/classes/beamline/impl/experiment/pwfa/__init__.py new file mode 100644 index 00000000..6b07e465 --- /dev/null +++ b/abel/classes/beamline/impl/experiment/pwfa/__init__.py @@ -0,0 +1,47 @@ +from abel.classes.beamline.impl.experiment import Experiment +from abel.classes.stage.stage import Stage +from abel.classes.spectrometer import Spectrometer +from abel.classes.beamline.impl.linac.linac import Linac + +class ExperimentPWFA(Experiment): + + def __init__(self, linac=None, stage=None, spectrometer=None): + self.stage = stage + + super().__init__(linac=linac, test_device=stage, spectrometer=spectrometer) + + + # assemble the trackables + def assemble_trackables(self): + + # check element classes, then assemble + + assert(isinstance(self.linac, Linac)) + + if self.test_device is None: + self.test_device = self.stage + assert(isinstance(self.test_device, Stage)) + + assert(isinstance(self.spectrometer, Spectrometer)) + + # assemble the RF linac + self.linac.assemble_trackables() + + # set the nominal energy of the stage as that coming out of the linac + self.stage.nom_energy = self.linac.nom_energy + + # set the spectrometer imaging energy to the nominal gain + self.spectrometer.nom_energy = self.stage.nom_energy + self.stage.nom_energy_gain + if self.spectrometer.imaging_energy_x is None: + self.spectrometer.imaging_energy_x = self.spectrometer.nom_energy + self.spectrometer.imaging_energy_y = self.spectrometer.nom_energy + + # run beamline constructor + super().assemble_trackables() + + + # TODO: add useful scans (e.g., plasma-density scan, object-plane scan, etc.) + + + + \ No newline at end of file diff --git a/abel/classes/beamline/impl/experiment/pwfa/preset/facet2.py b/abel/classes/beamline/impl/experiment/pwfa/preset/facet2.py new file mode 100644 index 00000000..1accd01d --- /dev/null +++ b/abel/classes/beamline/impl/experiment/pwfa/preset/facet2.py @@ -0,0 +1,103 @@ +from abel.classes.beamline.impl.experiment.pwfa import ExperimentPWFA +from abel.classes.source.impl.source_basic import SourceBasic +from abel.classes.rf_accelerator.impl.rf_accelerator_basic import RFAcceleratorBasic +from abel.classes.beamline.impl.linac.impl.conventional_linac import ConventionalLinac +from abel.classes.source.source import Source +from abel.classes.stage.impl.stage_basic import StageBasic +from abel.classes.stage.impl.stage_quasistatic_2d import StageQuasistatic2d +from abel.classes.stage.impl.stage_hipace import StageHipace +from abel.classes.spectrometer.quad_imaging.preset.facet2 import SpectrometerFACET2 +from abel.classes.beamline.impl.linac.linac import Linac +from abel.classes.bds.impl.bds_basic import BeamDeliverySystemBasic + +class FACET2(ExperimentPWFA): + + def __init__(self, energy=10e9, charge=1.6e-9, plasma_length=0.40, plasma_density=5e22, bunch_length=35e-6, beta_x=0.2, beta_y=0.05, emit_nx=5e-6, emit_ny=5e-6, rel_energy_spread=0.01, ion_species='Li', num_particles=200000, stage_class=StageHipace, imaging_energy=None, nom_accel_gradient=10e9, magnification_x=-5.0): + + super().__init__() + + self.energy = energy + self.charge = charge + self.beta_x = beta_x + self.beta_y = beta_y + self.emit_nx = emit_nx + self.emit_ny = emit_ny + self.rel_energy_spread = rel_energy_spread + self.bunch_length = bunch_length + self.ion_species = ion_species + self.plasma_length = plasma_length + self.plasma_density = plasma_density + self.imaging_energy = imaging_energy + self.nom_accel_gradient = nom_accel_gradient + self.magnification_x = magnification_x + + self.num_particles = num_particles + + self.stage_class = stage_class + self.num_nodes = 16 + + + + # assemble the trackables + def assemble_trackables(self): + + + # set up source + source = SourceBasic() + source.energy = 20e6 + source.charge = -1*abs(self.charge) + source.rel_energy_spread = self.rel_energy_spread + source.bunch_length = self.bunch_length + source.z_offset = 0 + source.beta_x = 1.0 + source.beta_y = 1.0 + source.emit_nx = self.emit_nx + source.emit_ny = self.emit_ny + source.num_particles = self.num_particles + + # set up RF accelerator + rf_accelerator = RFAcceleratorBasic() + rf_accelerator.length = 900.0 + rf_accelerator.nom_energy_gain = self.energy - source.energy + + # set up BDS (TODO: make into W-chicane with collimators) + bds = BeamDeliverySystemBasic() + bds.beta_x = self.beta_x + bds.beta_y = self.beta_y + bds.length = 100.0 + + # set up full RF linac + linac = ConventionalLinac() + linac.source = source + linac.rf_accelerator = rf_accelerator + linac.bds = bds + + # set up PWFA stage + stage = self.stage_class() + stage.num_nodes = self.num_nodes + stage.num_cell_xy = 511 + stage.ion_motion = True + stage.beam_ionization = True + stage.ion_species = self.ion_species + stage.length_flattop = self.plasma_length # [eV] + stage.plasma_density = self.plasma_density + stage.nom_accel_gradient = self.nom_accel_gradient + stage.probe_evolution = True + + # set up spectrometer + spectrometer = SpectrometerFACET2() + if self.magnification_x is not None: + spectrometer.magnification_x = self.magnification_x + if self.imaging_energy is not None: + spectrometer.imaging_energy_x = self.imaging_energy + spectrometer.imaging_energy_y = self.imaging_energy + + # assigning the objects + self.linac = linac + self.stage = stage + self.spectrometer = spectrometer + + # run PWFA experiment constructor + super().assemble_trackables() + + \ No newline at end of file diff --git a/abel/classes/beamline/impl/experiment/pwfa/preset/flashforward.py b/abel/classes/beamline/impl/experiment/pwfa/preset/flashforward.py new file mode 100644 index 00000000..c83a3399 --- /dev/null +++ b/abel/classes/beamline/impl/experiment/pwfa/preset/flashforward.py @@ -0,0 +1,79 @@ +from abel.classes.beamline.impl.experiment.pwfa import ExperimentPWFA +from abel.classes.source.impl.source_basic import SourceBasic +from abel.classes.source.source import Source +from abel.classes.stage.impl.stage_basic import StageBasic +from abel.classes.stage.impl.stage_hipace import StageHipace +#from abel.classes.spectrometer.impl.spectrometer_flashforward_impactx import SpectrometerFLASHForwardImpactX +from abel.classes.beamline.impl.linac.linac import Linac + +class FLASHForward(ExperimentPWFA): + + def __init__(self, energy=1.05e9, plasma_length=0.033, plasma_density=7e21, rel_energy_spread=0.001, ion_species='H'): + + self.energy = energy + self.rel_energy_spread = rel_energy_spread + self.ion_species = ion_species + self.plasma_length = plasma_length + self.plasma_density = plasma_density + + # set up empty elements + source = SourceBasic() + source.energy = self.energy + source.charge = -0.6e-9 + source.rel_energy_spread = self.rel_energy_spread + source.bunch_length = 83e-6 + source.z_offset = 0 + source.emit_nx = 3e-6 # [m rad] + source.emit_ny = 1e-6 # [m rad] + source.num_particles = 500000 + + stage = StageHipace() + stage.num_nodes = 16 + stage.num_cell_xy = 1023 + stage.ion_motion = True + stage.beam_ionization = True + stage.ion_species = self.ion_species + stage.length_flattop = self.plasma_length # [eV] + stage.nom_accel_gradient = 1e9 # [GV/m] + + stage.plasma_density = self.plasma_density # [m^-3] + stage.ramp_beta_mag = 6 + stage.mesh_refinement = True + + stage.upramp = stage.__class__() + stage.upramp.num_nodes = 5 + stage.upramp.nom_energy = source.energy + stage.upramp.ion_motion = stage.ion_motion + stage.upramp.ion_species = stage.ion_species + stage.upramp.mesh_refinement = stage.mesh_refinement + stage.upramp.num_cell_xy = stage.num_cell_xy + + stage.downramp = stage.__class__() + stage.downramp.num_nodes = stage.upramp.num_nodes + stage.downramp.nom_energy = source.energy + stage.downramp.ion_motion = stage.ion_motion + stage.downramp.ion_species = stage.ion_species + stage.downramp.mesh_refinement = stage.mesh_refinement + stage.downramp.num_cell_xy = stage.num_cell_xy + + source.beta_x = stage.matched_beta_function(source.energy) + source.beta_y = source.beta_x + + spectrometer = SpectrometerFLASHForwardImpactX() + spectrometer.imaging_energy_x = self.energy + spectrometer.imaging_energy_y = self.energy + + super().__init__(linac=source, stage=stage, spectrometer=spectrometer) + + # assemble the trackables + def assemble_trackables(self): + # define spectrometer + if isinstance(self.linac, Source): + self.spectrometer.imaging_energy = self.linac.energy + elif isinstance(self.linac, Linac): + self.spectrometer.imaging_energy = self.linac.source.energy + else: + raise ValueError("You must define a linac that is either a type Source or a type Linac") + + # set the bunch train pattern etc. + super().assemble_trackables() \ No newline at end of file diff --git a/abel/classes/runnable.py b/abel/classes/runnable.py index b78c6fbd..b94623a1 100644 --- a/abel/classes/runnable.py +++ b/abel/classes/runnable.py @@ -32,7 +32,7 @@ def perform_shot(self, shot): print('>> SHOT ' + str(shot+1) + '/' + str(self.num_shots), flush=True) # if overwrite_from is None: # TODO - self.track(beam=None, savedepth=self.savedepth, runnable=self, verbose=self.verbose) + self.track(beam=None, savedepth=self.savedepth, runnable=self, verbose=self.verbose) # This returns the beam that is saved in trackable.track()->Source/stage-parentclass.track()->childclass.track() (executed from beamline.track()), but is not assigned to a variable here. # save object to file self.save() diff --git a/abel/classes/source/impl/source_from_profile.py b/abel/classes/source/impl/source_from_profile.py new file mode 100644 index 00000000..c85a830c --- /dev/null +++ b/abel/classes/source/impl/source_from_profile.py @@ -0,0 +1,136 @@ +import time +import numpy as np +import scipy.constants as SI +import scipy.signal as sig +from abel import Source, Beam +from abel.utilities.beam_physics import generate_trace_space_xy, generate_symm_trace_space_xyz +from abel.utilities.relativity import energy2gamma +import pandas as pd +import re + +class SourceFromProfile(Source): + + def __init__(self, file_path: str, length=0, num_particles=1000, energy=None, charge=0, rel_energy_spread=None, energy_spread=None, z_offset=0, x_offset=0, y_offset=0, x_angle=0, y_angle=0, emit_nx=0, emit_ny=0, beta_x=None, beta_y=None, alpha_x=0, alpha_y=0, angular_momentum=0, wallplug_efficiency=1, accel_gradient=None, symmetrize=False, z_cutoff=None): + + super().__init__(length, charge, energy, accel_gradient, wallplug_efficiency, x_offset, y_offset, x_angle, y_angle) + + self.rel_energy_spread = rel_energy_spread # [eV] + self.energy_spread = energy_spread + self.z_offset = z_offset # [m] + self.num_particles = num_particles + + self.emit_nx = emit_nx # [m rad] + self.emit_ny = emit_ny # [m rad] + self.beta_x = beta_x # [m] + self.beta_y = beta_y # [m] + self.alpha_x = alpha_x # [m] + self.alpha_y = alpha_y # [m] + + self.angular_momentum = angular_momentum + self.symmetrize = symmetrize + self.z_cutoff = z_cutoff + self.file = file_path + self.file_type = re.search(r'\.([a-zA-Z0-9]+)$', file_path).group(1) + + def track(self, _=None, savedepth=0, runnable=None, verbose=False): + + file_type_to_function = { + "csv": "read_csv", + "xlsx": "read_excel", + "json": "read_json", + "parquet": "read_parquet", + "pkl": "read_pickle"} + # The pandas read-function depending on the filetype, feel free to add to + read_function = getattr(pd, file_type_to_function.get(self.file_type)) + """ + File must contain to arrays where z is first array, and Is is second array. + Given in meters and Ampere respectively. + """ + + # make empty beam + beam = Beam() + + # Lorentz gamma + gamma = energy2gamma(self.energy) + + # generate relative/absolute energy spreads + if self.rel_energy_spread is not None: + if self.energy_spread is None: + self.energy_spread = self.energy * self.rel_energy_spread + elif abs(self.energy_spread - self.energy * self.rel_energy_spread) > 0: + raise Exception("Both absolute and relative energy spread defined.") + + + # horizontal and vertical phase spaces + xs, xps, ys, yps = generate_trace_space_xy(self.emit_nx/gamma, self.beta_x, self.alpha_x, self.emit_ny/gamma, self.beta_y, self.alpha_y, self.num_particles, self.angular_momentum/gamma, symmetrize=self.symmetrize) + + # longitudinal phase space + if self.symmetrize: + num_tiling = 4 + num_particles_actual = round(self.num_particles/num_tiling) + else: + num_particles_actual = self.num_particles + + # Read data from file + data = read_function(self.file, header=None) # z-position and current + + zs0 = np.array(data[0]) + self.z_offset + Is0 = np.array(data[1]) + Is0 = sig.medfilt(Is0, kernel_size=5) + # Get particle distribution in Zs + + z_interp = np.linspace(zs0[0], zs0[-1], int(1e5)) + I_interp = np.interp(z_interp, zs0, Is0) + + zs = np.random.choice(z_interp, size=num_particles_actual, p=I_interp/np.sum(I_interp)) + Es = np.random.normal(loc=self.energy, scale=self.energy_spread, size=num_particles_actual) + if self.symmetrize: + zs = np.tile(zs, num_tiling) + Es = np.tile(Es, num_tiling) + + + # create phase space + beam.set_phase_space(xs=xs, ys=ys, zs=zs, xps=xps, yps=yps, Es=Es, Q=self.charge) + + # Apply filter(s) if desired + if self.z_cutoff is not None: + beam = self.z_filter(beam) + + # add jitters and offsets in super function + return super().track(beam, savedepth, runnable, verbose) + + + # ================================================== + # Filter out particles whose z < z_cutoff for testing instability etc. + def z_filter(self, beam): + xs = beam.xs() + ys = beam.ys() + zs = beam.zs() + pxs = beam.pxs() + pys = beam.pys() + pzs = beam.pzs() + weights = beam.weightings() + + # Apply the filter + bool_indices = (zs > self.z_cutoff) + zs_filtered = zs[bool_indices] + xs_filtered = xs[bool_indices] + ys_filtered = ys[bool_indices] + pxs_filtered = pxs[bool_indices] + pys_filtered = pys[bool_indices] + pzs_filtered = pzs[bool_indices] + weights_filtered = weights[bool_indices] + + # Initialise ABEL Beam object + beam_out = Beam() + + # Set the phase space of the ABEL beam + beam_out.set_phase_space(Q=np.sum(weights_filtered)*-SI.e, + xs=xs_filtered, + ys=ys_filtered, + zs=zs_filtered, + pxs=pxs_filtered, # Always use single particle momenta? + pys=pys_filtered, + pzs=pzs_filtered) + + return beam_out \ No newline at end of file diff --git a/abel/classes/spectrometer/__init__.py b/abel/classes/spectrometer/__init__.py new file mode 100644 index 00000000..f05a967c --- /dev/null +++ b/abel/classes/spectrometer/__init__.py @@ -0,0 +1,112 @@ +from abc import abstractmethod +from abel.classes.trackable import Trackable +from types import SimpleNamespace +import numpy as np + +class Spectrometer(Trackable): + + @abstractmethod + def __init__(self, nom_energy=None): + super().__init__() + + self.nom_energy = nom_energy + + self.evolution = SimpleNamespace() + + + def track(self, beam, savedepth=0, runnable=None, verbose=False): + return super().track(beam, savedepth, runnable, verbose) + + @abstractmethod + def get_length(self): + pass + + def survey_object(self): + from matplotlib import patches + rect = patches.Rectangle((0, -0.05), self.get_length(), 0.1) + rect.set_facecolor = 'k' + return rect + + + def plot_evolution(self): + + # do imports + import matplotlib.pyplot as plt + + evol = self.evolution + + # prepare plot + fig, axs = plt.subplots(3,3) + fig.set_figwidth(20) + fig.set_figheight(12) + col0 = "tab:gray" + col1 = "tab:blue" + col2 = "tab:orange" + long_label = 'Location [m]' + long_limits = [min(evol.location), max(evol.location)] + + # plot energy + axs[0,0].plot(evol.location, evol.energy / 1e9, color=col1) + axs[0,0].set_ylabel('Energy [GeV]') + axs[0,0].set_xlabel(long_label) + axs[0,0].set_xlim(long_limits) + + # plot charge + axs[0,1].plot(evol.location, abs(evol.charge[0]) * np.ones(evol.location.shape) * 1e9, ':', color=col0) + axs[0,1].plot(evol.location, abs(evol.charge) * 1e9, color=col1) + axs[0,1].set_ylabel('Charge [nC]') + axs[0,1].set_xlim(long_limits) + axs[0,1].set_ylim(0, abs(evol.charge[0]) * 1.3 * 1e9) + + # plot normalized emittance + axs[0,2].plot(evol.location, evol.emit_ny*1e6, color=col2) + axs[0,2].plot(evol.location, evol.emit_nx*1e6, color=col1) + axs[0,2].set_ylabel('Emittance, rms [mm mrad]') + axs[0,2].set_xlim(long_limits) + axs[0,2].set_yscale('log') + + # plot energy spread + axs[1,0].plot(evol.location, evol.rel_energy_spread*1e2, color=col1) + axs[1,0].set_ylabel('Energy spread, rms [%]') + axs[1,0].set_xlabel(long_label) + axs[1,0].set_xlim(long_limits) + axs[1,0].set_yscale('log') + + # plot bunch length + axs[1,1].plot(evol.location, evol.bunch_length*1e6, color=col1) + axs[1,1].set_ylabel(r'Bunch length, rms [$\mathrm{\mu}$m]') + axs[1,1].set_xlabel(long_label) + axs[1,1].set_xlim(long_limits) + + # plot beta function + axs[1,2].plot(evol.location, evol.beta_y, color=col2) + axs[1,2].plot(evol.location, evol.beta_x, color=col1) + axs[1,2].set_ylabel('Beta function [m]') + axs[1,2].set_xlabel(long_label) + axs[1,2].set_xlim(long_limits) + + # plot transverse offset + axs[2,0].plot(evol.location, evol.y*1e6, color=col2) + axs[2,0].plot(evol.location, evol.y*1e6, color=col1) + axs[2,0].set_ylabel(r'Transverse offset [$\mathrm{\mu}$m]') + axs[2,0].set_xlabel(long_label) + axs[2,0].set_xlim(long_limits) + + # plot dispersion + axs[2,1].plot(evol.location, evol.dispersion_y*1e3, color=col2) + axs[2,1].plot(evol.location, evol.dispersion_x*1e3, color=col1) + axs[2,1].plot(evol.location, evol.second_order_dispersion_x*1e3, ':', color=col1) + axs[2,1].set_ylabel('First-order dispersion [mm]') + axs[2,1].set_xlabel(long_label) + axs[2,1].set_xlim(long_limits) + + # plot beam size + axs[2,2].plot(evol.location, evol.beam_size_y*1e6, color=col2) + axs[2,2].plot(evol.location, evol.beam_size_x*1e6, color=col1) + axs[2,2].set_ylabel(r'Beam size, rms [$\mathrm{\mu}$m]') + axs[2,2].set_xlabel(long_label) + axs[2,2].set_xlim(long_limits) + + plt.show() + + \ No newline at end of file diff --git a/abel/classes/spectrometer/impl/spectrometer_facet_ocelot.py b/abel/classes/spectrometer/impl/spectrometer_facet_ocelot.py index d089a313..3fe6aa8b 100644 --- a/abel/classes/spectrometer/impl/spectrometer_facet_ocelot.py +++ b/abel/classes/spectrometer/impl/spectrometer_facet_ocelot.py @@ -5,14 +5,11 @@ class SpectrometerFacetOcelot(Spectrometer): - def __init__(self, dipole_field=-1, img_energy=None, obj_plane=0, mag_x=-4, img_energy_y=None, obj_plane_y=None, exact_tracking=True): + def __init__(self, dipole_field=-1, imaging_energy_x=None, object_plane_x=0, magnification_x=-4, imaging_energy_y=None, object_plane_y=None, exact_tracking=True): + + super().__init__(imaging_energy_x=imaging_energy_x, imaging_energy_y=imaging_energy_y, object_plane_x=object_plane_x, object_plane_y=object_plane_y, magnification_x=magnification_x) self.dipole_field = dipole_field - self.img_energy = img_energy - self.obj_plane = obj_plane - self.mag_x = mag_x - self.img_energy_y = img_energy_y - self.obj_plane_y = obj_plane_y self.exact_tracking = exact_tracking # initial guess for quadrupole strengths @@ -41,7 +38,7 @@ def get_lattice(self, ks=None, energy=None, obj_plane=None): # scale quad and dipole strengths to correct energy if ks is None: - ks = self.ks_for_img_energy*self.img_energy/energy + ks = self.ks_for_img_energy*self.imaging_energy_x/energy bend_angle = self.dipole_field*dipole_length*SI.c/energy # define elements @@ -82,17 +79,17 @@ def set_imaging(self): def img_condition_fcn(ks): # set vertical plane if not already - if self.img_energy_y is None: - self.img_energy_y = self.img_energy - if self.obj_plane_y is None: - self.obj_plane_y = self.obj_plane + if self.imaging_energy_y is None: + self.imaging_energy_y = self.imaging_energy_x + if self.object_plane_y is None: + self.object_plane_y = self.object_plane_x # calculate transfer matrices - lattice_x = self.get_lattice(ks, self.img_energy, self.obj_plane) - Rx = lattice_transfer_map(lattice_x, energy=self.img_energy/1e9) - lattice_y = self.get_lattice(ks, self.img_energy_y, self.obj_plane_y) - Ry = lattice_transfer_map(lattice_y, energy=self.img_energy/1e9) + lattice_x = self.get_lattice(ks, self.imaging_energy_x, self.object_plane_x) + Rx = lattice_transfer_map(lattice_x, energy=self.imaging_energy_x/1e9) + lattice_y = self.get_lattice(ks, self.imaging_energy_y, self.object_plane_y) + Ry = lattice_transfer_map(lattice_y, energy=self.imaging_energy_x/1e9) # return object function return (Rx[0,1])**2 + (Ry[2,3])**2 + (Rx[0,0]-self.mag_x)**2 @@ -159,7 +156,7 @@ def plot_twiss(self, energy=None, waist_plane=None): # get lattice if energy is None: - energy = self.img_energy + energy = self.imaging_energy_x if waist_plane is None: waist_plane = 0 lattice = self.get_lattice(energy=energy, obj_plane=waist_plane) @@ -185,7 +182,7 @@ def get_dispersion(self, energy=None): # set default energy if energy is None: - energy = self.img_energy + energy = self.imaging_energy_x # set the imaging and get the lattice self.set_imaging() @@ -212,7 +209,7 @@ def get_m12(self, energies): m12s = np.zeros(len(energies)) for i in range(len(energies)): - lattice_x = self.get_lattice(energy=energies[i], obj_plane=self.obj_plane) + lattice_x = self.get_lattice(energy=energies[i], obj_plane=self.object_plane_x) Rx = lattice_transfer_map(lattice_x, energy=energies[i]/1e9) m12s[i] = Rx[0, 1] diff --git a/abel/classes/spectrometer/impl/spectrometer_flashforward_impactx.py b/abel/classes/spectrometer/impl/spectrometer_flashforward_impactx.py new file mode 100644 index 00000000..7793d71c --- /dev/null +++ b/abel/classes/spectrometer/impl/spectrometer_flashforward_impactx.py @@ -0,0 +1,255 @@ +from abel.classes.spectrometer.spectrometer import Spectrometer +from types import SimpleNamespace +from abel.utilities.other import check_kwargs +import scipy.constants as SI +import numpy as np + +class SpectrometerFLASHForwardImpactX(Spectrometer): + + def __init__(self, imaging_energy_x=None, imaging_energy_y=None, object_plane_x=0.0, object_plane_y=None, magnification_x=-8.0, magnification_y=None): + + super().__init__(imaging_energy_x=imaging_energy_x, imaging_energy_y=imaging_energy_y, object_plane_x=object_plane_x, object_plane_y=object_plane_y, magnification_x=magnification_x, magnification_y=magnification_y) + + self.current_dipole = -200 # [A] + self.current_quad1 = 60 # [A] + self.current_quad2 = -60 # [A] + self.current_quad3 = 50 # [A] + + self.scale_quads = 1 + + self.g1 = 27.11 # [T/m] + self.g2 = -37.27 # [T/m] + self.g3 = 40.29 # [T/m] + + self.B_dipole = None + # TODO: implement imaging (using regular matrix tracking, to be added as a utility) + + # pre-defined lengths + self.length_dipole = 1.07 # [m] + self.length_quad = 0.1137 # [m] + + # beam line positions (quad and dipole centers) + self.s_CELLCENTRE = 209.932261 # [m] + self.s_Q11FLFDIAG = 210.590261 # [m] + self.s_Q12FLFDIAG = 210.856261 # [m] + self.s_Q21FLFDIAG = 211.122261 # [m] + self.s_Q22FLFDIAG = 211.388261 # [m] + self.s_Q23FLFDIAG = 211.768178 # [m] + self.s_dipoleLEMS = 215.686200 # [m] + self.s_LEMS = 217.045605 # [m] image plane + + self.evolution = SimpleNamespace() + + # lattice length + def get_length(self): + return self.s_LEMS - self.s_CELLCENTRE + + def current2strength_quad(self, I, p0): + g = I * 0.9 # TODO: improve conversion + k = g*SI.e/p0 + return k + + def field2strength_quad(self, g, p0): + k = g*SI.e/p0 + return k + + def current2field_dipole(self, I, B_dipole): + if B_dipole: + return B_dipole + else: + return I * 0.0014 # TODO: improve conversion + + def get_dispersion(self, energy=None): + if energy is None: + energy = self.imaging_energy_x + gamma0x = energy*SI.e/(SI.m_e*SI.c**2) + p0x = SI.m_e*gamma0x*SI.c*np.sqrt(1-1/gamma0x**2) + Bdip = self.current2field_dipole(self.current_dipole, self.B_dipole) + phi = Bdip*self.length_dipole*SI.e/p0x + return (self.s_LEMS-self.s_dipoleLEMS)*phi + + + # get the Ocelot lattice + def get_lattice(self, object_plane_x=None, object_plane_y=None, imaging_energy_x=None, imaging_energy_y=None): + + # do imports + import impactx + + # set the object planes + if object_plane_x is None: + object_plane_x = self.object_plane_x + if object_plane_y is None: + if self.object_plane_y is not None: + object_plane_y = self.object_plane_y + else: + object_plane_y = object_plane_x + + # set the imaging energies + if imaging_energy_x is None: + imaging_energy_x = self.imaging_energy_x + if imaging_energy_y is None: + if self.imaging_energy_y is not None: + imaging_energy_y = self.imaging_energy_y + else: + imaging_energy_y = imaging_energy_x + + # initialize lattice + lattice = [] + + # number of slices per ds in the element + ns = 25 + + gamma0x = imaging_energy_x*SI.e/(SI.m_e*SI.c**2); + p0x = SI.m_e*gamma0x*SI.c*np.sqrt(1-1/gamma0x**2); + gamma0y = imaging_energy_y*SI.e/(SI.m_e*SI.c**2); + p0y = SI.m_e*gamma0x*SI.c*np.sqrt(1-1/gamma0x**2); + + # define dipole + Bdip = self.current2field_dipole(self.current_dipole, self.B_dipole) + self.B_dipole = Bdip + phi = Bdip*self.length_dipole*SI.e/p0x + dipole = impactx.elements.ExactSbend(name="dipole", ds=self.length_dipole, phi=np.rad2deg(phi), B=Bdip, nslice=ns, rotation=90) + + # define quads + quad1 = impactx.elements.ExactQuad(name='quad1', ds=self.length_quad, k=self.field2strength_quad(self.g1*self.scale_quads, p0x), nslice=ns) + quad2 = impactx.elements.ExactQuad(name="quad2", ds=self.length_quad, k=self.field2strength_quad(self.g2*self.scale_quads, p0x), nslice=ns) + quad3 = impactx.elements.ExactQuad(name="quad3", ds=self.length_quad, k=self.field2strength_quad(self.g3*self.scale_quads, p0x), nslice=ns) + + # derived separations + d1 = self.s_Q11FLFDIAG - self.s_CELLCENTRE - self.length_quad/2 - object_plane_x; + d2 = self.s_Q12FLFDIAG - self.s_Q11FLFDIAG - self.length_quad; + d3 = self.s_Q21FLFDIAG - self.s_Q12FLFDIAG - self.length_quad; + d4 = self.s_Q22FLFDIAG - self.s_Q21FLFDIAG - self.length_quad; + d5 = self.s_Q23FLFDIAG - self.s_Q22FLFDIAG - self.length_quad; + d6 = self.s_dipoleLEMS - self.s_Q23FLFDIAG - self.length_quad/2 - self.length_dipole/2; + d7 = self.s_LEMS - self.s_dipoleLEMS - self.length_dipole/2; + + # drifts + drift1 = impactx.elements.ExactDrift(name="drift1", ds=d1, nslice=ns) + drift2 = impactx.elements.ExactDrift(name="drift2", ds=d2, nslice=ns) + drift3 = impactx.elements.ExactDrift(name="drift3", ds=d3, nslice=ns) + drift4 = impactx.elements.ExactDrift(name="drift4", ds=d4, nslice=ns) + drift5 = impactx.elements.ExactDrift(name="drift5", ds=d5, nslice=ns) + drift6 = impactx.elements.ExactDrift(name="drift6", ds=d6, nslice=ns) + drift7 = impactx.elements.ExactDrift(name="drift7", ds=d7, nslice=ns) + + # specify the lattice sequence + lattice.append(drift1) + lattice.append(quad1) + lattice.append(drift2) + lattice.append(quad1) + lattice.append(drift3) + lattice.append(quad2) + lattice.append(drift4) + lattice.append(quad2) + lattice.append(drift5) + lattice.append(quad3) + lattice.append(drift6) + lattice.append(dipole) + lattice.append(drift7) + + return lattice + + + + # tracking function + def track(self, beam0, savedepth=0, runnable=None, verbose=False): + + # set imaging energy automatically + if self.imaging_energy_x is None: + self.imaging_energy_x = beam0.energy() + + # get lattice + lattice = self.get_lattice() + + # run ImpactX + from abel.apis.impactx.impactx_api import run_impactx + beam, evol = run_impactx(lattice, beam0, nom_energy=self.imaging_energy_x, verbose=False, runnable=runnable) + + # save evolution + self.evolution = evol + + return super().track(beam, savedepth, runnable, verbose) + + + def plot_evolution(self): + + # do imports + import matplotlib.pyplot as plt + + evol = self.evolution + + # prepare plot + fig, axs = plt.subplots(3,3) + fig.set_figwidth(20) + fig.set_figheight(12) + col0 = "tab:gray" + col1 = "tab:blue" + col2 = "tab:orange" + long_label = 'Location [m]' + long_limits = [min(evol.location), max(evol.location)] + + # plot energy + axs[0,0].plot(evol.location, evol.energy / 1e9, color=col1) + axs[0,0].set_ylabel('Energy [GeV]') + axs[0,0].set_xlabel(long_label) + axs[0,0].set_xlim(long_limits) + + # plot charge + axs[0,1].plot(evol.location, abs(evol.charge[0]) * np.ones(evol.location.shape) * 1e9, ':', color=col0) + axs[0,1].plot(evol.location, abs(evol.charge) * 1e9, color=col1) + axs[0,1].set_ylabel('Charge [nC]') + axs[0,1].set_xlim(long_limits) + axs[0,1].set_ylim(0, abs(evol.charge[0]) * 1.3 * 1e9) + + # plot normalized emittance + axs[0,2].plot(evol.location, evol.emit_ny*1e6, color=col2) + axs[0,2].plot(evol.location, evol.emit_nx*1e6, color=col1) + axs[0,2].set_ylabel('Emittance, rms [mm mrad]') + axs[0,2].set_xlim(long_limits) + axs[0,2].set_yscale('log') + + # plot energy spread + axs[1,0].plot(evol.location, evol.rel_energy_spread*1e2, color=col1) + axs[1,0].set_ylabel('Energy spread, rms [%]') + axs[1,0].set_xlabel(long_label) + axs[1,0].set_xlim(long_limits) + axs[1,0].set_yscale('log') + + # plot bunch length + axs[1,1].plot(evol.location, evol.bunch_length*1e6, color=col1) + axs[1,1].set_ylabel(r'Bunch length, rms [$\mathrm{\mu}$m]') + axs[1,1].set_xlabel(long_label) + axs[1,1].set_xlim(long_limits) + + # plot beta function + axs[1,2].plot(evol.location, evol.beta_y, color=col2) + axs[1,2].plot(evol.location, evol.beta_x, color=col1) + axs[1,2].set_ylabel('Beta function [m]') + axs[1,2].set_xlabel(long_label) + axs[1,2].set_xlim(long_limits) + + # plot transverse offset + axs[2,0].plot(evol.location, evol.y*1e6, color=col2) + axs[2,0].plot(evol.location, evol.y*1e6, color=col1) + axs[2,0].set_ylabel(r'Transverse offset [$\mathrm{\mu}$m]') + axs[2,0].set_xlabel(long_label) + axs[2,0].set_xlim(long_limits) + + # plot dispersion + axs[2,1].plot(evol.location, evol.dispersion_y*1e3, color=col2) + axs[2,1].plot(evol.location, evol.dispersion_x*1e3, color=col1) + axs[2,1].plot(evol.location, evol.second_order_dispersion_x*1e3, ':', color=col1) + axs[2,1].set_ylabel('First-order dispersion [mm]') + axs[2,1].set_xlabel(long_label) + axs[2,1].set_xlim(long_limits) + + # plot beam size + axs[2,2].plot(evol.location, evol.beam_size_y*1e6, color=col2) + axs[2,2].plot(evol.location, evol.beam_size_x*1e6, color=col1) + axs[2,2].set_ylabel(r'Beam size, rms [$\mathrm{\mu}$m]') + axs[2,2].set_xlabel(long_label) + axs[2,2].set_xlim(long_limits) + + + plt.show() \ No newline at end of file diff --git a/abel/classes/spectrometer/quad_imaging/__init__.py b/abel/classes/spectrometer/quad_imaging/__init__.py new file mode 100644 index 00000000..57d50f5b --- /dev/null +++ b/abel/classes/spectrometer/quad_imaging/__init__.py @@ -0,0 +1,183 @@ +from abel.classes.spectrometer import Spectrometer +import scipy.constants as SI +import numpy as np + +class SpectrometerQuadImaging(Spectrometer): + + def __init__(self, angle_dipole=None, length_dipole=None, imaging_energy_x=None, imaging_energy_y=None, object_plane_x=None, object_plane_y=None, magnification_x=None, magnification_y=None): + + super().__init__() + + self.imaging_energy_x = imaging_energy_x + self.imaging_energy_y = imaging_energy_y + self.object_plane_x = object_plane_x + self.object_plane_y = object_plane_y + self.magnification_x = magnification_x + self.magnification_y = magnification_y + + self.angle_dipole = angle_dipole + self.length_dipole = length_dipole + + self.strengths_quads = None + self.length_quad = None + + self.length_drifts = None + + + # lattice length + def get_length(self): + ls, *_ = self.matrix_lattice() + return np.sum(ls) + + + @property + def field_dipole(self) -> float: + return self.angle_dipole*self.nom_energy/(self.length_dipole*SI.c) + + + + # full lattice + def matrix_lattice(self, ks_quads=None): + + # construct length list + ls = [self.length_drifts[0]] + for i in range(len(self.length_drifts)-2): + ls.append(self.length_quad) + ls.append(self.length_drifts[i+1]) + ls.append(self.length_dipole) + ls.append(self.length_drifts[-1]) + ls = np.array(ls) + + # bending strength array + inv_rhos = np.zeros_like(ls) + inv_rhos[-2] = self.angle_dipole/self.length_dipole + + # focusing strength array + if ks_quads is None: + ks_quads = self.strengths_quads + ks = np.zeros_like(ls) + for i in range(len(ks_quads)): + ks[2*i+1] = ks_quads[i] + + # sextupole strength array + ms = np.zeros_like(ls) + + # plasma-lens transverse taper array + taus = np.zeros_like(ls) + + return ls, inv_rhos, ks, ms, taus + + + def set_imaging(self): + + + # minimizer function for point-to-point imaging + from abel.utilities.beam_physics import evolve_transfer_matrix + + def minfun_point2point_imaging(params): + + ls, _, ks, _, _ = self.matrix_lattice(ks_quads=params) + + ks_x = ks*self.nom_energy/self.imaging_energy_x + Rx = evolve_transfer_matrix(ls, ks_x) + ks_y = ks*self.nom_energy/self.imaging_energy_x + Ry = evolve_transfer_matrix(ls, ks_y) + + R12 = Rx[0,1] + R34 = Ry[2,3] + magx = Rx[0,0] + + return R12**2 + R34**2 + (magx-self.magnification_x)**2 + + # perform minization (find k-values) + ks_guess = [1,-1,1] + from scipy.optimize import minimize + result = minimize(minfun_point2point_imaging, ks_guess, tol=1e-5, options={'maxiter': 1000}) + + # set solution to quads + if result.fun < 1e-5: + + # scale quadrupole strengths to the nominal energy + self.strengths_quads = result.x + + else: + raise Exception('No imaging solution found.') + + + ## PLOTTING OPTICS + + def plot_optics(self, show_beta_function=True, show_dispersion=False): + + from matplotlib import pyplot as plt + from matplotlib import patches + from copy import deepcopy + from abel.utilities.beam_physics import evolve_beta_function, evolve_dispersion + + # calculate evolution + ls, inv_rhos, ks, _, _ = self.matrix_lattice() + ssl = np.append([0.0], np.cumsum(ls)) + + beta0 = 0.01 + + if show_beta_function: + _, _, evol_beta_x = evolve_beta_function(ls, ks, beta0, fast=False) + _, _, evol_beta_y = evolve_beta_function(ls, -ks, beta0, fast=False) + ss_beta = evol_beta_x[0] + beta_xs = evol_beta_x[1] + beta_ys = evol_beta_y[1] + + # prepare plots + num_plots = 1 + int(show_beta_function) + int(show_dispersion) + height_ratios = np.ones((num_plots,1)) + height_ratios[0] = 0.1 + fig, axs = plt.subplots(num_plots,1, gridspec_kw={'height_ratios': height_ratios}) + fig.set_figwidth(7) + fig.set_figheight(11/3.1*np.sum(height_ratios)) + col0 = "tab:gray" + colx1 = "tab:blue" + coly = "tab:orange" + colx2 = "#d7e9f5" # lighter version of tab:blue + colz = "tab:green" + coloff = "#e69596" # lighter version of tab:red + long_label = 'Location (m)' + long_limits = [min(ssl), max(ssl)] + + # layout + n = 0 + axs[n].plot(ssl, np.zeros_like(ssl), '-', linewidth=0.5, color='k') + axs[n].axis('off') + for i in range(len(ls)): + if abs(inv_rhos[i]) > 0: # add dipoles + axs[n].add_patch(patches.Rectangle((ssl[i],-0.75), ls[i], 1.5, fc='#d9d9d9')) + if abs(ks[i]) > 0: # add quad or plasma lenses + axs[n].add_patch(patches.Rectangle((ssl[i],0), ls[i], np.sign(ks[i]), fc='#fcb577')) + axs[n].set_xlim(long_limits) + axs[n].set_ylim([-1, 1]) + + # shift the layout box down + box = axs[0].get_position() + vshift = 0.025 + box.y0 = box.y0 - vshift + box.y1 = box.y1 - vshift + axs[0].set_position(box) + + # plot beta function + if show_beta_function: + n += 1 + axs[n].plot(ss_beta, np.sqrt(beta0*np.ones_like(ss_beta)), ':', color=col0) + axs[n].plot(ss_beta, np.sqrt(beta_ys), color=coly, label=r'$y$') + axs[n].plot(ss_beta, np.sqrt(beta_xs), color=colx1, label=r'$x$') + axs[n].legend(loc='best', reverse=True, fontsize='small') + axs[n].set_ylabel(r'$\sqrt{\mathrm{Beta\hspace{0.3}function}}$ ($\sqrt{\mathrm{m}})$') + axs[n].set_xlim(long_limits) + + # plot dispersion + if show_dispersion: + pass + + # add horizontal axis label + axs[n].set_xlabel(long_label) + + + + \ No newline at end of file diff --git a/abel/classes/spectrometer/quad_imaging/impactx.py b/abel/classes/spectrometer/quad_imaging/impactx.py new file mode 100644 index 00000000..c9d5dddf --- /dev/null +++ b/abel/classes/spectrometer/quad_imaging/impactx.py @@ -0,0 +1,60 @@ +from abel.classes.spectrometer.quad_imaging import SpectrometerQuadImaging +from types import SimpleNamespace +from abel.utilities.other import check_kwargs +import scipy.constants as SI +import numpy as np + +class SpectrometerQuadImagingImpactX(SpectrometerQuadImaging): + + def __init__(self, imaging_energy_x=None, imaging_energy_y=None, object_plane_x=0.0, object_plane_y=None, magnification_x=-8.0, magnification_y=None): + + super().__init__(imaging_energy_x=imaging_energy_x, imaging_energy_y=imaging_energy_y, object_plane_x=object_plane_x, object_plane_y=object_plane_y, magnification_x=magnification_x, magnification_y=magnification_y) + + self.num_slices = 50 + self.enable_space_charge = False + self.enable_csr = True + self.enable_isr = True + + + def track(self, beam0, savedepth=0, runnable=None, verbose=False): + "Track plasma-lens-based interstage using ImpactX." + + # re-perform the matching + self.set_imaging() + + # get the lattice + lattice = self.get_impactx_lattice() + + # run ImpactX + from abel.apis.impactx.impactx_api import run_impactx + beam, self.evolution = run_impactx(lattice, beam0, nom_energy=self.nom_energy, verbose=False, runnable=runnable, space_charge=self.enable_space_charge, csr=self.enable_csr, isr=self.enable_isr) + + return super().track(beam, savedepth, runnable, verbose) + + + def get_impactx_lattice(self): + "Set up the ImpactX plasma-lens-based interstage lattice." + + from impactx import elements + + # initialize lattice + lattice = [] + + ls, inv_rhos, ks, _, _ = self.matrix_lattice() + + for i in range(len(ls)): + + if abs(inv_rhos[i]) > 0: + phi_dip = self.length_dipole*inv_rhos[i] + B_dip = inv_rhos[i]*self.nom_energy/SI.c + dipole = elements.ExactSbend(ds=self.length_dipole, phi=np.rad2deg(phi_dip), B=B_dip, nslice=self.num_slices, rotation=90) + lattice.append(dipole) + elif abs(ks[i]) > 0: + quad = elements.ExactQuad(ds=self.length_quad, k=ks[i], nslice=self.num_slices) + lattice.append(quad) + else: + drift = elements.ExactDrift(ds=ls[i], nslice=1) + lattice.append(drift) + + return lattice + \ No newline at end of file diff --git a/abel/classes/spectrometer/quad_imaging/preset/facet2.py b/abel/classes/spectrometer/quad_imaging/preset/facet2.py new file mode 100644 index 00000000..c76f6acb --- /dev/null +++ b/abel/classes/spectrometer/quad_imaging/preset/facet2.py @@ -0,0 +1,18 @@ +from abel.classes.spectrometer.quad_imaging.impactx import SpectrometerQuadImagingImpactX + +class SpectrometerFACET2(SpectrometerQuadImagingImpactX): + + def __init__(self, imaging_energy_x=None, imaging_energy_y=None, object_plane_x=0.0, object_plane_y=0.0, magnification_x=-10.0): + + super().__init__(imaging_energy_x=imaging_energy_x, imaging_energy_y=imaging_energy_y, object_plane_x=object_plane_x, object_plane_y=object_plane_y, magnification_x=magnification_x) + + self.angle_dipole = -6e-3 # [rad] + self.length_dipole = 0.978 # [m] + + self.strengths_quads = [-5,10,-10] + self.length_quad = 1.0 + + self.length_drifts = [1.897, 1.224, 1.224, 3.520, 8.831] + + + \ No newline at end of file diff --git a/abel/classes/spectrometer/quad_imaging/preset/flashforward.py b/abel/classes/spectrometer/quad_imaging/preset/flashforward.py new file mode 100644 index 00000000..34aafb8f --- /dev/null +++ b/abel/classes/spectrometer/quad_imaging/preset/flashforward.py @@ -0,0 +1,36 @@ +from abel.classes.spectrometer.quad_imaging.impactx import SpectrometerQuadImagingImpactX + +class SpectrometerFACET2(SpectrometerQuadImagingImpactX): + + def __init__(self, imaging_energy_x=None, imaging_energy_y=None, object_plane_x=0.0, object_plane_y=0.0, magnification_x=-10.0): + + super().__init__(imaging_energy_x=imaging_energy_x, imaging_energy_y=imaging_energy_y, object_plane_x=object_plane_x, object_plane_y=object_plane_y, magnification_x=magnification_x) + + self.angle_dipole = -350e-3 # [rad] + + # pre-defined lengths + self.length_dipole = 1.07 # [m] + self.length_quad = 0.1137 # [m] + + # beam line positions (quad and dipole centers) + self.s_CELLCENTRE = 209.932261 # [m] + self.s_Q11FLFDIAG = 210.590261 # [m] + self.s_Q12FLFDIAG = 210.856261 # [m] + self.s_Q21FLFDIAG = 211.122261 # [m] + self.s_Q22FLFDIAG = 211.388261 # [m] + self.s_Q23FLFDIAG = 211.768178 # [m] + self.s_dipoleLEMS = 215.686200 # [m] + self.s_LEMS = 217.045605 # [m] image plane + + # derived separations + d1 = self.s_Q11FLFDIAG - self.s_CELLCENTRE - self.length_quad/2; + d2 = self.s_Q12FLFDIAG - self.s_Q11FLFDIAG - self.length_quad; + d3 = self.s_Q21FLFDIAG - self.s_Q12FLFDIAG - self.length_quad; + d4 = self.s_Q22FLFDIAG - self.s_Q21FLFDIAG - self.length_quad; + d5 = self.s_Q23FLFDIAG - self.s_Q22FLFDIAG - self.length_quad; + d6 = self.s_dipoleLEMS - self.s_Q23FLFDIAG - self.length_quad/2 - self.length_dipole/2; + d7 = self.s_LEMS - self.s_dipoleLEMS - self.length_dipole/2; + + self.strengths_quads = [-5,10,-10] + + self.length_drifts = [d1, d2, d3, d4, d5, d6, d7] diff --git a/abel/classes/spectrometer/spectrometer.py b/abel/classes/spectrometer/spectrometer.py deleted file mode 100644 index 9957bae0..00000000 --- a/abel/classes/spectrometer/spectrometer.py +++ /dev/null @@ -1,21 +0,0 @@ -from abc import abstractmethod -from abel.classes.trackable import Trackable - -class Spectrometer(Trackable): - - @abstractmethod - def __init__(self): - super().__init__() - - def track(self, beam, savedepth=0, runnable=None, verbose=False): - return super().track(beam, savedepth, runnable, verbose) - - @abstractmethod - def get_length(self): - pass - - def survey_object(self): - from matplotlib import patches - rect = patches.Rectangle((0, -0.05), self.get_length(), 0.1) - rect.set_facecolor = 'k' - return rect \ No newline at end of file diff --git a/abel/classes/stage/impl/stage_basic.py b/abel/classes/stage/impl/stage_basic.py index 50e47bc0..344cf6f1 100644 --- a/abel/classes/stage/impl/stage_basic.py +++ b/abel/classes/stage/impl/stage_basic.py @@ -57,7 +57,10 @@ def __init__(self, nom_accel_gradient=None, nom_energy_gain=None, plasma_density def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): # get the driver - driver_incoming = self.driver_source.track() + if self.driver_source is not None: + driver_incoming = self.driver_source.track() + else: + driver_incoming = None original_driver = copy.deepcopy(driver_incoming) original_beam = copy.deepcopy(beam_incoming) @@ -69,10 +72,13 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): # ========== Rotate the coordinate system of the beams ========== # Perform beam rotations before calling on upramp tracking. - if self.parent is None: # Ensures that this is the main stage and not a ramp. + if self.parent is None and self.driver_source is not None: # Ensures that this is the main stage and not a ramp. # Will only rotate the beam coordinate system if the driver source of the stage has angular jitter or angular offset drive_beam_rotated, beam_rotated = self.rotate_beam_coordinate_systems(driver_incoming, beam_incoming) + else: + drive_beam_rotated = driver_incoming + beam_rotated = beam_incoming # ========== Prepare ramps ========== @@ -112,7 +118,8 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): # TODO: Temporary "drive beam evolution": Magnify the driver # Needs to be performed before self.track_downramp(). - driver.magnify_beta_function(self.downramp.ramp_beta_mag, axis_defining_beam=driver) + if driver is not None: + driver.magnify_beta_function(self.downramp.ramp_beta_mag, axis_defining_beam=driver) # Save beams to probe for consistency between ramps and stage if self.store_beams_for_tests: @@ -132,11 +139,13 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): # ========== Rotate the coordinate system of the beams back to original ========== # Perform un-rotation after track_downramp(). Also adds drift to the drive beam. - if self.parent is None: # Ensures that the un-rotation is only performed by the main stage and not by its ramps. + if self.parent is None and self.driver_source is not None: # Ensures that the un-rotation is only performed by the main stage and not by its ramps. # Will only rotate the beam coordinate system if the driver source of the stage has angular jitter or angular offset driver_outgoing, beam_outgoing = self.undo_beam_coordinate_systems_rotation(original_driver, driver_outgoing, beam_outgoing) - + else: + driver_outgoing = driver_outgoing + beam_outgoing = beam_outgoing # ========== Bookkeeping ========== # Store outgoing beams for comparison between ramps and its parent. Stored inside the ramps. @@ -167,7 +176,7 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): # ================================================== - def main_tracking_procedure(self, beam_ramped, drive_beam_ramped): + def main_tracking_procedure(self, beam, driver): """ Prepares and performs the beam tracking using the physics models of the stage. @@ -191,30 +200,33 @@ def main_tracking_procedure(self, beam_ramped, drive_beam_ramped): Drive beam after tracking. """ - beam = beam_ramped - drive_beam = drive_beam_ramped - drive_beam_ramped_location = drive_beam_ramped.location - beam_ramped_location = beam_ramped.location + if driver is not None: + x0_driver = driver.x_offset() + y0_driver = driver.y_offset() + else: + x0_driver = 0.0 + y0_driver = 0.0 # Betatron oscillations deltaEs = np.full(len(beam.Es()), self.nom_energy_gain_flattop) # Homogeneous energy gain for all macroparticles. if self.probe_evolution: - _, evol = beam.apply_betatron_motion(self.length_flattop, self.plasma_density, deltaEs, x0_driver=drive_beam_ramped.x_offset(), y0_driver=drive_beam_ramped.y_offset(), probe_evolution=self.probe_evolution) + _, evol = beam.apply_betatron_motion(self.length_flattop, self.plasma_density, deltaEs, x0_driver=x0_driver, y0_driver=y0_driver, probe_evolution=self.probe_evolution) self.evolution.beam = evol else: - beam.apply_betatron_motion(self.length_flattop, self.plasma_density, deltaEs, x0_driver=drive_beam_ramped.x_offset(), y0_driver=drive_beam_ramped.y_offset()) + beam.apply_betatron_motion(self.length_flattop, self.plasma_density, deltaEs, x0_driver=x0_driver, y0_driver=y0_driver) # Accelerate beam with homogeneous energy gain beam.set_Es(beam.Es() + self.nom_energy_gain_flattop) - # Decelerate the driver with homogeneous energy loss - drive_beam.set_Es(drive_beam_ramped.Es()*(1-self.depletion_efficiency)) - # Update the beam locations - drive_beam.location = drive_beam_ramped_location + self.length_flattop - beam.location = beam_ramped_location + self.length_flattop - - return beam, drive_beam + #beam.location = beam_ramped.location + self.length_flattop + + # Decelerate the driver with homogeneous energy loss + if driver is not None: + driver.set_Es(driver.Es()*(1-self.depletion_efficiency)) + #driver.location = driver.location + self.length_flattop + + return beam, driver # ================================================== diff --git a/abel/classes/stage/impl/stage_hipace.py b/abel/classes/stage/impl/stage_hipace.py index c9828f75..535b65df 100644 --- a/abel/classes/stage/impl/stage_hipace.py +++ b/abel/classes/stage/impl/stage_hipace.py @@ -64,7 +64,10 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): os.mkdir(tmpfolder) # generate driver - driver_incoming = self.driver_source.track() + if self.driver_source is not None: + driver_incoming = self.driver_source.track() + else: + driver_incoming = None # Set ramp lengths, nominal energies, nominal energy gains # and flattop nominal energy if not already done @@ -82,9 +85,12 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): beam0.save(filename = path_beam) # produce and save drive beam - filename_driver = 'driver.h5' - path_driver = tmpfolder + filename_driver - driver0.save(filename = path_driver, beam_name = 'driver') + if driver0 is not None: + filename_driver = 'driver.h5' + path_driver = tmpfolder + filename_driver + driver0.save(filename = path_driver, beam_name = 'driver') + else: + filename_driver = None # make directory if self.plasma_density_from_file is not None: @@ -105,20 +111,35 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): if self.driver_only: box_min_z = driver0.z_offset() + driver0.bunch_length() - np.max([2*np.pi/k_p(self.plasma_density), 2.1*blowout_radius(self.plasma_density, driver0.peak_current())]) else: - box_min_z = beam0.z_offset() - num_sigmas * beam0.bunch_length() - box_min_z = box_min_z - 1.5/k_p(self.plasma_density) - box_max_z = min(driver0.z_offset() + num_sigmas * driver0.bunch_length(), np.max(driver0.zs())+0.5/k_p(self.plasma_density)) + box_min_z = max(beam0.z_offset() - num_sigmas * beam0.bunch_length(), np.min(beam0.zs())-0.5/k_p(self.plasma_density)) + #box_min_z = box_min_z - 1.5/k_p(self.plasma_density) + if driver0 is not None: + box_max_z = min(driver0.z_offset() + num_sigmas * driver0.bunch_length(), np.max(driver0.zs())+0.5/k_p(self.plasma_density)) + else: + box_max_z = min(beam0.z_offset() + num_sigmas * beam0.bunch_length(), np.max(beam0.zs())+0.5/k_p(self.plasma_density)) box_range_z = [box_min_z, box_max_z] # making transverse box size - box_size_xy = 2*np.max([4/k_p(self.plasma_density), 2*blowout_radius(self.plasma_density, driver0.peak_current())]) + if driver0 is not None: + Rb = blowout_radius(self.plasma_density, driver0.peak_current()) + else: + Rb = blowout_radius(self.plasma_density, beam0.peak_current()) + + if driver0 is not None: + box_size_xy = 2*np.max([4/k_p(self.plasma_density), 2*blowout_radius(self.plasma_density, driver0.peak_current())]) + else: + box_size_xy = 2*np.max([4/k_p(self.plasma_density), 2*blowout_radius(self.plasma_density, beam0.peak_current())]) # calculate number of cells in x to get similar resolution dr = box_size_xy/self.num_cell_xy num_cell_z = round((box_max_z-box_min_z)/dr) # calculate the time step - beta_matched = np.sqrt(2*min(beam0.gamma(),driver0.gamma()/2))/k_p(self.plasma_density) + if driver0 is not None: + gamma_min = min(beam0.gamma(),driver0.gamma()/2) + else: + gamma_min = beam0.gamma()/2 + beta_matched = np.sqrt(2*gamma_min)/k_p(self.plasma_density) dz = beta_matched/20 # convert to number of steps (and re-adjust timestep to be divisible) @@ -163,9 +184,10 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): beam.trackable_number = beam_incoming.trackable_number beam.stage_number = beam_incoming.stage_number beam.location = beam_incoming.location - driver.trackable_number = beam_incoming.trackable_number - driver.stage_number = beam_incoming.stage_number - driver.location = beam_incoming.location + if driver is not None: + driver.trackable_number = beam_incoming.trackable_number + driver.stage_number = beam_incoming.stage_number + driver.location = beam_incoming.location beam_outgoing = beam driver_outgoing = driver @@ -215,7 +237,10 @@ def __extract_evolution(self, tmpfolder, beam0, runnable): # in-situ data path insitu_path = tmpfolder + 'diags/insitu/' - bunches = ['beam','driver'] + if self.driver_source is not None: + bunches = ['beam','driver'] + else: + bunches = ['beam'] for bunch in bunches: diff --git a/abel/classes/stage/impl/stage_quasistatic_2d.py b/abel/classes/stage/impl/stage_quasistatic_2d.py index 2e538bb5..0c6c9bd5 100644 --- a/abel/classes/stage/impl/stage_quasistatic_2d.py +++ b/abel/classes/stage/impl/stage_quasistatic_2d.py @@ -29,17 +29,22 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): warnings.simplefilter('ignore', category=RuntimeWarning) # make driver - driver_incoming = self.driver_source.track() + if self.driver_source is not None: + driver_incoming = self.driver_source.track() + else: + driver_incoming = None original_driver = copy.deepcopy(driver_incoming) # ========== Rotate the coordinate system of the beams ========== # Perform beam rotations before calling on upramp tracking. - if self.parent is None: # Ensures that this is the main stage and not a ramp. + if self.parent is None and self.driver_source is not None: # Ensures that this is the main stage and not a ramp. # Will only rotate the beam coordinate system if the driver source of the stage has angular jitter or angular offset drive_beam_rotated, beam_rotated = self.rotate_beam_coordinate_systems(driver_incoming, beam_incoming) - + else: + drive_beam_rotated = driver_incoming + beam_rotated = beam_incoming # ========== Prepare ramps ========== # If ramps exist, set ramp lengths, nominal energies, nominal energy gains @@ -75,11 +80,13 @@ def track(self, beam_incoming, savedepth=0, runnable=None, verbose=False): # ========== Rotate the coordinate system of the beams back to original ========== # Perform un-rotation after track_downramp(). Also adds drift to the drive beam. - if self.parent is None: # Ensures that the un-rotation is only performed by the main stage and not by its ramps. + if self.parent is None and self.driver_source is not None: # Ensures that the un-rotation is only performed by the main stage and not by its ramps. # Will only rotate the beam coordinate system if the driver source of the stage has angular jitter or angular offset driver_outgoing, beam_outgoing = self.undo_beam_coordinate_systems_rotation(original_driver, driver_outgoing, beam_outgoing) - + else: + driver_outgoing = driver_outgoing + beam_outgoing = beam_outgoing # ========== Bookkeeping ========== # Store beams for tests @@ -140,19 +147,24 @@ def main_tracking_procedure(self, beam0, driver0): # make copy of the beams to update later beam = copy.deepcopy(beam0) driver = copy.deepcopy(driver0) - driver0_location = driver0.location - beam0_location = beam0.location # ========== Wake-T simulation and extraction ========== # convert beams to WakeT bunches - driver0_wake_t = beam2wake_t_bunch(driver0, name='driver') + if driver0 is not None: + driver0_wake_t = beam2wake_t_bunch(driver0, name='driver') + else: + driver0_wake_t = None beam0_wake_t = beam2wake_t_bunch(beam0, name='beam') # create plasma stage box_min_z = beam0.z_offset(clean=True) - 5 * beam0.bunch_length(clean=True) - 0.25/k_p(self.plasma_density) - box_max_z = driver0.z_offset(clean=True) + 4 * driver0.bunch_length(clean=True) - box_size_r = 3 * blowout_radius(self.plasma_density, driver0.peak_current()) - k_beta_driver = k_p(self.plasma_density)/np.sqrt(2*driver0.gamma()) + if driver0 is None: + driver_or_beam = copy.deepcopy(beam0) + else: + driver_or_beam = driver0 + box_max_z = driver_or_beam.z_offset(clean=True) + 4 * driver_or_beam.bunch_length(clean=True) + box_size_r = 3 * blowout_radius(self.plasma_density, driver_or_beam.peak_current()) + k_beta_driver = k_p(self.plasma_density)/np.sqrt(2*driver_or_beam.gamma()) k_beta_beam = k_p(self.plasma_density)/np.sqrt(2*beam0.gamma()) lambda_betatron_min = 2*np.pi/max(k_beta_beam, k_beta_driver) lambda_betatron_max = 2*np.pi/min(k_beta_beam, k_beta_driver) @@ -170,19 +182,30 @@ def main_tracking_procedure(self, beam0, driver0): tmpfolder = CONFIG.temp_path + str(uuid.uuid4()) + os.sep if not os.path.exists(tmpfolder): os.mkdir(tmpfolder) - + + if driver0_wake_t is not None: + bunches0 = [driver0_wake_t, beam0_wake_t] + else: + bunches0 = [beam0_wake_t] + # perform tracking with suppress_stdout(): - bunches = plasma.track([driver0_wake_t, beam0_wake_t], opmd_diag=True, diag_dir=tmpfolder) - + bunches = plasma.track(bunches0, opmd_diag=True, diag_dir=tmpfolder) + # convert back to ABEL beams - beam_waket = wake_t_bunch2beam(bunches[1][-1]) - driver_waket = wake_t_bunch2beam(bunches[0][-1]) + if driver0_wake_t is not None: + beam_waket = wake_t_bunch2beam(bunches[1][-1]) + driver_waket = wake_t_bunch2beam(bunches[0][-1]) + else: + beam_waket = wake_t_bunch2beam(bunches[-1]) # save evolution of the beam and driver if self.probe_evolution: - self._driver_evolution = wake_t.diagnostics.analyze_bunch_list(bunches[0]) - self._beam_evolution = wake_t.diagnostics.analyze_bunch_list(bunches[1]) + if driver0_wake_t is not None: + self._driver_evolution = wake_t.diagnostics.analyze_bunch_list(bunches[0]) + self._beam_evolution = wake_t.diagnostics.analyze_bunch_list(bunches[1]) + else: + self._beam_evolution = wake_t.diagnostics.analyze_bunch_list(bunches) # Store wakefield and beam quantities self.__save_initial_step(tmpfolder) @@ -195,8 +218,15 @@ def main_tracking_procedure(self, beam0, driver0): # calculate energy gain delta_Es = self.length_flattop*(beam_waket.Es() - beam.Es())/dz + if driver0 is not None: + x0_driver = driver0.x_offset() + y0_driver = driver0.y_offset() + else: + x0_driver = 0.0 + y0_driver = 0.0 + # find driver offset (to shift the beam relative) and apply betatron motion - output = beam.apply_betatron_motion(self.length_flattop, self.plasma_density, delta_Es, x0_driver=driver0.x_offset(), y0_driver=driver0.y_offset(), radiation_reaction=self.enable_radiation_reaction, probe_evolution=self.probe_evolution) + output = beam.apply_betatron_motion(self.length_flattop, self.plasma_density, delta_Es, x0_driver=x0_driver, y0_driver=y0_driver, radiation_reaction=self.enable_radiation_reaction, probe_evolution=self.probe_evolution) if self.probe_evolution: Es_final, self.evolution.beam = output else: @@ -206,13 +236,14 @@ def main_tracking_procedure(self, beam0, driver0): beam.set_Es(Es_final) # decelerate driver (and remove nans) - delta_Es_driver = self.length_flattop*(driver0.Es()-driver_waket.Es())/dz - driver.apply_betatron_damping(delta_Es_driver) - driver.set_Es(driver0.Es() + delta_Es_driver) + if driver0 is not None: + delta_Es_driver = self.length_flattop*(driver0.Es()-driver_waket.Es())/dz + driver.apply_betatron_damping(delta_Es_driver) + driver.set_Es(driver0.Es() + delta_Es_driver) # Update the beam locations - driver.location = driver0_location + self.length_flattop - beam.location = beam0_location + self.length_flattop + #driver.location = driver0.location + self.length_flattop + #beam.location = beam0.location + self.length_flattop return beam, driver @@ -401,18 +432,22 @@ def __save_initial_step(self, tmpfolder): self.initial.plasma.density.rho = -(rho0_plasma/SI.e) # extract initial beam density - data0_beam = ts.get_particle(species='beam', var_list=['x','y','z','w'], iteration=min(ts.iterations)) - data0_driver = ts.get_particle(species='driver', var_list=['x','y','z','w'], iteration=min(ts.iterations)) extent0 = metadata0_plasma.imshow_extent Nbins0 = self.initial.plasma.density.rho.shape dr0 = (extent0[3]-extent0[2])/Nbins0[0] dz0 = (extent0[1]-extent0[0])/Nbins0[1] + data0_beam = ts.get_particle(species='beam', var_list=['x','y','z','w'], iteration=min(ts.iterations)) mask0_beam = np.logical_and(data0_beam[1] < dr0/2, data0_beam[1] > -dr0/2) jz0_beam, _, _ = np.histogram2d(data0_beam[0][mask0_beam], data0_beam[2][mask0_beam], weights=data0_beam[3][mask0_beam], bins=Nbins0, range=[extent0[2:4],extent0[0:2]]) - mask0_driver = np.logical_and(data0_driver[1] < dr0/2, data0_driver[1] > -dr0/2) - jz0_driver, _, _ = np.histogram2d(data0_driver[0][mask0_driver], data0_driver[2][mask0_driver], weights=data0_driver[3][mask0_driver], bins=Nbins0, range=[extent0[2:4],extent0[0:2]]) self.initial.beam.density.extent = metadata0_plasma.imshow_extent - self.initial.beam.density.rho = (jz0_beam+jz0_driver)/(dr0*dr0*dz0) + if self.driver_source is not None: + data0_driver = ts.get_particle(species='driver', var_list=['x','y','z','w'], iteration=min(ts.iterations)) + mask0_driver = np.logical_and(data0_driver[1] < dr0/2, data0_driver[1] > -dr0/2) + jz0_driver, _, _ = np.histogram2d(data0_driver[0][mask0_driver], data0_driver[2][mask0_driver], weights=data0_driver[3][mask0_driver], bins=Nbins0, range=[extent0[2:4],extent0[0:2]]) + jz0 = jz0_beam+jz0_driver + else: + jz0 = jz0_beam + self.initial.beam.density.rho = jz0/(dr0*dr0*dz0) diff --git a/abel/classes/stage/stage.py b/abel/classes/stage/stage.py index a7d1c871..927f13b7 100644 --- a/abel/classes/stage/stage.py +++ b/abel/classes/stage/stage.py @@ -98,12 +98,9 @@ def get_driver_source(self): """ if isinstance(self.driver_source, DriverComplex): - driver_source = self.driver_source.source - elif isinstance(self.driver_source, Source): - driver_source = self.driver_source - - return driver_source - + return self.driver_source.source + else: + return self.driver_source ## Define upramp and downramp, if present @@ -1188,6 +1185,9 @@ def dumped_power(self): # ================================================== def calculate_efficiency(self, beam0, driver0, beam, driver): + # abort if no driver or beam + if driver0 is None or beam0 is None: + return Etot0_beam = beam0.total_energy() Etot_beam = beam.total_energy() Etot0_driver = driver0.total_energy() @@ -1203,7 +1203,10 @@ def calculate_efficiency(self, beam0, driver0, beam, driver): # ================================================== def calculate_beam_current(self, beam0, driver0, beam=None, driver=None): - + + if driver0 is None: + driver0 = copy.deepcopy(beam0) + driver0.scale_charge(beam0.charge()*1e-15) dz = 40*np.mean([driver0.bunch_length(clean=True)/np.sqrt(len(driver0)), beam0.bunch_length(clean=True)/np.sqrt(len(beam0))]) num_sigmas = 6 z_min = beam0.z_offset() - num_sigmas * beam0.bunch_length() @@ -1849,12 +1852,7 @@ def plot_wake(self, aspect='equal', show_beam=True, savefig=None): return # make figures - has_final_step = self.final is not None \ - and hasattr(self.final, 'plasma.density.extent') \ - and hasattr(self.final, 'plasma.wakefield.onaxis.zs') \ - and hasattr(self.final, 'plasma.wakefield.onaxis.Ezs') \ - and hasattr(self.final, 'plasma.density.rho') \ - and hasattr(self.final, 'beam.density.rho') + has_final_step = self.final is not None num_plots = 1 + int(has_final_step) fig, ax = plt.subplots(num_plots,1) diff --git a/abel/utilities/beam_physics.py b/abel/utilities/beam_physics.py index e8b9ec5e..58992cfe 100644 --- a/abel/utilities/beam_physics.py +++ b/abel/utilities/beam_physics.py @@ -314,3 +314,22 @@ def evolve_second_order_dispersion(ls, inv_rhos, ks, ms, taus, fast=False): return DDx, DDpx, evolution + +def evolve_transfer_matrix(ls, ks, plasmalens=False, fast=True): + + # calculate transfer matrix evolution + Rtot = np.identity(4) + for i in range(len(ls)): + + # full beta evolution + if not fast: + s0 = np.sum(ls[:i]) + ss_l = s0 + np.linspace(0, ls[i], Nres) + for j in range(len(ss_l)): + R_l = Rmat(ss_l[j]-s0, ks[i], plasmalens=plasmalens) @ Rtot + + # final matrix + Rtot = Rmat(ls[i], ks[i], plasmalens=plasmalens) @ Rtot + + return Rtot + diff --git a/abel/utilities/other.py b/abel/utilities/other.py index 2d4ed864..c2b61495 100644 --- a/abel/utilities/other.py +++ b/abel/utilities/other.py @@ -36,4 +36,11 @@ def pad_upwards(arr_max, padding=0.05): """ if padding < 0.0: padding = np.abs(padding) - return arr_max*(1.0 + np.sign(arr_max)*padding) \ No newline at end of file + return arr_max*(1.0 + np.sign(arr_max)*padding) + +################################################### +def check_kwargs(valid_kwargs, kwargs): + for key in kwargs.keys(): + if kwargs and key not in valid_kwargs: + raise ValueError(f"function gotten unexpected keyword, {key}") + diff --git a/examples/experiment_example.ipynb b/examples/experiment_example.ipynb index 04b9ecff..978751c9 100644 --- a/examples/experiment_example.ipynb +++ b/examples/experiment_example.ipynb @@ -276,7 +276,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.12.3" + "version": "3.11.7" } }, "nbformat": 4, diff --git a/examples/facet2_example.ipynb b/examples/facet2_example.ipynb new file mode 100644 index 00000000..a77f004c --- /dev/null +++ b/examples/facet2_example.ipynb @@ -0,0 +1,290 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "c8ea0f6c-2fc7-4507-93a3-65629c41d868", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "/users/lindstrm/.abelconfig.toml\n", + "Loading ABEL config from '/users/lindstrm/.abelconfig.toml'\n" + ] + } + ], + "source": [ + "from abel import *\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "a96e1f53-3077-42a4-9620-fbe529593c7e", + "metadata": {}, + "outputs": [], + "source": [ + "facet2 = FACET2()\n", + "facet2.energy = 10.1e9\n", + "facet2.charge = 1.6e-9\n", + "facet2.plasma_length = 0.05\n", + "facet2.plasma_density = 2e22\n", + "facet2.nom_accel_gradient = 0.0\n", + "facet2.stage_class = StageHipace\n", + "facet2.num_nodes = 16" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8976f534-e00d-44c4-8e0b-9c14fa1d9f9b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "facet2.imaging_energy = 9e9\n", + "facet2.magnification_x = -9.0\n", + "facet2.assemble_trackables()\n", + "facet2.spectrometer.set_imaging()\n", + "facet2.spectrometer.plot_optics()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "7fcee601-f3ac-4a4d-a965-3def5945f282", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[37mTracked #0 \u001b[39m \u001b[1mSourceBasic \u001b[21m \u001b[37m(s =\u001b[39m \u001b[1m 0.0\u001b[21m m\u001b[37m)\u001b[39m : \u001b[37mE =\u001b[39m\u001b[1m 0.0\u001b[21m GeV\u001b[37m, Q =\u001b[39m\u001b[1m -1.60\u001b[21m nC\u001b[37m, σz =\u001b[39m \u001b[1m 35.0\u001b[21m µm\u001b[37m, σE =\u001b[39m\u001b[1m 1.0%\u001b[21m\u001b[37m, ε =\u001b[39m\u001b[1m 5.0\u001b[21m/\u001b[1m5.0\u001b[21m mm-mrad\u001b[0m\n", + "\u001b[37m ... #1 \u001b[39m \u001b[1mRFAcceleratorBasic \u001b[21m \u001b[37m(s =\u001b[39m \u001b[1m 900.0\u001b[21m m\u001b[37m)\u001b[39m : \u001b[37mE =\u001b[39m\u001b[1m 10.1\u001b[21m GeV\u001b[37m, Q =\u001b[39m\u001b[1m -1.60\u001b[21m nC\u001b[37m, σz =\u001b[39m \u001b[1m 35.0\u001b[21m µm\u001b[37m, σE =\u001b[39m\u001b[1m 0.0%\u001b[21m\u001b[37m, ε =\u001b[39m\u001b[1m 5.0\u001b[21m/\u001b[1m5.0\u001b[21m mm-mrad\u001b[0m\n", + "\u001b[37m ... #2 \u001b[39m \u001b[1mBeamDeliverySystemBasic\u001b[21m \u001b[37m(s =\u001b[39m \u001b[1m1000.0\u001b[21m m\u001b[37m)\u001b[39m : \u001b[37mE =\u001b[39m\u001b[1m 10.1\u001b[21m GeV\u001b[37m, Q =\u001b[39m\u001b[1m -1.60\u001b[21m nC\u001b[37m, σz =\u001b[39m \u001b[1m 35.0\u001b[21m µm\u001b[37m, σE =\u001b[39m\u001b[1m 0.0%\u001b[21m\u001b[37m, ε =\u001b[39m\u001b[1m 5.0\u001b[21m/\u001b[1m5.0\u001b[21m mm-mrad\u001b[0m\n", + ">> Finished HiPACE++ (job 12722731): 100%|\u001b[32m██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████\u001b[0m| 190/190 [00:46<00:00, 4.09 steps/s]\u001b[0m\n", + "\u001b[37m ... #3 \u001b[39m \u001b[1mStageHipace #1 \u001b[21m \u001b[37m(s =\u001b[39m \u001b[1m1000.0\u001b[21m m\u001b[37m)\u001b[39m : \u001b[37mE =\u001b[39m\u001b[1m 9.9\u001b[21m GeV\u001b[37m, Q =\u001b[39m\u001b[1m -1.60\u001b[21m nC\u001b[37m, σz =\u001b[39m \u001b[1m 35.0\u001b[21m µm\u001b[37m, σE =\u001b[39m\u001b[1m 0.7%\u001b[21m\u001b[37m, ε =\u001b[39m\u001b[1m 21.7\u001b[21m/\u001b[1m6.4\u001b[21m mm-mrad\u001b[0m\n", + "\u001b[37m ... #4 \u001b[39m \u001b[1mSpectrometerFACET2 \u001b[21m \u001b[37m(s =\u001b[39m \u001b[1m1020.7\u001b[21m m\u001b[37m)\u001b[39m : \u001b[37mE =\u001b[39m\u001b[1m 9.9\u001b[21m GeV\u001b[37m, Q =\u001b[39m\u001b[1m -1.60\u001b[21m nC\u001b[37m, σz =\u001b[39m \u001b[1m 36.1\u001b[21m µm\u001b[37m, σE =\u001b[39m\u001b[1m 0.7%\u001b[21m\u001b[37m, ε =\u001b[39m\u001b[1m 31.3\u001b[21m/\u001b[1m1315.4\u001b[21m mm-mrad\u001b[0m\n" + ] + } + ], + "source": [ + "facet2.run('facet2_test3', overwrite=True, parallel=True, num_shots=48)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "cfcc5c0a-09fe-47c8-a5e0-db89a65e9cc5", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "facet2.stage.plot_wake()\n", + "facet2.stage.plot_evolution()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "65b37866-a9fb-4fb9-b159-7ee13accb1dc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "facet2.spectrometer.plot_evolution()" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b48542e0-ad1b-4061-9775-e7d3f3a38da4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "facet2.plot_spectrometer_screen(xlims=[-50e-3, 50e-3], ylims=[-50e-3, 50e-3])" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "8d9d3176-6b38-4582-a1ad-2a0ca0197b7e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for i in range(facet2.num_outputs()):\n", + " facet2.get_beam(i).plot_lps()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "383b5016-b221-457c-92b6-de1e63d0b8cd", + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "'return' outside function (3397168687.py, line 1)", + "output_type": "error", + "traceback": [ + " \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[9]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[31m \u001b[39m\u001b[31mreturn\u001b[39m\n ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m 'return' outside function\n" + ] + } + ], + "source": [ + "return\n", + "facet2.scan('facet2_scan_example', \n", + " lambda obj, val: setattr(obj, 'charge', val) or obj, \n", + " np.logspace(np.log10(1e-12), np.log10(10e-9), 16),\n", + " label='Charge (nC)',\n", + " scale=1e-9,\n", + " num_shots_per_step=1, \n", + " parallel=True,\n", + " overwrite=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0dc45ba-a813-4827-80fe-5e030511e7c7", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "22e0486c-28af-4ed5-8d5a-62806a01ed91", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/flashforward_example.ipynb b/examples/flashforward_example.ipynb new file mode 100644 index 00000000..577938b4 --- /dev/null +++ b/examples/flashforward_example.ipynb @@ -0,0 +1,132 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 5, + "id": "c8ea0f6c-2fc7-4507-93a3-65629c41d868", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The autoreload extension is already loaded. To reload it, use:\n", + " %reload_ext autoreload\n" + ] + } + ], + "source": [ + "from abel import *\n", + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "a96e1f53-3077-42a4-9620-fbe529593c7e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[37mTracked #0 \u001b[39m \u001b[1mSourceBasic \u001b[21m \u001b[37m(s =\u001b[39m \u001b[1m 0.0\u001b[21m m\u001b[37m)\u001b[39m : \u001b[37mE =\u001b[39m\u001b[1m 1.1\u001b[21m GeV\u001b[37m, Q =\u001b[39m\u001b[1m -0.60\u001b[21m nC\u001b[37m, σz =\u001b[39m \u001b[1m 83.0\u001b[21m µm\u001b[37m, σE =\u001b[39m\u001b[1m 0.1%\u001b[21m\u001b[37m, ε =\u001b[39m\u001b[1m 3.0\u001b[21m/\u001b[1m1.0\u001b[21m mm-mrad\u001b[0m\n", + ">> Finished HiPACE++ (job 12658919): 100%|\u001b[32m█████████████████████████████████████\u001b[0m| 45/45 [01:26<00:00, 1.92s/ steps]\u001b[0m\n", + ">> Finished HiPACE++ (job 12659036): 100%|\u001b[32m███████████████████████████████████\u001b[0m| 230/230 [04:21<00:00, 1.14s/ steps]\u001b[0m\n", + ">> Finished HiPACE++ (job 12659088): 100%|\u001b[32m█████████████████████████████████████\u001b[0m| 45/45 [01:27<00:00, 1.94s/ steps]\u001b[0m\n", + "\u001b[37m ... #2 \u001b[39m \u001b[1mStageHipace #1 \u001b[21m \u001b[37m(s =\u001b[39m \u001b[1m 0.1\u001b[21m m\u001b[37m)\u001b[39m : \u001b[37mE =\u001b[39m\u001b[1m 1.0\u001b[21m GeV\u001b[37m, Q =\u001b[39m\u001b[1m -0.60\u001b[21m nC\u001b[37m, σz =\u001b[39m \u001b[1m 82.6\u001b[21m µm\u001b[37m, σE =\u001b[39m\u001b[1m 1.4%\u001b[21m\u001b[37m, ε =\u001b[39m\u001b[1m 3.3\u001b[21m/\u001b[1m1.1\u001b[21m mm-mrad\u001b[0m\n", + "\u001b[37m ... #3 \u001b[39m \u001b[1mSpectrometerFLASHForwardImpactX\u001b[21m \u001b[37m(s =\u001b[39m \u001b[1m 7.2\u001b[21m m\u001b[37m)\u001b[39m : \u001b[37mE =\u001b[39m\u001b[1m 1.0\u001b[21m GeV\u001b[37m, Q =\u001b[39m\u001b[1m -0.60\u001b[21m nC\u001b[37m, σz =\u001b[39m \u001b[1m 80.0\u001b[21m µm\u001b[37m, σE =\u001b[39m\u001b[1m 1.4%\u001b[21m\u001b[37m, ε =\u001b[39m\u001b[1m 4.8\u001b[21m/\u001b[1m299.2\u001b[21m mm-mrad\u001b[0m\n" + ] + } + ], + "source": [ + "experiment = FLASHForward(ion_species='Ar')\n", + "experiment.run('flashforward_test', overwrite=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "65b37866-a9fb-4fb9-b159-7ee13accb1dc", + "metadata": {}, + "outputs": [], + "source": [ + "experiment.spectrometer.plot_evolution()\n", + "experiment.plot_spectrometer_screen()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "9bb9e720-27d8-4be4-8a20-daf05a46ab6c", + "metadata": {}, + "outputs": [], + "source": [ + "experiment.component.upramp.plot_wake()\n", + "experiment.component.plot_wake()\n", + "experiment.component.downramp.plot_wake()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8d9d3176-6b38-4582-a1ad-2a0ca0197b7e", + "metadata": {}, + "outputs": [], + "source": [ + "experiment.get_beam(0).plot_lps()\n", + "experiment.get_beam(1).plot_lps()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "730bc176-bbf8-4ecd-8387-eb7df30887ba", + "metadata": {}, + "outputs": [], + "source": [ + "experiment.component.plot_evolution()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "383b5016-b221-457c-92b6-de1e63d0b8cd", + "metadata": {}, + "outputs": [], + "source": [ + "experiment.final_beam.plot_spectrometer_x()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e0dc45ba-a813-4827-80fe-5e030511e7c7", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}