def run(nx): # the band width D = nx * grid_step.x # the mapping mapping = hichi.TightFocusingMapping(spherical_pulse.R0, spherical_pulse.pulselength, D) # the bounds of the band x_min = mapping.get_min_coord() x_max = mapping.get_max_coord() band_min_coords = hichi.Vector3d(x_min, min_coords.y, min_coords.z) band_max_coords = hichi.Vector3d(x_max, max_coords.y, max_coords.z) # the field size for the periodic space (that is the real field size) grid_size = hichi.Vector3d(nx, NY, NZ) # the creation of the computational field with the approciate mapping field = hichi.PSATDField(grid_size, band_min_coords, grid_step, time_step) field = field.apply_mapping(mapping) # the field initialisation spherical_pulse.set_field(field) # the correction of the start conditions using the Poisson's equation field.convert_fields_poisson_equation() # the performing one iteration of the field solver field.update_fields() return get_fields(field)
def get_field_plane_(self, coords, shape, plane, last_coordinate_value, func): field = np.zeros(shape=(shape[1], shape[0])) if plane == Plane.XOY: for i0 in range(shape[0]): for i1 in range(shape[1]): coord = hichi.Vector3d(coords[0][i0], coords[1][i1], last_coordinate_value) field[i1, i0] = func(self, coord) return field elif plane == Plane.XOZ: for i0 in range(shape[0]): for i1 in range(shape[1]): coord = hichi.Vector3d(coords[0][i0], last_coordinate_value, coords[1][i1]) field[i1, i0] = func(self, coord) return field elif plane == Plane.YOZ: for i0 in range(shape[0]): for i1 in range(shape[1]): coord = hichi.Vector3d(last_coordinate_value, coords[0][i0], coords[1][i1]) field[i1, i0] = func(self, coord) return field return None
def new_random_array(size) : p_array = hichi.ParticleArray() #type = ELECTRON for i in range(size) : pos = hichi.Vector3d(1.2*i, 3.4*i, 5.6*i) mo = hichi.Vector3d(9.8*i, 7.6*i, 54.3*i) new_p = hichi.Particle(pos, mo, 0.5, hichi.ELECTRON) p_array.add(new_p) return p_array
def get_fields(field): global x, N res = np.zeros(shape=(N, )) for ix in range(N): coord_xy = hichi.Vector3d(x[ix], 0.0, 0.0) res[ix] = field.get_E(coord_xy).y return res
def get_fields(field): global x, y, N res = np.zeros(shape=(N, N)) for ix in range(N): for iy in range(N): coord_xy = hichi.Vector3d(x[ix], y[iy], 0.0) res[N - iy - 1, ix] = field.get_E(coord_xy).norm() return res
def gen_electron(gamma): """Electron creation. Args: gamma: energy Returns: electron """ pos = pfc.Vector3d(0, 0, 0) momentum_x = gamma * pfc.LIGHT_VELOCITY * pfc.ELECTRON_MASS momentum = pfc.Vector3d(momentum_x, 0, 0) particle = pfc.Particle(pos, momentum, 1.0, pfc.ELECTRON) return particle
def get_fields(field): x = np.arange(min_coords.x, max_coords.x, (max_coords.x - min_coords.x) / NX_FULL) y = np.arange(min_coords.y, max_coords.y, (max_coords.y - min_coords.y) / NY) res = np.zeros(shape=(NX_FULL, NY)) for ix in range(NX_FULL): for iy in range(NY): coord_xy = hichi.Vector3d(x[ix], y[iy], 0.0) E = field.get_E(coord_xy) res[ix, iy] = E.norm() return res
def get_fields(): global field, x, y, Nx, Ny Ey = np.zeros(shape=(Ny, Nx)) Bz = np.zeros(shape=(Ny, Nx)) for ix in range(Nx): for iy in range(Ny): coord_xy = hichi.Vector3d(x[ix], y[iy], 0.0) E = field.get_E(coord_xy) Ey[iy, ix] = E.y B = field.get_B(coord_xy) Bz[iy, ix] = B.z return Ey, Bz
def get_field_axis_(self, coords, n_points, axis, last_coordinate_value, func): field = np.zeros(shape=(n_points)) if axis == Axis.X: for i in range(n_points): coord = hichi.Vector3d(coords[i], last_coordinate_value[0], last_coordinate_value[1]) field[i] = func(self, coord) return field elif axis == Axis.Y: for i in range(n_points): coord = hichi.Vector3d(last_coordinate_value[0], coords[i], last_coordinate_value[1]) field[i] = func(self, coord) return field elif axis == Axis.Z: for i in range(n_points): coord = hichi.Vector3d(last_coordinate_value[0], last_coordinate_value[1], coords[i]) field[i] = func(self, coord) return field return None
def create_field(): d = (max_coords.x - min_coords.x) / grid_size.x grid_step = hichi.Vector3d(d, d, d) @cfunc("float64(float64,float64,float64)") def null_value(x, y, z): return 0.0 @cfunc("float64(float64,float64,float64)") def field_value(x, y, z): return np.sin(0.4 * np.pi * x) field = hichi.PSATDField(grid_size, min_coords, grid_step, time_step) field.set_E(null_value.address, field_value.address, null_value.address) field.set_B(null_value.address, null_value.address, field_value.address) field.convert_fields_poisson_equation() return field
def step(min_coords, max_coords, grid_size): """Calculating grid steps. Args: min_coords: minimum coordinate of the computational domain max_coords: maximum coordinate of the computational domain grid_size: computational domain size Returns: calculated step size """ steps = pfc.Vector3d(1, 1, 1) steps.x = (max_coords.x - min_coords.x) / (grid_size.x) steps.y = (max_coords.y - min_coords.y) / (grid_size.y) steps.z = (max_coords.z - min_coords.z) / (grid_size.z) return steps
def get_fields(): global field, x, z, N Ex = np.zeros(shape=(N, N)) Ey = np.zeros(shape=(N, N)) Ez = np.zeros(shape=(N, N)) Bx = np.zeros(shape=(N, N)) By = np.zeros(shape=(N, N)) Bz = np.zeros(shape=(N, N)) for ix in range(N): for iy in range(N): coord_xz = hichi.Vector3d(x[ix], 0.0, z[iy]) E = field.get_E(coord_xz) Ex[ix, iy] = E.x Ey[ix, iy] = E.y Ez[ix, iy] = E.z B = field.get_B(coord_xz) Bx[ix, iy] = B.x By[ix, iy] = B.y Bz[ix, iy] = B.z return Ex, Ey, Ez, Bx, By, Bz
def valueB(x, y, z): B = hichi.Vector3d(-np.cos(z), 0, 0) return B
def valueBx(x, y, z): Bx = -np.cos(z) return Bx def valueBy(x, y, z): By = 0 return By def valueBz(x, y, z): Bz = 0 return Bz field_size = hichi.Vector3d(5, 10, 11) min_coords = hichi.Vector3d(0.0, 1.0, 0.0) max_coords = hichi.Vector3d(3.5, 7.0, 2 * np.pi) field_step = (max_coords - min_coords) / field_size time_step = 1e-16 field1 = hichi.YeeField(field_size, min_coords, field_step, time_step) field2 = hichi.YeeField(field_size, min_coords, field_step, time_step) field1.set_E(valueE) field1.set_B(valueB) field2.set_E(valueEx, valueEy, valueEz) field2.set_B(valueBx, valueBy, valueBz) #show
import sys sys.path.append("../../python_modules") sys.path.append("../../bin") import pyHiChi as hichi from tight_focusing_fields import SphericalPulseC, SphericalPulsePython # ------------------- initializing ------------------------------------- FACTOR = 0.5 NX_FULL = int(FACTOR * 320) # size of field in full area NY = int(FACTOR * 256) NZ = int(FACTOR * 256) NX_BAND = int(56 * FACTOR) # size of field in the band grid_size = hichi.Vector3d(NX_BAND, NY, NZ) # real size of field # creating of spherical pulse spherical_pulse = SphericalPulsePython(f_number=0.3, R0=16, pulselength=2.0, edge_smoothing_angle=0.1) time_step = 1.0 / hichi.c # time step in CGS system of units max_iter = 32 # number of iterations to compute min_coords = hichi.Vector3d(-20, -20, -20) # bounds of full area max_coords = hichi.Vector3d(20, 20, 20) D = 3.5 * spherical_pulse.pulselength # band width # to compute the task in the full area just set # D = max_coords.x - min_coords.x
import pyHiChi as hichi import numpy as np from tight_focusing_fields import SphericalPulseC # the output directory DIR_RESULT = "./" # the creation of the spherical pulse # f_number=0.3 (opening angle = 1 rad) spherical_pulse = SphericalPulseC(f_number=0.3, R0=16, pulselength=2.0, edge_smoothing_angle=0.1) # the computational area (coordinates of the opposite corners of the parallelepiped) min_coords = hichi.Vector3d(-20, -20, -20) max_coords = hichi.Vector3d(20, 20, 20) # the field size for the entire original computational domain FACTOR = 1.0 # the coefficient to adjust the field size NX_FULL = int(320 * FACTOR) NY = int(256 * FACTOR) NZ = int(256 * FACTOR) full_grid_size = hichi.Vector3d(NX_FULL, NY, NZ) # the spatial step grid_step = (max_coords - min_coords) / full_grid_size # the time step which is equal to R0 in the universal system of units time_step = spherical_pulse.R0 / hichi.c
def value_E_analytical(pos, t): E = hichi.Vector3d(10**-5, 10**-5, 10**-5) #sin(pos.x) return E
def value_B_analytical(pos, t): B = hichi.Vector3d(0, 0, 0) return B
def value_E_analytical(pos, t): E = hichi.Vector3d(10**-5, 10**-5, 10**-5) #sin(pos.x) return E def value_B_analytical(pos, t): B = hichi.Vector3d(0, 0, 0) return B t = 0 p_array = hichi.ParticleArray() fields_array = [] for i in range(11): pos = hichi.Vector3d(1.2 * i, 3.4 * i, 5.6 * i) mo = hichi.Vector3d(i * 10, 0, 0) new_p = hichi.Particle(pos, mo, 0.5, hichi.ELECTRON) p_array.add(new_p) fields_array.append( hichi.FieldValue(value_E_analytical(pos, t), value_B_analytical(pos, t))) #Boris Pusher with RadiationReaction dt = 0.001 pusher = hichi.BorisPusher() rr = hichi.RadiationReaction() for k in range(11): print(p_array[0].get_momentum()) pusher(p_array, fields_array, dt) rr(p_array, fields_array, dt)
import sys sys.path.append("../bin/") import pyHiChi as hichi E = hichi.Vector3d(1.2, 2.2, 3.4) B = hichi.Vector3d(34, 5.6, 7.8) #FieldValue f = hichi.Field(E, B) print(f.get_E()) print(f.get_B()) f.set_E(B) f.set_B(E) print(f.get_E()) print(f.get_B()) f2 = hichi.Field(E.z, E.y, E.x, B.x, B.x, B.x) #Ex, Ey, Ez, Bx, By, Bz print(f2.get_E()) print(f2.get_B())
Bx = np.sin(x - z)/np.sqrt(2) #for xz return Bx def valueBy(x, y, z): By = 0 #for x or y or xz #By = np.sin(z) #for z return By def valueBz(x, y, z): #Bz = 0 #for y or z #Bz = np.sin(x) #for x Bz = np.sin(x - z)/np.sqrt(2) #for xz return Bz grid_size = hichi.Vector3d(20, 20, 20) min_coords = hichi.Vector3d(0.0, 0.0, 0.0) max_coords = hichi.Vector3d(2*np.pi, 2*np.pi, 2*np.pi) grid_step = (max_coords - min_coords) / grid_size time_step = 1e-14 field = hichi.YeeField(grid_size, min_coords, grid_step, time_step) field.set_E(valueEx, valueEy, valueEz) field.set_B(valueBx, valueBy, valueBz) field.set_PML(0, 0, 0) field.set_periodical_BC() #show import matplotlib.pyplot as plt import matplotlib.animation as animation
def value_E_analytical(pos, t): E = hichi.Vector3d(1, 0, 0) #sin(pos.x) return E
import sys sys.path.append("../bin") import pyHiChi as hichi import numpy as np from numba import cfunc, types, carray min_coords = hichi.Vector3d(-10, -10, 0.0) max_coords = hichi.Vector3d(10, 10, 0.0) time_step = 0.05 / hichi.c grid_size = hichi.Vector3d(128, 1, 1) # ---------------- create original field ---------- def create_field(): d = (max_coords.x - min_coords.x) / grid_size.x grid_step = hichi.Vector3d(d, d, d) @cfunc("float64(float64,float64,float64)") def null_value(x, y, z): return 0.0 @cfunc("float64(float64,float64,float64)") def field_value(x, y, z): return np.sin(0.4 * np.pi * x) field = hichi.PSATDField(grid_size, min_coords, grid_step, time_step) field.set_E(null_value.address, field_value.address, null_value.address) field.set_B(null_value.address, null_value.address, field_value.address) field.convert_fields_poisson_equation()
def valueE(x, y, z): E = hichi.Vector3d(0, np.cos(z), 0) #sin(x) return E
import sys sys.path.append("../bin") import pyHiChi as hichi import numpy as np def field_value(x, y, z): return np.exp(-x**2 - y**2 - z**2) * np.sin(5 * x) def null_value(x, y, z): return 0.0 min_coords = hichi.Vector3d(-5, -5, -5) max_coords = hichi.Vector3d(5, 5, 5) grid_size = hichi.Vector3d(64, 64, 64) grid_step = (max_coords - min_coords) / grid_size time_step = 0.1 / hichi.c field = hichi.PSATDField(grid_size, min_coords, grid_step, time_step) field.set_E(null_value, field_value, null_value) field.set_B(null_value, null_value, field_value) field.convert_fields_poisson_equation() # create the first transformed field # rotation def getRotatedField(field): mapping = hichi.RotationMapping(hichi.Axis.Z, -np.pi / 6) # local object
import sys sys.path.append("../bin") import pyHiChi as hichi import numpy as np from numba import cfunc min_coords = hichi.Vector3d(-10, -10, 0.0) max_coords = hichi.Vector3d(10, 10, 0.0) time_step = 0.05/hichi.c @cfunc("float64(float64,float64,float64)") def null_value(x, y, z): return 0.0 @cfunc("float64(float64,float64,float64,float64)") def null_value_t(x, y, z, t): return 0.0 # ------- create the first pulse (PSATD solver) --------------- @cfunc("float64(float64,float64,float64)") def field_value_1(x, y, z): return np.exp(-x**2-y**2)*np.sin(3*x) # omega=3 grid_size_1 = hichi.Vector3d(128, 128, 1) d1 = (max_coords.x - min_coords.x) / grid_size_1.x grid_step_1 = hichi.Vector3d(d1, d1, d1)
import sys sys.path.append("../bin/") import pyHiChi as hichi import numpy as np grid_size = hichi.Vector3d(5, 10, 11) min_coords = hichi.Vector3d(0.0, 1.0, 0.0) max_coords = hichi.Vector3d(3.5, 7.0, 2 * np.pi) def value_Ex(x, y, z): Ex = np.sin(2 * np.pi / (max_coords.z - min_coords.z) * z) return Ex def value_Ey(x, y, z): Ey = 0 return Ey def value_Ez(x, y, z): Ez = 0 return Ez def value_Bx(x, y, z): Bx = 0 return Bx def value_By(x, y, z):
import sys sys.path.append("../bin/") import pyHiChi as hichi import numpy as np field_size = hichi.Vector3d(144, 30, 1) pml_size = hichi.Vector3d(8, 0, 0) min_coords = hichi.Vector3d(0.0, 0.0, 0.0) max_coords = hichi.Vector3d(field_size.x * hichi.c, field_size.y * hichi.c, field_size.z * hichi.c) field_step = (max_coords - min_coords) / field_size time_step = 0.1 pml_left_end = min_coords.x + pml_size.x*field_step.x pml_right_end = max_coords.x - pml_size.x*field_step.x internal_width = pml_right_end - pml_left_end def value_Ex(x, y, z): Ex = 0 return Ex def value_Ey(x, y, z): if (x < pml_left_end or x >= pml_right_end): Ey=0 else: Ey = np.sin(2*np.pi/internal_width*(x - pml_left_end)) return Ey def value_Ez(x, y, z): Ez = 0 return Ez
import sys sys.path.append("../bin/") import pyHiChi as hichi # ensemble ensemble = hichi.Ensemble() for i in range(11): pos = hichi.Vector3d(1.2 * i, 1.3 * i, 1.6 * i) mo = hichi.Vector3d(1.1 * i, 1.4 * i, 1.5 * i) new_p = hichi.Particle(pos, mo, 0.5, hichi.ELECTRON) ensemble.add(new_p) for i in range(10): pos = hichi.Vector3d(13 * i, 14 * i, 17 * i) mo = hichi.Vector3d(12 * i, 15 * i, 16 * i) new_p = hichi.Particle(pos, mo, 0.5, hichi.POSITRON) ensemble.add(new_p) for i in range(13): pos = hichi.Vector3d(140 * i, 150 * i, 180 * i) mo = hichi.Vector3d(130 * i, 160 * i, 170 * i) new_p = hichi.Particle(pos, mo, 0.5, hichi.PROTON) ensemble.add(new_p) print('Count Particles: ', ensemble.size()) print('Count Electron: ', ensemble['Electron'].size()) #use index 'Electron' or hichi.ELECTRON print('Count Positron: ', ensemble['Positron'].size()) #same Electron print('Count Proton: ', ensemble['Proton'].size()) #same Electron print('Positions Electron: ') for elem in ensemble[hichi.ELECTRON]: print(elem.get_position())
import sys sys.path.append("../bin/") import pyHiChi as hichi #vector3d v = hichi.Vector3d(1.2, 2.2, 3.4) print("volume: ", v.volume()) print("norm: ", v.norm()) print("norm2: ", v.norm2()) print("vector: ", str(v)) print(v) print(v.x) print(v.y) print(v.z) v2 = hichi.Vector3d() print("v2: ", str(v2)) v2.x = 2.4 v2.y = 4.5 v2.z = 312 print("v2: ", str(v2))