"""Prepared B1 pulse, axisymmetric finite-volume hydrodynamics and local burn."""
import argparse
import json
import sys
from pathlib import Path

import numpy as np
from numba import njit

A_RAD = 7.565733250033928e-16
GAS = 8.314462618e3
AMBIENT = .01
LIGHT = 299792458.


@njit(cache=True)
def electron(rho, temp, ye, table):
    ld, lt, ep, ee = table
    d = (np.log(rho*ye/1000)-ld[0])/(ld[1]-ld[0])
    t = (np.log(temp)-lt[0])/(lt[1]-lt[0])
    if d < 0:
        p = rho*ye*GAS*temp
        return p, 1.5*p, 1., 1., 1., 1.
    d = min(d, len(ld)-1.00000001)
    t = min(t, len(lt)-1.00000001)
    i, j = int(d), max(0,int(t))
    x, y = d-i, t-j
    p0 = (1-x)*ep[i,j]+x*ep[i+1,j]
    p1 = (1-x)*ep[i,j+1]+x*ep[i+1,j+1]
    e0 = (1-x)*ee[i,j]+x*ee[i+1,j]
    e1 = (1-x)*ee[i,j+1]+x*ee[i+1,j+1]
    p = np.exp((1-y)*p0+y*p1)*.1
    e = np.exp((1-y)*e0+y*e1)*.1
    pd = ((1-y)*(ep[i+1,j]-ep[i,j])+y*(ep[i+1,j+1]-ep[i,j+1]))/(ld[1]-ld[0])
    ed = ((1-y)*(ee[i+1,j]-ee[i,j])+y*(ee[i+1,j+1]-ee[i,j+1]))/(ld[1]-ld[0])
    return p,e,pd,(p1-p0)/(lt[1]-lt[0]),ed,(e1-e0)/(lt[1]-lt[0])


@njit(cache=True)
def thermo(rho,temp,ye,yi,table):
    pe,ee,pd,pt,ed,et = electron(rho,temp,ye,table)
    ion = rho*yi*GAS*temp
    rad = A_RAD*temp**4
    p = pe+ion+rad/3
    e = ee+1.5*ion+rad
    cv = (et*ee+1.5*ion+4*rad)/temp
    c2 = (pd*pe+ion+(pt*pe+ion+4*rad/3)*(p+e-ed*ee-1.5*ion)/(cv*temp))/rho
    return p,e,cv,np.sqrt(max(c2,1.))


@njit(cache=True)
def state(rho,energy,ye,yi,table):
    if rho <= 0 or energy <= 0 or ye <= 0 or yi <= 0:
        raise ValueError('nonpositive hydro state')
    temp = min(energy/(1.5*rho*GAS*(ye+yi)),(energy/A_RAD)**.25)
    low,high=0.,np.inf
    for _ in range(40):
        p,e,cv,sound = thermo(rho,temp,ye,yi,table)
        change = (e-energy)/cv
        if abs(change) < 1e-7*temp:
            return p,temp,sound,cv
        if change>0:
            high=temp
        else:
            low=temp
        trial=temp-change
        if not low<trial<high:
            trial=.5*(low+high) if np.isfinite(high) else 2*temp
        temp=trial
    raise ValueError('EOS inversion did not converge')


@njit(cache=True)
def primitives(q,zz,table):
    nr,nz,_=q.shape
    w=np.empty((nr,nz,6))
    for i in range(nr):
        for j in range(nz):
            u=q[i,j]
            rho=u[0]
            vr,vz=u[1]/rho,u[2]/rho
            ye=0.
            yi=0.
            for k in range(len(zz)):
                yi+=u[4+k]
                ye+=zz[k]*u[4+k]
            p,t,c,cv=state(rho,u[3]-.5*rho*(vr*vr+vz*vz),ye/rho,yi/rho,table)
            w[i,j]=np.array([vr,vz,p,t,c,cv])
    return w


@njit(cache=True)
def minmod(a,b):
    return np.sign(a)*min(abs(a),abs(b)) if a*b>0 else 0.


@njit(cache=True)
def face(left,right,wl,wr,ll,rr,wll,wrr,dl,dr,dll,drr,normal,order,aa,zz,table):
    a=left.copy()
    b=right.copy()
    if order==2:
        for k in range(len(a)):
            a[k]+=dl*minmod((left[k]-ll[k])/(dll+dl),(right[k]-left[k])/(dl+dr))
            b[k]-=dr*minmod((right[k]-left[k])/(dl+dr),(rr[k]-right[k])/(dr+drr))
    states=(a,b)
    cells=(left,right)
    centers=(wl,wr)
    pressure=np.empty(2)
    sound=np.empty(2)
    for i in range(2):
        u=states[i]
        cell=cells[i]
        eint=u[3]-.5*(u[1]**2+u[2]**2)/u[0]
        source_eint=cell[3]-.5*(cell[1]**2+cell[2]**2)/cell[0]
        if order==1 or eint<.5*source_eint or max(left[0],right[0])>10*min(left[0],right[0]):
            u[:]=cell
            pressure[i]=centers[i][2]
            sound[i]=centers[i][4]
        else:
            species=u[4:4+len(aa)]
            species*=u[0]/(species@aa)
            pressure[i],_,sound[i],_=state(u[0],eint,species@zz/u[0],species.sum()/u[0],table)
    pa,pb=pressure
    va=a[normal+1]/a[0]
    vb=b[normal+1]/b[0]
    speed=max(abs(va)+sound[0],abs(vb)+sound[1])
    f=.5*(a*va+b*vb-speed*(b-a))
    f[normal+1]+=.5*(pa+pb)
    f[3]+=.5*(pa*va+pb*vb)
    return f


@njit(cache=True)
def hydro(q,w,re,ze,order,aa,zz,table):
    nr,nz,nv=q.shape
    dr=np.diff(re)
    dz=np.diff(ze)
    annulus=.5*np.diff(re**2)
    rhs=np.zeros_like(q)
    for j in range(nz):
        for i in range(1,nr):
            a,b=max(i-2,0),min(i+1,nr-1)
            f=face(q[i-1,j],q[i,j],w[i-1,j],w[i,j],q[a,j],q[b,j],w[a,j],w[b,j],
                   .5*dr[i-1],.5*dr[i],.5*dr[a],.5*dr[b],0,order,aa,zz,table)
            rhs[i-1,j]-=re[i]*f/annulus[i-1]
            rhs[i,j]+=re[i]*f/annulus[i]
        u=q[-1,j]
        f=u*max(w[-1,j,0],0.)
        f[1]+=w[-1,j,2]
        f[3]+=w[-1,j,2]*max(w[-1,j,0],0.)
        rhs[-1,j]-=re[-1]*f/annulus[-1]
    for i in range(nr):
        for j in range(1,nz):
            a,b=max(j-2,0),min(j+1,nz-1)
            f=face(q[i,j-1],q[i,j],w[i,j-1],w[i,j],q[i,a],q[i,b],w[i,a],w[i,b],
                   .5*dz[j-1],.5*dz[j],.5*dz[a],.5*dz[b],1,order,aa,zz,table)
            rhs[i,j-1]-=f/dz[j-1]
            rhs[i,j]+=f/dz[j]
        for j,sign in ((0,-1),(nz-1,1)):
            v=sign*max(sign*w[i,j,1],0.)
            f=q[i,j]*v
            f[2]+=w[i,j,2]
            f[3]+=w[i,j,2]*v
            rhs[i,j]-=sign*f/dz[j]
        for j in range(nz):
            rhs[i,j,1]+=w[i,j,2]*dr[i]/annulus[i]
    return rhs


@njit(cache=True)
def rates_at(temp, t0, step, rates):
    x=min(max((np.log(temp)-t0)/step,0.),len(rates)-1.0000001)
    i=int(x)
    return np.exp(rates[i]+(x-i)*(rates[i+1]-rates[i]))


@njit(cache=True)
def reaction(y,rate,react,change,delta,qnu,jacobian):
    n=len(y)
    rhs=np.zeros(n)
    jac=np.zeros((n,n))
    weak=0.
    for j in range(len(rate)):
        f=rate[j]
        for k in range(3):
            a=react[j,k]
            if a>=0:
                f*=y[a]
        weak+=qnu[j]*f
        for k in range(change.shape[1]):
            a=change[j,k]
            if a<0:
                break
            rhs[a]+=delta[j,k]*f
        if jacobian:
            for k in range(3):
                b=react[j,k]
                if b<0:
                    break
                derivative=rate[j]
                for l in range(3):
                    a=react[j,l]
                    if l!=k and a>=0:
                        derivative*=y[a]
                for l in range(change.shape[1]):
                    a=change[j,l]
                    if a<0:
                        break
                    jac[a,b]+=delta[j,l]*derivative
    return rhs,jac,weak


@njit(cache=True)
def burn(q,w,dt,volume,table,net,cutoff,deposition=None):
    aa,zz,masses,rate_table,t0,tstep,dense,react,change,delta,qnu=net
    total,weak_total=0.,0.
    for i in range(q.shape[0]):
        for j in range(q.shape[1]):
            if w[i,j,3]<cutoff or q[i,j,0]<.1:
                continue
            u=q[i,j]
            rho=u[0]
            y=u[4:4+len(aa)]/rho
            energy=u[3]-.5*(u[1]**2+u[2]**2)/rho
            elapsed=0.
            h=dt
            while elapsed<dt*(1-1e-12):
                h=min(h,dt-elapsed)
                _,temp,_,cv=state(rho,energy,y@zz,y.sum(),table)
                rate=rates_at(temp,t0,tstep,rate_table)
                rate*=np.where(dense==0,1.,np.where(dense==1,rho/1000,(rho/1000)**2))
                z=y.copy()
                good=False
                for _ in range(9):
                    f,jac,weak=reaction(z,rate,react,change,delta,qnu,True)
                    residual=z-y-h*f
                    if np.max(np.abs(residual))<2e-12 and z.min()>-2e-12:
                        good=True
                        break
                    z-=np.linalg.solve(np.eye(len(y))-h*jac,residual)
                released=(y-z)@masses*9.648533212e13
                loss=weak*h
                if not good or abs(released-loss)*rho>.04*cv*temp:
                    h*=.5
                    if h<dt*1e-8:
                        raise ValueError('burn substep exhausted')
                    continue
                z=np.maximum(z,0.)
                z/=z@aa
                released=(y-z)@masses*9.648533212e13
                heat=rho*(released-loss)
                energy+=heat
                u[3]+=heat
                total+=released*rho*volume[i,j]
                weak_total+=loss*rho*volume[i,j]
                if deposition is not None:
                    deposition[i,j]+=heat*volume[i,j]
                y=z
                elapsed+=h
                h*=1.5
            u[4:4+len(aa)]=y*rho
    return total,weak_total


@njit(cache=True)
def exchange(q,w,dt,re,ze,opacity):
    """Conservative positive exchange with a frozen FLD pair conductance."""
    nr,nz,_=q.shape
    r=.5*(re[:-1]+re[1:])
    z=.5*(ze[:-1]+ze[1:])
    area=.5*np.diff(re**2)
    dz=np.diff(ze)
    escaped=0.
    rad=A_RAD*w[:,:,3]**4
    internal=q[:,:,3]-.5*(q[:,:,1]**2+q[:,:,2]**2)/q[:,:,0]
    heat_capacity=w[:,:,5]*w[:,:,3]/(4*rad)
    # Two checkerboard passes in each coordinate prevent a cell from
    # donating against several stale radiation states simultaneously.
    for direction in range(2):
        for parity in range(2):
            for i in range(nr-(direction==0)):
                for j in range(nz-(direction==1)):
                    if ((i if direction==0 else j)%2)!=parity:
                        continue
                    k=i+(direction==0)
                    l=j+(direction==1)
                    va=2*np.pi*area[i]*dz[j]
                    vb=2*np.pi*area[k]*dz[l]
                    if direction==0:
                        distance=r[k]-r[i]
                        surface=2*np.pi*re[k]*dz[j]
                    else:
                        distance=z[l]-z[j]
                        surface=2*np.pi*area[i]
                    a,b=rad[i,j],rad[k,l]
                    if max(a,b)<1e10:
                        continue
                    ca=heat_capacity[i,j]*va
                    cb=heat_capacity[k,l]*vb
                    ra,rb=q[i,j,0],q[k,l,0]
                    if min(ra,rb)<.1:
                        # Freely escaping flux at the edge of the fluid.
                        if ra>=.1:
                            loss=min(dt*surface*LIGHT*a/4,.4*ca*a,.2*internal[i,j]*va)
                            q[i,j,3]-=loss/va
                            rad[i,j]-=loss/ca
                            internal[i,j]-=loss/va
                            escaped+=loss
                        elif rb>=.1:
                            loss=min(dt*surface*LIGHT*b/4,.4*cb*b,.2*internal[k,l]*vb)
                            q[k,l,3]-=loss/vb
                            rad[k,l]-=loss/cb
                            internal[k,l]-=loss/vb
                            escaped+=loss
                        continue
                    tau=opacity*.5*(ra+rb)*distance
                    ratio=abs(a-b)/(tau*.5*(a+b))
                    diffusion=LIGHT*surface/tau*(2+ratio)/(6+3*ratio+ratio**2)
                    inverse=1/ca+1/cb
                    change=(a-b)*(-np.expm1(-dt*diffusion*inverse))/inverse
                    # Restrict the lagged-capacity approximation in thin cells.
                    change=max(-min(.4*cb*b,.2*internal[k,l]*vb),min(change,.4*ca*a,.2*internal[i,j]*va))
                    q[i,j,3]-=change/va
                    q[k,l,3]+=change/vb
                    internal[i,j]-=change/va
                    internal[k,l]+=change/vb
                    rad[i,j]-=change/ca
                    rad[k,l]+=change/cb
    return escaped


def load_microphysics(code):
    sys.path[:0]=[str(code),str(code/'mixture-design')]
    import pulse_model as pm
    from fast_eos import FastEOS
    from updated_network import evaluate_rates,setup

    eos=FastEOS(code/'electron-eos.npz')
    ld=np.linspace(eos.ld[0],eos.ld[-1],360)
    lt=np.linspace(eos.lt[0],eos.lt[-1],550)
    table=(ld,lt,eos.ep(ld,lt),eos.ee(ld,lt))
    args,meta=setup()
    logt=np.linspace(np.log(2e7),np.log(3e9),2048)
    raw=np.array([evaluate_rates(np.exp(t)*1e-9,args[0],args[1],pm.NR,*args[10:]) for t in logt])*pm.PREF
    indices=np.full((pm.NR,6),-1,dtype=np.int64)
    changes=np.zeros_like(indices,dtype=float)
    for j in range(pm.NR):
        ids=np.flatnonzero(pm.STOICH[:,j])
        indices[j,:len(ids)]=ids
        changes[j,:len(ids)]=pm.STOICH[ids,j]
    net=(pm.AA,pm.ZZ,pm.MASS,np.log(np.maximum(raw,1e-300)),logt[0],logt[1]-logt[0],
         pm.DEXP,pm.REACT,indices,changes,pm.QNU*9.648533212e13)
    y=np.zeros(pm.NN)
    y[pm.SPECIES.index('p')]=2/17
    y[pm.SPECIES.index('n15')]=1/17
    return table,net,y,meta


def grid(dx, core, limit, growth):
    r=list(np.arange(round(core/dx)+1)*dx)
    delta=dx
    while r[-1]<limit:
        delta*=growth
        r.append(r[-1]+delta)
    r=np.array(r)
    z=np.r_[-r[:0:-1],r]
    return r,z


def initialize(trace,re,ze,table,net,y,args):
    t=trace['time_s']
    profile=args.profile
    crossing=float(np.interp(300.,trace['radius_m'][:,-1],t)) if args.contact_us is None else args.contact_us*1e-6
    if not profile and not t[0] <= crossing <= t[-1]:
        raise ValueError('contact time is outside archived pressure path')
    if profile:
        p=json.loads(profile.read_text())
        edge=np.r_[0.,p['outer_radius_m']]
        speed=-np.r_[0.,p['velocity_m_s']]
        temp=np.array(p['T_K'])
        crossing=0.
    else:
        edge,speed,temp=(np.array([np.interp(crossing,t,a) for a in trace[k].T])
                        for k in ('radius_m','reverse_velocity_m_s','temperature_K'))
    mass=trace['mass_kg']
    r=.5*(re[:-1]+re[1:])
    z=.5*(ze[:-1]+ze[1:])
    volume=np.pi*np.diff(re**2)[:,None]*np.diff(ze)[None,:]
    shape=volume.shape
    gas=np.zeros(shape+(5,))
    mu=(np.arange(1024)+.5)/512-1
    sin=np.sqrt(1-mu*mu)
    hemisphere=np.sign(mu)
    x=(np.arange(128)+.5)/128
    seed_radius=np.interp(args.seed_fraction,np.r_[0.,np.cumsum(mass)/sum(mass)],edge**3)**(1/3)
    from scipy.special import ndtri
    from scipy.stats import qmc
    # Conditional local mixing closure. The Sobol sample resolves the
    # one-point distribution of fully three-dimensional launch offsets.
    scattered = any((args.jitter_pointing,args.jitter_timing,args.jitter_speed))
    if scattered:
        noise=ndtri(qmc.Sobol(4,scramble=True,seed=args.scatter_seed).random_base2(17)).T.reshape(4,len(x),len(mu))
    radial_thermal=[]
    radial_speed=[]
    for k,m in enumerate(mass):
        rho=m/(4*np.pi/3*(edge[k+1]**3-edge[k]**3))
        radial_thermal.append((thermo(rho,temp[k],y@net[1],y.sum(),table)[1]/rho,
                               thermo(rho,temp[k]*args.thermal_scale,y@net[1],y.sum(),table)[1]/rho))
        shell_radius=(edge[k]**3+x*(edge[k+1]**3-edge[k]**3))**(1/3)
        radial_speed.append(np.mean(.5*np.interp(shell_radius,edge,speed)**2))
    u0,u1=mass@np.array(radial_thermal)
    k0=mass@np.array(radial_speed)
    velocity_scale=np.sqrt((u0+k0-u1)/k0)
    for k,m in enumerate(mass):
        radius=(edge[k]**3+x*(edge[k+1]**3-edge[k]**3))[:,None]**(1/3)
        seed=radius<seed_radius
        v=velocity_scale*np.interp(radius,edge,speed)
        offset=1.1*args.pointing*(~seed)*sin
        radius=radius-(v*args.coherent_timing*1e-6+1.1*args.coherent_speed)*(~seed)*hemisphere
        angular_mass=1+.01*args.coherent_loading*hemisphere*(~seed)
        tangent=0.
        if scattered:
            offset=offset+1.1*args.jitter_pointing*noise[0]*(~seed)
            tangent=1.1*args.jitter_pointing*noise[1]*(~seed)
            radius=radius+(v*args.jitter_timing*1e-6*noise[2]+1.1*args.jitter_speed*noise[3])*(~seed)
        rr=radius*sin-offset*mu
        zz=radius*mu+offset*sin
        cylindrical=np.hypot(rr,tangent)
        i0=np.clip(np.searchsorted(r,cylindrical)-1,0,len(r)-2)
        j0=np.clip(np.searchsorted(z,zz)-1,0,len(z)-2)
        fr=(cylindrical-r[i0])/(r[i0+1]-r[i0])
        fz=(zz-z[j0])/(z[j0+1]-z[j0])
        # Reflect the cylindrical momentum at the symmetry axis.
        near=cylindrical<r[0]
        parity=np.where(near,cylindrical/r[0],1.)
        fr=np.clip(fr,0,1)
        fz=np.clip(fz,0,1)
        rho=m/(4*np.pi/3*(edge[k+1]**3-edge[k]**3))
        _,energy,_,_=thermo(rho,temp[k]*args.thermal_scale,y@net[1],y.sum(),table)
        items=(1.,-v*sin*rr/np.maximum(cylindrical,1e-30)*parity,-v*mu,energy/rho+.5*v*v,seed)
        for i in (0,1):
            for j in (0,1):
                ix=((i0+i)*len(z)+j0+j).ravel()
                weight=m/(len(x)*len(mu))*angular_mass*(fr if i else 1-fr)*(fz if j else 1-fz)
                for field,value in enumerate(items):
                    gas[:,:,field]+=np.bincount(ix,weights=(weight*value).ravel(),minlength=volume.size).reshape(shape)
    gas/=volume[:,:,None]
    gas[:,:,0]+=AMBIENT
    gas[:,:,3]+=thermo(AMBIENT,1e5,y@net[1],y.sum(),table)[1]
    q=np.concatenate((gas[:,:,:4],gas[:,:,:1]*y,gas[:,:,4:]),axis=2)
    return q,volume,crossing


def run(args):
    table,net,y,meta=load_microphysics(args.code)
    re,ze=grid(args.dx,args.core,args.limit,args.growth)
    with np.load(args.trace) as trace:
        q,volume,preparation=initialize(trace,re,ze,table,net,y,args)
    def integral(state,k):
        return float(np.sum(state[:,:,k]*volume))
    initial_energy=integral(q,3)
    initial_mass=integral(q,0)
    t=0.
    end=preparation+args.duration*1e-6
    total,weak,rad,escape,peak=0.,0.,0.,0.,0.
    steps=0
    history=[]
    deposition=np.zeros_like(volume)
    ignition=None
    rc=.5*(re[1:]+re[:-1])
    zc=.5*(ze[1:]+ze[:-1])
    ignition_energy=.1*2.543067142842466e24
    retries=0
    dr=np.diff(re)[:,None]
    dz=np.diff(ze)[None,:]
    while t<end*(1-1e-12):
        w=primitives(q,net[1],table)
        courant=(abs(w[:,:,0])+w[:,:,4])/dr+(abs(w[:,:,1])+w[:,:,4])/dz
        dt=min(args.cfl/courant.max(),end-t)
        initial_step=integral(q,3)
        order=args.order
        while True:
            try:
                stage=q+dt*hydro(q,w,re,ze,order,net[0],net[1],table)
                if args.order==2:
                    stage=.5*(q+stage+dt*hydro(stage,primitives(stage,net[1],table),re,ze,order,net[0],net[1],table))
                w=primitives(stage,net[1],table)
                break
            except ValueError:
                retries+=1
                if order==2:
                    order=1
                else:
                    dt*=.5
                if dt<1e-13:
                    raise
        escape+=initial_step-integral(stage,3)
        q=stage
        w=primitives(q,net[1],table)
        if args.opacity>0:
            rad+=exchange(q,w,dt,re,ze,args.opacity)
            w=primitives(q,net[1],table)
        if t+dt>preparation:
            e,n=burn(q,w,min(dt,t+dt-preparation),volume,table,net,args.burn_cutoff*1e6,deposition)
            total+=e
            weak+=n
            if ignition is None and total-weak>=ignition_energy:
                ignition=dict(time_us=(t+dt-preparation)*1e6,
                              axial_z_m=float(np.sum(deposition*zc[None,:])/(total-weak)),
                              cylindrical_radius_m=float(np.sum(deposition*rc[:,None])/(total-weak)))
        t+=dt
        steps+=1
        peak=max(peak,float(w[:,:,3].max()))
        if steps%100==0 or t>=end*(1-1e-12):
            row=dict(time_us=(t-preparation)*1e6,steps=steps,peak_temperature_K=peak,hydro_retries=retries,
                     deposited_J=total-weak,rad_J=rad,remaining_mass_kg=integral(q,0))
            history.append(row)
            print(row,flush=True)
    delta=integral(q,3)+escape+rad-initial_energy-total+weak
    result=dict(history=history,deposited_J=total-weak,weak_J=weak,rad_J=rad,
                escaped_hydro_energy_J=escape,initial_energy_J=initial_energy,initial_mass_kg=initial_mass,
                energy_residual_J=delta,peak_temperature_K=peak,first_ten_percent_reference=ignition,
                mass_fraction_closure_max=float(np.max(abs(q[:,:,4:4+len(y)]@net[0]/q[:,:,0]-1))),
                args={k:str(v) if isinstance(v,Path) else v for k,v in vars(args).items()},network=meta)
    args.out.write_text(json.dumps(result,indent=2,allow_nan=False)+'\n')


if __name__=='__main__':
    parser=argparse.ArgumentParser(description=__doc__)
    parser.add_argument('trace',type=Path)
    parser.add_argument('--code',type=Path,required=True)
    parser.add_argument('--profile',type=Path)
    parser.add_argument('--dx',type=float,default=2.)
    parser.add_argument('--core',type=float,default=56.)
    parser.add_argument('--limit',type=float,default=850.)
    parser.add_argument('--growth',type=float,default=1.09)
    parser.add_argument('--thermal-scale',type=float,default=1.)
    parser.add_argument('--seed-fraction',type=float,default=.0008)
    parser.add_argument('--jitter-pointing',type=float,default=0.)
    parser.add_argument('--jitter-speed',type=float,default=0.)
    parser.add_argument('--jitter-timing',type=float,default=0.)
    parser.add_argument('--coherent-timing',type=float,default=0.)
    parser.add_argument('--coherent-speed',type=float,default=0.)
    parser.add_argument('--coherent-loading',type=float,default=0.)
    parser.add_argument('--scatter-seed',type=int,default=2284)
    parser.add_argument('--pointing',type=float,default=0.)
    parser.add_argument('--contact-us',type=float)
    parser.add_argument('--duration',type=float,default=82.2779579)
    parser.add_argument('--burn-cutoff',type=float,default=100.)
    parser.add_argument('--cfl',type=float,default=.28)
    parser.add_argument('--opacity',type=float,default=.001)
    parser.add_argument('--order',type=int,choices=(1,2),default=2)
    parser.add_argument('--out',type=Path,required=True)
    run(parser.parse_args())
