def new_to_old(filename):
f = DataFile(filename)
newfile = DataFile(os.path.splitext(filename)[0] + str(".BOUT_metrics.nc"),
create=True)
name_changes = {
"g_yy": "g_22",
"gyy": "g22",
"gxx": "g11",
"gxz": "g13",
"gzz": "g33",
"g_xx": "g_11",
"g_xz": "g_13",
"g_zz": "g_33"
}
for key in f.keys():
name = key
if name in name_changes:
name = name_changes[name]
newfile.write(name, np.asarray(f.read(key)))
f.close()
newfile.close()
newfile.list()
def calc_curvilinear_curvature(fname, field, grid):
from scipy.signal import savgol_filter
f = DataFile(str(fname), write=True)
B = f.read("B")
dBydz = np.zeros(np.shape(B))
dBydx = np.zeros(np.shape(B))
dBxdz = np.zeros(np.shape(B))
dBzdx = np.zeros(np.shape(B))
dx = grid.metric()["dx"]
dz = grid.metric()["dz"]
g_11 = grid.metric()["g_xx"]
g_22 = grid.metric()["g_yy"]
g_33 = grid.metric()["g_zz"]
g_12 = 0.0
g_13 = grid.metric()["g_xz"]
g_23 = 0.0
J = np.sqrt(g_11 * (g_22 * g_33 - g_23 * g_23) + g_12 *
(g_13 * g_23 - g_12 * g_33) + g_13 *
(g_12 * g_23 - g_22 * g_23))
Bx_smooth = np.zeros(B.shape)
By_smooth = np.zeros(B.shape)
Bz_smooth = np.zeros(B.shape)
for y in np.arange(0, B.shape[1]):
pol, _ = grid.getPoloidalGrid(y)
R = pol.R
Z = pol.Z
for x in np.arange(0, B.shape[0]):
Bx_smooth[x, y, :] = savgol_filter(
field.Bxfunc(R[x, :], y, Z[x, :]),
np.int(np.ceil(B.shape[-1] / 21) // 2 * 2 + 1), 5)
By_smooth[x, y, :] = savgol_filter(
field.Byfunc(R[x, :], y, Z[x, :]),
np.int(np.ceil(B.shape[-1] / 21) // 2 * 2 + 1), 5)
dBydz[x, y, :] = calc.deriv(By_smooth[x, y, :]) / dz[x, y, :]
dBxdz[x, y, :] = calc.deriv(Bx_smooth[x, y, :]) / dz[x, y, :]
for z in np.arange(0, B.shape[-1]):
Bz_smooth[:, y, z] = savgol_filter(
field.Bzfunc(R[:, z], y, Z[:, z]),
np.int(np.ceil(B.shape[0] / 7) // 2 * 2 + 1), 5)
dBzdx[:, y, z] = calc.deriv(Bz_smooth[:, y, z]) / dx[:, y, z]
dBydx[:, y, z] = calc.deriv(By_smooth[:, y, z]) / dx[:, y, z]
bxcvx = (-1 / J) * (dBydz / B**2.)
bxcvy = (1 / J) * ((dBxdz - dBzdx) / B**2.)
bxcvz = (1 / J) * (dBydx / B**2.)
f.write('bxcvz', bxcvz)
f.write('bxcvx', bxcvx)
f.write('bxcvy', bxcvy)
f.close()
def change_variable(filename, variable, new_value):
f = DataFile(filename)
newfile = DataFile(os.path.splitext(filename)[0] + str(variable) + "." +
str(new_value),
create=True)
var_changes = {str(variable)}
for key in f.keys():
name = key
if name in var_changes:
name = name_changes[name]
newfile.write(name, np.asarray(f.read(key)))
f.close()
newfile.close()
newfile.list()
def create(file_list,
path,
averagelast=1,
final=-1,
output="./",
informat="nc",
outformat=None):
"""Create restart files from data (dmp) files.
Parameters
----------
averagelast : int, optional
Number of time points (counting from `final`, inclusive) to
average over (default is 1 i.e. just take last time-point)
final : int, optional
The last time point to use (default is last, -1)
path : str, optional
Path to original restart files (default: "data")
output : str, optional
Path to write new restart files (default: current directory)
informat : str, optional
File extension of original files (default: "nc")
outformat : str, optional
File extension of new files (default: use the same as `informat`)
"""
if outformat is None:
outformat = informat
nfiles = len(file_list)
print(("Number of data files: ", nfiles))
for i in range(nfiles):
# Open each data file
infname = os.path.join(path, "BOUT.dmp." + str(i) + "." + informat)
outfname = os.path.join(output,
"BOUT.restart." + str(i) + "." + outformat)
print((infname, " -> ", outfname))
infile = DataFile(infname)
outfile = DataFile(outfname, create=True)
# Get the data always needed in restart files
hist_hi = infile.read("iteration")
print(("hist_hi = ", hist_hi))
outfile.write("hist_hi", hist_hi)
t_array = infile.read("t_array")
tt = t_array[final]
print(("tt = ", tt))
outfile.write("tt", tt)
tind = final
if tind < 0.0:
tind = len(t_array) + final
NXPE = infile.read("NXPE")
NYPE = infile.read("NYPE")
print(("NXPE = ", NXPE, " NYPE = ", NYPE))
outfile.write("NXPE", NXPE)
outfile.write("NYPE", NYPE)
# Get a list of variables
varnames = infile.list()
for var in varnames:
if infile.ndims(var) == 4:
# Could be an evolving variable
print((" -> ", var))
data = infile.read(var)
if averagelast == 1:
slice = data[final, :, :, :]
else:
slice = mean(data[(final - averagelast):final, :, :, :],
axis=0)
print(slice.shape)
outfile.write(var, slice)
infile.close()
outfile.close()
#!/usr/bin/env python
#
# Generate an input mesh
#
from boututils.datafile import DataFile # Wrapper around NetCDF4 libraries
nx = 5 # Minimum is 5: 2 boundary, one evolved
ny = 32 # Minimum 5. Should be divisible by number of processors (so powers of 2 nice)
dy = 1. # distance between points in y, in m/g22/lengthunit
ixseps1 = -1
ixseps2 = -1
f = DataFile()
f.open("test-staggered.nc", create=True)
f.write("nx", nx)
f.write("ny", ny)
f.write("dy", dy)
f.write("ixseps1", ixseps1)
f.write("ixseps2", ixseps2)
f.close()
def resizeY(newy,
path="data",
output=".",
informat="nc",
outformat=None,
myg=2):
"""Increase the number of Y points in restart files
NOTE:
* Can't overwrite
Parameters
----------
newy : int
ny for the new file
path : str, optional
Path to original restart files (default: "data")
output : str, optional
Path to write new restart files (default: current directory)
informat : str, optional
File extension of original files (default: "nc")
outformat : str, optional
File extension of new files (default: use the same as `informat`)
myg : int, optional
Number of ghost points in y (default: 2)
Returns
-------
True on success, else False
TODO
----
- Replace printing errors with raising `ValueError`
- Make informat work like `redistribute`
"""
if outformat is None:
outformat = informat
file_list = glob.glob(os.path.join(path, "BOUT.restart.*." + informat))
nfiles = len(file_list)
if nfiles == 0:
print("ERROR: No restart files found")
return False
for i in range(nfiles):
# Open each data file
infname = os.path.join(path, "BOUT.restart." + str(i) + "." + informat)
outfname = os.path.join(output,
"BOUT.restart." + str(i) + "." + outformat)
print("Processing %s -> %s" % (infname, outfname))
infile = DataFile(infname)
outfile = DataFile(outfname, create=True)
# Copy basic information
for var in ["hist_hi", "NXPE", "NYPE", "tt"]:
data = infile.read(var)
try:
# Convert to scalar if necessary
data = data[0]
except:
pass
outfile.write(var, data)
# Get a list of variables
varnames = infile.list()
for var in varnames:
if infile.ndims(var) == 3:
# Could be an evolving variable [x,y,z]
print(" -> Resizing " + var)
# Read variable from input
indata = infile.read(var)
nx, ny, nz = indata.shape
# y coordinate in input and output data
iny = (arange(ny) - myg + 0.5) / (ny - 2 * myg)
outy = (arange(newy) - myg + 0.5) / (newy - 2 * myg)
outdata = zeros([nx, newy, nz])
for x in range(nx):
for z in range(nz):
f = interp1d(iny,
indata[x, :, z],
bounds_error=False,
fill_value=0.0)
outdata[x, :, z] = f(outy)
outfile.write(var, outdata)
elif infile.ndims(var) == 2:
# Assume evolving variable [x,y]
print(" -> Resizing " + var)
# Read variable from input
indata = infile.read(var)
nx, ny = indata.shape
# y coordinate in input and output data
iny = (arange(ny) - myg + 0.5) / (ny - 2 * myg)
outy = (arange(newy) - myg + 0.5) / (newy - 2 * myg)
outdata = zeros([nx, newy])
for x in range(nx):
f = interp1d(iny,
indata[x, :],
bounds_error=False,
fill_value=0.0)
outdata[x, :] = f(outy)
outfile.write(var, outdata)
else:
# Copy variable
print(" -> Copying " + var)
# Read variable from input
data = infile.read(var)
try:
# Convert to scalar if necessary
data = data[0]
except:
pass
outfile.write(var, data)
infile.close()
outfile.close()
def resizeY(newy, path="data", output=".", informat="nc", outformat=None, myg=2):
"""
Resize all the restart files in Y
"""
if outformat is None:
outformat = informat
file_list = glob.glob(os.path.join(path, "BOUT.restart.*." + informat))
nfiles = len(file_list)
if nfiles == 0:
print("ERROR: No restart files found")
return False
for i in range(nfiles):
# Open each data file
infname = os.path.join(path, "BOUT.restart." + str(i) + "." + informat)
outfname = os.path.join(output, "BOUT.restart." + str(i) + "." + outformat)
print("Processing %s -> %s", infname, outfname)
infile = DataFile(infname)
outfile = DataFile(outfname, create=True)
# Copy basic information
for var in ["hist_hi", "NPES", "NXPE", "tt"]:
data = infile.read(var)
try:
# Convert to scalar if necessary
data = data[0]
except:
pass
outfile.write(var, data)
# Get a list of variables
varnames = infile.list()
for var in varnames:
if infile.ndims(var) == 3:
# Could be an evolving variable [x,y,z]
print(" -> " + var)
# Read variable from input
indata = infile.read(var)
nx, ny, nz = indata.shape
# y coordinate in input and output data
iny = (arange(ny) - myg + 0.5) / (ny - 2 * myg)
outy = (arange(newy) - myg + 0.5) / (newy - 2 * myg)
outdata = zeros([nx, newy, nz])
for x in range(nx):
for z in range(nz):
f = interp1d(iny, indata[x, :, z], bounds_error=False, fill_value=0.0)
outdata[x, :, z] = f(outy)
outfile.write(var, outdata)
infile.close()
outfile.close()
from past.utils import old_div
from boututils.datafile import DataFile # Wrapper around NetCDF4 libraries
from math import pow
from sys import argv
length = 80. # Length of the domain in m
nx = 5 # Minimum is 5: 2 boundary, one evolved
if len(argv)>1:
ny = int(argv[1]) # Minimum 5. Should be divisible by number of processors (so powers of 2 nice)
else:
ny = 256 # Minimum 5. Should be divisible by number of processors (so powers of 2 nice)
#dy = [[1.]*ny]*nx # distance between points in y, in m/g22/lengthunit
g22 = [[pow(old_div(float(ny-1),length),2)]*ny]*nx
g_22 = [[pow(old_div(length,float(ny-1)),2)]*ny]*nx
ixseps1 = -1
ixseps2 = 0
f = DataFile()
f.open("conduct_grid.nc", create=True)
f.write("nx", nx)
f.write("ny", ny)
#f.write("dy", dy)
f.write("g22",g22)
f.write("g_22", g_22)
f.write("ixseps1", ixseps1)
f.write("ixseps2", ixseps2)
f.close()
def smooth_metric(fname,
write_to_file=False,
return_values=False,
smooth_metric=True,
order=7):
from scipy.signal import savgol_filter
f = DataFile(str(fname), write=True)
B = f.read('B')
bxcvx = f.read('bxcvx')
bxcvz = f.read('bxcvz')
bxcvy = f.read('bxcvy')
J = f.read('J')
bxcvx_smooth = np.zeros(bxcvx.shape)
bxcvy_smooth = np.zeros(bxcvy.shape)
bxcvz_smooth = np.zeros(bxcvz.shape)
J_smooth = np.zeros(J.shape)
if smooth_metric:
g13 = f.read('g13')
g_13 = f.read('g_13')
g11 = f.read('g11')
g_11 = f.read('g_11')
g33 = f.read('g33')
g_33 = f.read('g_33')
g13_smooth = np.zeros(g13.shape)
g_13_smooth = np.zeros(g_13.shape)
g11_smooth = np.zeros(g11.shape)
g_11_smooth = np.zeros(g_11.shape)
g33_smooth = np.zeros(g33.shape)
g_33_smooth = np.zeros(g_33.shape)
for y in np.arange(0, bxcvx.shape[1]):
for x in np.arange(0, bxcvx.shape[0]):
bxcvx_smooth[x, y, :] = savgol_filter(
bxcvx[x, y, :],
np.int(np.ceil(bxcvx.shape[-1] / 2) // 2 * 2 + 1), order)
bxcvz_smooth[x, y, :] = savgol_filter(
bxcvz[x, y, :],
np.int(np.ceil(bxcvz.shape[-1] / 2) // 2 * 2 + 1), order)
bxcvy_smooth[x, y, :] = savgol_filter(
bxcvy[x, y, :],
np.int(np.ceil(bxcvy.shape[-1] / 2) // 2 * 2 + 1), order)
J_smooth[x, y, :] = savgol_filter(
J[x, y, :], np.int(np.ceil(J.shape[-1] / 2) // 2 * 2 + 1),
order)
if smooth_metric:
g11_smooth[x, y, :] = savgol_filter(
g11[x, y, :],
np.int(np.ceil(g11.shape[-1] / 2) // 2 * 2 + 1), order)
g_11_smooth[x, y, :] = savgol_filter(
g_11[x, y, :],
np.int(np.ceil(g_11.shape[-1] / 2) // 2 * 2 + 1), order)
g13_smooth[x, y, :] = savgol_filter(
g13[x, y, :],
np.int(np.ceil(g13.shape[-1] / 2) // 2 * 2 + 1), order)
g_13_smooth[x, y, :] = savgol_filter(
g_13[x, y, :],
np.int(np.ceil(g_13.shape[-1] / 2) // 2 * 2 + 1), order)
g33_smooth[x, y, :] = savgol_filter(
g33[x, y, :],
np.int(np.ceil(g33.shape[-1] / 2) // 2 * 2 + 1), order)
g_33_smooth[x, y, :] = savgol_filter(
g_33[x, y, :],
np.int(np.ceil(g_33.shape[-1] / 2) // 2 * 2 + 1), order)
if (write_to_file):
# f.write('bxcvx',bxcvx_smooth)
# f.write('bxcvy',bxcvy_smooth)
# f.write('bxcvz',bxcvz_smooth)
f.write('J', J_smooth)
if smooth_metric:
f.write('g11', g11_smooth)
f.write('g_11', g_11_smooth)
f.write('g13', g13_smooth)
f.write('g_13', g_13_smooth)
f.write('g33', g33_smooth)
f.write('g_33', g_33_smooth)
f.close()
if (return_values):
return bxcvx_smooth, bxcvy_smooth, bxcvz_smooth, bxcvx, bxcvy, bxcvz
def calc_curvilinear_curvature(fname, field, grid, maps):
from scipy.signal import savgol_filter
f = DataFile(str(fname), write=True)
B = f.read("B")
dx = grid.metric()["dx"]
dz = grid.metric()["dz"]
g_11 = grid.metric()["g_xx"]
g_22 = grid.metric()["g_yy"]
g_33 = grid.metric()["g_zz"]
g_12 = 0.0
g_13 = grid.metric()["g_xz"]
g_23 = 0.0
GR = np.zeros(B.shape)
GZ = np.zeros(B.shape)
Gphi = np.zeros(B.shape)
dRdz = np.zeros(B.shape)
dZdz = np.zeros(B.shape)
dRdx = np.zeros(B.shape)
dZdx = np.zeros(B.shape)
for y in np.arange(0, B.shape[1]):
pol, _ = grid.getPoloidalGrid(y)
R = pol.R
Z = pol.Z
# G = \vec{B}/B, here in cylindrical coordinates
GR[:, y, :] = field.Bxfunc(R, y, Z) / ((B[:, y, :])**2)
GZ[:, y, :] = field.Bzfunc(R, y, Z) / ((B[:, y, :])**2)
Gphi[:, y, :] = field.Byfunc(R, y, Z) / ((B[:, y, :])**2)
for x in np.arange(0, B.shape[0]):
dRdz[x, y, :] = calc.deriv(R[x, :]) / dz[x, y, :]
dZdz[x, y, :] = calc.deriv(Z[x, :]) / dz[x, y, :]
for z in np.arange(0, B.shape[-1]):
dRdx[:, y, z] = calc.deriv(R[:, z]) / dx[:, y, z]
dZdx[:, y, z] = calc.deriv(Z[:, z]) / dx[:, y, z]
R = f.read("R")
Z = f.read("Z")
dy = f.read("dy")
## calculate Jacobian and contravariant terms in curvilinear coordinates
J = R * (dZdz * dRdx - dZdx * dRdz)
Gx = (GR * dZdz - GZ * dRdz) * (R / J)
Gz = (GZ * dRdx - GR * dZdx) * (R / J)
G_x = Gx * g_11 + Gphi * g_12 + Gz * g_13
G_y = Gx * g_12 + Gphi * g_22 + Gz * g_23
G_z = Gx * g_13 + Gphi * g_23 + Gz * g_33
dG_zdy = np.zeros(B.shape)
dG_ydz = np.zeros(B.shape)
dG_xdz = np.zeros(B.shape)
dG_zdx = np.zeros(B.shape)
dG_ydx = np.zeros(B.shape)
dG_xdy = np.zeros(B.shape)
for y in np.arange(0, B.shape[1]):
for x in np.arange(0, B.shape[0]):
dG_ydz[x, y, :] = calc.deriv(G_y[x, y, :]) / dz[x, y, :]
dG_xdz[x, y, :] = calc.deriv(G_x[x, y, :]) / dz[x, y, :]
for z in np.arange(0, B.shape[-1]):
dG_ydx[:, y, z] = calc.deriv(G_y[:, y, z]) / dx[:, y, z]
dG_zdx[:, y, z] = calc.deriv(G_z[:, y, z]) / dx[:, y, z]
#this should really use the maps...
for x in np.arange(0, B.shape[0]):
for z in np.arange(0, B.shape[-1]):
dG_zdy[x, :, z] = calc.deriv(G_z[x, :, z]) / dy[x, :, z]
dG_xdy[x, :, z] = calc.deriv(G_x[x, :, z]) / dy[x, :, z]
bxcvx = (dG_zdy - dG_ydz) / J
bxcvy = (dG_xdz - dG_zdx) / J
bxcvz = (dG_ydx - dG_xdy) / J
bxcv = g_11 * (bxcvx**2) + g_22 * (bxcvy**2) + g_33 * (bxcvz**2) + 2 * (
bxcvz * bxcvx * g_13)
f.write('bxcvx', bxcvx)
f.write('bxcvy', bxcvy)
f.write('bxcvz', bxcvz)
f.write('J', J)
f.close()
def rotating_ellipse(nx=68,
ny=16,
nz=128,
xcentre=5.5,
I_coil=0.01,
curvilinear=True,
rectangular=False,
fname='rotating-ellipse.fci.nc',
a=0.4,
curvilinear_inner_aligned=True,
curvilinear_outer_aligned=True,
npoints=421,
Btor=2.5,
show_maps=False,
calc_curvature=True,
smooth_curvature=False,
return_iota=True,
write_iota=False):
yperiod = 2 * np.pi / 5.
field = zb.field.RotatingEllipse(xcentre=xcentre,
I_coil=I_coil,
radius=2 * a,
yperiod=yperiod,
Btor=Btor)
# Define the y locations
ycoords = np.linspace(0.0, yperiod, ny, endpoint=False)
start_r = xcentre + a / 2.
start_z = 0.
if rectangular:
print("Making rectangular poloidal grid")
poloidal_grid = zb.poloidal_grid.RectangularPoloidalGrid(
nx, nz, 1.0, 1.0, Rcentre=xcentre)
elif curvilinear:
print("Making curvilinear poloidal grid")
inner = zb.rzline.shaped_line(R0=xcentre,
a=a / 2.,
elong=0,
triang=0.0,
indent=0,
n=npoints)
outer = zb.rzline.shaped_line(R0=xcentre,
a=a,
elong=0,
triang=0.0,
indent=0,
n=npoints)
if curvilinear_inner_aligned:
print("Aligning to inner flux surface...")
inner_lines = get_lines(field,
start_r,
start_z,
ycoords,
yperiod=yperiod,
npoints=npoints)
if curvilinear_outer_aligned:
print("Aligning to outer flux surface...")
outer_lines = get_lines(field,
xcentre + a,
start_z,
ycoords,
yperiod=yperiod,
npoints=npoints)
print("creating grid...")
if curvilinear_inner_aligned:
if curvilinear_outer_aligned:
poloidal_grid = [
zb.poloidal_grid.grid_elliptic(inner,
outer,
nx,
nz,
show=show_maps)
for inner, outer in zip(inner_lines, outer_lines)
]
else:
poloidal_grid = [
zb.poloidal_grid.grid_elliptic(inner,
outer,
nx,
nz,
show=show_maps)
for inner in inner_lines
]
else:
poloidal_grid = zb.poloidal_grid.grid_elliptic(
inner, outer, nx, nz)
# Create the 3D grid by putting together 2D poloidal grids
grid = zb.grid.Grid(poloidal_grid, ycoords, yperiod, yperiodic=True)
maps = zb.make_maps(grid, field)
zb.write_maps(grid, field, maps, str(fname), metric2d=False)
if (curvilinear and calc_curvature):
print("calculating curvature...")
calc_curvilinear_curvature(fname, field, grid, maps)
if (calc_curvature and smooth_curvature):
smooth_metric(fname,
write_to_file=True,
return_values=False,
smooth_metric=True)
if (return_iota or write_iota):
rindices = np.linspace(start_r, xcentre + a, nx)
zindices = np.zeros((nx))
iota_bar = calc_iota(field, start_r, start_z)
if (write_iota):
f = DataFile(str(fname), write=True)
f.write('iota_bar', iota_bar)
f.close()
else:
print("Iota_bar = ", iota_bar)
ydown_xsplit = [nx]
yup_xin = [0]
yup_xout = [-1]
ydown_xin = [0]
ydown_xout = [-1]
nrad = [nx]
npol = [ny]
######################################################
print("Writing grid to file "+output)
of = DataFile()
of.open(output, create=True)
of.write("nx", nx)
of.write("ny", ny)
# Topology for original scheme
of.write("ixseps1", ixseps1)
of.write("ixseps2", ixseps2)
of.write("jyseps1_1", jyseps1_1)
of.write("jyseps1_2", jyseps1_2)
of.write("jyseps2_1", jyseps2_1)
of.write("jyseps2_2", jyseps2_2)
of.write("ny_inner", ny_inner)
# Grid spacing
of.write("dx", dx)
of.write("dy", dy)
def resizeY(newy, path="data", output=".", informat="nc", outformat=None, myg=2):
"""Increase the number of Y points in restart files
NOTE:
* Can't overwrite
Parameters
----------
newy : int
ny for the new file
path : str, optional
Path to original restart files (default: "data")
output : str, optional
Path to write new restart files (default: current directory)
informat : str, optional
File extension of original files (default: "nc")
outformat : str, optional
File extension of new files (default: use the same as `informat`)
myg : int, optional
Number of ghost points in y (default: 2)
Returns
-------
True on success, else False
TODO
----
- Replace printing errors with raising `ValueError`
- Make informat work like `redistribute`
"""
if outformat is None:
outformat = informat
file_list = glob.glob(os.path.join(path, "BOUT.restart.*."+informat))
nfiles = len(file_list)
if nfiles == 0:
print("ERROR: No restart files found")
return False
for i in range(nfiles):
# Open each data file
infname = os.path.join(path, "BOUT.restart."+str(i)+"."+informat)
outfname = os.path.join(output, "BOUT.restart."+str(i)+"."+outformat)
print("Processing %s -> %s" % (infname, outfname))
infile = DataFile(infname)
outfile = DataFile(outfname, create=True)
# Copy basic information
for var in ["hist_hi", "NXPE", "NYPE", "tt"]:
data = infile.read(var)
try:
# Convert to scalar if necessary
data = data[0]
except:
pass
outfile.write(var, data)
# Get a list of variables
varnames = infile.list()
for var in varnames:
if infile.ndims(var) == 3:
# Could be an evolving variable [x,y,z]
print(" -> Resizing " + var)
# Read variable from input
indata = infile.read(var)
nx, ny, nz = indata.shape
# y coordinate in input and output data
iny = (arange(ny) - myg + 0.5) / (ny - 2*myg)
outy = (arange(newy) - myg + 0.5) / (newy - 2*myg)
outdata = zeros([nx, newy, nz])
for x in range(nx):
for z in range(nz):
f = interp1d(
iny, indata[x, :, z], bounds_error=False, fill_value=0.0)
outdata[x, :, z] = f(outy)
outfile.write(var, outdata)
elif infile.ndims(var) == 2:
# Assume evolving variable [x,y]
print(" -> Resizing " + var)
# Read variable from input
indata = infile.read(var)
nx, ny = indata.shape
# y coordinate in input and output data
iny = (arange(ny) - myg + 0.5) / (ny - 2*myg)
outy = (arange(newy) - myg + 0.5) / (newy - 2*myg)
outdata = zeros([nx, newy])
for x in range(nx):
f = interp1d(iny, indata[x, :],
bounds_error=False, fill_value=0.0)
outdata[x, :] = f(outy)
outfile.write(var, outdata)
else:
# Copy variable
print(" -> Copying " + var)
# Read variable from input
data = infile.read(var)
try:
# Convert to scalar if necessary
data = data[0]
except:
pass
outfile.write(var, data)
infile.close()
outfile.close()
def create(averagelast=1, final=-1, path="data", output="./", informat="nc", outformat=None):
"""Create restart files from data (dmp) files.
Parameters
----------
averagelast : int, optional
Number of time points (counting from `final`, inclusive) to
average over (default is 1 i.e. just take last time-point)
final : int, optional
The last time point to use (default is last, -1)
path : str, optional
Path to original restart files (default: "data")
output : str, optional
Path to write new restart files (default: current directory)
informat : str, optional
File extension of original files (default: "nc")
outformat : str, optional
File extension of new files (default: use the same as `informat`)
"""
if outformat is None:
outformat = informat
file_list = glob.glob(os.path.join(path, "BOUT.dmp.*."+informat))
nfiles = len(file_list)
print(("Number of data files: ", nfiles))
for i in range(nfiles):
# Open each data file
infname = os.path.join(path, "BOUT.dmp."+str(i)+"."+informat)
outfname = os.path.join(output, "BOUT.restart."+str(i)+"."+outformat)
print((infname, " -> ", outfname))
infile = DataFile(infname)
outfile = DataFile(outfname, create=True)
# Get the data always needed in restart files
hist_hi = infile.read("iteration")
print(("hist_hi = ", hist_hi))
outfile.write("hist_hi", hist_hi)
t_array = infile.read("t_array")
tt = t_array[final]
print(("tt = ", tt))
outfile.write("tt", tt)
tind = final
if tind < 0.0:
tind = len(t_array) + final
NXPE = infile.read("NXPE")
NYPE = infile.read("NYPE")
print(("NXPE = ", NXPE, " NYPE = ", NYPE))
outfile.write("NXPE", NXPE)
outfile.write("NYPE", NYPE)
# Get a list of variables
varnames = infile.list()
for var in varnames:
if infile.ndims(var) == 4:
# Could be an evolving variable
print((" -> ", var))
data = infile.read(var)
if averagelast == 1:
slice = data[final, :, :, :]
else:
slice = mean(data[(final - averagelast)
:final, :, :, :], axis=0)
print(slice.shape)
outfile.write(var, slice)
infile.close()
outfile.close()
#!/usr/bin/env python
#
# Generate an input mesh
#
from boututils.datafile import DataFile # Wrapper around NetCDF4 libraries
nx = 5 # Minimum is 5: 2 boundary, one evolved
ny = 64 # Minimum 5. Should be divisible by number of processors (so powers of 2 nice)
f = DataFile()
f.open("conduct_grid.nc", create=True)
f.write("nx", nx)
f.write("ny", ny)
f.close()
ydown_xsplit = [nx]
yup_xin = [0]
yup_xout = [-1]
ydown_xin = [0]
ydown_xout = [-1]
nrad = [nx]
npol = [ny]
######################################################
print("Writing grid to file " + output)
of = DataFile()
of.open(output, create=True)
of.write("nx", nx)
of.write("ny", ny)
# Topology for original scheme
of.write("ixseps1", ixseps1)
of.write("ixseps2", ixseps2)
of.write("jyseps1_1", jyseps1_1)
of.write("jyseps1_2", jyseps1_2)
of.write("jyseps2_1", jyseps2_1)
of.write("jyseps2_2", jyseps2_2)
of.write("ny_inner", ny_inner)
# Grid spacing
of.write("dx", dx)
of.write("dy", dy)
def generate(
nx,
ny,
R=2.0,
r=0.2, # Major & minor radius
dr=0.05, # Radial width of domain
Bt=1.0, # Toroidal magnetic field
q=5.0, # Safety factor
mxg=2,
file="circle.nc",
):
# q = rBt / RBp
Bp = r * Bt / (R * q)
# Minor radius as function of x. Choose so boundary
# is half-way between grid points
h = dr / (nx - 2.0 * mxg) # Grid spacing in r
rminor = linspace(r - 0.5 * dr - (mxg - 0.5) * h, r + 0.5 * dr + (mxg - 0.5) * h, nx)
# mesh spacing in x and y
dx = ndarray([nx, ny])
dx[:, :] = r * Bt * h # NOTE: dx is toroidal flux
dy = ndarray([nx, ny])
dy[:, :] = 2.0 * pi / ny
# LogB = log(1/(1+r/R cos(theta))) =(approx) -(r/R)*cos(theta)
logB = zeros([nx, ny, 3]) # (constant, n=1 real, n=1 imag)
# At y = 0, Rmaj = R + r*cos(theta)
logB[:, 0, 1] = -(rminor / R)
# Moving in y, phase shift by (toroidal angle) / q
for y in range(1, ny):
dtheta = y * 2.0 * pi / ny / q # Change in poloidal angle
logB[:, y, 1] = -(rminor / R) * cos(dtheta)
logB[:, y, 2] = -(rminor / R) * sin(dtheta)
# Shift angle from one end of y to the other
ShiftAngle = ndarray([nx])
ShiftAngle[:] = 2.0 * pi / q
Rxy = ndarray([nx, ny])
Rxy[:, :] = r # NOTE : opposite to standard BOUT convention
Btxy = ndarray([nx, ny])
Btxy[:, :] = Bp
Bpxy = ndarray([nx, ny])
Bpxy[:, :] = Bt
Bxy = ndarray([nx, ny])
Bxy[:, :] = sqrt(Bt ** 2 + Bp ** 2)
hthe = ndarray([nx, ny])
hthe[:, :] = R
print("Writing to file '" + file + "'")
f = DataFile()
f.open(file, create=True)
# Mesh size
f.write("nx", nx)
f.write("ny", ny)
# Mesh spacing
f.write("dx", dx)
f.write("dy", dy)
# Metric components
f.write("Rxy", Rxy)
f.write("Btxy", Btxy)
f.write("Bpxy", Bpxy)
f.write("Bxy", Bxy)
f.write("hthe", hthe)
# Shift
f.write("ShiftAngle", ShiftAngle)
# Curvature
f.write("logB", logB)
# Input parameters
f.write("R", R)
f.write("r", r)
f.write("dr", dr)
f.write("Bt", Bt)
f.write("q", q)
f.write("mxg", mxg)
f.close()
def create(averagelast=1,
final=-1,
path="data",
output="./",
informat="nc",
outformat=None):
"""
Create restart files from data (dmp) files.
Inputs
======
averagelast Number of time points to average over.
Default is 1 i.e. just take last time-point
final The last time point to use. Default is last (-1)
path Path to the input data files
output Path where the output restart files should go
informat Format of the input data files
outformat Format of the output restart files
"""
if outformat is None:
outformat = informat
file_list = glob.glob(os.path.join(path, "BOUT.dmp.*." + informat))
nfiles = len(file_list)
print(("Number of data files: ", nfiles))
for i in range(nfiles):
# Open each data file
infname = os.path.join(path, "BOUT.dmp." + str(i) + "." + informat)
outfname = os.path.join(output,
"BOUT.restart." + str(i) + "." + outformat)
print((infname, " -> ", outfname))
infile = DataFile(infname)
outfile = DataFile(outfname, create=True)
# Get the data always needed in restart files
hist_hi = infile.read("iteration")
print(("hist_hi = ", hist_hi))
outfile.write("hist_hi", hist_hi)
t_array = infile.read("t_array")
tt = t_array[final]
print(("tt = ", tt))
outfile.write("tt", tt)
tind = final
if tind < 0.0:
tind = len(t_array) + final
NXPE = infile.read("NXPE")
NYPE = infile.read("NYPE")
NPES = NXPE * NYPE
print(("NPES = ", NPES, " NXPE = ", NXPE))
outfile.write("NPES", NPES)
outfile.write("NXPE", NXPE)
# Get a list of variables
varnames = infile.list()
for var in varnames:
if infile.ndims(var) == 4:
# Could be an evolving variable
print((" -> ", var))
data = infile.read(var)
if averagelast == 1:
slice = data[final, :, :, :]
else:
slice = mean(data[(final - averagelast):final, :, :, :],
axis=0)
print(slice.shape)
outfile.write(var, slice)
infile.close()
outfile.close()
def resizeY(newy,
path="data",
output=".",
informat="nc",
outformat=None,
myg=2):
"""
Resize all the restart files in Y
"""
if outformat is None:
outformat = informat
file_list = glob.glob(os.path.join(path, "BOUT.restart.*." + informat))
nfiles = len(file_list)
if nfiles == 0:
print("ERROR: No restart files found")
return False
for i in range(nfiles):
# Open each data file
infname = os.path.join(path, "BOUT.restart." + str(i) + "." + informat)
outfname = os.path.join(output,
"BOUT.restart." + str(i) + "." + outformat)
print("Processing %s -> %s" % (infname, outfname))
infile = DataFile(infname)
outfile = DataFile(outfname, create=True)
# Copy basic information
for var in ["hist_hi", "NPES", "NXPE", "tt"]:
data = infile.read(var)
try:
# Convert to scalar if necessary
data = data[0]
except:
pass
outfile.write(var, data)
# Get a list of variables
varnames = infile.list()
for var in varnames:
if infile.ndims(var) == 3:
# Could be an evolving variable [x,y,z]
print(" -> Resizing " + var)
# Read variable from input
indata = infile.read(var)
nx, ny, nz = indata.shape
# y coordinate in input and output data
iny = (arange(ny) - myg + 0.5) / (ny - 2 * myg)
outy = (arange(newy) - myg + 0.5) / (newy - 2 * myg)
outdata = zeros([nx, newy, nz])
for x in range(nx):
for z in range(nz):
f = interp1d(iny,
indata[x, :, z],
bounds_error=False,
fill_value=0.0)
outdata[x, :, z] = f(outy)
outfile.write(var, outdata)
elif infile.ndims(var) == 2:
# Assume evolving variable [x,y]
print(" -> Resizing " + var)
# Read variable from input
indata = infile.read(var)
nx, ny = indata.shape
# y coordinate in input and output data
iny = (arange(ny) - myg + 0.5) / (ny - 2 * myg)
outy = (arange(newy) - myg + 0.5) / (newy - 2 * myg)
outdata = zeros([nx, newy])
for x in range(nx):
f = interp1d(iny,
indata[x, :],
bounds_error=False,
fill_value=0.0)
outdata[x, :] = f(outy)
outfile.write(var, outdata)
else:
# Copy variable
print(" -> Copying " + var)
# Read variable from input
data = infile.read(var)
try:
# Convert to scalar if necessary
data = data[0]
except:
pass
outfile.write(var, data)
infile.close()
outfile.close()
def create(averagelast=1, final=-1, path="data", output="./", informat="nc", outformat=None):
"""
Create restart files from data (dmp) files.
Inputs
======
averagelast Number of time points to average over.
Default is 1 i.e. just take last time-point
final The last time point to use. Default is last (-1)
path Path to the input data files
output Path where the output restart files should go
informat Format of the input data files
outformat Format of the output restart files
"""
if outformat is None:
outformat = informat
file_list = glob.glob(os.path.join(path, "BOUT.dmp.*." + informat))
nfiles = len(file_list)
print(("Number of data files: ", nfiles))
for i in range(nfiles):
# Open each data file
infname = os.path.join(path, "BOUT.dmp." + str(i) + "." + informat)
outfname = os.path.join(output, "BOUT.restart." + str(i) + "." + outformat)
print((infname, " -> ", outfname))
infile = DataFile(infname)
outfile = DataFile(outfname, create=True)
# Get the data always needed in restart files
hist_hi = infile.read("iteration")
print(("hist_hi = ", hist_hi))
outfile.write("hist_hi", hist_hi)
t_array = infile.read("t_array")
tt = t_array[final]
print(("tt = ", tt))
outfile.write("tt", tt)
tind = final
if tind < 0.0:
tind = len(t_array) + final
NXPE = infile.read("NXPE")
NYPE = infile.read("NYPE")
NPES = NXPE * NYPE
print(("NPES = ", NPES, " NXPE = ", NXPE))
outfile.write("NPES", NPES)
outfile.write("NXPE", NXPE)
# Get a list of variables
varnames = infile.list()
for var in varnames:
if infile.ndims(var) == 4:
# Could be an evolving variable
print((" -> ", var))
data = infile.read(var)
if averagelast == 1:
slice = data[final, :, :, :]
else:
slice = mean(data[(final - averagelast) : final, :, :, :], axis=0)
print(slice.shape)
outfile.write(var, slice)
infile.close()
outfile.close()
def generate(
nx,
ny,
R=2.0,
r=0.2, # Major & minor radius
dr=0.05, # Radial width of domain
Bt=1.0, # Toroidal magnetic field
q=5.0, # Safety factor
mxg=2,
file="circle.nc"):
# q = rBt / RBp
Bp = r * Bt / (R * q)
# Minor radius as function of x. Choose so boundary
# is half-way between grid points
h = dr / (nx - 2. * mxg) # Grid spacing in r
rminor = linspace(r - 0.5 * dr - (mxg - 0.5) * h,
r + 0.5 * dr + (mxg - 0.5) * h, nx)
# mesh spacing in x and y
dx = ndarray([nx, ny])
dx[:, :] = r * Bt * h # NOTE: dx is toroidal flux
dy = ndarray([nx, ny])
dy[:, :] = 2. * pi / ny
# LogB = log(1/(1+r/R cos(theta))) =(approx) -(r/R)*cos(theta)
logB = zeros([nx, ny, 3]) # (constant, n=1 real, n=1 imag)
# At y = 0, Rmaj = R + r*cos(theta)
logB[:, 0, 1] = -(rminor / R)
# Moving in y, phase shift by (toroidal angle) / q
for y in range(1, ny):
dtheta = y * 2. * pi / ny / q # Change in poloidal angle
logB[:, y, 1] = -(rminor / R) * cos(dtheta)
logB[:, y, 2] = -(rminor / R) * sin(dtheta)
# Shift angle from one end of y to the other
ShiftAngle = ndarray([nx])
ShiftAngle[:] = 2. * pi / q
Rxy = ndarray([nx, ny])
Rxy[:, :] = r # NOTE : opposite to standard BOUT convention
Btxy = ndarray([nx, ny])
Btxy[:, :] = Bp
Bpxy = ndarray([nx, ny])
Bpxy[:, :] = Bt
Bxy = ndarray([nx, ny])
Bxy[:, :] = sqrt(Bt**2 + Bp**2)
hthe = ndarray([nx, ny])
hthe[:, :] = R
print("Writing to file '" + file + "'")
f = DataFile()
f.open(file, create=True)
# Mesh size
f.write("nx", nx)
f.write("ny", ny)
# Mesh spacing
f.write("dx", dx)
f.write("dy", dy)
# Metric components
f.write("Rxy", Rxy)
f.write("Btxy", Btxy)
f.write("Bpxy", Bpxy)
f.write("Bxy", Bxy)
f.write("hthe", hthe)
# Shift
f.write("ShiftAngle", ShiftAngle)
# Curvature
f.write("logB", logB)
# Input parameters
f.write("R", R)
f.write("r", r)
f.write("dr", dr)
f.write("Bt", Bt)
f.write("q", q)
f.write("mxg", mxg)
f.close()
#!/usr/bin/env python
#
# Generate an input mesh
#
from boututils.datafile import DataFile # Wrapper around NetCDF4 libraries
nx = 5 # Minimum is 5: 2 boundary, one evolved
ny = 32 # Minimum 5. Should be divisible by number of processors (so powers of 2 nice)
dy = 1. # distance between points in y, in m/g22/lengthunit
ixseps1 = -1
ixseps2 = -1
f = DataFile()
f.open("test-staggered.nc", create=True)
f.write("nx", nx)
f.write("ny", ny)
f.write("dy", dy)
f.write("ixseps1", ixseps1)
f.write("ixseps2", ixseps2)
f.close()
