def manual_genboundary(bspec,**kw):
kwp = sd(kw,**bspec);
getkw = mk_getkw(kwp,outletdefaults,prefer_passed = True);
btype = getkw("type");
lims = getkw('lim');
di = dict();
for dim,lim in zip(all_lims,lims):
di[dim] = lim;
if btype == 'outlet':
model = getkw('model');
di['label']= getkw('label');
di['phase_velocity'] = getkw('phase_velocity');
if model == 'none':
ret = outlet_none_tmpl.format(**di);
elif model == 'potential':
di = sd(manbounds_defs,**di);
if not test(di,'connection_rank'):
di['connection_rank'] ='';
else:
di['connection_rank'] = 'connection_rank {}'.format(
getkw('connection_rank'));
if not test(kwp,'voltage_measurement'):
di['voltage_measurement'] = '';
else:
raise NotImplementedError("haven't got to this yet...");
di['circuit'] = di['circuit'];
ret = outlet_pot_tmpl.format(**di);
elif model == 'laser':
raise NotImplementedError("need to implement the laser...");
else:
raise ValueError("unknown outlet model {}".format(model));
else:
raise NotImplementedError("yeah...");
return ret;
def genregions(**kw):
def getkw(l,scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = region_defaults[l];
if scale:
return [scale*i for i in ret];
return ret;
regsplit_dir, subdivs = getkw('region_split');
nonsplits = [x for x in ['x','y','z']
if x != regsplit_dir ];
limkw = [x+lims
for x in ['x','y','z']
for lims in ['min','max']];
lims = {k:lim for k,lim in zip(limkw,getkw('lims'))};
total_doms = getkw('domains');
doms = [total_doms//subdivs for i in range(subdivs)];
doms[-1] += total_doms % subdivs;
lmn,lmx = regsplit_dir+'min', regsplit_dir+'max';
mn,mx = lims[lmn],lims[lmx]
edges = [mn+i*(mx-mn)/subdivs
for i in range(subdivs)] + [mx];
mins = edges[:-1];
maxs = edges[1:];
reg = sd(lims,split=getkw("split_dir").upper+"SPLIT")
regions = [ sd(reg,**{lmn:mn,lmx:mx,'i':i,'domains':di})
for i,(mn,mx,di) in enumerate(zip(mins,maxs,doms)) ];
return mkregion_str(regions);
def gendats(di,
w0=w0*1e2,
width=0.46e-4,
L=0.043e-4,
N0=1.08e22,
depth=0.086e-4,
mindensity=1e18,
dat_xres=None,
new=False):
if new:
mkpinprick = mk45_pinprick_plasma
else:
mkpinprick = mk45_pinprick_plasma_old
targ_plasma, targ_neutral = mkpinprick(
dim = [i*1e-4 for i in d['tlim']],
N0 = N0,
laser_radius = w0,
width = width,
L = L,# 43nm
depth = depth, #chosen arbitrarily
mindensity=mindensity);
if not dat_xres:
dat_xres = di['res'][0]+1;
print("making targets for {}".format(di['pbsbase']));
dd = sd(di, f_2D = targ_plasma, dat_xres = dat_xres);
dat = gendat(**dd);
savetxt(
"{}/{}".format(di['pbsbase'],'target_plasma.dat'),
dat);
dd = sd(d, f_2D = targ_neutral, dat_xres = dat_xres);
dat = gendat(**dd);
savetxt(
"{}/{}".format(di['pbsbase'],'target_neutral.dat'),
dat);
def genregions(**kw):
def getkw(l, scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = region_defaults[l]
if scale:
return [scale * i for i in ret]
return ret
regsplit_dir, subdivs = getkw("region_split")
nonsplits = [x for x in ["x", "y", "z"] if x != regsplit_dir]
limkw = [x + lims for x in ["x", "y", "z"] for lims in ["min", "max"]]
lims = {k: lim for k, lim in zip(limkw, getkw("lims"))}
total_doms = getkw("domains")
doms = [total_doms // subdivs for i in range(subdivs)]
doms[-1] += total_doms % subdivs
lmn, lmx = regsplit_dir + "min", regsplit_dir + "max"
mn, mx = lims[lmn], lims[lmx]
edges = [mn + i * (mx - mn) / subdivs for i in range(subdivs)] + [mx]
mins = edges[:-1]
maxs = edges[1:]
reg = sd(lims, split=getkw("split_dir").upper + "SPLIT")
regions = [
sd(reg, **{lmn: mn, lmx: mx, "i": i, "domains": di}) for i, (mn, mx, di) in enumerate(zip(mins, maxs, doms))
]
return mkregion_str(regions)
def gendats(di,
h = 0.2e-4,
w = 0.66e-4,
spacing=0.66e-4,
width=0.45e-4,
N0=1.08e22,
targw=450e-7,
datfmt="%.4e",
dat_xres=None):
targ_plasma = mkgrate(
N0=N0,
spacing=spacing,
w=w,
h=h);
targ_neutral = mk45dum(
N0=N0,
width=targw);
print("making targets for {}".format(di['pbsbase']));
if not dat_xres:
dat_xres = di['res'][0]+1;
dd = sd(di, f_2D = targ_plasma, dat_xres = dat_xres,datfmt=datfmt);
dat = gendat(**dd);
savetxt(
"{}/{}".format(di['pbsbase'],'target_plasma.dat'),
dat);
dd = sd(d, f_2D = targ_neutral, dat_xres = dat_xres,datfmt=datfmt);
dat = gendat(**dd);
savetxt(
"{}/{}".format(di['pbsbase'],'target_neutral.dat'),
dat);
def mk_hpcmp_pbses(pbsbase='hotwater3d_tmpl',**kw):
hpcmp_defpbs = sd(kw,
pbsbase = pbsbase,
pbsname = pbsbase+'_oakley',
cluster = 'oakley',
concurrents=None,
queue = None,
ppn = None,);
return [
dict(
pbsname=pbsbase),
dict(
pbsname = pbsbase+'_oakley_autos',
cluster = 'oakley',),
hpcmp_defpbs,
sd(
hpcmp_defpbs,
pbsname=pbsbase+"_garnet",
cluster='garnet',
queue='standard_lw'),
sd(
hpcmp_defpbs,
pbsname=pbsbase+"_garnet_sm",
cluster='garnet',
queue='standard_sm',
walltime=24),
sd(
hpcmp_defpbs,
pbsname=pbsbase+"_garnet_48",
cluster="garnet",
queue="standard_lw",
walltime=48),
sd(
hpcmp_defpbs,
pbsname=pbsbase+"_garnet_debug",
cluster='garnet',
queue='debug',),
sd(
hpcmp_defpbs,
pbsname=pbsbase+"_armstrong",
cluster='armstrong',
queue='standard'),
sd(
hpcmp_defpbs,
pbsname=pbsbase+"_armstrong_debug",
cluster='armstrong',
queue='debug'),
sd(
hpcmp_defpbs,
pbsname=pbsbase+"_armstrong_48",
cluster='armstrong',
queue='standard',
walltime=48),
sd(
hpcmp_defpbs,
pbsname=pbsbase+"_armstrong_14",
cluster='armstrong',
queue='standard',
walltime=14),
];
def mk_hpcmp_pbses(pbsbase='hotwater3d_tmpl', **kw):
hpcmp_defpbs = sd(
kw,
pbsbase=pbsbase,
pbsname=pbsbase + '_oakley',
cluster='oakley',
concurrents=None,
queue=None,
ppn=None,
)
return [
dict(pbsname=pbsbase),
dict(
pbsname=pbsbase + '_oakley_autos',
cluster='oakley',
),
hpcmp_defpbs,
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet",
cluster='garnet',
queue='standard_lw'),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet_sm",
cluster='garnet',
queue='standard_sm',
walltime=24),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet_48",
cluster="garnet",
queue="standard_lw",
walltime=48),
sd(
hpcmp_defpbs,
pbsname=pbsbase + "_garnet_debug",
cluster='garnet',
queue='debug',
),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong",
cluster='armstrong',
queue='standard'),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong_debug",
cluster='armstrong',
queue='debug'),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong_48",
cluster='armstrong',
queue='standard',
walltime=48),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong_14",
cluster='armstrong',
queue='standard',
walltime=14),
]
def genregions(**kw):
def getkw(l, scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = region_defaults[l]
if scale:
return [scale * i for i in ret]
return ret
regsplit_dir, subdivs = getkw('region_split')
nonsplits = [x for x in ['x', 'y', 'z'] if x != regsplit_dir]
limkw = [x + lims for x in ['x', 'y', 'z'] for lims in ['min', 'max']]
lims = {k: lim
for k, lim in zip(limkw, getkw('lim', scale=1e-4))}
total_doms = getkw('domains')
doms = [total_doms // subdivs for i in range(subdivs)]
doms[-1] += total_doms % subdivs
lmn, lmx = regsplit_dir + 'min', regsplit_dir + 'max'
mn, mx = lims[lmn], lims[lmx]
edges = [mn + i * (mx - mn) / subdivs for i in range(subdivs)] + [mx]
split_cells = getkw(getkw("region_dom_split") + "cells")
mins = edges[:-1]
maxs = edges[1:]
if test(kw, "xcells") and test(kw, "ycells") and test(kw, "zcells"):
zcells_per_region = [kw['zcells'] // subdivs for i in range(subdivs)]
zcells_per_region[-1] += kw['zcells'] % subdivs
cellses = [
kw['xcells'] * kw['ycells'] * zc
for i, zc in enumerate(zcells_per_region)
]
else:
cellses = [None for i in range(subdivs)]
reg = sd(lims, split=getkw("region_dom_split").upper() + "SPLIT")
regions = [
sd(reg, **{
lmn: mn,
lmx: mx,
'i': i + 1,
'domains': di,
'cells': cells
})
for i, (mn, mx, di, cells) in enumerate(zip(mins, maxs, doms, cellses))
]
return mkregion_str(regions, split_cells=split_cells)
def mksim(pbsbase, **d):
print("making {}".format(pbsbase))
myd = sd(lsp_d, **d)
lsp = genlsp(**myd)
pbs = genpbs(pbsbase=pbsbase)
pbs = re.sub("../scripts/autozipper", "../../scripts/autozipper", pbs)
output(lsp, pbs, pbsbase, dats=["sine700points.dat", myd["targetdat"]], dir=pbsbase)
def mksim(pbsbase,**d):
print("making {}".format(pbsbase));
myd = sd(lsp_d, **d);
lsp=genlsp(**myd);
#two color hack
if test(myd, 'relative_phase'):
relative_phases="phase {}".format(myd['relative_phase'])
else:
relative_phases=''
lasers = '''
laser
wavelength 780e-7
spotsize 2.17e-4
laser
amplitude 0.36
wavelength 390e-7
{phase}
end
'''.format(phase=relative_phases);
if test(myd, 'two_colors'):
lsp = re.sub(r'type *19.*','type 85',lsp);
lsp = re.sub(r' *; *\\lambda *spotsize','',lsp);
lsp = re.sub('.*coefficients 7.80*e-03.*$', lasers,lsp,flags=re.MULTILINE);
pbs=genpbs(pbsbase=pbsbase,domains=myd['domains']);
pbs = re.sub("../scripts/autozipper","../../scripts/autozipper",pbs);
pbs = re.sub("lsp-10-xy","lsp-10-xy-multilaser",pbs);
output(lsp,pbs,pbsbase,
dats=["sine700points.dat", myd['targetdat']],
dir=pbsbase);
def gendat3d(
di,
w0=w0*1e2,
width=0.46e-4,
L=0.043e-4,
N0=1.08e22,
mindensity=1e18,
dat_xres=None,
dat_zres=4,#works for no z variation
fmt='%.4e'
):
targ_neutral = mk45_pinprick_neutral3d(
dim = [i*1e-4 for i in d['tlim']],
N0 = N0,
laser_radius = w0,
width = width,
L = L,# 43nm
mindensity=mindensity);
if not dat_xres:
dat_xres = di['res'][0]+1;
print("making targets for {}".format(di['pbsbase']));
dd = sd(di, f_3D = targ_neutral, dat_xres = dat_xres);
dat = gendat(dat_zres=dat_zres,datfmt=fmt,**dd);
savetxt(
"{}/{}".format(di['pbsbase'],di['dens_dat']),
dat);
def genonescale(**kw):
getkw = mk_getkw(kw, onescale_defaults)
slen = getkw("solid_len")
xlen = getkw("xlen")
kw1 = sd(kw, tlim=(0.0, xlen) + (0.0, 0.0, 0.0, 0.0), sdim=(xlen - slen, xlen) + (0.0, 0.0, 0.0, 0.0))
kw1["f_1D"] = genf(**kw1)
return gentargetdat(**kw1)
def genoptions(**kw):
if test(kw,"options"):
kw = sd(kw,kw['options']);
#quirks
getkw_outer = mk_getkw(kw,lspdefaults);
kw['maximum_restart_dump_time'] = getkw_outer('restart')
def genopt(k,getkw=getkw_outer,flag=False):
if not flag: flag = k;
i = getkw(k);
if re.search("_ns$",flag):
if isvalue(i):
i*=1e9;
else:
scaletuple(i,1e9);
if i is None or i is ():
return "";
elif i is True:
return "{} ON\n".format(flag);
elif i is False:
return "{} OFF\n".format(flag);
elif isvalue(i):
return "{} {}\n".format(flag,i);
else:
return "{} {} end\n".format(flag,joinspace(i));
def genopts(opts):
title,opts = opts;
getkw = mk_getkw(kw,opts);
tmpl=";;{}\n{}\n"
all_opts = "".join([
genopt(k,getkw) for k in sorted(opts.keys()) ]);
return tmpl.format(title,all_opts);
out=''.join([
genopts(iopts)
for iopts in [restart_opts, balance_opts,]
]);
out+=options_dont_touch
out+=''.join([
genopts(iopts) for iopts in [kinematic_opts,dump_opts,]
]);
#now we do big dumps
kw['interval_ns'] = getkw_outer("dumpinterval");
kw['times_ns'] = getkw_outer("dumptimes");
kw['steps'] = getkw_outer("dumpsteps");
def gen_dumpopt(dump,opt):
label = "{}_dump_{}".format(dump,opt);
if test(kw, label):
return genopt(label);
else:
return genopt(opt,flag=label);
for dump in bigdumps:
if not getkw_outer("dump_{}".format(dump)) : continue;
out += "dump_{}s_flag ON\n".format(dump);
for iopt in ['interval_ns','times_ns','steps']:
out += gen_dumpopt(dump,iopt);
return out;
def mktarg(di):
dd = sd(di,
f_2D=mk45(dim=[i * 1e-4 for i in di['tlim']],
N0=1.0804e22,
width=0.46e-4,
dropcorners='round'),
dat_xres=di['res'][0])
dat = gendat(**dd)
savetxt("{}/{}".format(di['pbsbase'], di['dens_dat']), dat)
def firsthash_new(frame,**kw):
kw['new']=True;
kw['dupes']=None;
hashes = genhash(frame,**kw);
uni,counts = np.unique(hashes,return_counts=True);
d=sd(kw,dupes=uni[counts>1],removedupes=True);
dupei = np.in1d(hashes, d['dupes'])
hashes[dupei] = -1
return hashes, retd;
def mkscale_sim(**d):
datf = "water-{}.dat".format(d["dat"])
d = sd(scale_sim, **d)
d["targetdat"] = datf
d["description"] = "scale length sim with {}".format(d["dat"])
if not test(d, "name"):
name = "longl_l={}_{}".format(d["dat"], d["I"])
else:
name = d["name"]
mksim(name, **d)
def mkscale_sim(**d):
datf = "water-{}.dat".format(d['dat'])
d = sd(scale_sim, **d)
d['targetdat'] = datf
d['description'] = "scale length sim with {}".format(d['dat'])
if not test(d, "name"):
name = "longl_l={}_{}".format(d['dat'], d['I'])
else:
name = d['name']
mksim(name, **d)
def genonescale(**kw):
getkw=mk_getkw(kw,onescale_defaults);
slen = getkw("solid_len");
xlen = getkw("xlen");
kw1 = sd(
kw,
tlim=(0.0, xlen) + (0.0,0.0,0.0,0.0),
sdim= (xlen-slen, xlen) + (0.0,0.0,0.0,0.0));
kw1['f_1D']= genf(**kw1)
return gendat(**kw1);
def genonescale(**kw):
getkw=mk_getkw(kw,onescale_defaults);
slen = getkw("solid_len");
xlen = getkw("xlen");
kw1 = sd(
kw,
tlim=(0.0, xlen) + (0.0,0.0,0.0,0.0),
sdim= (xlen-slen, xlen) + (0.0,0.0,0.0,0.0));
kw1['f_1D']= genf(**kw1)
return gendat(**kw1);
def mksim(pbsbase,**d):
print("making {}".format(pbsbase));
myd = sd(lsp_d, **d);
lsp=genlsp(**myd);
#making for different servers
pbses=dict(
oakley=genpbs(
pbsbase=pbsbase,
domains=myd['domains'],
cluster='oakley'),
garnet_debug=genpbs(
pbsbase=pbsbase,
domains=myd['domains'],
cluster='garnet',
queue='debug'),
garnet_debug_mem=genpbs(
pbsbase=pbsbase,
domains=myd['domains'],
cluster='garnet',
ppn=16,
queue='debug'),
garnet=genpbs(
pbsbase=pbsbase,
domains=myd['domains'],
cluster='garnet',
queue='standard_lw'),
garnet_short=genpbs(
pbsbase=pbsbase,
domains=myd['domains'],
cluster='garnet',
walltime=48,
queue='standard_lw'),
garnet_mem=genpbs(
pbsbase=pbsbase,
domains=myd['domains'],
cluster='garnet',
ppn=16,
queue='standard_lw'),
);
mkdir(pbsbase);
auxs = [
"sine700points.dat", myd['targetdat'],
"autozipper"
];
for aux in auxs:
sh.copy(aux, pbsbase);
pbsbase = "{0}/{0}".format(pbsbase);
with open(pbsbase+".lsp","w") as f:
f.write(lsp);
for pbsk in pbses:
fname = "{}_{}.pbs".format(
pbsbase,pbsk);
with open(fname,"w") as f:
f.write(pbses[pbsk]);
def genregions(**kw):
def getkw(l,scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = region_defaults[l];
if scale:
return [scale*i for i in ret];
return ret;
regsplit_dir, subdivs = getkw('region_split');
nonsplits = [x for x in ['x','y','z']
if x != regsplit_dir ];
limkw = [x+lims
for x in ['x','y','z']
for lims in ['min','max']];
lims = {k:lim for k,lim in zip(limkw,getkw('lim',scale=1e-4))};
total_doms = getkw('domains');
doms = [total_doms//subdivs for i in range(subdivs)];
doms[-1] += total_doms % subdivs;
lmn,lmx = regsplit_dir+'min', regsplit_dir+'max';
mn,mx = lims[lmn],lims[lmx]
edges = [mn+i*(mx-mn)/subdivs
for i in range(subdivs)] + [mx];
split_cells = getkw(getkw("region_dom_split")+"cells");
mins = edges[:-1];
maxs = edges[1:];
if test(kw,"xcells") and test(kw,"ycells") and test(kw,"zcells"):
zcells_per_region = [kw['zcells']//subdivs
for i in range(subdivs)]
zcells_per_region[-1] += kw['zcells'] % subdivs;
cellses = [ kw['xcells']*kw['ycells']*zc
for i,zc in enumerate(zcells_per_region)];
else:
cellses = [None for i in range(subdivs)];
reg = sd(lims,split=getkw("region_dom_split").upper()+"SPLIT")
regions = [ sd(reg,**{lmn:mn,lmx:mx,'i':i+1,'domains':di,'cells':cells})
for i,(mn,mx,di,cells) in enumerate(zip(mins,maxs,doms,cellses)) ];
return mkregion_str(regions, split_cells=split_cells);
def mksim(pbsbase, **d):
print("making {}".format(pbsbase))
myd = sd(lsp_d, **d)
lsp = genlsp(**myd)
pbs = genpbs(pbsbase=pbsbase)
pbs = re.sub("../scripts/autozipper", "../../scripts/autozipper", pbs)
output(lsp,
pbs,
pbsbase,
dats=["sine700points.dat", myd['targetdat']],
dir=pbsbase)
def mktarg(di):
dd = sd(
di,
f_2D = mk45(
dim = [i*1e-4 for i in di['tlim']],
N0 = 1.0804e22,
width = 0.46e-4,
dropcorners='round'));
dat = gendat(**dd);
savetxt(
"{}/{}".format(di['pbsbase'],di['dens_dat']),
dat);
def genconductor_boundaries(**kw):
getkw=mk_getkw(kw, condb_defaults);
conductorss='';
for I,conductor in enumerate(getkw('conductors')):
cd = sd(condb_objdef, **conductor);
if test(cd,'from') and test(cd,'to'):
cd['xmin'],cd['ymin'],cd['zmin'] = cd['from']
cd['xmax'],cd['ymax'],cd['zmax'] = cd['to']
pass;
else:
outlet = cd['outlet'];
if outlet not in all_lims:
raise ValueError('Unknown outlet "{}"'.format(outlet));
coords = outlet_coords(outlet,kw);
cd['width']*=1e-4;
cd['start']*=1e-4;
sign = lambda outlet: 1.0 if outlet[-2:] == 'ax' else -1.0
coords[outlet] += sign(outlet)*(cd['width'] + cd['start']);
coords[otherside(outlet)] += sign(outlet)*cd['start'];
conductorss += condb_tmpl.format(
i=I+1,
**sd(cd,**coords));
return conductorss;
def mktarg(di):
tw = di['tlim'][1] - di['tlim'][0]
dat_xres= int(tw/(di['lim'][1]-di['lim'][0])*di['res'][0]);
dd = sd(
di,
f_2D = mkcircle(
dim = [i*1e-4 for i in di['tlim']],
No = 3.34e22,
Ni = 0.0,
ro = 5e-4,
ri = 3e-4),
dat_xres= dat_xres,
);
return gendat(**dd);
def gendatrot(
di,
w0=w0*1e2,
width=0.46e-4,
L=0.043e-4,
N0=1.08e22,
mindensity=1e18,
spotz_width=20e-4,
yres = 75,
fmt='%.4e',):
print("warning: this will only work for rot3d");
targ_neutral = mk0_pinprick_neutral3d(
N0 = N0,
spotz_width=spotz_width,
laser_radius = w0,
width = width,
L = L,# 43nm
mindensity=mindensity);
#manual hacks to save space
#generate cell sized samples around the corners.
# x's edge
def getsamples(point,lims,res,ndxs = 3):
out=np.linspace(lims[0]*1e-4,lims[1]*1e-4,res+1);
dx = out[1] - out[0];
out = out[ out >= point - ndxs*dx ];
out = out[ out <= point + ndxs*dx ];
return list(out);
def axissamples(half_width, tlim, lim, res,ndxs=3):
p = [ tlim[0] ] + getsamples(-half_width,lim,res,ndxs=ndxs)
p+= [0.0] + getsamples(half_width,lim,res,ndxs=ndxs)
p+= [ tlim[1] ];
return np.array(p);
x = axissamples(
w0, di['tlim'][0:2], di['lim'][0:2], di['res'][0]);
y = np.linspace(
di['tlim'][2]*1e-4,di['tlim'][3]*1e-4,yres+1);
z = axissamples(
spotz_width/2.0,
di['tlim'][4:6], di['lim'][4:6], di['res'][2]);
print("making targets for {}".format(di['pbsbase']));
X,Y,Z=np.meshgrid(x,y,z,indexing='ij');
Q=targ_neutral(X,Y,Z)
dd = sd(di, data3D =(x,y,z,Q), datfmt=fmt);
dat = gendat(**dd);
savetxt(
"{}/{}".format(di['pbsbase'],di['dens_dat']),
dat);
def genconductors(**kw):
getkw=mk_getkw(kw, condb_defaults);
conductorss='';
for I,conductor in enumerate(getkw('conductors')):
cd = sd(condb_objdef, **conductor);
coords=dict();
if test(cd,'outlet'):
outlet = cd['outlet'];
if outlet not in all_lims:
raise ValueError('Unknown outlet "{}"'.format(outlet));
coords = outlet_coords(outlet,kw);
cd['width']*=1e-4;
cd['start']*=1e-4;
if outlet[-2:] == 'ax':
sign = 1.0;
else:
sign =-1.0
cd['type']= 'BLOCK';
coords[outlet] += sign*(cd['width'] + cd['start']);
coords[otherside(outlet)] += sign*cd['start'];
cd['from'] = (coords['xmin'],coords['ymin'],coords['zmin']);
cd['to'] = (coords['xmax'],coords['ymax'],coords['zmax']);
conductorss += condf_tmpl.format(
i=I+1,
xf=cd['from'][0],yf=cd['from'][1],zf=cd['from'][2],
**cd);
def mk_to(cd):
'''generate the to's'''
return ''.join([
condt_tmpl.format(xt=xt,yt=yt,zt=zt)
for xt,yt,zt in cd['to'] ]);
if cd['type'] == 'BLOCK':
if type(cd['to']) == list: cd['to'] = cd['to'][0]
conductorss += condt_tmpl.format(
xt=cd['to'][0],yt=cd['to'][1],zt=cd['to'][2]);
elif cd['type'] == 'PARALLELPIPED':
conductorss += mk_to(cd);
elif cd['type'] == 'TRILATERAL':
conductorss += mk_to(cd);
conductorss += 'sweep_direction {sweep_direction}\n'.format(
**cd);
else:
raise ValueError(
"Unknown conductor type '{}'".format(cd['type']));
return conductorss;
def mktarg(di, No = 3.34e22, ro = 5e-4, L = 1e-4):
tw = di['tlim'][1] - di['tlim'][0]
dat_xres= int(tw/(di['lim'][1]-di['lim'][0])*di['res'][0]);
dd = sd(
di,
f_2D = fuzzcircle(
dim = [i*1e-4 for i in di['tlim']],
No = No,
ro = ro,
L = L,
prexp=True),
dat_xres= dat_xres,
);
dat = gendat(**dd);
savetxt(
"{}/{}".format(di['pbsbase'],di['dens_dat']),
dat);
def gendatclean(
di,
width=0.46e-4,
N0=1.08e22,
fmt='%.4e',):
targ_neutral = mk45_clean_neutral2d(
width=width,
N0 = N0,);
print("making targets for {}".format(di['pbsbase']));
dd = sd(di,
f_2D = targ_neutral,
dat_xres=di['res'][0]+1,
dat_yres=di['res'][0]+1);
dat = gendat(datfmt=fmt,**dd);
savetxt(
"{}/{}".format(di['pbsbase'],di['dens_dat']),
dat);
contour_quantities=('RhoN10', 'RhoN10'),
),
#pmovies
no_pmovies=True,
#particle dumps
dump_particle=True,
particle_dump_interval_ns=1e-15,
);
d2 = sd(d,
lim = (-25,25,
-25,25,
0,0),
tlim = (-20,20,
-20,20,
0,0),
res =(1600,
1600,
0),
pbsbase='prexp2',
region_split=('y',3),
domains=96,
totaltime=400e-15,
particle_dump_interval_ns=1e-15,);
gensim(**d);
gensim(**d2);
def mktarg(di, No = 3.34e22, ro = 5e-4, L = 1e-4):
tw = di['tlim'][1] - di['tlim'][0]
dat_xres= int(tw/(di['lim'][1]-di['lim'][0])*di['res'][0]);
dd = sd(
di,
queue='standard',
walltime=24),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong_36",
cluster='armstrong',
queue='standard',
walltime=36),
]
return dd
#crazy
Es = [40, 4, 0.4, 0.04, 0.004, 4e-4]
ratio = 1.5 / 0.78
for E in Es:
d = sd(fromenergy(E, l=50e-6, cycles=cycles), **defd)
d.update(
n_s=1e19,
solid_len=50,
expf=ratio * d['l'] / 1e-6,
lim=(-850, 50, -800, 800, 0, 0),
tlim=(-800, 0, -700, 700, 0, 0),
res=(18 * 32, 32 * 32, 0),
totaltime=d['T'] * 4.0,
timestep=5e-15,
description="50um laser in search of 100 MeV",
dumpinterval=10e-15,
#movne
movne={'clim': (1e15, 1e19)},
)
mkpbsbase(d)
def genlsp(**kw):
def getkw(l, scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = defaults[l]
if scale:
return [scale * i for i in ret]
return ret
E0 = np.sqrt(2 * getkw('I') * 1e4 / (c * e0)) * 1e-5
xmin, xmax, ymin, ymax, zmin, zmax = getkw('lim', scale=1e-4)
fp = joinspace(getkw("fp", scale=1e-4))
components = joinspace(getkw("components"))
phases = joinspace(getkw("phases"))
l = getkw('l') * 100.0
if test(kw, 'resd'):
xres, yres, zres = getkw("resd")
kw['xcells'] = (xmax - xmin) / (l / xres)
kw['ycells'] = (ymax - ymin) / (l / yres)
kw['zcells'] = (zmax - zmin) / (l / zres)
else:
kw['xcells'], kw['ycells'], kw['zcells'] = getkw("res")
xcells, ycells, zcells = kw['xcells'], kw['ycells'], kw['zcells']
w0 = getkw('w') * 100.0
T = getkw('T') * 1e9
txmin, txmax, tymin, tymax, tzmin, tzmax = getkw('tlim', scale=1e-4)
domains = getkw('domains')
# we have that na~l/(pi*w), and the f-number~1/2na, thus
# f-number ~ pi*w/2l
fnum = np.pi * w0 / 2 / l
totaltime = getkw('totaltime') * 1e9
timestep = getkw('timestep') * 1e9
couraunt = min(
((xmax - xmin) / xcells / c_cgs) * 1e9,
((ymax - ymin) / ycells / c_cgs) * 1e9,
((zmax - zmin) / zcells / c_cgs) * 1e9,
)
if timestep > couraunt:
import sys
sys.stderr.write("warning: timestep exceeds couraunt limit\n")
targetdat = getkw('targetdat')
dumpinterval = getkw('dumpinterval') * 1e9
description = getkw('description')
restart = getkw('restart')
pexts = genpext(**sd(kw, species=getkw('pext_species')))
if test(kw, "regions"):
regions = kw['regions']
else:
regions = genregions(**kw)
if not test(kw, "no_pmovies"):
pmovies = '''
particle_movie_interval_ns {dumpinterval}
particle_movie_components Q X Y Z VX VY VZ XI YI ZI
'''.format(dumpinterval=dumpinterval)
else:
pmovies = ''
restarts = "maximum_restart_dump_time {}".format(
restart) if restart else ""
with open("hotwater3d_tmpl.lsp") as f:
s = f.read()
s = s.format(
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax,
zmin=zmin,
zmax=zmax,
xcells=kw['xcells'],
ycells=kw['ycells'],
zcells=kw['zcells'],
l=l,
w0=w0,
E0=E0,
fnum=fnum,
targ_xmin=txmin,
targ_xmax=txmax,
targ_ymin=tymin,
targ_ymax=tymax,
targ_zmin=tzmin,
targ_zmax=tzmax,
fp=fp,
pulse=T,
components=components,
phases=phases,
intensity=getkw('I'),
pmovies=pmovies,
regions=regions,
pexts=pexts,
domains=domains,
totaltime=totaltime,
timestep=timestep,
targetdat=targetdat,
dumpinterval=dumpinterval,
description=description,
restarts=restarts,
)
return s
domains=1000;
region_split=('z',68);
pbsbase="flashic_3d";
defpbs = dict(
pbsbase=pbsbase,
pbsname=pbsbase+"_oakley",
domains=domains,
cluster='oakley',
autozipper=False,
queue=None,
ppn=None,);
pbses=[
defpbs,
sd(
defpbs,
pbsname=pbsbase+"_garnet_debug",
cluster='garnet',
queue='debug'),
sd(
defpbs,
pbsname=pbsbase+"_garnet",
cluster='garnet',
queue='standard_lw'),
sd(
defpbs,
pbsname=pbsbase+"_garnet_short",
cluster='garnet',
queue='standard_lw',
walltime=48),];
gensim(
l = 0.8e-6,
def genoptions(**kw):
if test(kw, "options"):
kw = sd(kw, kw['options'])
#quirks
getkw_outer = mk_getkw(kw, lspdefaults, prefer_passed=True)
kw['maximum_restart_dump_time'] = getkw_outer('restart')
def genopt(k, getkw=getkw_outer, flag=False):
if not flag: flag = k
i = getkw(k)
if re.search("_ns$", flag):
if isvalue(i):
i *= 1e9
else:
scaletuple(i, 1e9)
if i is None or i is ():
return ""
elif i is True:
return "{} ON\n".format(flag)
elif i is False:
return "{} OFF\n".format(flag)
elif isvalue(i):
return "{} {}\n".format(flag, i)
else:
return "{} {} end\n".format(flag, joinspace(i))
def genopts(opts):
title, opts = opts
getkw = mk_getkw(kw, opts, prefer_passed=True)
tmpl = ";;{}\n{}\n"
all_opts = "".join([genopt(k, getkw) for k in sorted(opts.keys())])
return tmpl.format(title, all_opts)
out = ''.join([genopts(iopts) for iopts in [
restart_opts,
balance_opts,
]])
out += options_dont_touch
out += ''.join([genopts(iopts) for iopts in [
kinematic_opts,
dump_opts,
]])
#now we do big dumps
kw['interval_ns'] = getkw_outer("dumpinterval")
kw['times_ns'] = getkw_outer("dumptimes")
kw['steps'] = getkw_outer("dumpsteps")
def gen_dumpopt(dump, opt):
label = "{}_dump_{}".format(dump, opt)
if test(kw, label):
return genopt(label)
else:
return genopt(opt, flag=label)
for dump in bigdumps:
if not getkw_outer("dump_{}".format(dump)): continue
out += "dump_{}s_flag ON\n".format(dump)
for iopt in ['interval_ns', 'times_ns', 'steps']:
out += gen_dumpopt(dump, iopt)
return out
def genobjects(**kw):
getkw=mk_getkw(kw, condb_defaults);
ux = getkw('ux');
objss='';
for I,objspec in enumerate(getkw('objects')):
coords=dict();
#objd = sd(condb_defaults, **kw);
objd = sd(condb_objdef, **kw);
objd = sd(objd, **objspec);
objd['i'] = I + 1;
if test(objspec,'outlet'):
outlet = objd['outlet'];
if outlet not in all_lims:
raise ValueError('Unknown outlet "{}"'.format(outlet));
coords = outlet_coords(outlet,kw);
objd['width']*=ux;
objd['start']*=ux;
if outlet[-2:] == 'ax':
sign = 1.0;
else:
sign =-1.0
objd['type']= 'BLOCK';
coords[outlet] += sign*(objd['width'] + objd['start']);
coords[otherside(outlet)] += sign*objd['start'];
objd['crossstart']*=ux;
otherdims = [i for i in 'xyz' if i != outlet[:-3]];
for dim in otherdims:
if getkw('{}cells'.format(dim)) > 0:
coords['{}min'.format(dim)] += objd['crossstart'];
coords['{}max'.format(dim)] -= objd['crossstart'];
objd['from'] = (coords['xmin'],coords['ymin'],coords['zmin']);
objd['to'] = (coords['xmax'],coords['ymax'],coords['zmax']);
#objss += condf_tmpl.format(
# i=I+1,
# condon=objd['condon'],
# xf=objd['from'][0],yf=objd['from'][1],zf=objd['from'][2],
# **objd);
def mk_to(objd):
'''generate the to's'''
return ''.join([
condt_tmpl.format(xt=xt,yt=yt,zt=zt)
for xt,yt,zt in objd['to'] ]);
frms = ['BLOCK', 'PARALLELPIPED', 'TRILATERAL'];
if objd['type'] == 'SOLID':
objss += obj_solid_tmpl.format(**objd);
elif objd['type'] in frms:
objss += condf_tmpl.format(
xf=objd['from'][0],yf=objd['from'][1],zf=objd['from'][2],
**objd);
objd = sd(condb_objdef, **objd);
if objd['type'] == 'BLOCK':
if type(objd['to']) != list:
objd['to'] = [objd['to']];
objss += mk_to(objd);
if objd['type'] == 'TRILATERAL':
objss += 'sweep_direction {sweep_direction}\n'.format(
**objd);
elif objd['type'] == 'CONE':
objd = sd(obj_cone_defs, **objd);
coordtokeysl(objd, 'base', '{}b');
coordtokeysl(objd, 'apex', '{}ap');
coordtokeysl(objd, 'edge', '{}ed');
objss += obj_cone_tmpl.format(**objd);
elif objd['type'] == 'CYLINDER' or objd['type'] == 'TORUS':
objd = sd(obj_cyl_defs, **objd);
objd['axis'],objd['pitch'] = objd['axis_pitch'];
objd['azaxis'],objd['azpitch'] = objd['azimuthal_axis_pitch'];
objd['start_angle'],objd['sweep_angle'] = objd['azimuth_range'];
if objd['type'] == 'CYLINDER':
coordtokeysl(objd, 'base', '{}b');
objss += obj_cyl_tmpl.format(**objd);
elif objd['type'] == 'TORUS':
objd = sd(obj_torus_defs,**objd);
coordtokeysl(objd, 'center', '{}c');
objss += obj_torus_tmpl.format(**objd);
else:
raise Exception("WTFdiosjf03y2q8qencdq");
else:
raise ValueError(
"Unknown object type '{}'".format(objd['type']));
pass #end for
return objss;
def genoutlets(**kw):
outlet_tmpl = '''
;{side}
outlet
from {xf:e} {yf:e} {zf:e}
to {xt:e} {yt:e} {zt:e}
phase_velocity 1.0
drive_model NONE'''
laser10_tmpl = '''
;laser
outlet
from {xf:e} {yf:e} {zf:e}
to {xt:e} {yt:e} {zt:e}
phase_velocity 1.0
drive_model LASER
reference_point {fp}
components {components}
phases {phases}
temporal_function {lasertfunc}
analytic_function {laserafunc}
time_delay {time_delay}
'''
retoutlets = ''
laserkw = kw['laseroutlet'] if test(kw, 'laseroutlet') else dict()
laserkw = sd(kw, **laserkw)
getkw = mk_getkw(laserkw, outletdefaults, prefer_passed=True)
if not test(laserkw, 'nolaser'):
retoutlets += laser10_tmpl.format(
xf=kw['xmin'],
xt=kw['xmin'],
yf=kw['ymin'],
yt=kw['ymax'],
zf=kw['zmin'],
zt=kw['zmax'],
fp=joinspace(scaletuple(getkw("fp"))),
components=joinspace(getkw("components")),
phases=joinspace(getkw("phases")),
lasertfunc=getkw('lasertfunc'),
laserafunc=getkw('laserafunc'),
time_delay=getkw('laser_time_delay'),
)
else:
retoutlets += outlet_tmpl.format(
side='front',
xf=kw['xmin'],
xt=kw['xmin'],
yf=kw['ymin'],
yt=kw['ymax'],
zf=kw['zmin'],
zt=kw['zmax'],
)
retoutlets += outlet_tmpl.format(
side='back',
xf=kw['xmax'],
xt=kw['xmax'],
yf=kw['ymin'],
yt=kw['ymax'],
zf=kw['zmin'],
zt=kw['zmax'],
)
if kw['ycells'] > 0:
retoutlets += outlet_tmpl.format(
side='left',
xf=kw['xmin'],
xt=kw['xmax'],
yf=kw['ymin'],
yt=kw['ymin'],
zf=kw['zmin'],
zt=kw['zmax'],
)
retoutlets += outlet_tmpl.format(
side='right',
xf=kw['xmin'],
xt=kw['xmax'],
yf=kw['ymax'],
yt=kw['ymax'],
zf=kw['zmin'],
zt=kw['zmax'],
)
if kw['zcells'] > 0:
retoutlets += outlet_tmpl.format(
side='bottom',
xf=kw['xmin'],
xt=kw['xmax'],
yf=kw['ymin'],
yt=kw['ymax'],
zf=kw['zmin'],
zt=kw['zmin'],
)
retoutlets += outlet_tmpl.format(
side='top',
xf=kw['xmin'],
xt=kw['xmax'],
yf=kw['ymin'],
yt=kw['ymax'],
zf=kw['zmax'],
zt=kw['zmax'],
)
return retoutlets
domains = 1000
region_split = ('z', 68)
pbsbase = "flashic_3d"
defpbs = dict(
pbsbase=pbsbase,
pbsname=pbsbase + "_oakley",
domains=domains,
cluster='oakley',
autozipper=False,
queue=None,
ppn=None,
)
pbses = [
defpbs,
sd(defpbs,
pbsname=pbsbase + "_garnet_debug",
cluster='garnet',
queue='debug'),
sd(defpbs,
pbsname=pbsbase + "_garnet",
cluster='garnet',
queue='standard_lw'),
sd(defpbs,
pbsname=pbsbase + "_garnet_short",
cluster='garnet',
queue='standard_lw',
walltime=48),
]
gensim(
l=0.8e-6,
w=2.26e-6,
I=3e18,
def mksim(E, l, fn, cy, yres=20):
scale = 1.5
d = fromenergy(
E,
l=l * 1e-6,
cycles=cycles * cy,
l2w=l2w * fn,
)
d = sd(defd, **d)
mywidth = np.ceil(width * l)
margin = 15.0
mymargin = np.ceil(margin)
myedges = np.ceil(margin) + mywidth
timestep = l * 1e-6 / c / tstep
yres = int(np.ceil((2 * myedges) / (l / yres)))
pbsbase = pbsfmt.format(
l='0.8' if l == 0.78 else int(l),
I=d['I'],
scale=scale,
fn=np.pi * d['w'] / 2 / d['l'],
cs=cy,
)
pbses = mk_hpcmp_pbses(pbsbase=pbsbase,
domains=domains,
lspexec='lsp-10-xy')
print("processing {}".format(pbsbase))
#original targets
d.update(
pbsbase=pbsbase,
#target
fp='nc',
n_s=1e23,
solid_len=10,
expf=scale,
scale_with_min=True,
long_resd=20,
long_margin=(mymargin, mymargin),
n_min=1e16,
roundup_pp=True,
# others
lim=(0, 0, -myedges, myedges, 0, 0),
tlim=(0, 0, -mywidth, mywidth, 0, 0),
res=(0, yres, 0),
timestep=timestep,
dumpinterval=timestep * 2,
totaltime=d['T'] * 3.5,
description=pbsbase,
pbses=pbses,
domains=domains,
region_dom_split='y',
#movs
movne=dict(clim=(1e16, 1e23)),
movni=dict(clim=(1e16, 1e23)),
movdq=dict(clim=(-1e19, 1e19), linthresh=1e15),
movrho=dict(clim=(-1e19, 1e19), linthresh=1e15),
dir=True,
)
gensim(**d)
#scaled targets
if np.isclose(l, 0.78): return
scale = d['expf'] = l2L * l
pbsbase = pbsfmt.format(l=int(l),
I=d['I'],
scale=scale,
fn=np.pi * d['w'] / 2 / d['l'],
cs=cy)
d['pbsbase'] = pbsbase
print("processing {}".format(pbsbase))
d['pbses'] = mk_hpcmp_pbses(pbsbase=pbsbase,
domains=96,
lspexec='lsp-10-xy')
if np.isclose(l, 10.0): d['n_min'] = 5e16
#note I DO NOT remake movnes, because 1e17 is close enough.
gensim(**d)
0, tlim[1]-tlim[0],
0, tlim[3]-tlim[2],
0, tlim[5]-tlim[4])
def genf(**kw):
getkw=mk_getkw(kw,datdefaults);
if getkw('type') == 'singlescale':
tlim = mt(getkw('tlim'),m=getkw('unit'));
xdim = tlim[0], tlim[1];
return mkdecay(
getkw('n_s'), mt(getkw('sdim'),m=getkw('unit')),
xdim, getkw('expf')*getkw('unit'));
else:
raise NotImplementedError("Coming soon!");
onescale_defaults = sd(
datdefaults,
solid_len=10,
xlen=27.5,
);
def genonescale(**kw):
getkw=mk_getkw(kw,onescale_defaults);
slen = getkw("solid_len");
xlen = getkw("xlen");
kw1 = sd(
kw,
tlim=(0.0, xlen) + (0.0,0.0,0.0,0.0),
sdim= (xlen-slen, xlen) + (0.0,0.0,0.0,0.0));
kw1['f_1D']= genf(**kw1)
return gendat(**kw1);
def gendats(ds,**kw):
return [ gendat(**sd(kw, d))
for d in ds ];
fp=(-5, 0, 0),
totaltime=2e-12,
dumpinterval=5e-16,
timestep=5e-17,
no_pmovies=True,
targetdat="nopreplasma-thicker.dat",
pext_species=(10, 11),
description="long wavelength tnsa")
#these are simulations with longer scale length
scale_sim = sd(lsp_d,
lim=(-50, 50, -25, 25),
tlim=(-40, 40, -15, 15),
res=(1000, 500),
fp=(-4, 0, 0),
totaltime=450e-15,
dumpinterval=5e-16,
timestep=5e-17,
no_pmovies=True,
dat="5.625um",
pext_species=(10, 11))
def mkscale_sim(**d):
datf = "water-{}.dat".format(d['dat'])
d = sd(scale_sim, **d)
d['targetdat'] = datf
d['description'] = "scale length sim with {}".format(d['dat'])
if not test(d, "name"):
name = "longl_l={}_{}".format(d['dat'], d['I'])
else:
restart=23.95,
dump_restart_flag=True,
new_externalf=True,
#movs
movne=dict(ne_species='RhoN17', clim=(1e19, 1e23)),
movrho=dict(
clim=(-1e19, 1e19),
linthresh=1e15,
),
#pmovies
no_pmovies=True,
#particle dumps
pext_species=(17, ),
)
dlim = np.array([8.6e17 / 3.33 * 1e-3, 8.6e17 / 3.33])
dlim = np.log10(dlim)
print("creating range between {} and {}".format(dlim[0], dlim[1]))
denses = np.logspace(dlim[0], dlim[1], 5)
ds = [
sd(d,
pbsbase="bg_{:3.1e}".format(density),
externalf_2D=True,
f_2D=mkbgtarg(N_bg=density, dim=[i * 1e-4 for i in d['tlim']]),
dat_xres=500) for density in denses
]
for di in ds:
gensim(**di)
clim=(-1e19, 1e19),
linthresh=1e15,
),
#pmovies
no_pmovies=False,
#particle dumps
dump_particle=True,
particle_dump_interval_ns=0.0,
particle_dump_times_ns=(1e-4, 1.1e-4, 1.4e-4),
pext_species=(17, 18),
)
#generating scans
hf = np.arange(2.5, 20.0, 2.5)
fps = [-1.0, 0.0, 1.0] + list(-hf) + list(hf)
peak = [
sd(d, pbsbase='glypeak_fp={:0=+5.1f}'.format(fp), fp=(fp, 0.0, 0.0))
for fp in fps
]
for di in peak:
gensim(**di)
#other intensities
I3e18 = [
sd(d,
pbsbase='gly3e+18_fp={:0=+5.1f}'.format(fp),
I=3e18,
fp=(fp, 0.0, 0.0)) for fp in fps
]
I1e18 = [
sd(d,
pbsbase='gly1e+18_fp={:0=+5.1f}'.format(fp),
def genpext(**kw):
def getkw(l,scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = pext_defaults[l];
if scale:
return [scale*i for i in ret];
return ret;
tmpl='''
;
extract{i}
species {species}
direction {direction}
maximum_number 1000000000
start_time {start_time}
stop_time {stop_time}
at {position}
'''
lims = list(getkw('lim',scale=getkw('ux')));
lims[0] = [lims[0],0,0];
lims[1] = [lims[1],0,0];
lims[2] = [0,lims[2],0];
lims[3] = [0,lims[3],0];
lims[4] = [0,0,lims[4]];
lims[5] = [0,0,lims[5]];
dirs = ['X','X','Y','Y','Z','Z'];
planes = list(zip(dirs,lims));
if kw['zcells'] == 0:
del planes[4:6];
if kw['ycells'] == 0:
del planes[2:4];
def formatsp(sp,i):
return [
dict(i=i+j+1,
species=sp,
direction=d,
start_time=getkw('start_time'),
stop_time =getkw('stop_time'),
position =joinspace(lim))
for j,(d,lim) in enumerate(planes)];
pextplanes = [
tmpl.format(**d)
for i,sp in enumerate(getkw('species'))
for d in formatsp(sp,len(planes)*i)];
ret = joinspace(pextplanes);
if test(kw, 'extrapexts'):
ppl = len(pextplanes);
expext_def = dict(
species=10,
direction='X',
start_time=0,
stop_time=1,
position=(0.0,0.0,0.0),
);
expexts = [];
for p in getkw('extrapexts'):
if test(p,'species') and p['species'] != 'all':
expexts.append(p);
elif test(p,'species') and type(p['species']) != str:
expexts += [ sd(p, species = sp) for sp in p['species']];
else:
expexts += [ sd(p, species = sp) for sp in getkw('species') ];
for i,ep in enumerate(expexts):
pgetkw = mk_getkw(p, expext_def, prefer_passed = True);
ret+=tmpl.format(
i=ppl+i+1,
species = pgetkw('species'),
direction = pgetkw('direction'),
start_time = pgetkw('start_time'),
stop_time = pgetkw('stop_time'),
position = joinspace(pgetkw('position')),);
return ret;
pbsfmt='{l}um-{I:0.2e}-l={scale:0.3}um'
def mkpbsbase(d):
l = d['l']/1e-6;
if l > 1:
l = int(l);
else:
l = '{:0.1f}'.format(l)
d['pbsbase']=pbsfmt.format(
l=l,I=d['I'],scale=d['expf']);
####################################
# 10um scans
####################################
defds=[]
for E in Es:
d = sd(fromenergy(E,cycles=cycles), **defd);
d.update(
lim =( -50, 10, -120, 120,0,0),
tlim=( -40, 0, -110, 110,0,0),
res =( 60*4, 240*4, 0),
timestep = 5e-16,
totaltime= d['T']*3.75,
description="10um",
angular=True,
);
defds.append(d);
#10um, scale=1.5um
for d in defds:
d['pbsbase']=pbsfmt.format(
l=int(d['l']/1e-6),I=d['I'],scale=d['expf']);
def genboundaries(**kw):
retboundaries = ''
if test(kw,'manual_boundaries'):
return '\n'.join([
manual_genboundary(bspec,**kw)
for bspec in kw['manual_boundaries'] ]);
laserkw = kw['laseroutlet'] if test(kw, 'laseroutlet') else dict();
laserkw = sd(kw, **laserkw);
getkw = mk_getkw(laserkw,outletdefaults,prefer_passed = True);
lset = set();
side_label = dict(
xmin='front',
xmax='back',
ymin='left',
ymax='right',
zmin='bottom',
zmax='top');
ls = [];
if not test(laserkw, 'multilaser') and not (test(laserkw,'nolaser') or test(laserkw,'nolaser_outlet')):
ls = [ sd(laserkw, outlet='xmin') ];
elif test(laserkw,'multilaser'):
ls = kw['multilaser'];
print("experimental multi-lasers");
print("if you put more than one laser on a single outlet,");
print("be sure to be using my modifications to lsp for it.");
ls = kw['multilaser'];
#lasers
for l in ls:
l = sd(laserkw, **l);
lgetkw = mk_getkw(l, laserdefaults, prefer_passed = True);
outlet = lgetkw('outlet');
if outlet not in all_lims:
raise ValueError('Unknown outlet "{}"'.format(outlet));
lset.add(outlet);
retboundaries += laser10_tmpl.format(
fp = joinspace(mt(lgetkw("fp"),getkw('ux'))),
components = joinspace(lgetkw("components")),
phase_velocity = lgetkw('phase_velocity'),
phases = joinspace(lgetkw("phases")),
lasertfunc = lgetkw('lasertfunc'),
laserafunc = lgetkw('laserafunc'),
time_delay = lgetkw('laser_time_delay'),
**outlet_coords(outlet, l)
);
just_outlets = [i for i in all_lims if i not in lset];
if test(kw,'freespace'):
getkwfr = mk_getkw(
sd(kw,**kw['freespace']),frsp_defs,prefer_passed=True);
di=dict();
di['model_type'] = getkwfr('model_type');
if di['model_type'] not in ["WAVEABC","UNIAXIAL","CFSPML"]:
raise ValueError("unrecognized model_type for freespace");
if di['model_type']=="WAVEABC":
di['num_of_cells'] = "";
else:
di['num_of_cells'] = "number_of_cells {}".format(
getkwfr('num_of_cells'));
keeps = getkwfr('keep_outlets');
if keeps is None: keeps = [];
just_outlets = [ i for i in just_outlets
if i in keeps ];
if test(kw['freespace'],'frlim'):
for dim,lim in zip(getkwfr('frlim'),all_lims):
di[lim] = dim;
else:
dx = getkwfr('freesp_delta');
keepset = lset.union(just_outlets);
for lim in all_lims:
di[lim] = getkw(lim);
if lim in keepset:
if 'min' in lim:
di[lim] -= dx;
else:
di[lim] += dx;
di['refp'] = joinspace(getkwfr('freesp_refp'));
di['label']= getkwfr('freesp_label');
retboundaries += freespace_tmpl.format(**di);
#outlet boundaries which and are not removed by freespace
for side in just_outlets:
if laserkw[side[0]+'cells'] > 0:
retboundaries += outlet_none_tmpl.format(
label = side_label[side],
phase_velocity=getkw('phase_velocity'),
**outlet_coords(side, laserkw));
pwbtmpl='''
planewave
from {xmin:e} {ymin:e} {zmin:e}
to {xmax:e} {ymax:e} {zmax:e}
reference_point {refp}
polar_angle {polar}
azimuthal_angle {azimuth}
rotation_angle {rotation}
frequency {freq}
temporal_function {pwfunc}
'''
pwbdefs = dict(
polar=90,
azimuth=45,
rotation=-45,
freq=1e3,
pwfunc=3,
pw_refp=[0.0,0.0,0.0],
)
if test(kw, 'planewave_boundary'):
di=dict();
pwkw = sd(kw,**kw['planewave_boundary']);
getkwpw = mk_getkw(
pwkw,pwbdefs,prefer_passed=True);
if not test(pwkw, 'pwblim'):
raise ValueError("This requires pwblim for now");
pwlims = getkwpw('pwblim');
for dim,lim in zip(pwlims,all_lims):
di[lim] = dim;
for qi in ['polar','azimuth','rotation','freq','pwfunc']:
di[qi] = getkwpw(qi);
di['refp'] = joinspace(getkwpw('pw_refp'));
retboundaries+=pwbtmpl.format(**di);
return retboundaries;
lspexec='lsp-10-xy',
fp='nc',
#target
n_s=1e23,
solid_len=10,
expf=1.5,
#movne
movne={'clim': (1e14, 1e21)},
#pbs options
autozipper=True,
dir=True,
)
pbsfmt = '{l}um-{I:0.2e}-l={scale:0.3}um'
defds = []
for E in Es:
d = sd(fromenergy(E), **defd)
d.update(
dict(
l=10e-6,
lim=(-50, 10, -120, 120, 0, 0),
tlim=(-40, 0, -110, 110, 0, 0),
res=(60 * 5, 240 * 5, 0),
timestep=2e-16,
totaltime=d['T'] * 3.0,
description="10um",
#movne
movne={'clim': (1e14, 1e21)},
angular=True,
))
defds.append(d)
dumpinterval=5e-16,
timestep=5e-17,
no_pmovies=True,
targetdat="nopreplasma-thicker.dat",
pext_species=(10, 11),
description="long wavelength tnsa",
)
# these are simulations with longer scale length
scale_sim = sd(
lsp_d,
lim=(-50, 50, -25, 25),
tlim=(-40, 40, -15, 15),
res=(1000, 500),
fp=(-4, 0, 0),
totaltime=450e-15,
dumpinterval=5e-16,
timestep=5e-17,
no_pmovies=True,
dat="5.625um",
pext_species=(10, 11),
)
def mkscale_sim(**d):
datf = "water-{}.dat".format(d["dat"])
d = sd(scale_sim, **d)
d["targetdat"] = datf
d["description"] = "scale length sim with {}".format(d["dat"])
if not test(d, "name"):
name = "longl_l={}_{}".format(d["dat"], d["I"])
dens_dat='watercolumn.dat',
domains=700,
region_split=('z', 50),
pext_species=(10, 11),
restart=23.95,
dump_restart_flag=True,
)
Is = [5.4e17, 1e18, 1.5e18, 3e18, 1e19]
#vanillas
for I in Is:
pbsbase = "H2O-3d-{}".format(I)
print(pbsbase)
d = sd(
lsp_d,
I=I,
pbsbase=pbsbase,
pbses='defaults',
)
gensim(dir=True, **d)
for I in Is:
pbsbase = "H2Osm-3d-{}".format(I)
print(pbsbase)
d = sd(
lsp_d,
I=I,
pbsbase=pbsbase,
pbses='defaults',
domains=384,
region_split=('z', 16),
)
def gen_dumpopt(dump, opt):
label = "{}_dump_{}".format(dump, opt)
if test(kw, label):
return genopt(label)
else:
return genopt(opt, flag=label)
for dump in bigdumps:
if not getkw_outer("dump_{}".format(dump)): continue
out += "dump_{}s_flag ON\n".format(dump)
for iopt in ['interval_ns', 'times_ns', 'steps']:
out += gen_dumpopt(dump, iopt)
return out
pext_defaults = sd(lspdefaults, species=(10, ), start_time=0, stop_time=1)
def genpext(**kw):
def getkw(l, scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = pext_defaults[l]
if scale:
return [scale * i for i in ret]
return ret
tmpl = '''
;
extract{i}
'fp':(0,0,0),
'domains':48,
'totaltime':300e-15,
'timestep':4e-17,
'components':(0,1,0),
'phases':(0,0,0),
'targetdat':'watercolumn.dat',
'dumpinterval':2e-16,
'description':'Hotwater in 2d',
'pext_species':(10,),
'restart':None,
};
pext_defaults = sd(
defaults,
species=(10,),
start_time=0,
stop_time=1);
def genpext(**kw):
def getkw(l,scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = pext_defaults[l];
if scale:
return [scale*i for i in ret];
return ret;
tmpl='''
;
"res": (1400, 1600),
"tlim": (-27.5, 0, -15, 15),
"fp": (0, 0, 0),
"domains": 48,
"totaltime": 300e-15,
"timestep": 4e-17,
"components": (0, 1, 0),
"phases": (0, 0, 0),
"targetdat": "watercolumn.dat",
"dumpinterval": 2e-16,
"description": "Hotwater in 2d",
"pext_species": (10,),
"restart": None,
}
pext_defaults = sd(defaults, species=(10,), start_time=0, stop_time=1)
def genpext(**kw):
def getkw(l, scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = pext_defaults[l]
if scale:
return [scale * i for i in ret]
return ret
tmpl = """
;
extract{i}
def genlsp(**kw):
def getkw(l, scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = lspdefaults[l]
if scale:
return [scale * i for i in ret]
return ret
def mkdims(s=''):
return [s + 'x', s + 'y', s + 'z']
fmtd = {}
fmtd['options'] = genoptions(**kw)
fmtd['E0'] = np.sqrt(2 * getkw('I') * 1e4 / (c * e0)) * 1e-5
xmin, xmax, ymin, ymax, zmin, zmax = getkw('lim', scale=1e-4)
kw['xmin'], kw['xmax'] = xmin, xmax
kw['ymin'], kw['ymax'] = ymin, ymax
kw['zmin'], kw['zmax'] = zmin, zmax
txmin, txmax, tymin, tymax, tzmin, tzmax = getkw('tlim', scale=1e-4)
kw['txmin'], kw['txmax'] = txmin, txmax
kw['tymin'], kw['tymax'] = tymin, tymax
kw['tzmin'], kw['tzmax'] = tzmin, tzmax
l = fmtd['l'] = getkw('l') * 100.0
if test(kw, 'resd'):
xres, yres, zres = getkw("resd")
kw['xcells'] = (xmax - xmin) / (l / xres) if xres > 0 else 0
kw['ycells'] = (ymax - ymin) / (l / yres) if yres > 0 else 0
kw['zcells'] = (zmax - zmin) / (l / zres) if zres > 0 else 0
else:
kw['xcells'], kw['ycells'], kw['zcells'] = getkw("res")
xcells, ycells, zcells = kw['xcells'], kw['ycells'], kw['zcells']
#generating non x outlets
other_outlets = genoutlets(**kw)
w0 = fmtd['w0'] = getkw('w') * 100.0
fmtd['pulse'] = getkw('T') * 1e9
#generating grid
ygrid = zgrid = ''
if ycells > 0:
ygrid = ''';
ymin {ymin:e}
ymax {ymax:e}
y-cells {ycells}'''.format(ymin=ymin, ymax=ymax, ycells=ycells)
if zcells > 0:
zgrid = ''';
zmin {zmin:e}
zmax {zmax:e}
z-cells {zcells}'''.format(zmin=zmin, zmax=zmax, zcells=zcells)
fmtd['domains'] = getkw('domains')
# we have that na~l/(pi*w), and the f-number~1/2na, thus
# f-number ~ pi*w/2l
fmtd['fnum'] = np.pi * w0 / 2 / l
fmtd['totaltime'] = getkw('totaltime') * 1e9
fmtd['timestep'] = getkw('timestep') * 1e9
# calculate courant
couraunt = min(
((xmax - xmin) / xcells / c_cgs) * 1e9 if xcells > 0 else float('inf'),
((ymax - ymin) / ycells / c_cgs) * 1e9 if ycells > 0 else float('inf'),
((zmax - zmin) / zcells / c_cgs) * 1e9 if zcells > 0 else float('inf'),
)
if fmtd['timestep'] > couraunt:
print("warning: timestep exceeds couraunt limit\n")
#target
kw = gendens(**kw)
kw = gentemp(**kw)
for species in getkw('speciesl'):
l = 'n_' + species
fmtd[l] = kw[l]
l = '{}_thermalopts'.format(species)
fmtd[l] = kw[l]
fmtd['discrete'] = joinspace(getkw("discrete"))
fmtd['dens_flags'] = joinspace(
[1 if i else 0 for i in getkw("dens_flags")])
for idim, v in zip(mkdims(), getkw('tref')):
if v is None: v = kw['t' + idim + 'min']
fmtd['targref' + idim] = v
fmtd['dumpinterval'] = getkw('dumpinterval') * 1e9
description = getkw('description')
restart = getkw('restart')
pexts = genpext(**sd(kw, species=getkw('pext_species')))
if test(kw, "regions"):
regions = kw['regions']
else:
regions = genregions(**kw)
if not test(kw, "no_pmovies"):
pmovies = '''
particle_movie_interval_ns {dumpinterval}
particle_movie_components Q X Y Z VX VY VZ XI YI ZI
'''.format(dumpinterval=fmtd['dumpinterval'])
else:
pmovies = ''
fmtd['other_funcs'] = getkw('other_funcs')
lsptemplate = getkw("lsptemplate")
with open(lsptemplate) as f:
s = f.read()
s = s.format(xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax,
zmin=zmin,
zmax=zmax,
xcells=xcells,
ycells=ycells,
zcells=zcells,
ygrid=ygrid,
zgrid=zgrid,
other_outlets=other_outlets,
targ_xmin=txmin,
targ_xmax=txmax,
targ_ymin=tymin,
targ_ymax=tymax,
targ_zmin=tzmin,
targ_zmax=tzmax,
intensity=getkw('I'),
pmovies=pmovies,
regions=regions,
pexts=pexts,
description=description,
**fmtd)
return s
def genlsp(**kw):
def getkw(l, scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = defaults[l]
if scale:
return [scale * i for i in ret]
return ret
intensity = getkw("I")
E0 = np.sqrt(2 * getkw("I") * 1e4 / (c * e0)) * 1e-5
xmin, xmax, ymin, ymax = getkw("lim", scale=1e-4)
fp = joinspace(getkw("fp", scale=1e-4))
components = joinspace(getkw("components"))
phases = joinspace(getkw("phases"))
l = getkw("l") * 100.0
if test(kw, "resd"):
xres, yres = getkw("resd")
xcells = (xmax - xmin) / (l / xres)
ycells = (ymax - ymin) / (l / yres)
else:
xcells, ycells = getkw("res")
w0 = getkw("w") * 100.0
T = getkw("T") * 1e9
targ_xmin, targ_xmax, targ_ymin, targ_ymax = getkw("tlim", scale=1e-4)
domains = getkw("domains")
# we have that na~l/(pi*w), and the f-number~1/2na, thus
# f-number ~ pi*w/2l
fnum = np.pi * w0 / 2 / l
totalt = getkw("totaltime") * 1e9
timestep = getkw("timestep") * 1e9
couraunt = min(((xmax - xmin) / xcells / c_cgs) * 1e9, ((ymax - ymin) / ycells / c_cgs) * 1e9)
if timestep > couraunt:
import sys
sys.stderr.write("warning: timestep exceeds couraunt limit\n")
pexts = genpext(**sd(kw, species=getkw("pext_species")))
targetdat = getkw("targetdat")
dumpinterval = getkw("dumpinterval") * 1e9
description = getkw("description")
restart = getkw("restart")
if not test(kw, "no_pmovies"):
pmovies = """
particle_movie_interval_ns {dumpinterval}
particle_movie_components Q X Y VX VY XI YI
""".format(
dumpinterval=dumpinterval
)
else:
pmovies = ""
restarts = "maximum_restart_dump_time {}".format(restart) if restart else ""
with open("hotwater2d_tmpl.lsp") as f:
s = f.read()
s = s.format(
xmin=xmin,
xmax=xmax,
ymin=ymin,
ymax=ymax,
xcells=xcells,
ycells=ycells,
l=l,
w0=w0,
E0=E0,
fnum=fnum,
targ_xmin=targ_xmin,
targ_xmax=targ_xmax,
targ_ymin=targ_ymin,
targ_ymax=targ_ymax,
fp=fp,
pulse=T,
components=components,
phases=phases,
intensity=getkw("I"),
pmovies=pmovies,
pexts=pexts,
domains=domains,
totalt=totalt,
timestep=timestep,
targetdat=targetdat,
dumpinterval=dumpinterval,
description=description,
restarts=restarts,
)
return s
def genlsp(**kw):
def getkw(l,scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = defaults[l];
if scale:
return [scale*i for i in ret];
return ret;
intensity=getkw('I');
E0 = np.sqrt(2*getkw('I')*1e4/(c*e0))*1e-5
xmin,xmax, ymin,ymax = getkw('lim',scale=1e-4)
fp = joinspace(getkw("fp",scale=1e-4));
components = joinspace(getkw("components"));
phases = joinspace(getkw("phases"));
l = getkw('l')*100.0
if test(kw,'resd'):
xres,yres = getkw("resd");
xcells = (xmax-xmin)/(l/xres);
ycells = (ymax-ymin)/(l/yres);
else:
xcells, ycells = getkw("res");
w0 = getkw('w')*100.0;
T = getkw('T')*1e9;
targ_xmin,targ_xmax, targ_ymin,targ_ymax =getkw('tlim',scale=1e-4);
domains=getkw('domains');
# we have that na~l/(pi*w), and the f-number~1/2na, thus
# f-number ~ pi*w/2l
fnum=np.pi*w0/2/l;
totalt=getkw('totaltime')*1e9
timestep=getkw('timestep')*1e9;
couraunt = min(
((xmax-xmin)/xcells/c_cgs)*1e9,
((ymax-ymin)/ycells/c_cgs)*1e9)
if timestep > couraunt:
import sys
sys.stderr.write("warning: timestep exceeds couraunt limit\n");
pexts = genpext(**sd(kw,species=getkw('pext_species')));
targetdat = getkw('targetdat');
dumpinterval=getkw('dumpinterval')*1e9;
description=getkw('description');
restart = getkw('restart');
if not test(kw,"no_pmovies"):
pmovies ='''
particle_movie_interval_ns {dumpinterval}
particle_movie_components Q X Y VX VY XI YI
'''.format(dumpinterval=dumpinterval);
else:
pmovies = '';
restarts = "maximum_restart_dump_time {}".format(restart) if restart else "";
with open("hotwater2d_tmpl.lsp") as f:
s=f.read();
s=s.format(
xmin=xmin,xmax=xmax,ymin=ymin,ymax=ymax,
xcells=xcells,ycells=ycells,
l=l,w0=w0,E0=E0,
fnum=fnum,
targ_xmin=targ_xmin, targ_xmax=targ_xmax,
targ_ymin=targ_ymin, targ_ymax=targ_ymax,
fp=fp,pulse=T,components=components,phases=phases,
intensity=getkw('I'),
pmovies=pmovies,
pexts=pexts,
domains=domains,
totalt=totalt,
timestep=timestep,
targetdat=targetdat,
dumpinterval=dumpinterval,
description=description,
restarts=restarts
);
return s;
def mk_noextrapbs(d):
dd = sd(d)
pbsbase = dd['pbsbase']
hpcmp_defpbs = dict(
pbsbase=pbsbase,
pbsname=pbsbase,
cluster='oakley',
autozipper=False,
queue=None,
ppn=None,
)
dd['movne'] = False
dd['angular'] = False
dd['pbses'] = [
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet",
cluster='garnet',
queue='standard_lw'),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet_20",
cluster='garnet',
queue='standard_sm',
walltime=20),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet_24",
cluster='garnet',
queue='standard_sm',
walltime=24),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet_short",
cluster="garnet",
queue="standard_lw",
walltime=48),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet_64",
cluster="garnet",
queue="standard_lw",
walltime=64),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet_72",
cluster="garnet",
queue="standard_lw",
walltime=72),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_garnet_shorter",
cluster='garnet',
queue='standard_sm',
walltime=12),
sd(
hpcmp_defpbs,
pbsname=pbsbase + "_garnet_debug",
cluster='garnet',
queue='debug',
),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong_debug",
cluster='armstrong',
queue='debug'),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong",
cluster='armstrong',
queue='standard'),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong_short",
cluster='armstrong',
queue='standard',
walltime=48),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong_shorter",
cluster='armstrong',
queue='standard',
walltime=14),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong_24",
cluster='armstrong',
queue='standard',
walltime=24),
sd(hpcmp_defpbs,
pbsname=pbsbase + "_armstrong_36",
cluster='armstrong',
queue='standard',
walltime=36),
]
return dd
def genlsp(**kw):
def getkw(l,scale=None):
if test(kw, l):
ret = kw[l]
else:
ret = lspdefaults[l];
if scale:
return [scale*i for i in ret];
return ret;
def mkdims(s=''):
return [s+'x',s+'y',s+'z'];
ux = getkw('ux');
fmtd = {};
fmtd['options'] = genoptions(**kw);
fmtd['E0'] = np.sqrt(2*getkw('I')*1e4/(c*e0))*1e-5
spatial_lims = getkw('lim',scale=ux);
for dim,ilim in zip(all_lims,spatial_lims):
kw[dim] = fmtd[dim] = ilim;
if not test(kw,'tlim'):
target_lims=spatial_lims
else:
target_lims=getkw('tlim',scale=ux);
for dim,ilim in zip(all_lims,target_lims):
kw['t'+dim] = fmtd['t'+dim] = target_lims;
kw['targ_'+dim] = fmtd['targ_'+dim] = target_lims;
#SI
l=fmtd['l'] = getkw('l')*100.0
if test(kw,'resd'):
xres,yres,zres = getkw("resd");
kw['xcells'] = (xmax-xmin)/(l/xres) if xres > 0 else 0;
kw['ycells'] = (ymax-ymin)/(l/yres) if yres > 0 else 0;
kw['zcells'] = (zmax-zmin)/(l/zres) if zres > 0 else 0;
else:
kw['xcells'], kw['ycells'], kw['zcells'] = getkw("res");
xcells, ycells, zcells = kw['xcells'], kw['ycells'], kw['zcells'];
#generating outlets
fmtd['other_boundaries']=genboundaries(**kw);
fmtd['objects']=genobjects(**kw);
#dealing with conductors
fmtd['cond_temp'] = getkw('cond_temp');
fmtd['cond_fraction'] = getkw('cond_fraction');
fmtd['cond_threshold']= getkw('cond_threshold');
#others
w0=fmtd['w0'] = getkw('w')*100.0;
fmtd['pulse'] = getkw('T')*1e9;
#generating grid
xgrid,ygrid,zgrid=gengrids(**kw);
fmtd['domains']=getkw('domains');
# we have that na~l/(pi*w), and the f-number~1/2na, thus
# f-number ~ pi*w/2l
fmtd['fnum']=np.pi*w0/2/l;
fmtd['totaltime']=getkw('totaltime')*1e9
fmtd['timestep']=getkw('timestep')*1e9;
# calculate courant
if test(kw, 'xvargrid') or test(kw, 'yvargrid') or test(kw, 'zvargrid'):
print("warning: check couraunt condition of vargrids");
else:
def f_(v,*arg):
return kw[v.format(*arg)];
#f_ = format
dim_couraunts = [
( f_('{}max',dim) - f_('{}min',dim) ) / f_('{}cells',dim) / c_cgs * 1e9 if f_('{}cells',dim) > 0 else float('inf')
for dim in 'xyz'];
couraunt = min(*dim_couraunts);
if fmtd['timestep'] > couraunt:
print("warning: timestep exceeds couraunt limit\n");
#target
kw = gendens(**kw);
kw = gentemp(**kw);
fmtd['discrete'] = joinspace(getkw("discrete"));
fmtd['dens_flags']= joinspace([
1 if i else 0 for i in getkw("dens_flags")]);
fmtd['gb_flags']= joinspace([
1 if i else 0 for i in getkw("gb_flags")]);
for dim,v in zip('xyz',getkw('tref')):
if v is None: v = kw['t'+dim+'min'];
fmtd['targref'+dim] = v;
fmtd['targref'] = joinspace(mt([
fmtd['targref'+dim] for dim in 'xyz'],getkw('ux')));
fmtd['gammabeta'] = joinspace(getkw('gammabeta'));
for species in getkw('speciesl'):
def setspeciesv(fmt,defaultl,join=False,scale=False):
l = fmt.format(species);
if test(kw,l):
v = kw[l];
if scale: v=mt(v,getkw('ux'));
if join: v=joinspace(v);
else:
v = fmtd[defaultl];
fmtd[l] = v;
l = 'n_'+species;
fmtd[l] = kw[l];
l = '{}_thermalopts'.format(species);
fmtd[l] = kw[l];
setspeciesv('{}_discrete','discrete');
setspeciesv('{}_targref','targref');
setspeciesv('{}_gb','gammabeta',join=True);
if test(kw, '{}_tlims'.format(species)):
splim = getkw('{}_tlim'.format(species),scale=ux);
else:
splim = getkw('tlim',scale=ux);
for dim,i in zip(all_lims,splim):
fmtd['{}_{}'.format(species,dim)] = i;
pass
fmtd['dumpinterval']=getkw('dumpinterval')*1e9;
description=getkw('description');
restart = getkw('restart');
pexts = genpext(**sd(kw,species=getkw('pext_species')));
if test(kw, "regions"):
regions = kw['regions'];
else:
regions = genregions(**kw);
if not test(kw,"no_pmovies"):
pmovies ='''
particle_movie_interval_ns {dumpinterval}
particle_movie_components Q X Y Z VX VY VZ XI YI ZI
'''.format(dumpinterval=fmtd['dumpinterval']);
else:
pmovies = '';
fmtd['other_funcs'] = getkw('other_funcs');
lsptemplate=getkw("lsptemplate");
with open(lsptemplate) as f:
s=f.read();
s=s.format(
xgrid=xgrid,
ygrid=ygrid,
zgrid=zgrid,
intensity=getkw('I'),
pmovies=pmovies,
regions=regions,
pexts=pexts,
description=description,
**fmtd
);
return s;
d['dat_xres'] = 10000
print("making targets...sit tight.")
gensim(**d)
splits = [
#dom/reg regions
(32, 7),
(7 * 8, 7 * 4),
(7 * 4, 7 * 8),
(7 * 4, 7 * 4),
(7 * 8, 7 * 8)
]
glyscans = [
sd(
d,
pbsbase='gly_{:02d}_{:02d}'.format(i, r),
region_split=('y', r),
discrete=(2, 2, 1),
domains=i * r,
) for i, r in splits
]
def rm_targ(i):
if 'f_2D' in i:
del i['f_2D']
del i['dat_xres']
sh.copy('glycol45/target45.dat', i['pbsbase'])
return i
glyscans[:] = [rm_targ(i) for i in glyscans]
ppn=48,
walltime=inf,
lspexec='lsp-10-3d',
concurrents=None,
label=None,
mkrundir=False,
)
cluster = dict(ppn=48,
max_walltime=9999,
mpi='mpirun -np {}',
max_ppn=48,
condafile="~/conda")
clusters = {
'ramses':
sd(
cluster,
mpi='mpirun -np {} -hostfile $PBS_NODEFILE',
),
'oakley':
sd(cluster, max_ppn=12, max_walltime=96, mpi='mpiexec -n {}'),
'garnet_standard_lw':
sd(cluster, max_ppn=32, max_walltime=168, mpi='aprun -n {}'),
'garnet_standard_sm':
sd(cluster, max_ppn=32, max_walltime=24, mpi='aprun -n {}'),
'garnet_debug':
sd(cluster, max_ppn=32, max_walltime=1, mpi='aprun -n {}'),
'armstrong_standard':
sd(cluster, max_ppn=24, max_walltime=168, mpi='aprun -n {}'),
'armstrong_debug':
sd(cluster, max_ppn=24, max_walltime=0.5, mpi='aprun -n {}'),
}
