Пример #1
0
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)
Пример #2
0
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);
Пример #3
0
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)
Пример #4
0
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)
    mkdir(pbsbase)

    pbsbase = dir + "/" + pbsbase
    dats = ["sine700points.dat", myd['targetdat']]
    for dat in dats:
        sh.copy(dat, dir)
    with open(pbsbase + ".lsp", "w") as f:
        f.write(lsp)
    with open(pbsbase + ".pbs", "w") as f:
        f.write(pbs)
Пример #5
0
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]);
Пример #6
0
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);
    mkdir(pbsbase);
    
    pbsbase = dir+"/"+pbsbase;
    dats = ["sine700points.dat", myd['targetdat']];
    for dat in dats:
        sh.copy(dat, dir);
    with open(pbsbase+".lsp","w") as f:
        f.write(lsp);
    with open(pbsbase+".pbs","w") as f:
        f.write(pbs);
Пример #7
0
#!/usr/bin/env python3
from genlsp import genlsp
from genpbs import genpbs
from pys import sd, test


def output(lsp,
           pbs,
           pbsbase,
           dats=["sine700points.dat", "watercolumn.dat"],
           dir=None):
    if dir:
        mkdir(dir)
        pbsbase = dir + "/" + pbsbase
        for dat in dats:
            sh.copy(dat, dir)
    with open(pbsbase + ".lsp", "w") as f:
        f.write(lsp)
    with open(pbsbase + ".pbs", "w") as f:
        f.write(pbs)


pbsbase = "test3d2d"
lsp = genlsp(timestep=1e-17,
             totaltime=10e-15,
             lim=(-30, 5, -20, 20, 0, 0),
             tlim=(-27.5, 0, -15, 15, 0, 0),
             res=(1400, 1600, 0))
pbs = genpbs(pbsbase=pbsbase, lspexec='lsp-10-xy')
output(lsp, pbs, pbsbase)
Пример #8
0
#!/usr/bin/env python

from genlsp import genlsp
from genpbs import genpbs

pbsbase = "hotwater2d_baseline"
lsp = genlsp(lim=(-30, 5, -20, 20),
             res=(350 * 4, 400 * 4),
             tlim=(-27.5, 0, -15, 15),
             no_pmovies=True,
             timestep=4e-17,
             dumpinterval=2e-16)
pbs = genpbs(pbsbase=pbsbase)
with open(pbsbase + ".lsp", "w") as f:
    f.write(lsp)
with open(pbsbase + ".pbs", "w") as f:
    f.write(pbs)
Пример #9
0
def gensim(**kw):
    getkw =  mk_getkw(kw,defaults);
    pbsbase=getkw("pbsbase");
    files = ["sine700points.dat"];
    if test(kw, "autozipper"):
        files.append('zipper');
    files.append('loopscript');
    #
    # target creation
    #
    if test(kw,'singlescale'):
        if type(getkw('fp')) != tuple:
            fpx = get_roundfpx(kw);
            if getkw('fp') != 'nc':
                fpx += getkw('fp');
            kw['fp'] = (fpx,0.0,0.0);
        tlim = getkw('tlim')
        kw['xlen'] = tlim[1]-tlim[0];
        dens = genonescale(**kw);
        kw['dens_dat'] = "{}um.dat".format(getkw('expf'));
        files.append((kw['dens_dat'], dens));
    elif test(kw, 'scale_with_min'):
        #this involves a single scale where we
        #pick the min. We figure out the longitudinal
        #dimensions ourselves
        if not test(kw,'long_res') and not test(kw,'long_resd'):
            raise ValueError(
                "you must supply a longitudinal resolution for scale_with_min");
        long_margin = getkw('long_margin');
        expf,n_s,n_min,slen=getkw('expf','n_s','n_min','solid_len');
        pp_len = expf*np.log(n_s/n_min);
        if test(kw,'roundup_pp'):
            pp_len = np.ceil(pp_len);
        elif test(kw,'roundup_ten_pp'):
            pp_len = np.ceil(pp_len/10) * 10;
        if type(getkw('fp')) != tuple:
            fpx = get_roundfpx(kw);
            if getkw('fp') != 'nc':
                fpx += getkw('fp');
            kw['fp'] = (fpx,0.0,0.0);
        kw['lim'] = list(getkw('lim'));
        kw['tlim'] = list(getkw('tlim'));
        kw['res']  = list(getkw('res'));
        kw['tlim'][0] = -pp_len;
        kw['tlim'][1] = slen;
        kw['lim'][0] = kw['tlim'][0] - long_margin[0];
        kw['lim'][1] = kw['tlim'][1] + long_margin[1];
        xlen = kw['lim'][1] - kw['lim'][0];
        if test(kw, 'long_res'):
            kw['res'][0]  = xlen * kw['long_res']
        elif test(kw, 'long_resd'):
            kw['res'][0]  = int(np.round(xlen / (getkw('l')*1e6 / kw['long_resd'])));
        kw['timestep'] = getkw('timestep');
        if xlen*1e-6/kw['res'][0] < c*kw['timestep']:
            print("adapting timestep...");
            kw['timestep'] = xlen*1e-6/kw['res'][0];
        dens = genonescale(xlen=kw['tlim'][1]-kw['tlim'][0], **kw);
        kw['dens_dat'] = "{:0.2f}um.dat".format(getkw('expf'));
        files.append((kw['dens_dat'], dens));
        print("from scale_with_min, generated dimensions:");
        print(take(kw,['expf','res','tlim','lim','timestep']))
    #elif test(kw,'shelf'):
    #    if type(getkw('fp')) != tuple:
            # tlim = getkw('tlim');
            # kw['xlen'] = tlim[1]-tlim[0];
            # if test(kw, 'slen'):
            # if getkw('fp') != 'nc':
            #     fpx += getkw('fp');
            # kw['fp'] = (fpx,0.0,0.0);
    elif (test(kw,'externalf_1D') and test(kw, 'f_1D')) or (test(kw,'externalf_2D') and test(kw, 'f_2D')):
        if not test(kw, 'dats'): kw['dats']=[];
        tlim = getkw('tlim');
        if not test(kw, 'new_externalf'):
            kwp = sd(kw,
                     tlim=(0, tlim[1]-tlim[0],
                           0, tlim[3]-tlim[2],
                           0, 0),
                     unit=1e-4);
        else:
            kwp = sd(kw, unit=1e-4);
        if not test(kw, 'dens_dat'):
            kw['dens_dat'] = "watercolumn.dat";
        kw['dats'] += [(kw['dens_dat'], kwp)];
    if test(kw, 'dats'):
        files.extend([
            (fname, gendat(**sd(kw,**dat)))
            for fname,dat in kw['dats']
        ]);
    #
    # movies
    #
    movs = takef(kw,['movne','movni','movdq','movrho','movE','movB','movS']);
    #yes really.
    tyf = lambda s: re.search(r"mov(\w+)",s).group(1);
    movs = { tyf(k) : movs[k]
             for k in movs
             if movs[k]};
    for movtype in sorted(movs.keys()):
        sname ='mov'+movtype;
        movd={};
        if type(kw[sname]) == dict:
            movd = sd(kw,**kw[sname]);
        if not test(movd,'n_c'):
            movd['n_c'] = nc(kw['l']);
        movd['type'] = movtype;
        movstr=gen_mov(**movd);
        #adding it to pbs
        if not test(kw, "concurrents") or kw['concurrents'] is None:
            kw['concurrents'] = [(sname,'./'+sname)];
        else:
            kw['concurrents'] += [(sname,'./'+sname)];
        files.append((sname,movstr,0o755) );
    if test(kw,'angular'):
        #adding it to pbs
        if test(kw, "concurrents") and kw['concurrents'] is not None:
            kw['concurrents'] += [('genangular','./genangular')];
        else:
            kw['concurrents'] = [('genangular','./genangular')];
        files.append('genangular');

    #
    #special subdivisions
    #
    if test(kw, "splittime"):
        totaltime = getkw("totaltime");
        # Structure of splittime 
        # [ (totaltime, dict) ]
        # Each tuple represents a slice of the restarts
        # totaltime is supposed to be the end of that time slice.
        # The dict is what enters subdiv.
        # 
        # This does very little, it just overloads totaltime and
        # sets each `lspexec` of the restarts to r. It also adds a `pre`
        # that copies the restart files, facilitated by the "setrestart"
        # script.
        #
        # We read the last totaltime over the passed keyword.
        st = getkw("splittime");
        kw['subdivs'] = [];
        for i,(itime, id) in enumerate(st):
            if id is None: id = {};
            igetkw = mk_getkw(
                sd(kw,**id),
                defaults
            );
            if i == 0:
                si = '';
            else:
                si =  '_{}'.format(i);
            kw['subdivs'].append(
                sd(id,
                   totaltime=itime,
                   lspexec  =igetkw("lspexec")+" -r ",
                   dump_restart_flag=True,
                   pbsbase=pbsbase+si,));
    subdivs = getkw("subdivs");
    if len(subdivs) == 0:
        subdivs = [kw];
    for subdiv in subdivs:
        if not subdiv: subdiv=dict();
        ikw = sd(kw,**subdiv);
        igetkw = mk_getkw(ikw, defaults);
        pbses = igetkw('pbses');
        ipbsbase = igetkw('pbsbase');
        lsp=genlsp(**ikw);
        files.append((ipbsbase+".lsp", lsp));
        if pbses is None:
            files.append((ipbsbase+".pbs",genpbs(**ikw)))
        else:
            if pbses == "defaults":
                pbses = mk_hpcmp_pbses(
                    **ikw);
            for pbs in pbses:
                files.append(
                    (pbs['pbsname']+".pbs",
                     genpbs(**sd(ikw,**pbs)))
                );
    if test(kw,'extra_files'):
        files.extend(kw['extra_files']);
    dir=getkw('dir');
    if dir == True: dir = pbsbase;
    output(dir=dir,files=files);
Пример #10
0
#!/usr/bin/env python

from genlsp import genlsp
from genpbs import genpbs

pbsbase = "waterwake-again"
lsp = genlsp(
    w=8.17e-6,
    T=120e-15,
    l=3e-6,
    I=1.52e17,
    fp=(0, 0, 0),
    lim=(-85, 85, -35, 35),
    res=(170 * 10, 70 * 10),
    tlim=(-75, 75, -20, 20),
    timestep=1e-16,
    totaltime=1.2e-12,
    dumpinterval=5e-16,
    targetdat="steamjet.dat",
    description="longer micron lwfa?",
)
pbs = genpbs(pbsbase=pbsbase)
with open(pbsbase + ".lsp", "w") as f:
    f.write(lsp)
with open(pbsbase + ".pbs", "w") as f:
    f.write(pbs)
Пример #11
0
def output(lsp,pbs,pbsbase,
           dats=["sine700points.dat","watercolumn.dat"],
           dir=None):
    if dir:
        mkdir(dir);
        pbsbase = dir+"/"+pbsbase;
        for dat in dats:
            sh.copy(dat, dir);
    with open(pbsbase+".lsp","w") as f:
        f.write(lsp);
    with open(pbsbase+".pbs","w") as f:
        f.write(pbs);
pbsbase="test3d2d";
lsp=genlsp(
    timestep=1e-17,
    totaltime=10e-15,
    lim=( -30, 5,
           -20,20,
             0,0),
    tlim=(-27.5,0,
          -15  ,15,
            0  ,0),
    res =(1400,
          1600,
             0));
pbs=genpbs(
    pbsbase=pbsbase,
    lspexec='lsp-10-xy'
);
output(lsp,pbs,pbsbase);