local void newrun(void) {
eps = getdparam("eps"); // get input parameters
dtime = getdparam("dtime");
nstatic = getiparam("nstatic");
#if !defined(QUICKSCAN)
theta = getdparam("theta");
#endif
usequad = getbparam("usequad");
tstop = getdparam("tstop");
dtout = getdparam("dtout");
options = getparam("options");
outputs = getparam("outputs");
if (! strnull(infile)) // if data file was given
inputdata(); // then read inital data
else { // else make initial data
nbody = getiparam("nbody"); // get number of bodies
// I added this
timesteps = getiparam("timesteps"); // get number of timesteps
init_random(getiparam("seed")); // set random number gen.
testdata(); // and make plummer model
}
rsize = 1.0; // start root w/ unit cube
nstep = 0; // begin counting steps
tout = tnow; // schedule first output
}
FITS *rawopen(string name, string status, int naxis, int *nsize)
{
FITS *f;
int i,ndim,bitpix;
f = (FITS *) allocate(sizeof(FITS));
if (streq(status,"old")){ /* handle an old file */
f->fd = stropen(name,"r");
ndim = nemoinpi(getparam("naxis"),nsize,naxis);
if (ndim < 1) error("naxis= returns %d from parser",ndim);
f->naxis = ndim;
for (i=ndim; i<naxis; i++) nsize[i] = 1;
for (i=0; i<ndim; i++) f->axes[i] = nsize[i];
for (i=ndim; i<MAXNAX; i++) f->axes[i] = 1;
bitpix = getiparam("bitpix");
fit_setbitpix(bitpix);
if (bitpix==8) f->type = TYPE_8INT;
else if (bitpix==16) f->type = TYPE_16INT;
else if (bitpix==32) f->type = TYPE_32INT;
else if (bitpix==-32) f->type = TYPE_FLOAT;
else error("Invalid bitpix: %d",bitpix);
f->bytepix = ABS(bitpix)/8;
f->status = STATUS_OLD;
f->bscale = getdparam("bscale");
f->bzero = getdparam("bzero");
f->offset = getiparam("offset");
f->skip = f->offset;
f->ncards = 0;
} else
error("Cannot rawopen %s as \"%s\"\n",name,status);
fit_setblocksize( getiparam("blocksize") * getiparam("blocking") );
return f;
}
void gspsphere(void)
{
real gamma0, mcut, r, sig2, eint = 0.0;
static real *sig2tab = NULL;
bodyptr bp;
nbody = getiparam("nbody");
assert(nbody > 0);
gamma0 = getdparam("gamma");
mcut = getdparam("mcut");
assert(0.0 < mcut && mcut <= 1.0);
if (sig2tab == NULL)
sig2tab = calc_sig2_gsp(gsp, ggsp, 0.0);
if (btab == NULL)
btab = (bodyptr) allocate(nbody * SizeofBody);
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) {
Mass(bp) = gsp->mtot / nbody;
r = r_mass_gsp(gsp, xrandom(0.0, mcut * gsp->mtot));
pickshell(Pos(bp), NDIM, r);
CLRV(Vel(bp));
Rho(bp) = rho_gsp(gsp, r);
sig2 = sig2_gsp(gsp, ggsp, 0.0, sig2tab, r);
EntFunc(bp) = sig2 / rpow(Rho(bp), gamma0 - 1);
Uintern(bp) = sig2 / (gamma0 - 1);
eint += Mass(bp) * Uintern(bp);
}
eprintf("[%s: thermal energy = %f]\n", getargv0(), eint);
}
int main(int argc, string argv[])
{
stream istr, ostr;
bodyptr btab = NULL;
int nbody;
real tnow;
string intags[MaxBodyFields];
gsprof *gsp;
initparam(argv, defv);
layout_body(bodyfields, Precision, NDIM);
istr = stropen(getparam("in"), "r");
get_history(istr);
if (! get_snap(istr, &btab, &nbody, &tnow, intags, FALSE))
error("%s: snapshot input failed\n", getargv0());
if (! set_member(intags, PosTag))
error("%s: position data missing\n", getargv0());
if (! set_member(intags, MassTag))
error("%s: mass data missing\n", getargv0());
gsp = snapgsp(btab, nbody, getiparam("npoint"),
getdparam("alpha"), getdparam("beta"));
if (! strnull(getparam("out"))) {
ostr = stropen(getparam("out"), "w");
put_history(ostr);
put_gsprof(ostr, gsp);
strclose(ostr);
}
return (0);
}
int main(int argc, string argv[])
{
real rrange[2], rmax;
int np;
double lgrs;
gsprof *gsp;
stream ostr;
initparam(argv, defv);
setrange(rrange, getparam("rrange"));
np = getiparam("npoint");
rmax = pow(2.0, floor(log2(32.0 / getdparam("alpha"))));
if (rmax < rrange[1] && getbparam("smartrange")) {
lgrs = log2(rrange[1] / rrange[0]) / (np - 1);
np = 1 + log2(rmax / rrange[0]) / lgrs;
eprintf("[%s: warning: npoint = %d -> %d rrange[1] = %f -> %f]\n",
getprog(), getiparam("npoint"), np, rrange[1], rmax);
rrange[1] = rmax;
}
gsp = gsp_expd(getdparam("mtot"), getdparam("alpha"), getdparam("zdisk"),
np, rrange[0], rrange[1]);
ostr = stropen(getparam("out"), "w");
put_history(ostr);
gsp_write(ostr, gsp);
fflush(NULL);
return 0;
}
int main(int argc, string argv[])
{
stream istr, ostr;
string times, *vecs, *produce, iotags[MaxBodyFields];
bool expand;
snapshot snap = { NULL, 0, 0.0 };
initparam(argv, defv);
istr = stropen(getparam("in"), "r");
get_history(istr);
ostr = stropen(getparam("out"), "w");
put_history(ostr);
times = getparam("times");
vecs = burststring(getparam("vectors"), ", ");
expand = streq(getparam("produce"), "*");
if (! expand) {
produce = burststring(getparam("produce"), ", ");
layout_body(produce, Precision, NDIM);
}
while (get_snapshot_timed(istr, snap, iotags, expand, times)) {
eprintf("[%s: rotating time %f]\n", getprog(), snap.time);
snaprotate(&snap, iotags, vecs, getparam("order"), getbparam("invert"),
getdparam("thetax"), getdparam("thetay"), getdparam("thetaz"));
put_snapshot(ostr, snap, iotags);
skip_history(istr);
}
strclose(ostr);
return (0);
}
int main(int argc, string argv[])
{
stream istr, ostr;
gsprof *gsp;
int np, i;
real r0, lgrs, r;
initparam(argv, defv);
istr = stropen(getparam("in"), "r");
get_history(istr);
gsp = get_gsprof(istr);
if (! strnull(getparam("out"))) {
ostr = stropen(getparam("out"), "w");
put_history(ostr);
put_gsprof(ostr, gsp);
strclose(ostr);
}
np = getiparam("npoint");
r0 = 1.0 / getdparam("r0inv");
lgrs = getdparam("lgrstep");
printf("%12s%12s%12s%12s%12s%12s\n",
"radius", "log rho", "drho/dr", "mass", "mtot-mass", "radius(m)");
for (i = 0; i < np; i++) {
r = r0 * rpow(2.0, lgrs * i);
printf("%12.5f%12.7f%12.3e%12.8f%12.8f%12.5f\n", r,
rlog10(rho_gsp(gsp, r)), drho_gsp(gsp, r),
mass_gsp(gsp, r), gsp->mtot - mass_gsp(gsp, r),
r_mass_gsp(gsp, mass_gsp(gsp, r)));
}
free_gsprof(gsp);
return (0);
}
nemo_main()
{
anisorad = getdparam("anisorad");
mcutoff = getdparam("mcutoff");
ntab = MXTB;
plummer();
writemodel(getparam("out"));
}
void main(int argc, string argv[])
{
initparam(argv, defv);
if (within(getdparam("val"), getparam("range"), getdparam("fuzz")))
printf("within returns TRUE\n");
else
printf("within returns FALSE\n");
}
void gspmodel(void)
{
real beta_a, mcut, vcut, vfac;
static real *sig2 = NULL;
real r, vmax2, sigr, sig, x, y, vr, v1, v2;
bodyptr bp;
vector rhat, vec1, vec2, vtmp;
beta_a = getdparam("beta_a");
assert(beta_a <= 1.0);
nbody = getiparam("nbody");
assert(nbody > 0);
mcut = getdparam("mcut");
assert(0.0 < mcut && mcut <= 1.0);
vcut = getdparam("vcut");
assert(vcut > 0.0);
if (sig2 == NULL)
sig2 = calc_sig2_gsp(gsp, ggsp, beta_a);
if (btab == NULL)
btab = (bodyptr) allocate(nbody * SizeofBody);
vfac = rsqrt(1 - beta_a);
for (bp = btab; bp < NthBody(btab, nbody); bp = NextBody(bp)) {
Mass(bp) = gsp->mtot / nbody;
r = r_mass_gsp(gsp, xrandom(0.0, mcut * gsp->mtot));
vmax2 = -2 * rsqr(vcut) * phi_gsp(ggsp, r);
if (vfac > 1.0)
vmax2 = vmax2 / rsqr(vfac);
sigr = rsqrt(sig2_gsp(gsp, ggsp, beta_a, sig2, r));
sig = fixsigma(sigr, rsqrt(vmax2));
do {
vr = grandom(0.0, sig);
v1 = grandom(0.0, sig);
v2 = grandom(0.0, sig);
} while (vr*vr + v1*v1 + v2*v2 > vmax2);
picktriad(rhat, vec1, vec2);
MULVS(Pos(bp), rhat, r);
MULVS(Vel(bp), rhat, vr);
MULVS(vtmp, vec1, v1 * vfac);
ADDV(Vel(bp), Vel(bp), vtmp);
MULVS(vtmp, vec2, v2 * vfac);
ADDV(Vel(bp), Vel(bp), vtmp);
Phi(bp) = phi_gsp(ggsp, r);
Aux(bp) = Phi(bp) + 0.5 * dotvp(Vel(bp), Vel(bp));
}
if (getbparam("besort"))
qsort(btab, nbody, SizeofBody, berank);
if (getbparam("zerocm"))
snapcenter(btab, nbody, MassField.offset);
if (! strnull(getparam("auxvar")))
setauxvar(btab, nbody);
}
void nemo_main()
{
int seed;
rmin = -0.5 * getdparam("size");
rmax = -rmin;
nbody = getiparam("nbody");
sigma = getdparam("sigma");
seed = init_xrandom(getparam("seed"));
zerocm = getbparam("zerocm");
mkcube();
writegalaxy(getparam("out"), getparam("headline"));
free(btab);
}
int main(int argc, string argv[])
{
real rrange[2];
gsprof *gsp;
stream ostr;
initparam(argv, defv);
setrange(rrange, getparam("rrange"));
gsp = plumgsp(getdparam("mtot"), getdparam("a"),
getiparam("npoint"), rrange[0], rrange[1]);
ostr = stropen(getparam("out"), "w");
put_history(ostr);
put_gsprof(ostr, gsp);
strclose(ostr);
return (0);
}
int main(int argc, string argv[])
{
stream istr, ostr;
real eps2, tnow;
int nforce, nbody, i;
bodyptr btab = NULL;
string intags[MaxBodyFields];
initparam(argv, defv);
layout_body(bodytags, Precision, NDIM);
istr = stropen(getparam("in"), "r");
get_history(istr);
ostr = stropen(getparam("out"), "w");
put_history(ostr);
eps2 = rsqr(getdparam("eps"));
nforce = -1; /* use nforce as flag... */
while (get_snap(istr, &btab, &nbody, &tnow, intags, FALSE)) {
if (nforce == -1 && ! set_member(intags, MassTag))
error("%s: Mass data missing from 1st snapshot\n", getargv0());
if (! set_member(intags, PosTag))
error("%s: %s data missing\n", getargv0(), PosTag);
if (nforce == -1)
nforce = (strnull(getparam("nforce")) ?
nbody : MIN(getiparam("nforce"), nbody));
for (i = 0; i < nforce; i++)
sum1force(btab, nbody, i, eps2);
put_snap(ostr, &btab, &nforce, &tnow, bodytags);
}
return (0);
}
int main(int argc, string argv[])
{
stream istr;
gsprof *tgsp, *mgsp;
real beta_a, *sig2, rrange[2], lgrs, r;
int np, i;
initparam(argv, defv);
istr = stropen(getparam("gsp"), "r");
get_history(istr);
tgsp = get_gsprof(istr);
strclose(istr);
if (! strnull(getparam("grav"))) {
istr = stropen(getparam("grav"), "r");
get_history(istr);
mgsp = get_gsprof(istr);
strclose(istr);
} else
mgsp = tgsp;
beta_a = getdparam("beta_a");
sig2 = calc_sig2_gsp(tgsp, mgsp, beta_a);
np = getiparam("npoint");
setrange(rrange, getparam("rrange"));
lgrs = rlog2(rrange[1] / rrange[0]) / (np - 1);
printf("%12s %12s\n", "radius", "sig_r^2");
for (i = 0; i < np; i++) {
r = rrange[0] * rpow(2.0, lgrs * i);
printf("%12.5f %12.7f\n",
r, sig2_gsp(tgsp, mgsp, beta_a, sig2, r));
}
return (0);
}
int main(int argc, string argv[])
{
stream outstr;
int nmodel;
real tzero = 0.0;
initparam(argv, defv);
layout_body(bodyfields, Precision, NDIM);
nbody = getiparam("nbody");
nmodel = getiparam("nmodel");
if (nbody < 1 || nmodel < 1)
error("%s: absurd value for nbody or nmodel\n", getprog());
btab = (bodyptr) allocate(nbody * SizeofBody);
init_random(getiparam("seed"));
outstr = stropen(getparam("out"), "w");
put_history(outstr);
while (--nmodel >= 0) {
plummodel(getdparam("mfrac"));
if (getbparam("besort"))
qsort(btab, nbody, SizeofBody, berank);
if (getbparam("zerocm"))
snapcenter(btab, nbody, MassField.offset);
put_snap(outstr, &btab, &nbody, &tzero, bodyfields);
fflush(outstr);
}
return (0);
}
nemo_main()
{
real xtrans(real), ytrans(real);
formalaxis = getbparam("formalaxis");
xlabdn = getdparam("xlabdn");
xszlab = getdparam("xszlab");
ylablf = getdparam("ylablf");
yszlab = getdparam("yszlab");
plinit("***", 0.0, 20.0, 0.0, 20.0);
xaxis( 2.0, 2.0, 16.0, xrange, -3, xtrans, "x");
xaxis( 2.0, 18.0, 16.0, xrange, -3, xtrans, NULL);
yaxis( 2.0, 2.0, 16.0, yrange, -7, ytrans, "y");
yaxis(18.0, 2.0, 16.0, yrange, -7, ytrans, NULL);
plstop();
}
int main(int argc, string argv[])
{
stream istr, ostr;
string itags[MaxBodyFields];
initparam(argv, defv);
new_field(&LinkField, IntType, LinkTag); /* use int's worth of space */
new_field(&LinkField + 1, NULL, NULL);
layout_body(bodytags, Precision, NDIM);
istr = stropen(getparam("in"), "r");
get_history(istr);
if (! get_snap(istr, &btab, &nbody, &tnow, itags, TRUE))
error("%s: snapshot input failed\n", getargv0());
if (! set_member(itags, PosTag))
error("%s: %s data missing\n", getargv0(), PosTag);
if (getbparam("subkey") && ! set_member(itags, KeyTag))
error("%s: %s data missing\n", getargv0(), KeyTag);
findobj(getdparam("bcrit"), getiparam("nmin"), getbparam("subkey"));
ostr = stropen(getparam("out"), "w");
put_history(ostr);
put_snap(ostr, &btab, &nbody, &tnow,
set_union(itags, set_cons(KeyTag, NULL)));
strclose(ostr);
return (0);
}
int main(int argc, string *argv)
{
initparam(argv, defv);
printf("program %s:\n", getprog());
printf(" input = \"%s\" [%o]\n", getparam("input"),
getparamstat("input"));
printf(" output = \"%s\" [%o]\n", getparam("output"),
getparamstat("output"));
printf(" answer = %d [%o]\n", getiparam("answer"),
getparamstat("answer"));
printf(" value = %g [%o]\n", getdparam("value"),
getparamstat("value"));
printf(" flag = %s [%o]\n", getbparam("flag") ? "TRUE" : "FALSE",
getparamstat("flag"));
printf(" foobar = \"%s\" [%o]\n", getparam("foobar"),
getparamstat("foobar"));
printf(" VERSION = \"%s\" [%o]\n", getversion(),
getparamstat("VERSION"));
if (getbparam("flag")) {
printf("getparamstat(\"junk\") = %o\n", getparamstat("junk"));
printf("calling getparam(\"junk\")\n");
(void) getparam("junk");
}
return (0);
}
void nemo_main()
{
real x,y = 0;
int count, random;
string name;
int work = 0;
x = getdparam("real");
count = getiparam("count");
random = getiparam("random");
name = getparam("in");
if (*name) {
work++;
get_number(name,&y);
} else
dprintf(1,"No input file specified\n");
name = getparam("out");
if (*name) {
work++;
put_number(name,y+x,count,random);
} else
dprintf(1,"No output file specified\n");
if (work==0) warning("No work done, use in=, out=, or both");
}
void nemo_main()
{
int i, nrad, n;
int mode = getiparam("mode");
if (mode==1) {
dubinski();
return;
}
sign_L = getdparam("sign");
nrad = nemoinpi(getparam("nbody"),nbody,MAXRAD);
n = nemoinpd(getparam("radius"),radius,MAXRAD);
if (n!=nrad) error("radius=");
n = nemoinpd(getparam("mass"),mass,MAXRAD);
if (n!=nrad) error("mass=");
n = nemoinpd(getparam("phi"),phi,MAXRAD);
if (n!=nrad) error("phi=");
nobj_max = nbody[0];
for (i=1; i<nrad; i++)
if (nbody[i] > nobj_max) nobj_max = nbody[i];
pmass = (real *) allocate(sizeof(real)*nobj_max);
pphase = allocate_mdarray3(nobj_max,2,NDIM);
headline = getparam("headline");
for (i=0; i<nrad; i++) {
makering(nbody[i],mass[i],radius[i],phi[i]);
writesnap(nbody[i]);
}
strclose(outstr);
nemo_dprintf(1,"Total number of particles written: %d\n",ntot);
}
void testdisk(void)
{
int ndisk, i;
real rmin2, rmax2, eps2, sigma, r_i, theta_i, m_i, v_i;
bodyptr gp, sp;
ndisk = getiparam("ndisk");
ngalaxy = ndisk + (getbparam("nosphr") ? 0 : nspheroid);
galaxy = (bodyptr) allocate(ngalaxy * SizeofBody);
rmin2 = rsqr(getdparam("rmin"));
rmax2 = rsqr(getdparam("rmax"));
eps2 = rsqr(getdparam("eps"));
sigma = getdparam("sigma");
init_random(getiparam("seed"));
for (i = 0; i < ndisk; i++) { /* build disk */
gp = NthBody(galaxy, i);
Mass(gp) = 0.0; /* set mass to zero */
r_i = rsqrt(rmin2 + i * (rmax2 - rmin2) / (ndisk - 1.0));
theta_i = xrandom(0.0, TWO_PI);
Pos(gp)[0] = r_i * rsin(theta_i); /* set positions */
Pos(gp)[1] = r_i * rcos(theta_i);
Pos(gp)[2] = 0.0;
if (r_i < rsph[NTAB-1])
m_i = seval(r_i, &rsph[0], &msph[0], &msph[NTAB], NTAB);
else
m_i = msph[NTAB-1];
v_i = rsqrt(MAX(m_i, 0.0) * r_i*r_i / rpow(r_i*r_i + eps2, 1.5));
/* set velocities */
Vel(gp)[0] = grandom( v_i * rcos(theta_i), sigma);
Vel(gp)[1] = grandom(- v_i * rsin(theta_i), sigma);
Vel(gp)[2] = grandom( 0.0, sigma);
}
if (! getbparam("nosphr"))
for (i = 0; i < nspheroid; i++) { /* append spheroid */
sp = NthBody(spheroid, i);
gp = NthBody(galaxy, ndisk + i);
memcpy(gp, sp, SizeofBody);
}
if (getbparam("zerocm"))
snapcenter(galaxy, ngalaxy, MassField.offset);
}
int main(int argc, string argv[])
{
double alpha, rcut;
int model;
initparam(argv, defv);
alpha = getdparam("alpha");
rcut = getdparam("rcut");
model = (alpha <= 0.0 ? -1 : getiparam("model"));
ndisk = getiparam("ndisk");
init_random(getiparam("seed"));
readgsp();
setprof(model, alpha, rcut);
layout_body(bodyfields, Precision, NDIM);
disk = (bodyptr) allocate(ndisk * SizeofBody);
makedisk(getbparam("randspin"));
if (! getbparam("randspin")) // if spins not random
bodyfields[2] = NULL; // don't write AuxVec field
writemodel();
fflush(NULL);
return 0;
}
void nemo_main()
{
int seed;
rmin = -0.5 * getdparam("size");
rmax = -rmin;
ngrid = getiparam("ngrid");
nbody = ngrid * ngrid * ngrid ;
zerocm = getbparam("zerocm");
mkgrid();
writegalaxy(getparam("out"), getparam("headline"));
free(btab);
}
void force_calc(void)
{
real *pp, *ap;
double cpubase;
string *rminxstr;
int i;
bodyptr bp;
tol = getdparam("tol");
eps = getdparam("eps");
rsize = getdparam("rsize");
rminxstr = burststring(getparam("rmin"), ", ");
if (xstrlen(rminxstr, sizeof(string)) < NDIM) {
SETVS(rmin, - rsize / 2.0);
} else
for (i = 0; i < NDIM; i++)
rmin[i] = atof(rminxstr[i]);
dprintf(0,"initial rsize: %8f rmin: %8f %8f %8f\n",
rsize, rmin[0], rmin[1], rmin[2]);
fcells = getdparam("fcells");
phidata = pp = (real *) allocate(ntest * sizeof(real));
accdata = ap = (real *) allocate(ntest * NDIM * sizeof(real));
cpubase = cputime();
maketree(massdata, nmass);
cputree = cputime() - cpubase;
dprintf(0," final rsize: %8f rmin: %8f %8f %8f\n",
rsize, rmin[0], rmin[1], rmin[2]);
cpubase = cputime();
n2btot = nbctot = 0;
for (bp = testdata; bp < testdata+ntest; bp++) {
hackgrav(bp);
*pp++ = Phi(bp);
SETV(ap, Acc(bp));
ap += NDIM;
n2btot += n2bterm;
nbctot += nbcterm;
}
cpufcal = cputime() - cpubase;
}
local void writesnap(string name, string headline)
{
stream outstr;
real tzero = getdparam("time");
int bits = MassBit | PhaseSpaceBit | TimeBit;
if (! streq(headline, ""))
set_headline(headline);
outstr = stropen(name, "w");
put_history(outstr);
put_snap(outstr, &disktab, &ndisk, &tzero, &bits);
strclose(outstr);
}
void setparams()
{
infile = getparam ("in");
outfile = getparam ("out");
if(hasvalue("gauss")) { /* gaussian beam */
if(nemoinpr(getparam("gauss"),&gauss_fwhm,1) != 1)
error ("gauss=%s : beam must have 1 dimension",
getparam("gauss"));
gauss_cut = 0.0;
} else
error("need gauss=");
spike = getdparam("spike");
fraction = getdparam("fraction");
cutoff = getdparam("cutoff");
noise = getdparam("noise");
nsmooth = 1;
dir = getparam("dir");
Qbad = hasvalue("bad");
if (Qbad) bad = getdparam("bad");
}
int main(int argc, string argv[])
{
stream outstr = NULL;
int nmodel;
real tzero = 0.0;
initparam(argv, defv);
layout_body(bodyfields, Precision, NDIM);
npol = getdparam("n");
mpol = getdparam("m");
nbody = getiparam("nbody");
btab = (bodyptr) allocate(nbody * SizeofBody);
init_random(getiparam("seed"));
nmodel = getiparam("nmodel");
if (! ((npol == 1.0 && mpol == -1.0) ||
(npol == 0.5 && mpol == -0.5)))
polysolve(getdparam("hstep"), getbparam("listmodel"));
if (! strnull(getparam("out"))) {
outstr = stropen(getparam("out"), "w");
put_history(outstr);
}
while (--nmodel >= 0) {
if (npol == 1.0 && mpol == -1.0)
polymodel1();
else if (npol == 0.5 && mpol == -0.5)
polymodel2();
else
polymodel();
if (getbparam("besort"))
qsort(btab, nbody, SizeofBody, berank);
if (getbparam("zerocm"))
snapcenter(btab, nbody, MassField.offset);
if (outstr != NULL)
put_snap(outstr, &btab, &nbody, &tzero, bodyfields);
fflush(outstr);
}
return (0);
}
local void oldrun(void) {
restorestate(getparam("restore")); // read in old state file
if (getparamstat("eps") & ARGPARAM) // was eps given new value?
eps = getdparam("eps"); // use command line value
if (getparamstat("nstatic") & ARGPARAM) // likewise for others...
nstatic = getiparam("nstatic");
#if !defined(QUICKSCAN)
if (getparamstat("theta") & ARGPARAM)
theta = getdparam("theta");
#endif
if (getparamstat("usequad") & ARGPARAM)
usequad = getbparam("usequad");
if (getparamstat("options") & ARGPARAM)
options = getparam("options");
if (getparamstat("outputs") & ARGPARAM)
outputs = getparam("outputs");
if (getparamstat("tstop") & ARGPARAM)
tstop = getdparam("tstop");
if (getparamstat("dtout") & ARGPARAM)
dtout = getdparam("dtout");
if (scanopt(options, "new-tout")) // if output time reset
tout = tnow + dtout; // then offset from now
}
void nemo_main()
{
int n;
stream parstr, outstr;
string molfile = getparam("mol");
string outfile = getparam("out");
string outdir = getparam("outdir");
string exefile = "radex";
string datfile = "mol.dat";
string parfile = "input.txt";
string logfile = "radex.txt";
char dname[256], cmd[256];
real fmin = getdparam("fmin");
real fmax = getdparam("fmax");
real tkin = getdparam("tkin");
int npartner;
string *partner;
real density[MAXPARTNER];
real tbg = getdparam("tbg");
real cdmol = getdparam("cdmol");
real deltav = getdparam("deltav");
partner = burststring(getparam("partner"),",");
npartner = xstrlen(partner,sizeof(string))-1;
if (npartner < 1 || npartner>MAXPARTNER) error("too few/many partners");
n = nemoinpr(getparam("density"),density,MAXPARTNER);
if (n != npartner) error("need matching numbers for partner= and density=");
run_mkdir(outdir);
sprintf(dname,"%s/%s",outdir,parfile);
parstr = stropen(dname,"w");
fprintf(parstr,"%s\n",molfile);
fprintf(parstr,"%s\n",outfile);
fprintf(parstr,"%g %g\n",fmin,fmax);
fprintf(parstr,"%g\n",tkin);
fprintf(parstr,"%d\n",npartner);
for (n=0; n<npartner; n++) {
fprintf(parstr,"%s\n",partner[n]);
fprintf(parstr,"%g\n",density[n]);
}
fprintf(parstr,"%g\n",tbg);
fprintf(parstr,"%g\n",cdmol);
fprintf(parstr,"%g\n",deltav);
fprintf(parstr,"0\n");
strclose(parstr);
run_cd(outdir);
sprintf(cmd,"%s < %s > %s ", exefile, parfile, logfile);
run_sh(cmd);
}
void setparams()
{
int nw,nws[3];
infile = getparam ("in");
outfile = getparam ("out");
if(hasvalue("gauss")) { /* gaussian beam */
if(nemoinpr(getparam("gauss"),&gauss_fwhm,1) != 1)
error ("gauss=%s : beam must have 1 dimension",
getparam("gauss"));
gauss_cut = getrparam("cut");
} else /* beam by hand */
lsmooth = nemoinpr(getparam("smooth"),smooth,MSMOOTH);
nsmooth = getdparam("nsmooth");
dir = getparam("dir");
Qbad = hasvalue("bad");
if (Qbad) bad = getdparam("bad");
mode = getiparam("mode");
nw = nemoinpi("wiener",nws,3);
if (nw>0) {
/* for now */
nxw = nyw = nws[0];
}
}
