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 __init__(self,profile,eqconf='unset',sep='unset',**kwargs):
self.ny = kwargs.get('ny',3) # TF filament number (y-dir)
self.alpha = kwargs.get('alpha',1-1e-4)
self.color = cycle(sns.color_palette('Set2',10))
self.profile = profile
self.loop = self.profile.loop
self.bound = {} # initalise bounds
self.bindex = {'internal':[0],'interior':[0],'external':[0]} # index
for side in ['internal','interior','external']:
self.bound[side] = {'r':[],'z':[]}
if side in kwargs:
self.add_bound(kwargs[side],side)
if self.profile.nTF is not 'unset' and \
(eqconf is not 'unset' or sep is not 'unset'):
if eqconf is not 'unset':
plasma = {'config':eqconf}
sf = SF(Setup(eqconf).filename)
self.tf = TF(profile=self.profile,sf=sf)
else:
plasma = {'r':sep['r'],'z':sep['z']}
self.tf = TF(profile=self.profile)
self.cage = coil_cage(nTF=self.profile.nTF,rc=self.tf.rc,
plasma=plasma,ny=self.ny,alpha=self.alpha)
x = self.tf.get_loops(self.loop.draw())
self.cage.set_TFcoil(x['cl'],smooth=False)
else:
if self.profile.obj is 'E':
errtxt = 'nTF and SFconfig keywords not set\n'
errtxt += 'unable to calculate stored energy\n'
errtxt += 'initalise with \'nTF\' keyword'
raise ValueError(errtxt)
def load_sf(self, eq_names):
sf_dict, sf_list = OrderedDict(), []
for configuration in eq_names:
sf = SF(Setup(configuration).filename)
sf_dict[configuration] = sf.filename.split('/')[-1]
sf_list.append(sf)
self.config['eqdsk'] = sf_dict
return sf_list
def get_seperatrix(self, nplasma=80, alpha=1 - 1e-4, plot=False, **kwargs):
self.nplasma = nplasma
self.plasma_loop = np.zeros((self.nplasma, 3)) # initalise loop array
if 'sf' in kwargs or 'setup' in kwargs or 'config' in kwargs:
if 'sf' in kwargs: # seperatrix directly from sf object
sf = kwargs['sf']
elif 'setup' in kwargs:
setup = kwargs.get('setup')
sf = SF(setup.filename)
elif 'config' in kwargs:
setup = Setup(kwargs.get('config'))
sf = SF(setup.filename)
r, z = sf.get_boundary(alpha=alpha)
self.eqdsk = sf.eqdsk
self.LFP = np.array([sf.LFPr, sf.LFPz])
else:
if 'eqdsk' in kwargs: # seperatrix from eqdsk
self.eqdsk = geqdsk.read(kwargs.get('eqdsk'))
r, z = self.eqdsk['rbdry'], self.eqdsk['zbdry']
elif 'r' in kwargs and 'z' in kwargs: # separatrix from input
r, z = kwargs.get('r'), kwargs.get('z')
self.eqdsk = {
'rcentr': 9.0735,
'zmagx': 0.15295,
'bcentr': -5.6211
}
LFindex = np.argmax(r)
self.LFP = np.array([r[LFindex], z[LFindex]])
if not hasattr(self, 'eqdsk'):
errtxt = '\n'
errtxt += 'Require plasma={} input of following types:\n'
errtxt += '1) configuration flag, {\'config\':\'SN\'} \n'
errtxt += '2) eqdsk file, {\'eqdsk\':\'\'} \n'
errtxt += '3) seperatrix profile, {\'r\':[],\'z\':[]}'
raise ValueError(errtxt)
r, z = geom.clock(r, z)
(self.plasma_loop[:,0],self.plasma_loop[:,2]) = \
geom.rzSLine(r,z,npoints=self.nplasma)
self.plasma_length = geom.length(self.plasma_loop[:, 0],
self.plasma_loop[:, 2])
rfun, zfun = geom.rzfun(r, z)
self.plasma_interp = {'r': rfun, 'z': zfun}
if plot:
pl.plot(self.plasma_loop[:, 0], self.plasma_loop[:, 2])
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()
from nova.firstwall import main_chamber
from nova.shape import Shape
import seaborn as sns
sns.set(context='talk', style='white', font='sans-serif', font_scale=7 / 8)
Color = cycle(sns.color_palette('Set2'))
pkl = PKL('SXdev', directory='../../Movies/')
name = 'SX'
nTF, ripple = 18, True
base = {'TF': 'dtt', 'eq': 'DTT_SN', 'name': name}
config, setup = select(base, nTF=nTF, update=False)
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,
'savefig.pad_inches': 0.1,
'lines.linewidth': 0.75
}
sns.set(context='paper',
style='white',
font='sans-serif',
palette='Set2',
font_scale=7 / 8,
rc=rc)
Color = cycle(sns.color_palette('Set2'))
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()
ax[i][j].axis('equal')
#ax[i][j].set_xlim([2.6000000000000001, 17.699999999999999])
#ax[i][j].set_ylim([-14.292150967273809, 9.0768966517738079])
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,
from nova.loops import Profile
import seaborn as sns
rc = {'figure.figsize':[7*10/16,7],'savefig.dpi':150, #*12/16
'savefig.jpeg_quality':100,'savefig.pad_inches':0.1,
'lines.linewidth':0.75}
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()
'figure.figsize': [7, 7 * 16 / 12],
'savefig.dpi': 125, #
'savefig.jpeg_quality': 200,
'savefig.pad_inches': 0.1,
'lines.linewidth': 1.5
}
sns.set(context='talk',
style='white',
font='sans-serif',
palette='Set2',
font_scale=7 / 8,
rc=rc)
color = sns.color_palette('Set2', 5)
config, setup = select(base={'TF': 'dtt', 'eq': 'DEMO_FW_SOF'}, nTF=18)
sf = SF(setup.filename)
pf = PF(sf.eqdsk)
pf.plot(coils=pf.coil, label=True, plasma=False, current=True)
levels = sf.contour(plot_vac=False)
rb = RB(setup, sf)
rb.firstwall(plot=True, debug=False, color=color[1])
rb.trim_sol()
filename = trim_dir('../../Data/') + 'CATIA_FW.xlsx'
wb = load_workbook(filename=filename, read_only=True, data_only=True)
ws = wb[wb.get_sheet_names()[0]]
FW = {}
for col, var in zip([5, 6], ['r', 'z']):
row = ws.columns[col]
FW[var] = np.zeros(len(row) - 1)
'savefig.pad_inches': 0.1,
'lines.linewidth': 0.75
}
sns.set(context='paper',
style='white',
font='sans-serif',
palette='Set2',
font_scale=7 / 8,
rc=rc)
Color = cycle(sns.color_palette('Set2'))
#base = {'TF':'dtt','eq':'SN'}
base = {'TF': 'dtt', 'eq': 'SN2014_EOF'}
#config,setup = select(base={'TF':'dtt','eq':'SN2014_EOF'},nTF=18)
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,
}
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('moveSX_Dev3')
nPF, nCS, nTF = 4, 3, 18
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)
from itertools import cycle import numpy as np from nova.radial_build import RB from nova.shelf import PKL import nova.cross_coil as cc from nova.coils import PF, TF from time import time 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)
date = '2017_03_10'
elif machine == 'dtt':
eq_names = ['DTT_SN']
date = '2017_03_08'
else:
raise ValueError('list machine type')
mc = main_chamber(machine,date=date)
mc.generate(eq_names,psi_n=1.07,flux_fit=True,plot=False,symetric=False)
mc.load_data(plot=False) # load from file
mc.shp.plot_bounds()
config = {'TF':machine,'eq':eq_names[0]}
config,setup = select(config,nTF=nTF,update=False)
sf = SF(setup.filename)
sf.contour()
rb = RB(sf,setup)
rb.generate(mc,plot=True,DN=False,debug=False)
rb.get_sol(plot=True)
#pl.plot(rb.segment['divertor']['r'],rb.segment['divertor']['z'])
profile = Profile(config['TF'],family='S',part='TF',nTF=nTF,obj='L')
shp = Shape(profile,eqconf=config['eq'],ny=3)
shp.add_vessel(rb.segment['vessel_outer'])
#shp.minimise(ripple=ripple,verbose=True)
font_scale=7 / 8,
rc=rc)
#config,setup = select(base={'TF':'dtt','eq':'SN'},nTF=18,nPF=5,nCS=3)
#config,setup = select(base={'TF':'dtt','eq':'SX'},nTF=18,nPF=5,nCS=3)
#config,setup = select(base={'TF':'dtt','eq':'DEMO_FW_SOF'},nTF=18)
#config,setup = select(base={'TF':'dtt','eq':'SN2014_EOF'},nTF=18)
setup.firstwall['flux_fit'] = False
if 'DN' in setup.configuration:
DN = True
else:
DN = False
sf = SF(setup.filename)
sf.shape_parameters() #verbose=True
#pf = PF(sf.eqdsk)
eq_names = ['DEMO_SN_SOF', 'DEMO_SN_EOF']
mc = main_chamber('DTT') # ,date='2017_03_03'
mc.generate(eq_names, psi_n=1.07, flux_fit=True, debug=True)
mc.load_data()
mc.draw(True)
#target = targets(sf,setup.targets)
#target.place(debug=True)
'''
import seaborn as sns
rc = {
'figure.figsize': [7 * 10 / 16, 7],
'savefig.dpi': 250, #*12/16
'savefig.jpeg_quality': 100,
'savefig.pad_inches': 0.1,
'lines.linewidth': 1
}
sns.set(context='poster',
style='white',
font='sans-serif',
palette='Set2',
font_scale=0.75,
rc=rc)
Color = cycle(sns.color_palette('Set2'))
text = linelabel(Ndiv=20, value='')
nTF = 18
for eq in ['DEMO_SN_SOF', 'DEMO_SN_EOF']:
config = {'TF': 'demo', 'eq': eq}
config, setup = select(config, nTF=nTF, update=False)
sf = SF(setup.filename)
sf.get_boundary(plot=True, alpha=1 - 1e-5)
text.add(eq)
sf.sol(plot=True)
text.plot()
pl.axis('equal')
pl.axis('off')
'lines.linewidth': 0.75
}
sns.set(context='paper',
style='white',
font='sans-serif',
palette='Set2',
font_scale=7 / 8,
rc=rc)
Color = cycle(sns.color_palette('Set2'))
base = {'TF': 'dtt', 'eq': 'DN'}
config, setup = select(base=base, update=False, nTF=18, nPF=4, nCS=3)
config['TF'] = config['TF'].replace('DN', 'SN')
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,
from amigo import geom
rc = {'figure.figsize':[8*10/16,8],'savefig.dpi':150, #*12/16
'savefig.jpeg_quality':100,'savefig.pad_inches':0.1,
'lines.linewidth':0.75}
sns.set(context='paper',style='white',font='sans-serif',palette='Set2',
font_scale=7/8,rc=rc)
nTF = 16
config = {'TF':'SN','eq':'DEMO_SNb'}
profile = Profile(config['TF'],family='S',load=True,part='TF',
nTF=nTF,obj='L',npoints=250)
setup = Setup(config['eq'])
sf = SF(setup.filename)
tf = TF(profile,sf=sf)
pf = PF(sf.eqdsk)
rb = RB(setup,sf)
cage = coil_cage(nTF=nTF,rc=tf.rc,plasma={'config':config['eq']},coil=tf.x['cl'])
demo = DEMO()
demo.fill_part('Vessel')
demo.fill_part('Blanket')
demo.fill_part('TF_Coil')
demo.plot_ports()
demo.plot_limiter()
sf.contour(Nlevel=51,plot_vac=False,lw=0.5)
pl.plot(sf.rbdry,sf.zbdry,color=0.75*np.ones(3),lw=1)
import pylab as pl
from nova.shelf import PKL
import seaborn as sns
rc = {'figure.figsize':[7*10/16,7],'savefig.dpi':150, #*12/16
'savefig.jpeg_quality':100,'savefig.pad_inches':0.1,
'lines.linewidth':0.75}
sns.set(context='paper',style='white',font='sans-serif',palette='Set2',
font_scale=7/8,rc=rc)
Color = cycle(sns.color_palette('Set2'))
base = {'TF':'dtt','eq':'SN','label':'SX'}
config,setup = select(base=base,update=False,nTF=18,nPF=5,nCS=3)
sf = SF(setup.filename)
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=2e4,
boundary=sf.get_sep(expand=1.1),zmin=sf.Xpoint[1]-6)
eq.gen_opp()
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()
'savefig.pad_inches': 0.1,
'lines.linewidth': 0.75
}
sns.set(context='paper',
style='white',
font='sans-serif',
palette='Set2',
font_scale=7 / 8,
rc=rc)
Color = cycle(sns.color_palette('Set2'))
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()
'lines.linewidth': 1.5
}
sns.set(context='talk',
style='white',
font='sans-serif',
palette='Set2',
font_scale=7 / 8,
rc=rc)
nPF, nTF = 3, 18
config = {'TF': 'SN_dtt', 'eq': 'SN_{:d}PF_{:d}TF'.format(nPF, nTF)}
config = {'TF': 'SN_dtt', 'eq': 'DEMO_SNb'}
setup = Setup(config['eq'])
sf = SF(setup.filename)
pf = PF(sf.eqdsk)
pf.plot(coils=pf.coil, label=True, plasma=False, current=True)
levels = sf.contour()
rb = RB(setup, sf)
rb.firstwall(plot=False, debug=False)
profile = Profile(config['TF'],
family='S',
part='TF',
nTF=18,
obj='L',
load=True)
def get_boundary(filename, alpha=1e-3):
sf = SF(filename)
r, z = sf.get_boundary(alpha=alpha)
return r, z
tf = TF(R=X[:,0],Z=X[:,2])
tf.energy(nTF,Iturn=134*68e3)
pl.plot(tf.Rmid,tf.Zmid)
'''
#setup = Setup('SN')
#sf = SF(setup.filename)
#eq = EQ(sf,pf,sigma=0.2,boundary=rb.get_fw(expand=0.25),n=7.5e4)
#eq.plotj(trim=True)
#pl.plot(sf.rbdry,sf.zbdry,color=0.75*np.ones(3),lw=1.5)
for conf in ['SN', 'X', 'SFm', 'SX', 'SXex']: #
print(conf)
setup = Setup(conf)
sf = SF(setup.filename)
pf = PF(sf.eqdsk)
rb = RB(setup, sf)
rb.firstwall(calc=False, plot=True, debug=False)
rb.vessel()
pf.plot(coils=pf.coil, label=True, plasma=False, current=False)
tf = TF(nTF=18,
shape={
'vessel': rb.loop,
'pf': pf,
'fit': False,
'setup': setup,
'plot': True,
'config': conf,
'coil_type': 'A'
})
'figure.figsize': [8 * 12 / 16, 8],
'savefig.dpi': 120, #
'savefig.jpeg_quality': 100,
'savefig.pad_inches': 0.1,
'lines.linewidth': 2
}
sns.set(context='talk',
style='white',
font='sans-serif',
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'])
