def __init__(self, config, family='S', nTF=16, obj='L'):
self.nTF = nTF
self.config = config
datadir = trim_dir('../../Data')
file = 'salome_input' # config # +'_{}{}{}'.format(family,nTF,obj)
self.filename = datadir + '/' + file + '.json'
self.profile = Profile(config['TF'],
family=family,
load=True,
part='TF',
nTF=nTF,
obj=obj,
npoints=250)
setup = Setup(config['eq'])
self.sf = SF(setup.filename)
self.tf = TF(self.profile, sf=self.sf)
self.pf = PF(self.sf.eqdsk)
self.PF_support() # calculate PF support seats
self.CS_support() # calculate CS support seats
self.Gravity_support()
self.cage = coil_cage(nTF=nTF,
rc=self.tf.rc,
ny=3,
plasma={'config': config['eq']},
coil=self.tf.x['cl'])
self.eq = EQ(self.sf,
self.pf,
dCoil=0.5,
sigma=0,
boundary=self.sf.get_sep(expand=0.5),
n=1e3)
self.eq.plasma()
self.ff = force_feild(self.pf.index, self.pf.coil, self.eq.coil,
self.eq.plasma_coil)
config = {'TF': 'dtt', 'eq': 'SN'}
config['TF'] = '{}{}{:d}'.format(config['eq'], config['TF'], nTF)
setup = Setup(config['eq'])
sf = SF(setup.filename)
rb = RB(setup, sf)
pf = PF(sf.eqdsk)
profile = Profile(config['TF'],
family='S',
part='TF',
nTF=nTF,
obj='L',
load=True)
tf = TF(profile, sf=sf)
eq = EQ(sf, pf, dCoil=2.0, limit=[5.2, 13, -6.5, 6], n=5e3) #
eq.get_plasma_coil()
eq.run(update=False)
inv = INV(sf, eq, tf)
Lpf = inv.grid_PF(nPF=nPF)
Lcs = inv.grid_CS(nCS=nCS, Zbound=[-12, 8], gap=0.1)
Lo = np.append(Lpf, Lcs)
inv.update_coils()
inv.fit_PF(offset=0.3)
'''
inv.fix_boundary_psi(N=31,alpha=1-1e-4,factor=1) # add boundary points
inv.fix_boundary_feild(N=31,alpha=1-1e-4,factor=1) # add boundary points
inv.add_null(factor=3,point=sf.Xpoint)
Rex,arg = 1.5,40
R = sf.Xpoint[0]*(Rex-1)/np.sin(arg*np.pi/180)
class SALOME(object):
def __init__(self, config, family='S', nTF=16, obj='L'):
self.nTF = nTF
self.config = config
datadir = trim_dir('../../Data')
file = 'salome_input' # config # +'_{}{}{}'.format(family,nTF,obj)
self.filename = datadir + '/' + file + '.json'
self.profile = Profile(config['TF'],
family=family,
load=True,
part='TF',
nTF=nTF,
obj=obj,
npoints=250)
setup = Setup(config['eq'])
self.sf = SF(setup.filename)
self.tf = TF(self.profile, sf=self.sf)
self.pf = PF(self.sf.eqdsk)
self.PF_support() # calculate PF support seats
self.CS_support() # calculate CS support seats
self.Gravity_support()
self.cage = coil_cage(nTF=nTF,
rc=self.tf.rc,
ny=3,
plasma={'config': config['eq']},
coil=self.tf.x['cl'])
self.eq = EQ(self.sf,
self.pf,
dCoil=0.5,
sigma=0,
boundary=self.sf.get_sep(expand=0.5),
n=1e3)
self.eq.plasma()
self.ff = force_feild(self.pf.index, self.pf.coil, self.eq.coil,
self.eq.plasma_coil)
def write(self):
print('writing', self.filename, self.nTF)
color = sns.color_palette('Set2', 12)
data = {
'p': self.profile.loop.p,
'section': self.tf.section,
'pf': self.pf.coil,
'nTF': self.nTF,
'color': color,
'PFsupport': self.PFsupport,
'CSsupport': self.CSsupport,
'Gsupport': self.Gsupport,
'OISsupport': self.OISsupport
}
with open(self.filename, 'w') as f:
json.dump(data, f, indent=4)
def CS_support(self):
depth = self.tf.section['winding_pack']['depth']
side = self.tf.section['case']['side']
width = self.tf.section['winding_pack']['width']
inboard = self.tf.section['case']['inboard']
nose = self.tf.section['case']['nose']
segment = self.profile.loop.p[0]
ro, zo = segment['p0']['r'], segment['p0']['z']
theta = np.pi / self.nTF
rsep = (depth / 2 + side) / np.tan(theta)
rnose = ro - (width + inboard + nose)
rwp = ro - (width + inboard)
if rsep <= rnose:
ynose = depth / 2 + side
else:
ynose = rnose * np.tan(theta)
if rsep <= rwp:
ywp = depth / 2 + side
else:
ywp = rwp * np.tan(theta)
self.tf.loop_interpolators(offset=0) # construct TF interpolators
TFloop = self.tf.fun['out']
L = minimize_scalar(SALOME.cs_top,
method='bounded',
args=(rwp, TFloop),
bounds=[0.5, 1]).x
ztop = float(TFloop['z'](L))
self.CSsupport = {
'rnose': rnose,
'ynose': ynose,
'rwp': rwp,
'ywp': ywp,
'ztop': ztop,
'zo': zo,
'dt': side
}
def cs_top(L, rwp, TFloop):
err = abs(TFloop['r'](L) - rwp)
return err
def support_arm(L, coil, TFloop):
dl = np.sqrt((coil['r'] - TFloop['r'](L))**2 +
(coil['z'] - TFloop['z'](L))**2)
return dl
def intersect(x, xc, nhat, TFloop):
L, s = x # unpack
rTF, zTF = TFloop['r'](L), TFloop['z'](L)
rs, zs = s * nhat + xc
err = np.sqrt((rTF - rs)**2 + (zTF - zs)**2)
return err
def connect(self, coil, loop, edge=0.15, hover=0.1, argmin=60):
L = minimize_scalar(SALOME.support_arm,
method='bounded',
args=(coil, loop),
bounds=[0, 1]).x
rTF, zTF = loop['r'](L), loop['z'](L)
nhat = np.array([rTF - coil['r'], zTF - coil['z']])
ndir = 180 / np.pi * np.arctan(abs(nhat[1] / nhat[0])) # angle, deg
if ndir < argmin: # limit absolute support angle
nhat = np.array([
np.sign(nhat[0]),
np.tan(argmin * np.pi / 180) * np.sign(nhat[1])
])
nhat /= np.linalg.norm(nhat)
above = np.sign(np.dot(nhat, [0, 1]))
zc = coil['z'] + above * (coil['dz'] / 2 + hover)
nodes = [[] for _ in range(4)]
for i, sign in enumerate([-1, 1]): # inboard / outboard
rc = coil['r'] + sign * (coil['dr'] / 2 + edge)
nodes[i] = [rc, zc]
xc = np.array([rc, zc])
xo = np.array([L, 0.5])
res = minimize(SALOME.intersect,
xo,
method='L-BFGS-B',
bounds=([0, 1], [0, 15]),
args=(xc, nhat, loop))
rs, zs = res.x[1] * nhat + xc
nodes[3 - i] = [rs, zs]
return nodes
def PF_support(self):
self.tf.loop_interpolators(offset=-0.15) # construct TF interpolators
TFloop = self.tf.fun['out']
self.PFsupport = {}
for name in self.pf.index['PF']['name']:
coil = self.pf.coil[name]
nodes = self.connect(coil, TFloop, edge=0.15, hover=0.1, argmin=60)
self.PFsupport[name] = nodes
def GS_placement(L, radius, TFloop):
return abs(radius - TFloop['r'](L))
def Gravity_support(self, radius=13, width=0.75):
self.tf.loop_interpolators(offset=-0.15) # construct TF interpolators
TFloop = self.tf.fun['out']
self.tf.loop_interpolators(offset=0)
Sloop = self.tf.fun['out']
L = minimize_scalar(SALOME.GS_placement,
method='bounded',
args=(radius - width / 2, Sloop),
bounds=[0, 0.5]).x
coil = {
'r': Sloop['r'](L) + width / 2,
'z': Sloop['z'](L) - width / 2,
'dr': width,
'dz': width
}
nodes = self.connect(coil, TFloop, edge=0, hover=0, argmin=90)
self.Gsupport = {'base': nodes}
z = [[self.pf.coil[name]['z']-self.pf.coil[name]['dz']/2]\
for name in self.pf.coil]
floor = np.min(z) - 1
self.Gsupport['zbase'] = float(Sloop['z'](L))
self.Gsupport['zfloor'] = floor
self.Gsupport['radius'] = radius
self.Gsupport['width'] = width
def OIS_placment(L, TFloop, point):
err = (point[0] - TFloop['r'](L))**2 + (point[1] - TFloop['z'](L))**2
return err
def draw_OIS(self, L, width, thickness, TFloop):
dl = width / TFloop['L']
rcl = np.array([TFloop['r'](L - dl / 2), TFloop['r'](L + dl / 2)])
zcl = np.array([TFloop['z'](L - dl / 2), TFloop['z'](L + dl / 2)])
ro, zo = np.mean(rcl), np.mean(zcl)
L = minimize_scalar(SALOME.OIS_placment,
method='bounded',
args=(TFloop, (ro, zo)),
bounds=[0, 1]).x
dr, dz = TFloop['r'](L) - ro, TFloop['z'](L) - zo
rcl += dr / 2
zcl += dz / 2
dt = np.array([rcl[1] - rcl[0], 0, zcl[1] - zcl[0]])
dt /= np.linalg.norm(dt)
dn = np.cross(dt, np.array([0, 1, 0]))
rcl = np.append(rcl + dn[0] * thickness / 2,
rcl[::-1] - dn[0] * thickness / 2)
zcl = np.append(zcl + dn[2] * thickness / 2,
zcl[::-1] - dn[2] * thickness / 2)
nodes = [[rcl[i], zcl[i]] for i in range(4)]
return nodes
def OIS(self, width=3.5, thickness=0.15, rmin=10):
self.tf.loop_interpolators(offset=0) # construct TF interpolators
TFloop = self.tf.fun['cl']
self.OISsupport = {}
for i, (L, width) in enumerate(zip([0.4, 0.64], [4.5, 2.5])):
nodes = self.draw_OIS(L, width, thickness, TFloop)
self.OISsupport['OIS{:d}'.format(i)] = nodes
def plot(self):
self.tf.fill()
self.pf.plot(coils=self.pf.coil, label=True, current=True)
self.pf.plot(coils=self.eq.coil, plasma=True)
for name in self.PFsupport:
nodes = np.array(self.PFsupport[name])
geom.polyfill(nodes[:, 0], nodes[:, 1], color=0.4 * np.ones(3))
nodes = np.array(self.Gsupport['base'])
geom.polyfill(nodes[:, 0], nodes[:, 1], color=0.4 * np.ones(3))
pl.plot(self.Gsupport['radius'] * np.ones(2),
[self.Gsupport['zbase'], self.Gsupport['zfloor']],
'o-',
color=0.4 * np.ones(3),
lw=4)
for name in self.OISsupport:
nodes = np.array(self.OISsupport[name])
geom.polyfill(nodes[:, 0], nodes[:, 1], color=0.4 * np.ones(3))
rnose = self.CSsupport['rnose']
rwp = self.CSsupport['rwp']
zo = self.CSsupport['zo']
ztop = self.CSsupport['ztop']
rCS = [rnose, rwp, rwp, rnose]
zCS = [zo, zo, ztop, ztop]
geom.polyfill(rCS, zCS, color=0.4 * np.ones(3))
def ansys(self, plot=False, nl=250, nr=5, ny=5):
filename = '../../Data/TFload_{:d}'.format(self.nTF)
ans = table(filename)
ans.f.write('! loading tables for {:d}TF coil concept\n'.format(
self.nTF))
ans.f.write('! loop length parameterized from 0-1\n')
ans.f.write('! loop starts at the inboard midplane\n')
ans.f.write('! loop progresses in the anti-clockwise direction\n')
ans.f.write('! tables defined with cylindrical coordinate system\n')
ans.f.write(
'! body applied to nodes of winding-pack in cartisean system x,y,z\n'
)
ans.f.write(
'! winding-pack must be labled as named-selection \'wp\'\n')
ans.f.write('\nlocal,11,1,{:1.9f},0,{:1.9f},0,90,0'\
.format(self.sf.mo[0],self.sf.mo[1]))
ans.f.write(' ! define local cylindrical coordinate system\n')
ans.f.write('csys,0 ! restore to cartesian\n')
ans.f.write('\n! per-TF PF coil forces (Fr,Fz) [N]\n')
ans.f.write('! order as numbered in plots\n')
F = self.ff.get_force()['F']
ans.load('F_coil', F / self.nTF)
ans.write_array()
ans.f.write('\n/nopr ! suppress large table output\n')
self.tf.loop_interpolators(offset=0,
full=True) # construct TF interpolators
TFloop = self.tf.fun['cl']
ngrid = {'nr': 20, 'nt': 150} # coordinate interpolation grid
ndata = {
'nl': nl,
'nr': nr,
'ny': ny
} # coordinate interpolation grid
l = np.linspace(0, 1, 250) # calculate grid extent
xin, zin = self.tf.fun['in']['r'](l), self.tf.fun['in']['z'](l)
rin = np.sqrt((xin - self.sf.mo[0])**2 + (zin - self.sf.mo[1])**2)
rmin = np.min(rin) # minimum radius
xout, zout = self.tf.fun['out']['r'](l), self.tf.fun['out']['z'](l)
rout = np.sqrt((xout - self.sf.mo[0])**2, (zout - self.sf.mo[1])**2)
rmax = np.max(rout) # maximum radius
radius = np.linspace(rmin, rmax, ngrid['nr'])
theta = np.linspace(-np.pi, np.pi, ngrid['nt'])
l_map = np.zeros((ngrid['nr'], ngrid['nt']))
dr_map = np.zeros((ngrid['nr'], ngrid['nt']))
for i in range(ngrid['nr']):
for j in range(ngrid['nt']):
x = self.sf.mo[0] + radius[i] * np.cos(theta[j])
z = self.sf.mo[1] + radius[i] * np.sin(theta[j])
L = minimize_scalar(SALOME.OIS_placment,
method='bounded',
args=(TFloop, (x, z)),
bounds=[0, 1]).x
xl, zl = TFloop['r'](L), TFloop['z'](L)
l_map[i, j] = L
dr_map[i,j] = np.sqrt((x-xl)**2+(z-zl)**2)*\
np.sign(np.dot([x-xl,z-zl],[x-self.sf.mo[0],z-self.sf.mo[1]]))
width = self.tf.section['winding_pack']['width']
depth = self.tf.section['winding_pack']['depth']
cross_section = width * depth
l_data = np.linspace(0, 1, ndata['nl'])
if ndata['nr'] > 1:
dr_data = np.linspace(-width / 2, width / 2, ndata['nr'])
else:
dr_data = np.array([0])
if ndata['ny'] > 1:
dy_data = np.linspace(-depth / 2, depth / 2, ndata['ny'])
else:
dy_data = np.array([0])
Fbody = {}
for var in ['x', 'y', 'z']:
Fbody[var] = np.zeros((ndata['nl'], ndata['nr'], ndata['ny']))
self.tf.loop_interpolators(offset=0, full=True) # centreline
Jturn = self.cage.Iturn / cross_section
for i, l in enumerate(l_data):
iter_str = '\rcalculating TF body force:'
iter_str += 'segment {:d} of {:d}'.format(i, ndata['nl'])
sys.stdout.write(iter_str)
sys.stdout.flush()
xo = self.tf.fun['cl']['r'](l)
zo = self.tf.fun['cl']['z'](l)
dxo = self.tf.fun['cl']['dr'](l)
dzo = self.tf.fun['cl']['dz'](l)
that = np.array([dxo, 0, dzo])
that /= np.linalg.norm(that)
J = Jturn * that # current density vector
nhat = np.array([that[2], 0, -that[0]])
for j, dr in enumerate(dr_data):
for k, dy in enumerate(dy_data):
point = np.array([xo, dy, zo]) + dr * nhat
Fb = self.ff.topple(point,
J,
self.cage,
self.eq.Bpoint,
method='BS') # body force
for m, var in enumerate(['x', 'y', 'z']): # store
Fbody[var][i, j, k] = Fb[m]
if plot:
Fvec = Fb / np.linalg.norm(Fb)
Fvec = that
pl.arrow(point[0],
point[2],
Fvec[0],
Fvec[2],
head_width=0.15,
head_length=0.3)
print('\n',
np.sum(Fbody['x'][:-1, :, :]) * 1e-9,
np.sum(Fbody['y'][:-1, :, :]) * 1e-9,
np.sum(Fbody['z'][:-1, :, :]) * 1e-9)
ans.f.write('\n! parametric coil length, fn(theta)\n')
ans.load('l_map', l_map, [radius, theta])
ans.write(['radus', 'theta'])
ans.f.write('\n! parametric coil offset, fn(theta)\n')
ans.load('dr_map', dr_map, [radius, theta])
ans.write(['radus', 'theta'])
for var in ['x', 'y', 'z']:
ans.f.write(
'\n! winding-pack body force, Fbody_{} [N/m3]\n'.format(var))
ans.load('Fbody_{}'.format(var), Fbody[var],
[l_data, dr_data, dy_data])
ans.write(['l_map', 'dr_map', 'offset'])
ans.f.write('/gopr ! enable output\n')
apdlstr = '''
pi = 4*atan(1)
csys,11 ! switch to cylindrical coordinate system
esel,s,elem,,wp ! select winding pack (requires named selection 'wp')
*get,nel,elem,0,count
*vget,el_sel,elem,,esel ! selection mask
*vget,el_id,elem,,elist ! winding pack selection array
*vget,el_vol,elem,,geom ! element volume
*vget,el_radius,elem,,cent,x ! element radius
*vget,el_theta,elem,,cent,y ! element theta
*vget,el_offset,elem,,cent,z ! element axial offset
*voper,el_theta,el_theta,mult,pi/180 ! convert to radians
csys,0 ! return coordinate system
! compress selections
*dim,el_v,array,nel
*dim,el_r,array,nel
*dim,el_t,array,nel
*dim,el_o,array,nel
*dim,el_l,array,nel
*dim,el_dr,array,nel
*vmask,el_sel
*vfun,el_v,comp,el_vol ! volume
*vmask,el_sel
*vfun,el_r,comp,el_radius ! radius
*vmask,el_sel
*vfun,el_t,comp,el_theta ! theta
*vmask,el_sel
*vfun,el_o,comp,el_offset ! offset
*vitrp,el_l,l_map,el_r,el_t ! interpolate l_map table
*vitrp,el_dr,dr_map,el_r,el_t ! interpolate dr_map table
xyz = 'x','y','z' ! axes
fcum,add ! accumulate nodal forces
*do,i,1,nel ! apply forces to loads
esel,s,elem,,el_id(i)
nsle ! select nodes attached to element
nsel,r,node,,wp ! ensure all nodes from winding pack
*get,nnd,node,0,count ! count nodes
*do,j,1,3 ! Fx,Fy,Fz - all nodes attached to element
F,all,F%xyz(j)%,Fbody_%xyz(j)%(el_l(i),el_dr(i),el_o(i))*el_v(i)*el_v(i)/nnd
*enddo
*enddo
allsel
'''
ans.f.write(apdlstr)
ans.close()
sf = SF(setup.filename)
pf = PF(sf.eqdsk)
for coil in pf.index['CS']['name']:
pf.coil[coil]['r'] = 2.7
pf.coil[coil]['dr'] = 0.8
profile = Profile(config['TF'], family='S', part='TF', nTF=nTF, obj='L')
tf = TF(profile=profile, sf=sf)
#tf.adjust_xo('dz',value=-2)
#tf.fill()
eq = EQ(sf,
pf,
dCoil=2.0,
sigma=0,
boundary=sf.get_sep(expand=1.0),
zmin=-10,
n=2e3)
inv = INV(pf, tf, dCoil=0.25)
inv.load_equlibrium(sf)
inv.fix_boundary()
inv.fix_target()
inv.plot_fix(tails=True)
inv.add_plasma()
Lnorm = inv.snap_coils()
'''
Lpf = inv.grid_PF(nPF=4)
nTF = 18 #,nPF,nCS = 18,6,5
config = {'TF': 'dtt', 'eq': 'SFp'}
config, setup = select(config, nTF=nTF, update=False) # nPF=nPF,nCS=nCS
sf = SF(setup.filename)
rb = RB(setup, sf)
pf = PF(sf.eqdsk)
tf = TF(
Profile(config['TF'], family='S', part='TF', nTF=nTF, obj='L', load=True))
rb.firstwall(symetric=True, DN=True, plot=True)
#pf.plot(coils=pf.coil,label=False,plasma=False,current=True)
tf.fill()
#sf.cpasma *= 1.1
eq = EQ(sf, pf, dCoil=1.5, sigma=0, boundary=sf.get_sep(expand=1.1), n=3e3)
eq.gen_bal()
#eq.gen_opp()
sf.contour()
inv = INV(sf, eq, tf)
L = inv.grid_coils(offset=0.3)
#pf.plot(coils=pf.coil,label=False,plasma=False,current=True)
inv.fix_boundary_psi(N=25, alpha=1 - 1e-4, factor=1) # add boundary points
inv.fix_boundary_feild(N=25, alpha=1 - 1e-4, factor=1) # add boundary points
#inv.add_null(factor=1,point=sf.Xpoint)
inv.add_null(factor=1, point=sf.Xpoint_array[:, 0])
ax[i][j].axis('off')
title = ['SN', 'X', 'SF-', 'SF+', 'SX', 'SXex']
for j, config in enumerate(['SN', 'X', 'SFm', 'SFp', 'SX', 'SXex']):
print('')
print(config)
pl.sca(ax[0][j])
pl.title(title[j])
Color = cycle(sns.color_palette('Set2'))
setup = Setup(config)
sf = SF(setup.filename)
rb = RB(setup, sf)
pf = PF(sf.eqdsk)
eq = EQ(sf, pf, sigma=0.1, boundary=rb.get_fw(expand=0.25), n=5e4)
#eq = EQ(sf,pf,sigma=0.1,boundary=rb.get_fw(expand=0.25),n=5e3)
sf.contour(Nlevel=21, lw=0.5)
pl.plot([14, 14], [-14.5, 9.5], 'o', alpha=0)
pf.plot(coils=pf.coil, label=False, plasma=False, current=False)
rb.firstwall(calc=False, plot=True, debug=False)
rb.vessel()
tf = TF(nTF=16,
shape={
'vessel': rb.loop,
'pf': pf,
'fit': True,
'setup': setup,
if __name__ is '__main__': # test functions
from nova.config import Setup
from nova.streamfunction import SF
from nova.elliptic import EQ
from nova.coils import PF
from nova.radial_build import RB
setup = Setup('SN_3PF_18TF')
sf = SF(setup.filename)
pf = PF(sf.eqdsk)
rb = RB(setup, sf)
eq = EQ(sf,
pf,
dCoil=0.25,
sigma=0,
boundary=rb.get_fw(expand=0.25),
n=1e3)
eq.get_plasma_coil()
#eq.gen_opp()
ff = force_feild(pf.index, pf.coil, eq.coil, eq.plasma_coil)
Fcoil = ff.get_force()
ff.plot()
pf.plot(coils=pf.coil, label=True, plasma=False, current=True)
pf.plot(coils=eq.coil, label=False, plasma=True, current=False)
pl.axis('equal')
pl.axis('off')
print(Fcoil['F'][:, 1])
'''
nPF, nCS, nTF = 5, 5, 18
config = {'TF': 'dtt', 'eq': 'SFm'}
config['TF'] = '{}{}{:d}'.format(config['eq'], config['TF'], nTF)
setup = Setup(config['eq'])
sf = SF(setup.filename)
rb = RB(setup, sf)
pf = PF(sf.eqdsk)
tf = TF(
Profile(config['TF'], family='S', part='TF', nTF=nTF, obj='L', load=True))
eq = EQ(sf,
pf,
dCoil=2.0,
sigma=0,
n=1e4,
boundary=sf.get_sep(expand=0.75),
rmin=sf.Xpoint[0] - 3.5,
zmin=sf.Xpoint[1] - 3.5)
eq.gen_opp()
theta, dXpoint = -5 * np.pi / 180, [0.5, -1]
pivot = np.argmin(sf.rbdry) # rotate/translate eqdsk
rp, zp = sf.rbdry[pivot], sf.zbdry[pivot]
TRT = geom.rotate2D(theta, xo=rp, yo=zp)[1] # trial rotate/translate
zref = sf.Mpoint[1]
dz = zref - np.dot(TRT, np.append(sf.Mpoint, 1))[1] # correct z-shift
R, TRT = geom.rotate2D(theta, xo=rp, yo=zp, dy=dz)
points = np.zeros((eq.nr * eq.nz, 2))
values = eq.psi.flatten()
config, setup = select(base=base, update=False, nTF=18, nPF=5, nCS=3)
sf = SF(setup.filename)
rb = RB(setup, sf)
pf = PF(sf.eqdsk)
tf = TF(
Profile(config['TF'],
family='S',
part='TF',
nTF=config['nTF'],
obj='L',
load=True))
tf.fill()
eq = EQ(sf,
pf,
dCoil=1.0,
sigma=0,
n=1e4,
boundary=sf.get_sep(expand=1.1),
zmin=sf.Xpoint[1] - 2)
eq.gen_opp()
inv = INV(sf, eq, tf)
#L = inv.grid_coils()
Lpf = inv.grid_PF(nPF=config['nPF'])
Lcs = inv.grid_CS(nCS=config['nCS'], Zbound=[-8, 8], gap=0.1, fdr=1)
L = np.append(Lpf, Lcs)
inv.update_coils()
inv.fit_PF(offset=0.3)
inv.fix_boundary_psi(N=25, alpha=1 - 1e-4, factor=1) # add boundary points
sf = SF(setup.filename)
rb = RB(setup, sf)
pf = PF(sf.eqdsk)
tf = TF(
Profile(config['TF'],
family='S',
part='TF',
nTF=config['nTF'],
obj='L',
load=True))
#tf.fill()
eq = EQ(sf,
pf,
dCoil=1.5,
sigma=0,
n=5e3,
boundary=sf.get_sep(expand=1.1),
zmin=-abs(sf.Xpoint[1]) - 2,
zmax=abs(sf.Xpoint[1]) + 2)
#eq.gen_opp(Zerr=5e-4)
eq.gen_bal(Zerr=5e-4, tol=1e-4)
'''
inv = INV(sf,eq,tf)
Lpf = inv.grid_PF(nPF=config['nPF'])
Lcs = inv.grid_CS(nCS=config['nCS'],Zbound=[-8,8],gap=0.1,fdr=1)
L = np.append(Lpf,Lcs)
inv.update_coils()
inv.fit_PF(offset=0.3)
inv.fix_boundary_psi(N=25,alpha=1-1e-2,factor=1) # add boundary points
#inv.fix_boundary_feild(N=25,alpha=1-1e-2,factor=1) # add boundary points
tf = TF(
Profile(config['TF'], family='S', part='TF', nTF=nTF, obj='L', load=True))
#pf.plot(coils=pf.coil,label=False,plasma=False,current=True)
demo = DEMO()
demo.fill_part('Vessel')
demo.fill_part('Blanket')
#demo.fill_part('TF_Coil')
demo.plot_ports()
demo.plot_limiter()
pl.axis('off')
#tf.fill()
eq = EQ(sf, pf, dCoil=1.5, sigma=0, boundary=sf.get_sep(expand=1.2), n=1e3)
eq.gen_opp()
inv = INV(sf, eq, tf)
inv.fix_boundary_psi(N=25, alpha=1 - 1e-4, factor=1) # add boundary points
#inv.fix['r'] -= 0.01
inv.initialize_log()
#inv.get_weight()
eq.fit(inv, N=3)
'''
for _ in range(3):
inv.update_coils()
inv.set_background()
sns.set(context='paper',style='white',font='sans-serif',palette='Set2',
font_scale=7/8,rc=rc)
Color = cycle(sns.color_palette('Set2'))
pkl = PKL('DEMO_SN54')
nTF = 16
config = {'TF':'SN','eq':'DEMO_SN'}
setup = Setup(config['eq'])
sf = SF(setup.filename)
rb = RB(setup,sf)
pf = PF(sf.eqdsk)
tf = TF(Profile(config['TF'],family='S',part='TF',nTF=nTF,obj='L',load=True))
eq = EQ(sf,pf,dCoil=2.0,sigma=0,boundary=sf.get_sep(expand=1.5),n=1e4)
eq.gen_opp()
inv = INV(sf,eq,tf)
Lpf = inv.grid_PF(nPF=4)
Lcs = inv.grid_CS(nCS=3,Zbound=[-8.2,11],gap=0.1)
Lo = np.append(Lpf,Lcs)
inv.update_coils()
inv.fit_PF(offset=0.3) # fit PF coils to TF
inv.fix_boundary_psi(N=25,alpha=1-1e-4,factor=1) # add boundary points
inv.fix_boundary_feild(N=25,alpha=1-1e-4,factor=1) # add boundary points
inv.add_null(factor=1,point=sf.Xpoint)
inv.set_swing()
profile = Profile(config['TF'], family='S', part='TF', nTF=nTF, obj='L')
tf = TF(profile=profile)
#pf.plot(coils=pf.coil,label=False,plasma=False,current=True)
demo = DEMO()
demo.fill_part('Vessel')
demo.fill_part('Blanket')
#demo.fill_part('TF_Coil')
demo.plot_ports()
demo.plot_limiter()
pl.axis('off')
tf.fill()
eq = EQ(sf, pf, dCoil=1.5, sigma=0, boundary=sf.get_sep(expand=1.5), n=5e3)
eq.gen_opp()
'''
inv = INV(sf,eq,tf)
L = inv.grid_coils(offset=0.3)
inv.fix_boundary_psi(N=25,alpha=1-1e-4,factor=1) # add boundary points
inv.fix_boundary_feild(N=25,alpha=1-1e-4,factor=1) # add boundary points
inv.add_null(factor=1,point=sf.Xpoint)
inv.set_swing(width=250)
inv.initialize_log()
inv.set_background()
inv.get_weight()
inv.set_Lo(L) # set position bounds
Lnorm = loops.normalize_variables(inv.Lo)
inv.update_position(Lnorm,update_area=True)
'lines.linewidth':2}
sns.set(context='talk',style='white',font='sans-serif',palette='Set2',
font_scale=7/8,rc=rc)
nTF,nPF,nCS = 18,4,3
config = {'TF':'dtt','eq':'SN'}
config,setup = select(config,nTF=nTF,nPF=nPF,nCS=nCS,update=False)
profile = Profile(config['TF'],family='S',part='TF',
nTF=nTF,obj='L',load=True,npoints=50)
sf = SF(setup.filename)
tf = TF(profile,sf=sf)
tf.fill()
#rb = RB(setup,sf)
pf = PF(sf.eqdsk)
eq = EQ(sf,pf,boundary=tf.get_loop(expand=0.5),n=1e3,sigma=0)
eq.get_plasma_coil()
ff = force_feild(pf.index,pf.coil,eq.coil,eq.plasma_coil)
#eq.run()
#eq.plotj()
#pf.coil['Coil6']['r'] -= 1.5
#eq.coils()
#eq.gen_opp(sf.Mpoint[1])
#eq.resample()
#eq.plotb(alpha=1)
#inv = INV(sf,pf,eq)
pf.plot(coils=eq.coil,label=False,plasma=True,current=False,alpha=0.5)
#inv.plot_coils()
from nova import loops import scipy.optimize as op from amigo.addtext import linelabel from nova.loops import Profile config = 'SN' setup = Setup(config) sf = SF(setup.filename) rb = RB(setup, sf) pf = PF(sf.eqdsk) profile = Profile(config, family='S', part='TF', nTF=18, objective='L') tf = TF(profile) eq = EQ(sf, pf, dCoil=2.5, sigma=0, boundary=sf.get_sep(expand=0.5), n=5e2) eq.get_plasma_coil() eq.run(update=False) inv = INV(sf, eq, tf) inv.initialize_log() Lpf = inv.grid_PF(nPF=5) Lcs = inv.grid_CS(nCS=5) Lo = np.append(Lpf, Lcs) inv.update_coils() inv.fit_PF(offset=0.3) inv.fix_boundary_psi(N=31, alpha=1 - 1e-4, factor=1) # add boundary points #inv.fix_boundary_feild(N=11,alpha=1-1e-4,factor=1) # add boundary points
palette='Set2',
font_scale=7 / 8,
rc=rc)
config = 'DEMO_SN'
setup = Setup(config)
sf = SF(setup.filename)
sf.get_boundary(plot=True)
config = 'DEMO_SNb'
setup = Setup(config)
sf = SF(setup.filename)
sf.get_boundary(plot=True)
pf = PF(sf.eqdsk)
eq = EQ(sf, pf, limit=[4.5, 14.5, -8, 8], n=1e4)
rb = RB(setup, sf)
#sf.contour(plot_vac=True)
#sf.get_legs(debug=True)
rb.set_firstwall(sf.eqdsk['xlim'], sf.eqdsk['ylim'])
pl.plot(rb.Rb, rb.Zb)
sf.sol(dr=3e-3)
rb.get_sol(plot=True)
pl.plot(sf.eqdsk['xlim'], sf.eqdsk['ylim'])
r = demo.parts['Vessel']['r'] # set vessel boundary
z = demo.parts['Vessel']['z']