def test_equality(self): '''Tests whether two slicers with the same config are equal in the sense of the == and != operator (calling __eq__, __ne__) ''' unif_bin_slicer = MeshSlicer(self.mesh, context) unif_bin_slicer2 = MeshSlicer(self.mesh, context) self.assertTrue(unif_bin_slicer == unif_bin_slicer2, 'comparing two uniform bin slicers with '+ 'identical config using == returns False') self.assertFalse(unif_bin_slicer != unif_bin_slicer2, 'comparing two uniform bin slicers with '+ 'identical config using != returns True')
def test_inequality(self): '''Tests whether two slicers with differing meshs are not equal in the sense of the == and != operator (calling __eq__, __ne__) ''' unif_bin_slicer = MeshSlicer(self.mesh, context) unif_bin_slicer2 = MeshSlicer(self.create_mesh(nslices=self.nslices+1), context) self.assertTrue(unif_bin_slicer != unif_bin_slicer2, 'comparing two uniform bin slicers with '+ 'different config using != returns False') self.assertFalse(unif_bin_slicer == unif_bin_slicer2, 'comparing two uniform bin slicers with '+ 'different config using == returns True')
def setUp(self): #beam parameters self.intensity = 1.234e9 self.circumference = 111. self.gamma = 20.1 #simulation parameters self.macroparticlenumber = 100 #must be multiple of nslices self.particlenumber_per_mp = self.intensity / self.macroparticlenumber #create a bunch self.bunch = self.create_bunch() #create a params for slicers self.nslices = 32 self.z_cuts = (-20., 30.) #asymmetric to check uniform_charge_slicer self.n_sigma_z = 5 self.mesh = self.create_mesh() self.basic_slicer = MeshSlicer(self.mesh, context) self.basic_slice_set = self.basic_slicer.slice(self.bunch)
def test_sliceset_macroparticles(self): '''Tests whether the sum of all particles per slice is equal to the specified number of macroparticles when specifying z_cuts which lie outside of the bunch ''' #create a bunch and a slice set encompassing the whole bunch z_min, z_max = -2., 2. bunch = self.create_bunch(zmin=z_min, zmax=z_max) z_cuts = (z_min - 1, z_max + 1) mesh = self.create_mesh(z_cuts=z_cuts) slice_set = MeshSlicer(mesh, context).slice(bunch) n_particles = gpuarray.sum(slice_set.n_macroparticles_per_slice).get() self.assertEqual(self.macroparticlenumber, n_particles, 'the SliceSet lost/added some particles')
def setUp(self): #beam parameters self.intensity = 1.234e9 self.circumference = 111. self.gamma = 20.1 #simulation parameters self.macroparticlenumber = 100 #must be multiple of nslices self.particlenumber_per_mp = self.intensity/self.macroparticlenumber #create a bunch self.bunch = self.create_bunch() #create a params for slicers self.nslices = 32 self.z_cuts = (-20.,30.) #asymmetric to check uniform_charge_slicer self.n_sigma_z = 5 self.mesh = self.create_mesh() self.basic_slicer = MeshSlicer(self.mesh, context) self.basic_slice_set = self.basic_slicer.slice(self.bunch)
class TestSlicing(unittest.TestCase): def setUp(self): #beam parameters self.intensity = 1.234e9 self.circumference = 111. self.gamma = 20.1 #simulation parameters self.macroparticlenumber = 100 #must be multiple of nslices self.particlenumber_per_mp = self.intensity / self.macroparticlenumber #create a bunch self.bunch = self.create_bunch() #create a params for slicers self.nslices = 32 self.z_cuts = (-20., 30.) #asymmetric to check uniform_charge_slicer self.n_sigma_z = 5 self.mesh = self.create_mesh() self.basic_slicer = MeshSlicer(self.mesh, context) self.basic_slice_set = self.basic_slicer.slice(self.bunch) def tearDown(self): pass def test_long_cuts(self): '''Tests whether the z_cuts are initialized correctly''' (cut_tail, cut_head) = self.basic_slicer.get_long_cuts(self.bunch) self.assertAlmostEqual(self.z_cuts[0], cut_tail, 'get_long_cuts incorrect (tail cut)') self.assertAlmostEqual(self.z_cuts[1], cut_head, 'get_long_cuts incorrect (head cut)') # def test_z_cuts_warning(self): # '''Tests whether a warning is raised whenever # z_cut_tail >= z_cut_head # ''' # mesh = self.create_mesh(z_cuts=tuple(reversed(self.z_cuts))) # warnings = AccumulatorPrinter() # slicer = MeshSlicer(mesh, warningprinter=warnings) # self.assertTrue(len(warnings.log) > 0, # 'no warning generated when z_cut head < z_cut tail') def test_equality(self): '''Tests whether two slicers with the same config are equal in the sense of the == and != operator (calling __eq__, __ne__) ''' unif_bin_slicer = MeshSlicer(self.mesh, context) unif_bin_slicer2 = MeshSlicer(self.mesh, context) self.assertTrue( unif_bin_slicer == unif_bin_slicer2, 'comparing two uniform bin slicers with ' + 'identical config using == returns False') self.assertFalse( unif_bin_slicer != unif_bin_slicer2, 'comparing two uniform bin slicers with ' + 'identical config using != returns True') def test_inequality(self): '''Tests whether two slicers with differing meshs are not equal in the sense of the == and != operator (calling __eq__, __ne__) ''' unif_bin_slicer = MeshSlicer(self.mesh, context) unif_bin_slicer2 = MeshSlicer( self.create_mesh(nslices=self.nslices + 1), context) self.assertTrue( unif_bin_slicer != unif_bin_slicer2, 'comparing two uniform bin slicers with ' + 'different config using != returns False') self.assertFalse( unif_bin_slicer == unif_bin_slicer2, 'comparing two uniform bin slicers with ' + 'different config using == returns True') def test_sliceset_macroparticles(self): '''Tests whether the sum of all particles per slice is equal to the specified number of macroparticles when specifying z_cuts which lie outside of the bunch ''' #create a bunch and a slice set encompassing the whole bunch z_min, z_max = -2., 2. bunch = self.create_bunch(zmin=z_min, zmax=z_max) z_cuts = (z_min - 1, z_max + 1) mesh = self.create_mesh(z_cuts=z_cuts) slice_set = MeshSlicer(mesh, context).slice(bunch) n_particles = gpuarray.sum(slice_set.n_macroparticles_per_slice).get() self.assertEqual(self.macroparticlenumber, n_particles, 'the SliceSet lost/added some particles') def test_add_statistics(self): """ Tests whether any error gets thrown when calling the statistics functions of the slicer. Does not do any specific tests """ self.basic_slicer.add_statistics(self.basic_slice_set, self.bunch, True, self.basic_slice_set.lower_bounds, self.basic_slice_set.upper_bounds) self.basic_slice_set.mean_x # self.basic_slice_set.eff_epsn_y # def test_emittance_no_dispersion(self): # """ Tests whether the effective emittance and emittance are the same # for a beam with no dispersion effects # """ # bunch = self.create_bunch_with_params(1, 42, 0., 20) # slice_set = self.basic_slicer.slice(bunch) # self.basic_slicer.add_statistics(slice_set, bunch, True) # for n in xrange(self.nslices): # self.assertAlmostEqual(slice_set.epsn_x[n], # slice_set.eff_epsn_x[n], # places=4, # msg='The effective emittance is not the ' + # 'same as the emittance for no dispersion') # exclude this test for now, fails at the moment but not clear whether # this should be changed #def test_sliceset_dimensions(self): # '''Tests whether the dimensions of several slice_set properties # match the specified number of slices # ''' # self.assertTrue(self.basic_slice_set.slice_widths.size == # self.nslices, 'slice_widths has wrong dimension') # #print(self.basic_slice_set.slice_positions) # self.assertTrue(self.basic_slice_set.slice_positions.size == # self.nslices, 'slice_positions has wrong dimension') def create_mesh(self, nslices=None, z_cuts=None): if nslices is None: nslices = self.nslices if z_cuts is None: z_cuts = self.z_cuts return UniformMesh1D(z_cuts[0], np.diff(z_cuts)[0] / nslices, nslices, mathlib=cumath) def create_bunch(self, zmin=-1., zmax=1.): z = np.linspace(zmin, zmax, num=self.macroparticlenumber) y = np.copy(z) x = np.copy(z) xp = np.linspace(-0.5, 0.5, num=self.macroparticlenumber) yp = np.copy(xp) dp = np.copy(xp) coords_n_momenta_dict = { 'x': x, 'y': y, 'z': z, 'xp': xp, 'yp': yp, 'dp': dp } return Particles(self.macroparticlenumber, self.particlenumber_per_mp, e, m_p, self.circumference, self.gamma, coords_n_momenta_dict) def create_bunch_with_params(self, alpha_x, beta_x, disp_x, gamma): np.random.seed(0) beta_y = beta_x alpha_y = alpha_x disp_y = disp_x alpha0 = [0.00308] C = 6911. Q_s = 0.017 epsn_x = 3.75e-6 epsn_y = 3.75e-6 linear_map = LinearMap(alpha0, Q_s, C) # then transform... intensity = 1.05e11 sigma_z = 0.23 gamma_t = 1. / np.sqrt(linear_map.alpha_array[0]) p0 = np.sqrt(gamma**2 - 1) * m_p * c beta_z = np.abs( (linear_map.eta(dp=0, gamma=gamma) * linear_map.circumference / (2 * np.pi * linear_map.Q_s))) epsn_z = 4 * np.pi * sigma_z**2 * p0 / (beta_z * e) #print ('epsn_z: ' + str(epsn_z)) bunch = generate_Gaussian6DTwiss( macroparticlenumber=10000, intensity=intensity, charge=e, gamma=gamma, mass=m_p, circumference=linear_map.circumference, alpha_x=0., beta_x=1., epsn_x=epsn_x, alpha_y=0., beta_y=1., epsn_y=epsn_y, beta_z=beta_z, epsn_z=epsn_z) # Scale to correct beta and alpha xx = bunch.x.copy() yy = bunch.y.copy() bunch.x *= np.sqrt(beta_x) bunch.xp = -alpha_x / np.sqrt(beta_x) * xx + 1. / np.sqrt( beta_x) * bunch.xp bunch.y *= np.sqrt(beta_y) bunch.yp = -alpha_y / np.sqrt(beta_y) * yy + 1. / np.sqrt( beta_y) * bunch.yp bunch.x += disp_x * bunch.dp bunch.y += disp_y * bunch.dp return bunch
class TestSlicing(unittest.TestCase): def setUp(self): #beam parameters self.intensity = 1.234e9 self.circumference = 111. self.gamma = 20.1 #simulation parameters self.macroparticlenumber = 100 #must be multiple of nslices self.particlenumber_per_mp = self.intensity/self.macroparticlenumber #create a bunch self.bunch = self.create_bunch() #create a params for slicers self.nslices = 32 self.z_cuts = (-20.,30.) #asymmetric to check uniform_charge_slicer self.n_sigma_z = 5 self.mesh = self.create_mesh() self.basic_slicer = MeshSlicer(self.mesh, context) self.basic_slice_set = self.basic_slicer.slice(self.bunch) def tearDown(self): pass def test_long_cuts(self): '''Tests whether the z_cuts are initialized correctly''' (cut_tail, cut_head) = self.basic_slicer.get_long_cuts(self.bunch) self.assertAlmostEqual(self.z_cuts[0], cut_tail, 'get_long_cuts incorrect (tail cut)') self.assertAlmostEqual(self.z_cuts[1], cut_head, 'get_long_cuts incorrect (head cut)') # def test_z_cuts_warning(self): # '''Tests whether a warning is raised whenever # z_cut_tail >= z_cut_head # ''' # mesh = self.create_mesh(z_cuts=tuple(reversed(self.z_cuts))) # warnings = AccumulatorPrinter() # slicer = MeshSlicer(mesh, warningprinter=warnings) # self.assertTrue(len(warnings.log) > 0, # 'no warning generated when z_cut head < z_cut tail') def test_equality(self): '''Tests whether two slicers with the same config are equal in the sense of the == and != operator (calling __eq__, __ne__) ''' unif_bin_slicer = MeshSlicer(self.mesh, context) unif_bin_slicer2 = MeshSlicer(self.mesh, context) self.assertTrue(unif_bin_slicer == unif_bin_slicer2, 'comparing two uniform bin slicers with '+ 'identical config using == returns False') self.assertFalse(unif_bin_slicer != unif_bin_slicer2, 'comparing two uniform bin slicers with '+ 'identical config using != returns True') def test_inequality(self): '''Tests whether two slicers with differing meshs are not equal in the sense of the == and != operator (calling __eq__, __ne__) ''' unif_bin_slicer = MeshSlicer(self.mesh, context) unif_bin_slicer2 = MeshSlicer(self.create_mesh(nslices=self.nslices+1), context) self.assertTrue(unif_bin_slicer != unif_bin_slicer2, 'comparing two uniform bin slicers with '+ 'different config using != returns False') self.assertFalse(unif_bin_slicer == unif_bin_slicer2, 'comparing two uniform bin slicers with '+ 'different config using == returns True') def test_sliceset_macroparticles(self): '''Tests whether the sum of all particles per slice is equal to the specified number of macroparticles when specifying z_cuts which lie outside of the bunch ''' #create a bunch and a slice set encompassing the whole bunch z_min, z_max = -2., 2. bunch = self.create_bunch(zmin=z_min, zmax=z_max) z_cuts = (z_min-1, z_max+1) mesh = self.create_mesh(z_cuts=z_cuts) slice_set = MeshSlicer(mesh, context).slice(bunch) n_particles = gpuarray.sum(slice_set.n_macroparticles_per_slice).get() self.assertEqual(self.macroparticlenumber, n_particles, 'the SliceSet lost/added some particles') def test_add_statistics(self): """ Tests whether any error gets thrown when calling the statistics functions of the slicer. Does not do any specific tests """ self.basic_slicer.add_statistics( self.basic_slice_set, self.bunch, True, self.basic_slice_set.lower_bounds, self.basic_slice_set.upper_bounds ) self.basic_slice_set.mean_x # self.basic_slice_set.eff_epsn_y # def test_emittance_no_dispersion(self): # """ Tests whether the effective emittance and emittance are the same # for a beam with no dispersion effects # """ # bunch = self.create_bunch_with_params(1, 42, 0., 20) # slice_set = self.basic_slicer.slice(bunch) # self.basic_slicer.add_statistics(slice_set, bunch, True) # for n in xrange(self.nslices): # self.assertAlmostEqual(slice_set.epsn_x[n], # slice_set.eff_epsn_x[n], # places=4, # msg='The effective emittance is not the ' + # 'same as the emittance for no dispersion') # exclude this test for now, fails at the moment but not clear whether # this should be changed #def test_sliceset_dimensions(self): # '''Tests whether the dimensions of several slice_set properties # match the specified number of slices # ''' # self.assertTrue(self.basic_slice_set.slice_widths.size == # self.nslices, 'slice_widths has wrong dimension') # #print(self.basic_slice_set.slice_positions) # self.assertTrue(self.basic_slice_set.slice_positions.size == # self.nslices, 'slice_positions has wrong dimension') def create_mesh(self, nslices=None, z_cuts=None): if nslices is None: nslices = self.nslices if z_cuts is None: z_cuts = self.z_cuts return UniformMesh1D(z_cuts[0], np.diff(z_cuts)[0] / nslices, nslices, mathlib=cumath) def create_bunch(self, zmin=-1., zmax=1.): z = np.linspace(zmin, zmax, num=self.macroparticlenumber) y = np.copy(z) x = np.copy(z) xp = np.linspace(-0.5, 0.5, num=self.macroparticlenumber) yp = np.copy(xp) dp = np.copy(xp) coords_n_momenta_dict = { 'x': x, 'y': y, 'z': z, 'xp': xp, 'yp': yp, 'dp': dp } return Particles( self.macroparticlenumber, self.particlenumber_per_mp, e, m_p, self.circumference, self.gamma, coords_n_momenta_dict ) def create_bunch_with_params(self,alpha_x, beta_x, disp_x, gamma): np.random.seed(0) beta_y = beta_x alpha_y = alpha_x disp_y = disp_x alpha0= [0.00308] C = 6911. Qs = 0.017 epsn_x = 3.75e-6 epsn_y = 3.75e-6 linear_map = LinearMap(alpha0, Qs, C) # then transform... intensity = 1.05e11 sigma_z = 0.23 gamma_t = 1. / np.sqrt(linear_map.alpha_array[0]) p0 = np.sqrt(gamma**2 - 1) * m_p * c beta_z = np.abs((linear_map.eta(dp=0, gamma=gamma) * linear_map.circumference / (2 * np.pi * linear_map.Qs))) epsn_z = 4 * np.pi * sigma_z**2 * p0 / (beta_z * e) #print ('epsn_z: ' + str(epsn_z)) bunch = generate_Gaussian6DTwiss( macroparticlenumber=10000, intensity=intensity, charge=e, gamma=gamma, mass=m_p, circumference=linear_map.circumference, alpha_x=0., beta_x=1., epsn_x=epsn_x, alpha_y=0., beta_y=1., epsn_y=epsn_y, beta_z=beta_z, epsn_z=epsn_z) # Scale to correct beta and alpha xx = bunch.x.copy() yy = bunch.y.copy() bunch.x *= np.sqrt(beta_x) bunch.xp = -alpha_x/np.sqrt(beta_x) * xx + 1./np.sqrt(beta_x) * bunch.xp bunch.y *= np.sqrt(beta_y) bunch.yp = -alpha_y/np.sqrt(beta_y) * yy + 1./np.sqrt(beta_y) * bunch.yp bunch.x += disp_x * bunch.dp bunch.y += disp_y * bunch.dp return bunch