real gfunc2(real x)
{
real y;
y = rpow(x, 1 / (npol - 0.5));
return (rpow(2 - y, npol - 1.5) * rpow(1 - y, 2*mpol + 2));
}
real gfunc1(real x)
{
if (rlog10(x) * (2*mpol + 2) < -36.0)
return (0.0);
else
return (rpow(1 - rsqr(x), npol - 1.5) * rpow(x, 2*mpol + 2));
}
local void testdata(void) {
real rsc, vsc, r, v, x, y;
bodyptr p;
float scale = 1.0f;
float vscale = 1.0f;
float mscale = 1.0f;
if (nbody < 1) // check for silly values
error("%s: absurd value for nbody\n", getargv0());
bodytab = (bodyptr) allocate(nbody * sizeof(body));
// alloc space for bodies
rsc = (3 * PI) / 16; // set length scale factor
vsc = rsqrt(1.0 / rsc); // find speed scale factor
for (p = bodytab; p < bodytab+nbody; p++) { // loop over particles
Type(p) = BODY; // tag as a body
//Mass(p) = 1.0 / nbody; // set masses equal
// Set mass randomly, like in brute
Mass(p) = (rand() / (float) RAND_MAX) * mscale;
x = xrandom(0.0, MFRAC); // pick enclosed mass
r = 1.0 / rsqrt(rpow(x, -2.0/3.0) - 1); // find enclosing radius
pickshell(Pos(p), NDIM, rsc * r); // pick position vector
do { // select from fn g(x)
x = xrandom(0.0, 1.0); // for x in range 0:1
y = xrandom(0.0, 0.1); // max of g(x) is 0.092
} while (y > x*x * rpow(1 - x*x, 3.5)); // using von Neumann tech
v = x * rsqrt(2.0 / rsqrt(1 + r*r)); // find resulting speed
pickshell(Vel(p), NDIM, vsc * v); // pick velocity vector
}
tnow = 0.0; // set elapsed model time
}
real sig2_gsp(gsprof *tgsp, gsprof *mgsp, real beta_a, real *sig2, real r)
{
int n = tgsp->npoint - 1;
real r0, rn, gamma, m0, c0;
r0 = tgsp->radius[0];
rn = tgsp->radius[n];
if (r < r0) {
gamma = 2 * beta_a + mgsp->alpha + tgsp->alpha + 2;
m0 = mass_gsp(mgsp, r0);
if (gamma != 0.0) {
c0 = sig2[0] + m0 / (gamma * r0);
return (- (m0 / r0) * rpow(r / r0, 2 + mgsp->alpha) / gamma +
c0 * rpow(r0 / r, 2 * beta_a + tgsp->alpha));
} else {
c0 = sig2[0] + rlog(r0) * m0 / r0;
return (- rlog(r) * m0 / rpow(r0, 3 + mgsp->alpha) /
rpow(r, 2 * beta_a + tgsp->alpha) +
c0 * rpow(r0 / r, 2 * beta_a + tgsp->alpha));
}
} else if (r > rn) {
if (tgsp->density[n] > 0) {
gamma = 2 * beta_a + mgsp->beta + tgsp->beta + 2;
return (- mgsp->mtot / ((2*beta_a + tgsp->beta - 1) * r) +
(mgsp->mtot - mass_gsp(mgsp, r)) / (gamma * r));
} else
return (0.0);
} else
return (seval(r, tgsp->radius, sig2, sig2 + n + 1, n + 1));
}
real r_mass_gsp(gsprof *gsp, real m)
{
int n = gsp->npoint - 1, k = 0;
if (m < 0 || m > gsp->mtot)
error("%s.r_mass_gsp: undefined for m = %g\n", getargv0(), m);
if (m < gsp->mass[0])
return (gsp->radius[0] * rpow(m / gsp->mass[0], 1/(3+gsp->alpha)));
else if (m > gsp->mass[n])
return (gsp->radius[n] *
rpow((gsp->mtot - m) / (gsp->mtot - gsp->mass[n]),
1 / (3 + gsp->beta)));
while (gsp->mass[k] == gsp->mass[k+1])
k++;
while (gsp->mass[n] == gsp->mass[n-1] ||
gsp->mass[n-1] == gsp->mass[n-2])
n--;
if (gsp->rm_coef == NULL) {
gsp->rm_coef = (real *) allocate(3 * gsp->npoint * sizeof(real));
if (k > 0 || n < gsp->npoint - 1)
eprintf("[%s.r_mass_gsp: spline range %d to %d]\n",
getargv0(), k, n);
spline(gsp->rm_coef, gsp->mass + k, gsp->radius + k, n + 1 - k);
if (isnan((double) gsp->rm_coef[0]))
error("%s.r_mass_gsp: spline fit undefined\n", getargv0());
}
return (seval(m, gsp->mass + k, gsp->radius + k, gsp->rm_coef, n + 1 - k));
}
gsprof *plumgsp(real mtot, real a, int np, real rmin, real rmax)
{
gsprof *gsp;
real *rtab, *dtab, *mtab, lgrs;
int i;
assert(mtot > 0.0 && a > 0.0);
gsp = (gsprof *) allocate(sizeof(gsprof));
rtab = (real *) allocate(np * sizeof(real));
dtab = (real *) allocate(np * sizeof(real));
mtab = (real *) allocate(np * sizeof(real));
lgrs = rlog2(rmax / rmin) / (np - 1);
for (i = 0; i < np; i++) {
rtab[i] = rmin * rexp2(lgrs * i);
dtab[i] = (3 / FOUR_PI) * mtot * a*a /
rpow(rsqr(rtab[i]) + a*a, 2.5);
mtab[i] = mtot * rqbe(rtab[i]) /
rpow(rsqr(rtab[i]) + a*a, 1.5);
}
gsp->npoint = np;
gsp->radius = rtab;
gsp->density = dtab;
gsp->mass = mtab;
gsp->alpha = 0.0;
gsp->beta = -5.0;
gsp->mtot = mtot;
return (gsp);
}
void polymodel(void)
{
gsl_interp_accel *pmsplacc = gsl_interp_accel_alloc();
bodyptr p;
real rad, phi, vel, psi, vr, vp, a, E, J;
vector rhat, vtmp, vper;
for (p = btab; p < NthBody(btab, nbody); p = NextBody(p)) {
rad = rad_m(xrandom(0.0, mtot));
phi = gsl_spline_eval(pmspline, (double) rad, pmsplacc);
vel = pick_v(phi);
psi = pick_psi();
vr = vel * rcos(psi);
vp = vel * rsin(psi);
Mass(p) = mtot / nbody;
pickshell(rhat, NDIM, 1.0);
MULVS(Pos(p), rhat, rad);
pickshell(vtmp, NDIM, 1.0);
a = dotvp(vtmp, rhat);
MULVS(vper, rhat, - a);
ADDV(vper, vper, vtmp);
a = absv(vper);
MULVS(vper, vper, vp / a);
MULVS(Vel(p), rhat, vr);
ADDV(Vel(p), Vel(p), vper);
Phi(p) = phi;
E = phi + 0.5 * rsqr(vel);
J = rad * ABS(vp);
Aux(p) = Kprime * rpow(phi1 - E, npol - 1.5) * rpow(J, 2 * mpol);
}
gsl_interp_accel_free(pmsplacc);
}
real pick_psi(void)
{
static real hmax = -1.0;
real x, psi;
if (hmax < 0.0)
hmax = (mpol > 0 ? rpow(2.0, mpol) : 1);
x = vnpick(hfunc, 0.0, 1.0, hmax, "hfunc");
psi = racos(1 - rpow(x, 1 / (mpol + 1)));
return (xrandom(-1.0, 1.0) < 0.0 ? PI - psi : psi);
}
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;
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, char *argv[])
{
MINT *a, *b, *c, *d;
short h;
mp_set_memory_functions (NULL, NULL, NULL);
a = itom (123);
b = xtom ("DEADBEEF");
c = itom (0);
d = itom (0);
move (a, b);
madd (a, b, c);
msub (a, b, c);
mult (a, b, c);
mdiv (b, a, c, d);
sdiv (b, 2, c, &h);
msqrt (a, c, d);
pow (b, a, a, c);
rpow (a, 3, c);
gcd (a, b, c);
mcmp (a, b);
if (argc > 1)
{
min (c);
mout (a);
}
mtox (b);
mfree(a);
exit (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);
}
real rho_gsp(gsprof *gsp, real r)
{
int n = gsp->npoint - 1;
if (r < 0)
error("%s.rho_gsp: undefined for r = %g\n", getargv0(), r);
if (r < gsp->radius[0])
return (gsp->density[0] * rpow(r / gsp->radius[0], gsp->alpha));
else if (r > gsp->radius[n])
return (gsp->density[n] * rpow(r / gsp->radius[n], gsp->beta));
if (gsp->dr_coef == NULL) {
gsp->dr_coef = (real *) allocate(3 * (n + 1) * sizeof(real));
spline(gsp->dr_coef, gsp->radius, gsp->density, n + 1);
}
return (seval(r, gsp->radius, gsp->density, gsp->dr_coef, n + 1));
}
void sphreport(stream ostr, smxptr sm, string options)
{
bodyptr *bptr = sm->kd->bptr;
int i, nupd, nlev[MAXLEV+1], *rprof = sm->rprof;
real rbsum, rbmin, rbmax, flev[MAXLEV+1], flev4, xi[NRPROF-1];
nupd = 0;
for (i = 0; i <= MAXLEV; i++)
nlev[i] = 0;
rbsum = 0.0;
for (i = 0; i < sm->kd->ngas; i++) {
if (Update(bptr[i])) {
nupd++;
nlev[NewLevel(bptr[i])]++;
rbsum += Smooth(bptr[i]);
rbmin = (nupd == 1 ? Smooth(bptr[i]) : MIN(rbmin, Smooth(bptr[i])));
rbmax = (nupd == 1 ? Smooth(bptr[i]) : MAX(rbmin, Smooth(bptr[i])));
}
}
flev4 = 0.0;
for (i = 0; i <= MAXLEV; i++) {
flev[i] = 100.0 * ((real) nlev[i]) / ((real) nupd);
if (i >= 4)
flev4 += flev[i];
}
fprintf(ostr, "\n%9s %9s %9s %9s %29s %9s\n",
"log hmin", "log havg", "log hmax", "freqavg",
"timestep level distribution", "CPUsph");
fprintf(ostr,
"%9.4f %9.4f %9.4f %9.2f %5.1f %5.1f %5.1f %5.1f %5.1f %9.3f\n",
rlog10(rbmin), rlog10(rbsum / nupd), rlog10(rbmax),
sm->freqsum / nupd, flev[0], flev[1], flev[2], flev[3], flev4,
cputime() - sm->cpustart);
if (scanopt(options, "corrfunc")) {
for (i = 0; i <= NRPROF - 2; i++)
xi[i] = -1 + rpow(8.0, i/2.0) * (rprof[i] - rprof[i+1]) /
((1 - rsqrt(0.125)) * rprof[0]);
fprintf(ostr, "\n ");
for (i = NRPROF - 2; i >= 0; i--)
fprintf(ostr, " xi%d", i);
fprintf(ostr, "\n ");
for (i = NRPROF - 2; i >= 0; i--)
fprintf(ostr, "%6.2f", xi[i]);
fprintf(ostr, "\n");
}
if (scanopt(options, "levelhist")) {
fprintf(ostr, "\n ");
for (i = 0; i <= MAXLEV; i++)
if (nlev[i] != 0)
fprintf(ostr, i<10 ? " lev%d" : " lev%d", i);
fprintf(ostr, "\n ");
for (i = 0; i <= MAXLEV; i++)
if (nlev[i] != 0)
fprintf(ostr, "%6d", nlev[i]);
fprintf(ostr, "\n");
}
fflush(ostr);
}
int p_capicua(int n)
{
int n1 = n;
int cifra = cifras(n);
if(cifra == 1 && n != 9)return n+1; //si es d una sola cifra
int FR = n/rpow(10, cifra - cifra/2); //frontal
int BR = n%rpow(10, cifra/2); //last-back
int iFR = inverso(FR);
if( iFR == BR) //palindromo
{
n = n+rpow(10, cifras(FR)); //le sumo el 10, 100, o 1000
FR = n/rpow(10, cifra - cifra/2);
iFR = inverso(FR); //como cambio fr, hay q actualizarlo
//
}
n = n-BR; //le resto la parte d atras
n = n+iFR; //y la sustituyo por la de alante
if(n1 > n) //si num viejo es mayor que el nuevo
{ //necesitamos el prox palindromo
n = n+rpow(10, cifras(FR));
FR = n/rpow(10, cifra - cifra/2);
iFR = inverso(FR);
BR = n%rpow(10, cifra/2);
n = n-BR;
n = n+iFR;
}
return n;
}
real pick_v(real phi)
{
real vmax, x;
static real gmax = -1.0;
vmax = rsqrt(2 * phi1 - 2 * phi);
if (npol > 1.5) {
x = vnpick(gfunc1, 0.0, 1.0, 1.0, "gfunc1");
return (vmax * x);
} else {
if (gmax < 0.0) {
x = (npol + 4*mpol + 2.5) / (npol + 2*mpol + 0.5);
if (0.0 <= x && x < 1.0)
gmax = rpow(2 - x, npol - 1.5) * rpow(1 - x, 2*mpol + 2);
else
gmax = MAX(gfunc2(0.0), gfunc2(0.99));
}
x = vnpick(gfunc2, 0.0, 1.0, gmax, "gfunc2");
return (vmax * (1 - rpow(x, 1 / (npol - 0.5))));
}
}
int StackPow(void)
{
if(curstksize < 2){
return 1;
}
stack[0] = rpow(stack[1], stack[0]);
for(int i = 1; i < curstksize - 1; ++i){
stack[i] = stack[i + 1];
}
--curstksize;
return 0;
}
void plummodel(real mfrac)
{
real rsc, vsc, r, v, x, y;
bodyptr p;
if (mfrac < 0 || mfrac > 1) // check for silly values
error("%s: absurd value for mfrac\n", getprog());
rsc = (3 * PI) / 16; // set length scale factor
vsc = rsqrt(1.0 / rsc); // and speed scale factor
for (p = btab; p < NthBody(btab,nbody); p = NextBody(p)) {
// loop over particles
Mass(p) = 1.0 / nbody; // set masses equal
x = xrandom(0.0, mfrac); // pick enclosed mass
r = 1.0 / rsqrt(rpow(x, -2.0/3.0) - 1); // find enclosing radius
pickshell(Pos(p), NDIM, rsc * r); // pick position vector
do { // use von Neumann rejection
x = xrandom(0.0, 1.0); // for x in range 0:1
y = xrandom(0.0, 0.1); // max of g(x) is 0.092
} while (y > x*x * rpow(1 - x*x, 3.5)); // select from g(x)
v = x * rsqrt(2.0 / rsqrt(1 + r*r)); // find resulting speed
pickshell(Vel(p), NDIM, vsc * v); // pick velocity vector
Phi(p) = -1.0 / (rsc * rsqrt(rsqr(r) + 1)); // compute model potential
}
}
void gravforce(void)
{
double cpustart;
vector rmid;
actlen = FACTIVE * 216 * tdepth; /* estimate list length */
actlen = actlen * rpow(theta, -2.5); /* allow for opening angle */
active = (nodeptr *) allocate(actlen * sizeof(nodeptr));
interact = (cellptr) allocate(actlen * sizeof(cell));
cpustart = cputime(); /* record time, less alloc */
actmax = nfcalc = nbbcalc = nbccalc = 0; /* zero cumulative counters */
active[0] = (nodeptr) root; /* initialize active list */
CLRV(rmid); /* set center of root cell */
walkgrav(active, active + 1, interact, interact + actlen,
(nodeptr) root, rsize, rmid); /* scan tree, update forces */
cpuforce = cputime() - cpustart; /* store CPU time w/o alloc */
free(active); /* free up temp storage */
free(interact);
}
void setprof(void)
{
int j;
real r, msphr;
rdtab[0] = mdtab[0] = vctab[0] = 0.0;
for (j = 1; j < NTAB; j++) {
r = rcut * rpow(((real) j) / (NTAB - 1), 2.0);
rdtab[j] = r;
mdtab[j] = 1 - rexp(- alpha1 * r) - alpha1 * r * rexp(- alpha1 * r);
msphr = (sphr != NULL ? mass_gsp(sphr, r) : 0.0);
vctab[j] = rsqrt(msphr / r - gdisk(r) * r);
}
eprintf("[%s: rcut = %8.4f/alpha M(rcut) = %8.6f mdisk]\n",
getargv0(), rdtab[NTAB-1] * alpha1, mdtab[NTAB-1]);
if ((mdtab[0] == mdtab[1]) || (mdtab[NTAB-2] == mdtab[NTAB-1]))
error("%s: disk mass table is degenerate\n", getargv0());
spline(&rdtab[NTAB], &mdtab[0], &rdtab[0], NTAB); /* for r_d = r_d(m) */
spline(&vctab[NTAB], &rdtab[0], &vctab[0], NTAB); /* for v_c = v_c(r) */
}
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);
}
void gravcalc(void)
{
double cpustart;
vector rmid;
if (active == NULL) { // if this is the 1st call
actmax = FACTIVE * 216 * (tdepth + 1); // estimate list length
#if !defined(QUICKSCAN)
if (theta > 0.1)
actmax = actmax * rpow(theta,-2.5); // allow for opening angle
else
actmax = 5.0 * ncell; // guess total node count
#endif
active = (nodeptr *) allocate(actmax * sizeof(nodeptr));
interact = (cellptr) allocate(actmax * sizeof(cell));
}
cpustart = cputime(); // record time, less alloc
acttot = nfcalc = nbbcalc = nbccalc = 0; // zero cumulative counters
active[0] = (nodeptr) root; // initialize active list
CLRV(rmid); // set center of root cell
walktree(active, active + 1, interact, interact + actmax,
(nodeptr) root, rsize, rmid); // scan tree, update forces
cpuforce = cputime() - cpustart; // store CPU time w/o alloc
}
int rpow(int b, int e)
{
return (e == 0)? 1 : b*rpow(b,e-1);
}
real hfunc(real x)
{
return (rpow(2 - rpow(x, 1 / (mpol + 1)), mpol));
}
