def load__field():
# ------------------------------------------------- #
# --- [1] load ems_pst.field & source.dat --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
const = lcn.load__constants(inpFile=cnsFile)
import nkUtilities.load__pointFile as lpf
inpFile = "dat/ems_pst.field"
BField = lpf.load__pointFile(inpFile=inpFile, returnType="point")
inpFile = "dat/source_wofield.dat"
source = lpf.load__pointFile(inpFile=inpFile, returnType="structured")
# ------------------------------------------------- #
# --- [2] store in grid --- #
# ------------------------------------------------- #
import nkBasicAlgs.store__inGrid3D as sig
BField_ = sig.store__inGrid3D( Data=BField, x1MinMaxNum=const["x1MinMaxNum"], \
x2MinMaxNum=const["x2MinMaxNum"], \
x3MinMaxNum=const["x3MinMaxNum"], )
source[:, :, :, 3:6] = BField_[:, :, :, 3:6]
# ------------------------------------------------- #
# --- [3] save as source.dat --- #
# ------------------------------------------------- #
import nkUtilities.save__pointFile as spf
outFile = "dat/source.dat"
spf.save__pointFile(outFile=outFile, Data=source)
def make__in7():
# -- execute this script to generate grided field -- #
# -- sf7 : post processor for poisson-superfish -- #
# -- in7 : input file for sf7 -- #
# ------------------------------------------------- #
# --- [1] load config file --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnfFile = "dat/parameter.conf"
const = lcn.load__constants( inpFile=cnfFile )
# ------------------------------------------------- #
# --- [2] write in file --- #
# ------------------------------------------------- #
line1 = "rect noscreen\n"
line2 = "{0} {1} {2} {3}\n".format( const["sf7_xMinMaxNum"][0], const["sf7_yMinMaxNum"][0], \
const["sf7_xMinMaxNum"][1], const["sf7_yMinMaxNum"][1] )
line3 = "{0} {1}\n".format( int( const["sf7_xMinMaxNum"][2]-1 ), \
int( const["sf7_yMinMaxNum"][2]-1 ) )
line4 = "end\n"
# line3 :: number of space should be prescribed == Not number of nodes.
text = line1 + line2 + line3 + line4
with open( const["in7File"], "w" ) as f:
f.write( text )
print( "[make__in7.py] outFile :: {0} ".format( const["in7File"] ) )
def select__particles_judge():
# ------------------------------------------------- #
# --- [1] preparation --- #
# ------------------------------------------------- #
# -- [1-1] probe file -- #
outFile = "dat/selected.dat"
inpFile = "prb/probe{0:06}.dat"
# -- [1-2] load constants -- #
cnsFile = "dat/particle.conf"
import nkUtilities.load__constants as lcn
const = lcn.load__constants( inpFile=cnsFile )
# ------------------------------------------------- #
# --- [2] select probe File --- #
# ------------------------------------------------- #
with open( outFile, "w" ) as f:
# -- [2-1] write header -- #
f.write( "# FileNumber\n" )
# -- [2-2] judge and save result -- #
for ik in range( const["npt"] ):
Data = lpf.load__pointFile( inpFile=inpFile.format( ik+1 ), returnType="point" )
if ( judge__particles( Data=Data ) is True ):
f.write( "{0}\n".format( ik+1 ) )
# ------------------------------------------------- #
# --- [3] save as file --- #
# ------------------------------------------------- #
return()
def into__namelist(inpFile="dat/parameter.conf", outFile="dat/input.lst"):
# ------------------------------------------------- #
# --- [1] load constants info --- #
# ------------------------------------------------- #
const = lcn.load__constants(inpFile=inpFile)
keys = [ "EFieldListFile", "BFieldListFile", "EFieldParamFile", "BFieldParamFile", \
"particleFile" , "popoutFile" , "probeFileBase" , "bpmFile", \
"flag__axisymmetry" , "flag__popoutBoundary", \
"flag__probeField" , "flag__beamposmonitor", \
"particleBoundary__x", "particleBoundary__y" , "particleBoundary__z", \
"type__iterMax" , "type__dt", "iterMax", "dt", "alpha_wci", "alpha_CFL", \
"t_simuStart" , "t_simuEnd", "t_probeStart", "t_probeStep", "t_probeEnd", \
"bpm_direction" , "bpm_screen_pos", "mp", "qe" ]
print(keys)
# ------------------------------------------------- #
# --- [2] save constants in File --- #
# ------------------------------------------------- #
snl.save__namelist(outFile=outFile, const=const, keys=keys)
print()
print("[into__namelist.py] inpFile :: {0} ".format(inpFile))
print("[into__namelist.py] converted into... ")
print("[into__namelist.py] outFile :: {0} ".format(outFile))
print()
return ()
def generate__line_coord():
# ------------------------------------------------- #
# --- [1] load parameter --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
const = lcn.load__constants( inpFile="dat/parameter.conf" )
# ------------------------------------------------- #
# --- [2] generate radial line --- #
# ------------------------------------------------- #
rval = np.linspace( const["r1"], const["r2"], const["nData"] )
angle = const["theta"] / 360.0 * 2.0 * np.pi
xg = np.cos( angle ) * rval
yg = np.sin( angle ) * rval
zg = np.zeros( ( const["nData"], ) )
Data = np.concatenate( [ arr[:,np.newaxis] for arr in (xg,yg,zg) ], axis=-1 )
# ------------------------------------------------- #
# --- [3] save in file --- #
# ------------------------------------------------- #
import nkUtilities.save__pointFile as spf
outFile = "dat/out.dat"
spf.save__pointFile( outFile=outFile, Data=Data )
return()
def select__particles_array():
# ------------------------------------------------- #
# --- [1] preparation --- #
# ------------------------------------------------- #
# -- [1-1] probe file -- #
outFile = "dat/selected.dat"
# -- [1-2] args -- #
import nkUtilities.genArgs as gar
args = gar.genArgs()
array = None
if ( args["array"] is not None ):
array = [ int( val ) for val in args["array"] ]
# -- [1-3] load constants -- #
if ( array is None ):
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
const = lcn.load__constants( inpFile=cnsFile )
array = [ int( val ) for val in const["post.select.pt.array"] ]
# -- [1-3] write all particles num -- #
with open( outFile, "w" ) as f:
# -- [1-3-1] write header -- #
f.write( "# FileNumber\n" )
# -- [1-3-2] judge and save result -- #
for ipt in array:
f.write( "{0}\n".format( ipt ) )
return()
def make__answer():
# ------------------------------------------------- #
# --- [1] coordinate settings --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
const = lcn.load__constants(inpFile=cnsFile)
import nkUtilities.equiSpaceGrid as esg
grid = esg.equiSpaceGrid( x1MinMaxNum=const["x1MinMaxNum"], x2MinMaxNum=const["x2MinMaxNum"], \
x3MinMaxNum=const["x3MinMaxNum"], returnType = "point" )
BField = np.zeros((grid.shape[0], 6))
BField[:, 0:3] = grid
# ------------------------------------------------- #
# --- [2] coil position settings --- #
# ------------------------------------------------- #
x_, y_, z_ = 0, 1, 2
theta = np.linspace(0.0, 2.0 * np.pi, const["ntheta"])
coil_x = const["coil_center"][x_] + np.cos(theta)
coil_y = const["coil_center"][y_] + np.sin(theta)
coil_z1 = +const["coil_center"][z_] + theta * 0.0
coil_z2 = -const["coil_center"][z_] + theta * 0.0
coil1 = np.concatenate(
[coil_x[:, None], coil_y[:, None], coil_z1[:, None]], axis=1)
coil2 = np.concatenate(
[coil_x[:, None], coil_y[:, None], coil_z2[:, None]], axis=1)
# ------------------------------------------------- #
# --- [3] coil field --- #
# ------------------------------------------------- #
import nkPhysicsRoutines.calc__biotSavartBField as bsf
field1 = bsf.calc__biotSavartBField(bfield=BField,
coils=coil1,
I0=const["I0"])
field2 = bsf.calc__biotSavartBField(bfield=BField,
coils=coil2,
I0=const["I0"])
field = np.zeros((field1.shape[0], field1.shape[1]))
field[:, 0:3] = field1[:, 0:3]
field[:, 3:6] = field1[:, 3:6] + field2[:, 3:6]
shape = ( int( const["x3MinMaxNum"][2] ), int( const["x2MinMaxNum"][2] ), \
int( const["x1MinMaxNum"][2] ), 6 )
field = np.reshape(field, shape)
# ------------------------------------------------- #
# --- [4] save point Field --- #
# ------------------------------------------------- #
outFile = "dat/coilfield.dat"
import nkUtilities.save__pointFile as spf
spf.save__pointFile(outFile=outFile, Data=field)
return ()
def display__sf7():
x_, y_, z_ = 0, 1, 2
bx_, by_, bz_ = 3, 4, 5
# ------------------------------------------------- #
# --- [1] Arguments --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnfFile = "dat/parameter.conf"
const = lcn.load__constants(inpFile=cnfFile)
config = lcf.load__config()
datFile = const["bfieldFile"]
pngFile = "png/bfield_{0}.png"
# ------------------------------------------------- #
# --- [2] Fetch Data --- #
# ------------------------------------------------- #
import nkUtilities.load__pointFile as lpf
Data = lpf.load__pointFile(inpFile=datFile, returnType="point")
# ------------------------------------------------- #
# --- [3] config Settings --- #
# ------------------------------------------------- #
cfs.configSettings(configType="cMap_def", config=config)
config["FigSize"] = (8, 3)
config["cmp_position"] = [0.16, 0.12, 0.97, 0.88]
config["xTitle"] = "Z (m)"
config["yTitle"] = "R (m)"
config["xMajor_Nticks"] = 8
config["yMajor_Nticks"] = 3
config["cmp_xAutoRange"] = True
config["cmp_yAutoRange"] = True
config["cmp_xRange"] = [-5.0, +5.0]
config["cmp_yRange"] = [-5.0, +5.0]
config["vec_AutoScale"] = True
config["vec_AutoRange"] = True
config["vec_AutoScaleRef"] = 200.0
config["vec_nvec_x"] = 24
config["vec_nvec_y"] = 6
config["vec_interpolation"] = "nearest"
# ------------------------------------------------- #
# --- [4] plot Figure --- #
# ------------------------------------------------- #
cmt.cMapTri( xAxis=Data[:,z_], yAxis=Data[:,x_], cMap=Data[:,bz_], \
pngFile=pngFile.format( "Bz" ), config=config )
cmt.cMapTri( xAxis=Data[:,z_], yAxis=Data[:,x_], cMap=Data[:,bx_], \
pngFile=pngFile.format( "Br" ), config=config )
absB = np.sqrt(Data[:, bz_]**2 + Data[:, bx_]**2)
fig = cmt.cMapTri(pngFile=pngFile.format("Bv"), config=config)
fig.add__cMap(xAxis=Data[:, z_], yAxis=Data[:, x_], cMap=absB)
fig.add__vector ( xAxis=Data[:,z_], yAxis=Data[:,x_], \
uvec=Data[:,bz_], vvec=Data[:,bx_], color="blue" )
fig.save__figure()
def histogram__energy(div=11, eRange=None):
# inpFile = "dat/particles.dat"
# pngFile = "png/histogram__initParticles.png"
inpFile = "bpm/screen_bpm.dat"
pngFile = "png/histogram__bpmParticles.png"
x_, y_, z_ = 0, 1, 2
vx_, vy_, vz_ = 3, 4, 5
# ------------------------------------------------- #
# --- [1] load constants & data --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
pcnsFile = "dat/particle.conf"
const = lcn.load__constants(inpFile=cnsFile)
pconst = lcn.load__constants(inpFile=pcnsFile)
# ------------------------------------------------- #
# --- [2] make hist of particle's energy --- #
# ------------------------------------------------- #
Data = lpf.load__pointFile(inpFile=inpFile, returnType="point")
vabs = np.sqrt(Data[:, vx_]**2 + Data[:, vy_]**2 + Data[:, vz_]**2)
beta = vabs / const["cv"]
print(np.min(beta), np.max(beta))
Th = 1.0 / (np.sqrt(1.0 - beta**2)) - 1.0
hEk = const["mp"] * const["cv"]**2 / const["qe"] * Th
# histogram, bins = np.histogram( hEk, bins=div, range=eRange )
# haxis = ( 0.5 * ( bins + np.roll( bins, 1 ) ) )[1:]
# haxis = haxis / 1000.0
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1)
# ax.set_facecolor( "lightcyan" )
ax.grid(zorder=1, color="gray")
ax.hist( hEk, bins=div, range=eRange, rwidth=0.7, color="royalblue", \
edgecolor="white", linewidth=1.8, zorder=2 )
fig.savefig(pngFile)
def interpret__config(inpFile="dat/parameter.conf", outFile="dat/input.conf"):
# ------------------------------------------------- #
# --- [1] load constants info --- #
# ------------------------------------------------- #
const = lcn.load__constants(inpFile=inpFile)
keys = lcn.load__constants(inpFile=inpFile, returnKeys=True)
print(keys)
# ------------------------------------------------- #
# --- [2] save constants in File --- #
# ------------------------------------------------- #
scn.save__constants(outFile=outFile, const=const, keys=keys)
print()
print("[interpret__config.py] inpFile :: {0} ".format(inpFile))
print("[interpret__config.py] converted into... ")
print("[interpret__config.py] outFile :: {0} ".format(outFile))
print()
return ()
def make__poleSurface():
# ------------------------------------------------- #
# --- [1] load constants --- #
# ------------------------------------------------- #
cnsFile = "dat/parameter.conf"
import nkUtilities.load__constants as lcn
const = lcn.load__constants(inpFile=cnsFile)
lc1 = const["geometry.pole_lc_top"]
lc2 = const["geometry.pole_lc_bot"]
radius = const["geometry.r_pole"]
side = const["geometry.side"]
# ------------------------------------------------- #
# --- [2] interpolation / gmsh <-> elmer --- #
# ------------------------------------------------- #
nop = True
if (side in ["+", "+-", "-+"]):
generate__mesh_to_interpolate(lc1=lc1,
lc2=lc2,
radius=radius,
side="+")
convert__meshFormat(direction="gmsh->elmer")
ret = interpolate__grid_to_mesh(side="+")
nop = False
if (side in ["-", "+-", "-+"]):
generate__mesh_to_interpolate(lc1=lc1,
lc2=lc2,
radius=radius,
side="-")
convert__meshFormat(direction="gmsh->elmer")
ret = interpolate__grid_to_mesh(side="-")
nop = False
if (side in ["+-", "-+"]):
generate__mesh_to_interpolate(lc1=lc1,
lc2=lc2,
radius=radius,
side="+-")
convert__meshFormat(direction="gmsh->elmer")
ret = interpolate__grid_to_mesh(side="+-")
nop = False
if (nop):
print("[make__poleSurface.py] no Operation !!! ERROR !!! ")
else:
convert__meshFormat(direction="elmer->gmsh", side=side)
return ()
def show__waveCondition():
# ------------------------------------------------- #
# --- [1] constants --- #
# ------------------------------------------------- #
cnsFile = "dat/parameter.conf"
import nkUtilities.load__constants as lcn
const = lcn.load__constants(inpFile=cnsFile)
# ------------------------------------------------- #
# --- [2] calculate amplitude --- #
# ------------------------------------------------- #
omega = 2.0 * np.pi * const["tw_frequency"]
tau = 1.0 / const["tw_frequency"]
vphT = const["beta_wave"] * const["cv"] * tau
P_loss = omega * const["Ustored"] / const["Qvalue"]
amplitude_factor = np.sqrt(const["P_input"] / P_loss)
energy_gain = np.sqrt(const["Lcavity"] * const["rsh"] * const["P_input"])
# ------------------------------------------------- #
# --- [3] display --- #
# ------------------------------------------------- #
print()
print("[calculate__power_of_wave] frequency :: {0}".format(
const["tw_frequency"]))
print("[calculate__power_of_wave] omega :: {0}".format(omega))
print("[calculate__power_of_wave] T :: {0}".format(tau))
print("[calculate__power_of_wave] Lcavity :: {0}".format(
const["Lcavity"]))
print("[calculate__power_of_wave] vph * T :: {0}".format(vphT))
print()
print("[calculate__power_of_wave] Ustored :: {0}".format(
const["Ustored"]))
print("[calculate__power_of_wave] Qvalue :: {0}".format(
const["Qvalue"]))
print("[calculate__power_of_wave] rsh :: {0}".format(
const["rsh"]))
print("[calculate__power_of_wave] P_input :: {0}".format(
const["P_input"]))
print("[calculate__power_of_wave] t_transit :: {0}".format(
const["t_transit_time"]))
print()
print("[calculate__power_of_wave] P_loss :: {0}".format(P_loss))
print("[calculate__power_of_wave] amplitude :: {0}".format(
amplitude_factor))
print(
"[calculate__power_of_wave] energy_gain :: {0}".format(energy_gain))
print()
def load__config( config=None ):
# ------------------------------------------------- #
# --- [1] Arguments --- #
# ------------------------------------------------- #
if ( config is None ):
dirname = os.path.dirname( os.path.abspath( __file__ ) )
config = os.path.join( dirname, "default.conf" )
# ------------------------------------------------- #
# --- [2] load constants --- #
# ------------------------------------------------- #
const = lcn.load__constants( inpFile=config )
return( const )
def display__phasespace():
x_, y_, z_ = 1, 2, 3
vx_, vy_, vz_ = 4, 5, 6
MeV = 1.e+6
# ------------------------------------------------- #
# --- [1] load config & data --- #
# ------------------------------------------------- #
# -- [2-1] load config -- #
cnsFile = "dat/parameter.conf"
import nkUtilities.load__constants as lcn
const = lcn.load__constants(inpFile=cnsFile)
# -- [2-2] load data & energy calculation -- #
inpFile = "prb/collected.dat"
with open(inpFile, "r") as f:
Data = np.loadtxt(f)
Data = Data[np.where(Data[:, x_] < 0.010)]
Data = Data[np.where(Data[:, 13] > 0.0)]
Data[:, vx_:vz_ + 1] = Data[:, vx_:vz_ + 1] / const["cv"]
# ------------------------------------------------- #
# --- [3] ploting --- #
# ------------------------------------------------- #
# -- [3-1] settings -- #
pngFile = "png/phasespace_{0}.png"
config = lcf.load__config()
config["FigSize"] = (5, 5)
config["plt_marker"] = "o"
config["plt_markersize"] = 0.3
config["plt_linewidth"] = 0.0
# -- [3-2] xAxis -- #
fig = pl1.plot1D(pngFile=pngFile.format("x_vx"), config=config)
fig.add__plot(xAxis=Data[:, x_], yAxis=Data[:, vx_])
fig.set__axis()
fig.save__figure()
# -- [3-3] yAxis -- #
fig = pl1.plot1D(pngFile=pngFile.format("y_vy"), config=config)
fig.add__plot(xAxis=Data[:, y_], yAxis=Data[:, vy_])
fig.set__axis()
fig.save__figure()
# -- [3-4] zAxis -- #
fig = pl1.plot1D(pngFile=pngFile.format("z_vz"), config=config)
fig.add__plot(xAxis=Data[:, z_], yAxis=Data[:, vz_])
fig.set__axis()
fig.save__figure()
def beam_loading_curve():
# ------------------------------------------------- #
# --- [1] make beam loading curve --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
const = lcn.load__constants( inpFile=cnsFile )
Ibeam = np.linspace( const["Ibeam_Min"], const["Ibeam_Max"], const["Ibeam_num"] )
P0_RFs = np.linspace( const["P0_RF_Min"], const["P0_RF_Max"], const["P0_RF_num"] )
BeamCurve = np.zeros( (const["Ibeam_num"],const["P0_RF_num"]) )
tau_attenuation = const["alpha_attenuation"] * const["length_cavity"]
for ik,P0_RF in enumerate( P0_RFs ):
term1 = np.sqrt( const["shunt_impedance"]*const["length_cavity"]*P0_RF*( 1.0 - np.exp( -2.0*tau_attenuation ) ) )
term2 = Ibeam*const["shunt_impedance"]*const["length_cavity"] / 2.0 * ( 1.0 - 2.0*tau_attenuation*np.exp( -2.0*tau_attenuation ) / ( 1.0 - np.exp( -2.0*tau_attenuation ) ) )
BeamCurve[:,ik] = ( term1 - term2 )
outFile = "dat/beam_loading_curve.dat"
import nkUtilities.save__pointFile as spf
spf.save__pointFile( outFile=outFile, Data=BeamCurve )
# ------------------------------------------------- #
# --- [2] config settings --- #
# ------------------------------------------------- #
import nkUtilities.load__config as lcf
config = lcf.load__config()
config["xTitle"] = "Beam Current (mA)"
config["yTitle"] = "Beam Energy (MeV)"
config["plt_xAutoRange"] = False
config["plt_yAutoRange"] = False
config["plt_xRange"] = [ 0.0, 300 ]
config["plt_yRange"] = [ 0.0, 30.0 ]
pngFile = "png/beam_loading_curve.png"
# ------------------------------------------------- #
# --- [3] plot --- #
# ------------------------------------------------- #
Ibeam = Ibeam / const["current_unit"]
BeamCurve = BeamCurve / const["energy_unit"]
import nkUtilities.plot1D as pl1
fig = pl1.plot1D( config=config, pngFile=pngFile )
for ik in range( const["P0_RF_num"] ):
fig.add__plot( xAxis=Ibeam, yAxis=BeamCurve[:,ik] )
fig.set__axis()
fig.save__figure()
def make__batch():
import nkUtilities.load__constants as lcn
cnsFIle = "dat/parameter.conf"
const = lcn.load__constants(inpFile=cnsFIle)
line1 = "cd/d {0}\n".format(const["cur_dir"])
line2 = "start /w /min %SFDIR%automesh maglens\n"
line3 = "start /w /min %SFDIR%pandira maglens\n"
line4 = "start /w /min %SFDIR%sf7 maglens.in7 maglens.t35\n"
line5 = "exit\n"
with open(const["batchFile"], "w") as f:
f.write(line1 + line2 + line3 + line4 + line5)
print("[make__batch.py] outFile :: {0} ".format(const["batchFile"]))
print()
def sequencial__TEmode():
# ------------------------------------------------- #
# --- [1] load constants --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
inpFile = "dat/parameter.conf"
const = lcn.load__constants(inpFile=inpFile)
# ------------------------------------------------- #
# --- [2] calculate TE mode at each time --- #
# ------------------------------------------------- #
timearr = np.linspace(const["tMin"], const["tMax"], const["LT"])
for ik in range(const["LT"]):
waveguide__TEmode(time=timearr[ik], kstep=ik)
def generate__samplewave():
# ------------------------------------------------- #
# --- [1] Load Config --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
const = lcn.load__constants( inpFile=cnsFile )
import nkUtilities.equiSpaceGrid as esg
x1MinMaxNum = const["x1MinMaxNum"]
x2MinMaxNum = const["x2MinMaxNum"]
x3MinMaxNum = const["x3MinMaxNum"]
grid = esg.equiSpaceGrid( x1MinMaxNum=x1MinMaxNum, x2MinMaxNum=x2MinMaxNum, \
x3MinMaxNum=x3MinMaxNum, returnType = "point" )
kx, ky = const["sample_kx"], const["sample_ky"]
wave1 = np.cos( grid[:,0] * 2.0*np.pi*kx ) + np.sin( grid[:,1] *2.0*np.pi*ky )
wave2 = np.sin( grid[:,0] * 2.0*np.pi*kx ) + np.cos( grid[:,1] *2.0*np.pi*ky )
wave1_ = np.concatenate( (grid,wave1[:,None]), axis=1 )
wave2_ = np.concatenate( (grid,wave2[:,None]), axis=1 )
size = (int(x3MinMaxNum[2]),int(x2MinMaxNum[2]),int(x1MinMaxNum[2]),4)
wave1 = np.reshape( wave1_, size )
wave2 = np.reshape( wave2_, size )
# ------------------------------------------------- #
# --- [2] save in File --- #
# ------------------------------------------------- #
import nkUtilities.save__pointFile as spf
wavFile1 = "dat/sample_wave1.dat"
wavFile2 = "dat/sample_wave2.dat"
spf.save__pointFile( outFile=wavFile1, Data=wave1 )
spf.save__pointFile( outFile=wavFile2, Data=wave2 )
# ------------------------------------------------- #
# --- [3] display eigen mode --- #
# ------------------------------------------------- #
import nkUtilities.cMapTri as cmt
pngFile1 = "png/sample_wave1.png"
pngFile2 = "png/sample_wave2.png"
cmt.cMapTri( xAxis=wave1_[...,0], yAxis=wave1_[...,1], cMap=wave1_[...,3], pngFile=pngFile1 )
cmt.cMapTri( xAxis=wave2_[...,0], yAxis=wave2_[...,1], cMap=wave2_[...,3], pngFile=pngFile2 )
return()
def display__xyzE_histogram():
bins_x, bins_y, bins_z, bins_e = 100, 100, 100, 100
range_x, range_y, range_z, range_e = None, None, None, None
pngFile = "png/histogram_{0}.png"
MeV = 1.e+6
x_ , y_ , z_ = 1, 2, 3
vx_, vy_, vz_ = 4, 5, 6
# ------------------------------------------------- #
# --- [1] load config & data --- #
# ------------------------------------------------- #
# -- [1-1] load config -- #
cnsFile = "dat/parameter.conf"
import nkUtilities.load__constants as lcn
const = lcn.load__constants( inpFile=cnsFile )
config = lcf.load__config()
# -- [1-2] load data & energy calculation -- #
inpFile = "prb/collected.dat"
with open( inpFile, "r" ) as f:
Data = np.loadtxt( f )
# -- [1-3] energy calculation -- #
beta = np.sqrt( Data[:,vx_]**2 + Data[:,vy_]**2 + Data[:,vz_]**2 ) / const["cv"]
gamma = 1.0 / ( np.sqrt( 1.0 - beta**2 ) )
energy = ( gamma - 1.0 ) * const["mp"] * const["cv"]**2 / np.abs( const["qe"] ) / MeV
# ------------------------------------------------- #
# --- [2] draw histogram --- #
# ------------------------------------------------- #
# -- [2-1] Number of particles -- #
config["yTitle"] = "Number of particles"
# -- [2-2] Number of particles -- #
import nkUtilities.make__histogram as hst
config["xTitle"] = "X (m)"
hist_x, bound_x = hst.make__histogram( Data=Data[:,x_], bins=bins_x, range=range_x, \
config=config, pngFile=pngFile.format( "x" ) )
config["xTitle"] = "Y (m)"
hist_y, bound_y = hst.make__histogram( Data=Data[:,y_], bins=bins_y, range=range_y, \
config=config, pngFile=pngFile.format( "y" ) )
config["xTitle"] = "Z (m)"
hist_z, bound_z = hst.make__histogram( Data=Data[:,z_], bins=bins_z, range=range_z, \
config=config, pngFile=pngFile.format( "z" ) )
def display__initialAxisymmField():
x_ , y_ , z_ = 0, 1, 2
vx_, vy_, vz_ = 3, 4, 5
# ------------------------------------------------- #
# --- [1] Load Config & Eigenmode --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
const = lcn.load__constants( inpFile=cnsFile )
import nkUtilities.load__pointFile as lpf
efield = lpf.load__pointFile( inpFile=const["EFieldFile"], returnType="structured" )
bfield = lpf.load__pointFile( inpFile=const["BFieldFile"], returnType="structured" )
config = lcf.load__config()
pngFile = "png/field_init_{0}.png"
# ------------------------------------------------- #
# --- [2] prepare cos & sin theta --- #
# ------------------------------------------------- #
time = np.linspace( const["tw_tStart"], const["tw_tEnd"], const["tw_tDiv"] )
theta = 2.0*np.pi*const["freq"] * time + const["phase_delay"]
costh = np.cos( theta )
# ------------------------------------------------- #
# --- [2] convert into vts File --- #
# ------------------------------------------------- #
import nkVTKRoutines.convert__vtkStructuredGrid as vts
import nkUtilities.save__pointFile as spf
vtsFile = "png/wave{0:04}.vts"
Data = np.zeros( (efield.shape[0],efield.shape[1],efield.shape[2],9) )
# -- [2-2] Main Loop -- #
for ik in range( const["tw_tDiv"] ):
# -- [3-3] wave data synthesize -- #
wave = np.zeros_like( Data )
wave[...,0:3] = np.copy( efield[...,0:3] )
wave[...,3:6] = efield[...,3:]*costh[ik]
wave[...,6:9] = bfield[...,3:]*costh[ik]
# -- [3-4] save as vts file -- #
vts.convert__vtkStructuredGrid( Data=wave, outFile=vtsFile.format(ik) )
def generate__particleSample():
xp_, yp_, zp_ = 0, 1, 2
vx_, vy_, vz_ = 3, 4, 5
import nkUtilities.load__constants as lcn
inpFile = "dat/particle.conf"
const = lcn.load__constants(inpFile=inpFile)
# ------------------------------------------------- #
# --- [1] particle generation --- #
# ------------------------------------------------- #
# -- [1-1] systematic components (xp) -- #
Data = np.zeros((const["npt"], 6))
Data[:, xp_] = np.linspace(const["xMin"], const["xMax"], const["npt"])
Data[:, yp_] = np.linspace(const["yMin"], const["yMax"], const["npt"])
Data[:, zp_] = np.linspace(const["zMin"], const["zMax"], const["npt"])
# -- [1-2] systematic components (vp) -- #
Data[:, vx_] = const["cv"] * const["beta_x"]
Data[:, vy_] = const["cv"] * const["beta_y"]
Data[:, vz_] = const["cv"] * const["beta_z"]
# -- [1-3] random components (xp) -- #
Data[:,
xp_] = Data[:, xp_] + np.random.randn(const["npt"]) * const["sigma_x"]
Data[:,
yp_] = Data[:, yp_] + np.random.randn(const["npt"]) * const["sigma_y"]
Data[:,
zp_] = Data[:, zp_] + np.random.randn(const["npt"]) * const["sigma_z"]
# -- [1-4] random components (vp) -- #
Data[:, vx_] = Data[:, vx_] + np.random.randn(
const["npt"]) * const["cv"] * const["sigma_vx"]
Data[:, vy_] = Data[:, vy_] + np.random.randn(
const["npt"]) * const["cv"] * const["sigma_vy"]
Data[:, vz_] = Data[:, vz_] + np.random.randn(
const["npt"]) * const["cv"] * const["sigma_vz"]
# ------------------------------------------------- #
# --- [2] save in outFile --- #
# ------------------------------------------------- #
outFile = "dat/particles.dat"
import nkUtilities.save__pointFile as spf
spf.save__pointFile(outFile=outFile, Data=Data)
return ()
def convert__spf2point( inpFile=None ):
#
# x => r direction
# y => t direction
#
xp_, yp_, zp_ = 0, 1, 2
ex_, ey_, ez_ = 3, 4, 5
# ------------------------------------------------- #
# --- [1] arguments --- #
# ------------------------------------------------- #
cnsFile = "dat/field.conf"
import nkUtilities.load__constants as lcn
const = lcn.load__constants( inpFile=cnsFile )
if ( inpFile is None ):
inpFile = const["superfishFile"]
import nkUtilities.load__pointFile as lpf
Data = lpf.load__pointFile( inpFile=inpFile, returnType="structured" )
print( Data.shape )
LK, LJ, LI = Data.shape[0], Data.shape[1], Data.shape[2]
Data = np.reshape( Data, (LK*LJ*LI,7) )
# ------------------------------------------------- #
# --- [2] convert into field-type pointFile --- #
# ------------------------------------------------- #
pData = np.zeros( (Data.shape[0],6) )
pData[:,xp_] = Data[:,1]
pData[:,yp_] = 0.0
pData[:,zp_] = Data[:,0]
pData[:,ex_] = Data[:,4] * const["efield_factor"]
pData[:,ey_] = 0.0 * const["efield_factor"]
pData[:,ez_] = Data[:,3] * const["efield_factor"]
index = np.lexsort( ( pData[:,xp_], pData[:,yp_], pData[:,zp_]) )
pData = pData[index]
pData = np.reshape( pData, (LI,1,LJ,6) )
import nkUtilities.save__pointFile as spf
names = ["xp","yp","zp","Ex","Ey","Ez"]
spf.save__pointFile( outFile=const["efieldFile"], Data=pData, names=names )
def generate__travellingWave():
# ------------------------------------------------- #
# --- [1] Load Config & Eigenmode --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
const = lcn.load__constants(inpFile=cnsFile)
import nkUtilities.load__pointFile as lpf
wave1 = lpf.load__pointFile(inpFile=const["wavFile1"],
returnType="structured")
wave2 = lpf.load__pointFile(inpFile=const["wavFile2"],
returnType="structured")
# ------------------------------------------------- #
# --- [2] prepare cos & sin theta --- #
# ------------------------------------------------- #
time = np.linspace(const["t_start"], const["t_end"], const["nTime"])
theta = 2.0 * np.pi * const["frequency"] * 1.e6 * time + const["phase"]
costh = np.cos(theta)
sinth = np.sin(theta)
# ------------------------------------------------- #
# --- [3] save in File --- #
# ------------------------------------------------- #
# -- [3-1] preparation -- #
import nkVTKRoutines.convert__vtkStructuredGrid as vts
import nkUtilities.save__pointFile as spf
datFile = "dat/wave{0:04}.dat"
vtsFile = "png/wave{0:04}.vts"
# -- [3-2] Main Loop -- #
for ik in range(const["nTime"]):
# -- [3-3] wave data synthesize -- #
wave = np.zeros_like(wave1)
wave[..., 0:3] = wave1[..., 0:3]
wave[..., 3:] = wave1[..., 3:] * costh[ik] + wave2[..., 3:] * sinth[ik]
# -- [3-4] save as vts file -- #
vts.convert__vtkStructuredGrid(Data=wave, outFile=vtsFile.format(ik))
# -- [3-5] save as dat file -- #
spf.save__pointFile(outFile=datFile.format(ik), Data=wave)
def generate__travellingWave():
# ------------------------------------------------- #
# --- [1] Load Config & Eigenmode --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
const = lcn.load__constants(inpFile=cnsFile)
import nkUtilities.load__pointFile as lpf
wave1 = lpf.load__pointFile(inpFile=const["tw_cosEigenFile"],
returnType="structured")
wave2 = lpf.load__pointFile(inpFile=const["tw_sinEigenFile"],
returnType="structured")
# ------------------------------------------------- #
# --- [2] prepare cos & sin theta --- #
# ------------------------------------------------- #
t_period = 1.0 / (const["tw_frequency"])
tStart = const["tw_timeStart"]
tEnd = const["tw_timeStart"] + t_period * const["tw_nCycle"]
time = np.linspace(tStart, tEnd, const["tw_nTime"])
theta = 2.0 * np.pi * const["tw_frequency"] * time + const["tw_phase"]
costh = np.cos(theta)
sinth = np.sin(theta)
# ------------------------------------------------- #
# --- [3] save in File --- #
# ------------------------------------------------- #
# -- [3-1] preparation -- #
import nkVTKRoutines.convert__vtkStructuredGrid as vts
import nkUtilities.save__pointFile as spf
vtsFile = "png/wave{0:04}.vts"
# -- [3-2] Main Loop -- #
for ik in range(const["tw_nTime"]):
# -- [3-3] wave data synthesize -- #
wave = np.zeros_like(wave1)
wave[..., 0:3] = wave1[..., 0:3]
wave[..., 3:] = wave1[..., 3:] * costh[ik] + wave2[..., 3:] * sinth[ik]
# -- [3-4] save as vts file -- #
vts.convert__vtkStructuredGrid(Data=wave, outFile=vtsFile.format(ik))
def select__allparticles():
# ------------------------------------------------- #
# --- [1] preparation --- #
# ------------------------------------------------- #
# -- [1-1] probe file -- #
outFile = "dat/selected.dat"
# -- [1-2] load constants -- #
cnsFile = "dat/particle.conf"
import nkUtilities.load__constants as lcn
const = lcn.load__constants( inpFile=cnsFile )
# -- [1-3] write all particles num -- #
with open( outFile, "w" ) as f:
# -- [1-3-1] write header -- #
f.write( "# FileNumber\n" )
# -- [1-3-2] judge and save result -- #
for ik in range( const["npt"] ):
f.write( "{0}\n".format( ik+1 ) )
return()
def expand__pole_cs(inpFile=None, outFile=None):
# ------------------------------------------------- #
# --- [1] Arguments --- #
# ------------------------------------------------- #
if (inpFile is None): inpFile = "dat/pole_cs.dat"
if (outFile is None): outFile = "dat/gridData.dat"
cnsFile = "dat/expand.conf"
import nkUtilities.load__constants as lcn
const = lcn.load__constants(inpFile=cnsFile)
# ------------------------------------------------- #
# --- [2] Load Settings --- #
# ------------------------------------------------- #
x1MinMaxNum = const["x1MinMaxNum"]
x2MinMaxNum = const["x2MinMaxNum"]
radius = const["radius"]
with open(inpFile, "r") as f:
pole = np.loadtxt(f)
ra = pole[:, 0]
fa = pole[:, 2]
# ------------------------------------------------- #
# --- [3] expand rz Profile >> axi-symmetric --- #
# ------------------------------------------------- #
ret = axi.expand__axisymmetric( ra=ra, fa=fa, radius=radius, \
x1MinMaxNum=x1MinMaxNum, x2MinMaxNum=x2MinMaxNum )
# ------------------------------------------------- #
# --- [4] save result --- #
# ------------------------------------------------- #
import nkUtilities.save__pointFile as spf
spf.save__pointFile(outFile=outFile, Data=ret)
def generate__bFieldSample():
x_, y_, z_ = 0, 1, 2
vx_, vy_, vz_ = 0, 1, 2
# ------------------------------------------------- #
# --- [1] load config File --- #
# ------------------------------------------------- #
inpFile = "dat/parameter.conf"
import nkUtilities.load__constants as lcn
const = lcn.load__constants(inpFile=inpFile)
# ------------------------------------------------- #
# --- [2] grid generation --- #
# ------------------------------------------------- #
import nkUtilities.equiSpaceGrid as esg
x1MinMaxNum = [
const["xMin_bfield"], const["xMax_bfield"], const["LI_bfield"]
]
x2MinMaxNum = [
const["yMin_bfield"], const["yMax_bfield"], const["LJ_bfield"]
]
x3MinMaxNum = [
const["zMin_bfield"], const["zMax_bfield"], const["LK_bfield"]
]
ret = esg.equiSpaceGrid( x1MinMaxNum=x1MinMaxNum, x2MinMaxNum=x2MinMaxNum, \
x3MinMaxNum=x3MinMaxNum, returnType = "structured" )
bfield = np.zeros_like((ret))
bfield[..., vz_] = const["strength_bfield"]
Data = np.concatenate((ret, bfield), axis=3)
# ------------------------------------------------- #
# --- [3] save in File --- #
# ------------------------------------------------- #
outFile = "dat/bfield_sample.dat"
import nkUtilities.save__pointFile as spf
spf.save__pointFile(outFile=outFile, Data=Data)
def generate__axisymm_coord():
cnfFile = "dat/parameter.conf"
outFile = "dat/axisymm_coord.dat"
import nkUtilities.load__constants as lcn
const = lcn.load__constants( inpFile=cnfFile )
import nkUtilities.equiSpaceGrid as esg
x1MinMaxNum = [ const["rMin"], const["rMax"], const["LI"] ]
x2MinMaxNum = [ 0.0, 0.0, 1 ]
x3MinMaxNum = [ const["zMin"], const["zMax"], const["LK"] ]
ret = esg.equiSpaceGrid( x1MinMaxNum=x1MinMaxNum, x2MinMaxNum=x2MinMaxNum, \
x3MinMaxNum=x3MinMaxNum, returnType = "point" )
# ------------------------------------------------- #
# --- [3] save in file --- #
# ------------------------------------------------- #
with open( outFile, "w" ) as f:
np.savetxt( f, ret )
return()
def calculate__field():
# ------------------------------------------------- #
# --- [1] coordinate settings --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
const = lcn.load__constants(inpFile=cnsFile)
# ------------------------------------------------- #
# --- [2] coil position settings --- #
# ------------------------------------------------- #
x_, y_, z_ = 0, 1, 2
theta = np.linspace(0.0, 2.0 * np.pi, const["ntheta"])
coil_x = const["coil_center"][x_] + np.cos(theta)
coil_y = const["coil_center"][y_] + np.sin(theta)
coil_z1 = +const["coil_center"][z_] + theta * 0.0
coil_z2 = -const["coil_center"][z_] + theta * 0.0
coil1 = np.concatenate(
[coil_x[:, None], coil_y[:, None], coil_z1[:, None]], axis=1)
coil2 = np.concatenate(
[coil_x[:, None], coil_y[:, None], coil_z2[:, None]], axis=1)
# ------------------------------------------------- #
# --- [3] load BField coordinate --- #
# ------------------------------------------------- #
inpFile = "dat/ems_pst.coord"
import nkUtilities.load__pointFile as lpf
coord = lpf.load__pointFile(inpFile=inpFile, returnType="point")
BField = np.zeros((coord.shape[0], 6))
BField[:, 0:3] = coord
# ------------------------------------------------- #
# --- [4] coil field --- #
# ------------------------------------------------- #
import nkPhysicsRoutines.calc__biotSavartBField as bsf
field1 = bsf.calc__biotSavartBField(bfield=BField,
coils=coil1,
I0=const["I0"])
field2 = bsf.calc__biotSavartBField(bfield=BField,
coils=coil2,
I0=const["I0"])
field = np.zeros((field1.shape[0], field1.shape[1]))
field[:, 0:3] = field1[:, 0:3]
field[:, 3:6] = field1[:, 3:6] + field2[:, 3:6]
# shape = ( int( const["x3MinMaxNum"][2] ), int( const["x2MinMaxNum"][2] ), \
# int( const["x1MinMaxNum"][2] ), 6 )
# field = np.reshape( field, shape )
# ------------------------------------------------- #
# --- [5] save point Field --- #
# ------------------------------------------------- #
outFile = "dat/ems_pst.field"
import nkUtilities.save__pointFile as spf
spf.save__pointFile(outFile=outFile, Data=field)
def display__axial_interaction(time=0.0, nRepeat=1):
x_, y_, z_ = 0, 1, 2
vx_, vy_, vz_ = 3, 4, 5
# ------------------------------------------------- #
# --- [1] Load Config & Eigenmode --- #
# ------------------------------------------------- #
import nkUtilities.load__constants as lcn
cnsFile = "dat/parameter.conf"
pngFile = "png/axial/axial_interaction_{0}.png"
config = lcf.load__config()
const = lcn.load__constants(inpFile=cnsFile)
import nkUtilities.load__pointFile as lpf
wave1 = lpf.load__pointFile(inpFile=const["tw_cosEigenFile"],
returnType="point")
wave2 = lpf.load__pointFile(inpFile=const["tw_sinEigenFile"],
returnType="point")
val = 0.0
eps = 1.e-10
index1 = np.where(np.abs(wave1[:, x_] - val) <= eps)
index2 = np.where(np.abs(wave2[:, x_] - val) <= eps)
wave1 = wave1[index1]
wave2 = wave2[index2]
zAxis = wave1[:, z_]
ez1 = wave1[:, vz_]
ez2 = wave2[:, vz_]
ez1Stack = np.copy(ez1)
ez2Stack = np.copy(ez2)
zStack = np.copy(zAxis)
zLeng = np.max(zAxis) - np.min(zAxis)
for ik in range(1, nRepeat):
ez1_ = (np.copy(ez1))[1:]
ez2_ = (np.copy(ez2))[1:]
zAxis_ = (np.copy(zAxis) + zLeng * float(ik))[1:]
ez1Stack = np.concatenate([ez1Stack, ez1_])
ez2Stack = np.concatenate([ez2Stack, ez2_])
zStack = np.concatenate([zStack, zAxis_])
zAxis = zStack
ez1 = ez1Stack
ez2 = ez2Stack
# ------------------------------------------------- #
# --- [2] prepare cos & sin theta --- #
# ------------------------------------------------- #
theta = 2.0 * np.pi * const["tw_frequency"] * time + const["tw_phase"]
costh = +np.cos(theta)
sinth = +np.sin(theta)
# ------------------------------------------------- #
# --- [3] config Settings --- #
# ------------------------------------------------- #
config["FigSize"] = (10, 3)
config["cmp_position"] = [0.12, 0.16, 0.97, 0.92]
config["xTitle"] = "Z (m)"
config["yTitle"] = "Ez (V/m)"
config["plt_xAutoRange"] = False
config["plt_yAutoRange"] = False
config["plt_xRange"] = [0.0, 1.40]
config["plt_yRange"] = [-6.e+6, 6.e+6]
config["xMajor_Nticks"] = 6
# ------------------------------------------------- #
# --- [4] collect particles --- #
# ------------------------------------------------- #
import collect__particles as clp
ret = clp.collect__particles(target_time=time)
npt = ret.shape[0]
height = 3.e6
ppos = np.linspace(-height, +height, npt)
zpos = ret[:, 3]
# ------------------------------------------------- #
# --- [4] plot Figure ( bfield ) --- #
# ------------------------------------------------- #
stime = "t{0:.3f}ns".format(time / 1e-9)
Ez = ez1 * costh + ez2 * sinth
fig = pl1.plot1D(config=config, pngFile=pngFile.format(stime))
fig.add__plot(xAxis=zAxis, yAxis=Ez)
fig.add__plot(xAxis=zpos, yAxis=ppos, marker="o")
fig.set__axis()
fig.save__figure()
