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]; } }