示例#1
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");
}
示例#2
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;
}
示例#3
0
void setparams()
{
    input = getparam("in");
    otimes = getparam("times");
    if (strcmp(otimes,"all")==0) {
        trange[0] = -HUGE;
        trange[1] =  HUGE;
    } else
    	setrange(trange, otimes);

    nplot=getiparam("nplot");    

    xvar = getparam("xvar");
    xvar_idx = get_idx(xvar);
    if (hasvalue("xlabel"))
        xlabel = getparam("xlabel");
    else
        xlabel = xvar;
    setrange(xrange, getparam("xrange"));

    yvar = getparam("yvar");
    yvar_idx = get_idx(yvar);
    if (hasvalue("ylabel"))
        ylabel = getparam("ylabel");
    else
        ylabel = yvar;
    setrange(yrange, getparam("yrange"));

    visib = getparam("visib");
    psize = getparam("psize");
#ifdef COLOR
    color = getparam("color");
#endif
    maxsteps = getiparam("maxsteps");
}
示例#4
0
void nemo_main()
{
    stream  instr, outstr;
    int     nx, ny, nz;        /* size of scratch map */
    int     nx1,ny1,nz1;
    int     nxaver, nyaver,nzaver;
    int     i,j,k, i0,j0,k0, i1,j1,k1;
    imageptr iptr=NULL, iptr1=NULL;      /* pointer to images */
    real    sum, tmp, zzz;
    bool    Qreorder = FALSE;
    bool    Qdummy, Qsample;
    string  reorder;

    instr = stropen(getparam("in"), "r");
    nxaver=getiparam("nxaver");
    nyaver=getiparam("nyaver");
    nzaver=getiparam("nzaver");
    Qdummy = getbparam("dummy");

    nx1 = nemoinpi(getparam("x"),ix,MAXDIM);
    ny1 = nemoinpi(getparam("y"),iy,MAXDIM);
    nz1 = nemoinpi(getparam("z"),iz,MAXDIM);
    if (nx1<0 || ny1<0 || nz1<0) error("Error parsing x,y,z=");
    Qsample = nx1>0 || ny1>0 || nz1>0;
    if (Qsample) warning("Sampling will be done");

    read_image( instr, &iptr);

    nx = Nx(iptr);	                   /* old cube size */
    ny = Ny(iptr);      
    nz = Nz(iptr);      
    nx1 = ax_index("x",nx,nx1,ix);         /* initialize new cube axes */
    ny1 = ax_index("y",ny,ny1,iy);         /* before any reordering */
    nz1 = ax_index("z",nz,nz1,iz);

    Qreorder = hasvalue("reorder");
    if (Qreorder) {
      reorder = getparam("reorder");
      if (strlen(reorder) != 3) error("Reorder must have 3 letters");
    } 

    outstr = stropen(getparam("out"), "w");

    if (nxaver>1 || nyaver>1 || nzaver>1) {  /*  averaging, but retaining size */
        dprintf(0,"Averaging map %d * %d * %d pixels; mapsize %d * %d * %d\n",
                   nxaver,nyaver,nzaver,nx,ny,nz);
        nx1 = nx/nxaver;  if (nx % nxaver) warning("X binning not even");
        ny1 = ny/nyaver;  if (ny % nyaver) warning("Y binning not even");
        nz1 = nz/nzaver;  if (nz % nzaver) warning("X binning not even");
	LOOP(k1,nz1) {
	  k = k1*nzaver;
	  LOOP(j1,ny1) {
            j = j1*nyaver;
	    LOOP(i1,nx1) {
	      i = i1*nxaver;
	      sum = 0.0;
	      LOOP(k0,nzaver) LOOP(j0,nyaver) LOOP(i0,nxaver) sum += CV(iptr, i+i0, j+j0, k+k0);
	      sum /= (real) (nxaver*nyaver*nzaver);
	      LOOP(k0,nzaver) LOOP(j0,nyaver) LOOP(i0,nxaver) CV(iptr, i+i0, j+j0, k+k0) = sum;
            }
示例#5
0
void nemo_main()
{
    string *tags;

    dprintf(2,"TSF: MaxSetLen = %d\n",MaxSetLen);   /* DEBUG - PJT */
    instr = stropen(getparam("in"), "r");
    maxprec = getbparam("maxprec");
    maxline = getiparam("maxline");
    indent = getiparam("indent");
#ifdef unix
    if(!hasvalue("margin")) {
	struct winsize w;
	ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
	margin = w.ws_col;
    } else
#endif
    margin = getiparam("margin");
    allline = getbparam("allline");
    if (hasvalue("item")) warning("item= is broken");
    testtag = getparam("item");
    xml = getbparam("xml");
    if (xml) {     /* if XML output used, it should print all items */
      allline = TRUE;
      printf("<nemo>\n");
    }
    octal = getbparam("octal");
    while ((tags = list_tags(instr)) != NULL) {
        print_item(*tags);
	free(*tags);
	free((char *)tags);
    }
    if (xml) printf("</nemo>\n");
}
示例#6
0
void nemo_main()
{
  stream  outstr;
  int     nx, ny, nz;  
  int     ix, iy, iz;
  imageptr optr=NULL;        /* pointer to image, needs to be NULL to force new */
  real    tmp, sum = 0.0;

  outstr = stropen(getparam("out"), "w");

  nx = getiparam("nx");
  ny = getiparam("ny");
  nz = getiparam("nz");

  dprintf(0,"Creating image cube (size : %d x %d x %d)\n",nx,ny,nz);

  create_cube(&optr,nx,ny,nz);

  for (iz=0; iz<nz; iz++) {
    for (iy=0; iy<ny; iy++) {
      for (ix=0; ix<nx/2; ix++) {
        CubeValue(optr,ix,iy,iz) = 0.0;
      }
    }
  }

  write_image(outstr, optr);



}
示例#7
0
setparams()
{
    trakflag = FALSE;
    input = getparam("in");
    times = getparam("times");

    xvar = getparam("xvar");
    if (hasvalue("xlabel"))
        xlabel = getparam("xlabel");
    else
	xlabel = xvar;
    setrange(xrange, getparam("xrange"));

    yvar = getparam("yvar");
    if (hasvalue("ylabel"))
        ylabel = getparam("ylabel");
    else
	ylabel = yvar;
    setrange(yrange, getparam("yrange"));
 
    zvar = getparam("zvar");
    if (hasvalue("zlabel"))
        zlabel = getparam("zlabel");
    else
	zlabel = zvar;
    setrange(zrange, getparam("zrange"));
 
    visib = getparam("visib");
    psize = getparam("psize");
    fillcircle = getbparam("fill_circle");

    if (hasvalue("xticks"))
      setticks(xticks, &nxticks, getparam("xticks"));
    else {
      xticks[0] = xrange[0];
      xticks[1] = xrange[1];
      nxticks = - getiparam("nxticks");
    } 
    if (hasvalue("yticks"))
      setticks(yticks, &nyticks, getparam("yticks"));
    else {
      yticks[0] = yrange[0];
      yticks[1] = yrange[1];
      nyticks = - getiparam("nyticks");
    } 
    if (hasvalue("zticks"))
      setticks(zticks, &nzticks, getparam("zticks"));
    else {
      zticks[0] = zrange[0];
      zticks[1] = zrange[1];
      nzticks = - getiparam("nzticks");
    } 

    s2box_opt = getparam("s2box");
    
#ifdef COLOR
    color = getparam("color");
    setrange(crange, getparam("crange"));
#endif
}
示例#8
0
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;
}
示例#9
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);
}
示例#10
0
int nemo_main() {
    int sock, mode = 0, 
      direction = 0,
      port = getiparam("port"),
      buffer_size = getiparam("bufsize");
    string rhost = NULL;
    bool Qreport = getbparam("report");

    if (hasvalue("host_sender")) {
      mode = CONNECT;
      direction = RECEIVE;
      rhost = getparam("host_sender");
    } else {
      mode = LISTEN;
      direction = SEND;
    }

    switch (mode) {
	case LISTEN:	sock = do_listen(port, rhost);
			break;
	case CONNECT:	sock = do_connect(port, rhost);
			break;
        default:	error("bad mode");
                        break;
    }
    switch (direction) {
        case SEND:	do_transfer(STDIN_FILENO, sock, buffer_size, FALSE, port);
			break;
        case RECEIVE:	do_transfer(sock, STDOUT_FILENO, buffer_size, Qreport, port);
			break;
        default:	error("bad direction");
			break;
    }
    return 0;
}
示例#11
0
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
}
示例#12
0
nemo_main()
{
  int n=getiparam("n");
  int iter=getiparam("iter");
  int m=getiparam("m");
  int seed = init_xrandom(getparam("seed"));
  int i,j,k,l;
  real *x, sum;
  real t0,t1,t2;

  init_timers(100);
  stamp_timers(0);

  x = (real *) allocate(n*sizeof(real));

  for (i=0; i<n; i++)         /* init the whole array */
    x[i] = xrandom(0.0,1.0);
  for (i=0; i<m; i++)         /* cache it in again ? */
    x[i] = xrandom(0.0,1.0);

  sum = 0.0;
  t0 = cputime();
  stamp_timers(1);
  if (m==0) {                         /* do it in one sweep, the N^2 algorithm */
    stamp_timers(2);
    for (l=0; l<iter;  l++)
      for (j=0; j<n; j++)
	for (i=0; i<n; i++)
	  sum += FUN(x[i],x[j]);
    stamp_timers(3);
  } else {                            /* N/M times a small M*M patch that may be in cache */
    stamp_timers(2);
    for (l=0; l<iter; l++)
      for (k=0; k<n-m; k++)
	for (j=k; j<k+m; j++)
	  for (i=k; i<k+m; i++)
	    sum += FUN(x[i],x[j]);
    stamp_timers(3);
  }
  stamp_timers(4);
  t1 = cputime();
  if (m)
    printf("%d %d %d sum=%lg Mops=%lg\n",
	 n,iter,m,sum,iter*m*m*n/(t1-t0)/60.0/1e6);
  else
    printf("%d %d %d sum=%lg Mops=%lg\n",
	 n,iter,m,sum,iter*n*n/(t1-t0)/60.0/1e6);
  stamp_timers(5);
  printf("%Ld %Ld %Ld %Ld %Ld\n",
	 diff_timers(0,1),
	 diff_timers(1,2),
	 diff_timers(2,3),
	 diff_timers(3,4),
	 diff_timers(4,5));
}
示例#13
0
void setparams(void)
{
  int i,n;
  real tmpr[3];

  isel = getiparam("select");

  switch (nemoinpd(getparam("scale"),scale,3)) {
  case 1:
    scale[1] = scale[0];
    scale[2] = 1.0;
    break;
  case 2:
    scale[2] = 1.0;
    break;
  case 3:
    break;
  case 0:
    scale[0] = scale[1] = scale[2] = 1.0;
    break;
  default:
    error("parsing error scale=%s",getparam("scale"));
  }
  if (nemoinpd(getparam("iscale"),iscale,2) != 2)
    error("parsing error scale=%s - must be 2 numbers",getparam("scale"));
  object = getparam("object");
  comment = getparam("comment");
  Qcdmatrix = getbparam("cdmatrix");
  Qradecvel = getbparam("radecvel");
  Qrefmap = hasvalue("refmap");
  if (Qrefmap)
    set_refmap(getparam("refmap"));

  Qcrpix = hasvalue("crpix");
  if (Qcrpix) {
    nref =  nemoinpr(getparam("crpix"),tmpr,3);
    for (i=0; i<nref; i++)
      ref_crpix[i] = tmpr[i];
  }
  Qcrval = hasvalue("crval");
  if (Qcrval) {
    nref =  nemoinpr(getparam("crval"),tmpr,3);
    for (i=0; i<nref; i++)
      ref_crval[i] = tmpr[i];
  }
  Qcdelt = hasvalue("cdelt");
  if (Qcdelt) {
    nref =  nemoinpr(getparam("cdelt"),tmpr,3);
    for (i=0; i<nref; i++)
      ref_cdelt[i] = tmpr[i];
  }
  Qdummy = getbparam("dummy");
  nfill = getiparam("nfill");
}
示例#14
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);
}
示例#15
0
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);
}
示例#16
0
int main(int argc, string argv[])
{
  string prog, itags[MaxBodyFields];
  stream xstr;
  int nprof, nbody, nsamp;
  real *prof1, *prof2, rrange[2], tnow;
  bodyptr btab = NULL;

  initparam(argv, defv);
  layout_body(fields, Precision, NDIM);
  prog = mktemp((string) copxstr("/tmp/sm_XXXXXX", sizeof(char)));
  xstr = execmap(prog);
  get_history(xstr);
  nprof = getiparam("nprof");
  prof1 = (real *) allocate((2 + nprof) * sizeof(real));
  prof2 = (real *) allocate((2 + nprof) * sizeof(real));
  setrange(rrange, getparam("rrange"));
  nsamp = 0;
  while (get_snap(xstr, &btab, &nbody, &tnow, itags, FALSE)) {
    setprofile(prof1, prof2, nprof, rrange, btab, nbody);
    nsamp++;
  }
  if (unlink(prog) != 0)
    error("%s: can't unlink %s\n", getargv0(), prog);
  if (nsamp == 0)
    error("%s: no data in input\n", getargv0());
  listdensity(prof1, prof2, nprof, rrange, nsamp);
  return (0);
}
示例#17
0
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);
}
示例#18
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);
}
示例#19
0
文件: tsf.c 项目: jasminegrosso/zeno
int main(int argc, string argv[])
{
    string tag;

    initparam(argv, defv);
    instr = stropen(getparam("in"), "r");
    maxprec = getbparam("maxprec");
    maxline = getiparam("maxline");
    indent = getiparam("indent");
    margin = getiparam("margin");
    while ((tag = next_item_tag(instr)) != NULL) {
        print_item(tag);
	free(tag);
    }
    return (0);
}
示例#20
0
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);
}
示例#21
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);
}
示例#22
0
文件: gsp.c 项目: jasminegrosso/zeno
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);
}
示例#23
0
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);
}
示例#24
0
nemo_main()
{
    imageptr iptr=NULL, optr=NULL;
    string *filename;
    stream instr, outstr;
    int i, j, i0, j0, nfiles;
    int nx, ny, nx1, ny1, ix, iy, n;

    nx = hasvalue("nx") ? getiparam("nx") : 0;
    ny = hasvalue("ny") ? getiparam("ny") : 0;
    
    filename = burststring(getparam("in")," ,\n");
    nfiles = xstrlen(filename,sizeof(string))-1;
    if (nx==0 && ny==0)
      error("Need at least one of nx= or ny=");
    else if (nx==0) {
      nx = nfiles/ny;
      dprintf(0,"nx=%d ny=%d nfiles=%d\n",nx,ny,nfiles);
      if (nfiles % ny) error("nfiles=%d/ny=%d does not divide evenly",nfiles,ny);
    } else if (ny==0) {
      ny = nfiles/nx;
      dprintf(0,"nx=%d ny=%d nfiles=%d\n",nx,ny,nfiles);
      if (nfiles % nx) error("nfiles=%d/nx=%d does not divide evenly",nfiles,nx);
    }

    for (iy=0, n=0; iy<ny; iy++) {
      for (ix=0; ix<nx; ix++, n++) {
	instr = stropen (filename[n],"r");
	read_image (instr,&iptr);               /* read image */
	strclose(instr);                        /* close image file */
	if (n==0) {
	  nx1 = Nx(iptr);
	  ny1 = Ny(iptr);
	  create_image(&optr,nx*nx1,ny*ny1);
	}
	i0 = ix*nx1;
	j0 = iy*ny1;
	for (j=0; j<ny1; j++)
	  for (i=0; i<nx1; i++)
	    MapValue(optr,i+i0,j+j0) = MapValue(iptr,i,j);
	i++;
      }
    }
    outstr = stropen(getparam("out"),"w");
    write_image(outstr,optr);
    strclose(outstr);
}
示例#25
0
void nemo_main()
{
    stream outstr;
    
    potential = get_potential(getparam("potname"),
                    getparam("potpars"), getparam("potfile"));
    rmin = getdparam("rmin");
    rmax = getdparam("rmax");
    rref = rmax;
    if (hasvalue("rref")) rref = getdparam("rref");
    Qkey = hasvalue("key");
    if (Qkey) key = getiparam("key");
    Qconstant = getbparam("constant");

    ndisk = getiparam("nbody");
    jz_sign = getiparam("sign");
    nmodel = getiparam("nmodel");
    totmass = getdparam("mass");
    offset = getdparam("phase") * PI / 180.0;    
    Qtest = getbparam("test");
    Quniform = getbparam("uniform");
    if (ABS(jz_sign) != 1) error("sign must be +1 or -1");

    Qlinear = hasvalue("k");
    if (Qlinear)
      SPk = getdparam("k");	/* corrected for rot counter clock wise */
    else if (hasvalue("pitch"))
      pitch = getdparam("pitch"); /* corrected for rot counter clock wise */
    else
      error("Either k= (linear) or pitch= (logarithmic) spiral indicator needed");
    
    init_xrandom(getparam("seed"));

    outstr = stropen(getparam("out"), "w");
    put_history(outstr);
    if (hasvalue("headline"))
	set_headline(getparam("headline"));
    setdensity();
    
    while (nmodel--) {
        testdisk(nmodel);
        writegalaxy(outstr);
    }
    strclose(outstr);
    free(disk);
}
示例#26
0
nemo_main()
{
    FunctionTable *ftp;
    string fmt1, fmode = getparam("mode");
    char fmt[100];
    real x[MAX_LINES], y;
    bool Qinv;
    int i, n, mode=FUNTAB_SPLINE;

    if (hasvalue("x") && hasvalue("y")) error("Can only handle x= or y=");

    Qinv = hasvalue("y");
    if (streq(fmode,"linear")) mode = FUNTAB_LINEAR;

    if (Qinv) {
        n = nemoinpd(getparam("y"),x,MAX_LINES);
        if (n<0) error("Error # %d parsing y=; or too many?",n);
    } else {
        n = nemoinpd(getparam("x"),x,MAX_LINES);
        if (n<0) error("Error # %d parsing x=; or too many?",n);
    }
    fmt1 = getparam("format");
    sprintf(fmt,"%s %s\n",fmt1,fmt1);
    dprintf(1,"Using format=\"%s\"\n",fmt);

    if (Qinv)
        ftp = ft_open(getparam("in"), mode,
                  getiparam("ycol"), getiparam("xcol"));
    else
        ftp = ft_open(getparam("in"), mode,
                  getiparam("xcol"), getiparam("ycol"));


    for (i=0; i<n; i++) {
        if (mode == FUNTAB_LINEAR)
            y = ft_linear(ftp, x[i]);
        else if (mode == FUNTAB_SPLINE)
            y = ft_spline(ftp, x[i]);
        else
            error("Bad mode");        
        printf(fmt,x[i], y);
    }

    ft_close(ftp);                  
}
示例#27
0
nemo_main()
{
    int seed;

    alpha = getdparam("alpha");
    rcut = getdparam("rcut");
    mdisk = getdparam("mdisk");
    Qtoomre = getdparam("Qtoomre");
    gammas = getdparam("gamma");
    ndisk = getiparam("nbody");
    z0 = getdparam("z0");             /* was called epsi in mkbaredisk */
    cmode = getiparam("mode");
    zmode = getiparam("zmode");
    seed = init_xrandom(getparam("seed"));
    Qtab = getbparam("tab");
    inittables();
    makedisk();
    writesnap(getparam("out"), getparam("headline"));
}
示例#28
0
setparams()
{
    string inname = getparam("in");
    nmax = nemo_file_lines(inname,getiparam("nmax"));
    if (nmax<0) error("Error opening %s",inname);
    if (nmax==0) error("No data?");
    instr = stropen (inname,"r");

    if (hasvalue("out"))
        outstr=stropen(getparam("out"),"w");
    else
        outstr=NULL;

    nxcol = nemoinpi(getparam("xcol"),xcolnr,MAXCOL);
    if (nxcol<0) error("Illegal xcol= nxcol=%d",nxcol);
    nycol = nemoinpi(getparam("ycol"),ycolnr,MAXCOL);
    if (nycol<0) error("Illegal ycol= nycol=%d",nycol);

    if (hasvalue("dxcol"))
        dxcolnr = getiparam("dxcol");
    else
        dxcolnr = 0;

    if (hasvalue("dycol"))
        dycolnr = getiparam("dycol");
    else
        dycolnr = 0;

    if (hasvalue("xrange"))
        setrange(xrange,getparam("xrange"));
    else {
        xrange[0] = -HUGE;
        xrange[1] = HUGE;
    } 
    
    method = getparam("fit");
    nsigma = getdparam("nsigma");
    order = getiparam("order");
    if (order<0) error("order=%d of %s cannot be negative",order,method);
    Qtab = getbparam("tab");

    mpfit_mode = getiparam("mpfit");
}
示例#29
0
int main(int argc, string argv[])
{
    initparam(argv, defv);
    readgsp();
    init_random(getiparam("seed"));
    layout_body(bodyfields, Precision, NDIM);
    gspmodel();
    writemodel();
    return (0);
}
示例#30
0
int main(int argc, string argv[])
{
  stream istr;
  string bodytags[] = { PosTag, NULL }, intags[MaxBodyFields];
  bodyptr btab = NULL, bp;
  int nbody, nshell, n;
  real tnow, vals[3];
  matrix tmpm, qmat;
  vector v1, v2, v3;

  initparam(argv, defv);
  istr = stropen(getparam("in"), "r");
  get_history(istr);
  layout_body(bodytags, Precision, NDIM);
  printf("#%11s %3s %11s %11s %11s\n",
	 "time", "n", "r_rms", "c/a", "b/a");
  while (get_snap(istr, &btab, &nbody, &tnow, intags, FALSE)) {
    if (! set_member(intags, PosTag))
      error("%s: %s data missing\n", getargv0(), PosTag);
    if (nbody % getiparam("nbin") != 0)
      error("%s: nbin does not divide number of bodies\n", getargv0());
    nshell = nbody / getiparam("nbin");
    for (n = 0; n < nbody; n += nshell) {
      CLRM(qmat);
      for (bp = NthBody(btab, n); bp < NthBody(btab, n + nshell);
	   bp = NextBody(bp)) {
	OUTVP(tmpm, Pos(bp), Pos(bp));
	ADDM(qmat, qmat, tmpm);
      }
      eigensolve(v1, v2, v3, vals, qmat);
      printf(" %11.6f %3d %11.6f %11.6f %11.6f\n",
	     tnow, n / nshell, rsqrt(tracem(qmat) / nshell),
	     rsqrt(vals[2] / vals[0]), rsqrt(vals[1] / vals[0]));
      if (getbparam("listvec")) {
	printf("#\t\t\t\t\t\t\t%8.5f  %8.5f  %8.5f\n", v1[0], v1[1], v1[2]);
	printf("#\t\t\t\t\t\t\t%8.5f  %8.5f  %8.5f\n", v2[0], v2[1], v2[2]);
	printf("#\t\t\t\t\t\t\t%8.5f  %8.5f  %8.5f\n", v3[0], v3[1], v3[2]);
      }
    }
  }
  return (0);
}