char* showHistogramParams(const HistogramParams* hp)
{
char* buf;
if (0 > asprintf(&buf,
"histogram-params = { \n"
" phi = %g\n"
" theta = %g\n"
" psi = %g\n"
" startRaw = %g\n"
" endRaw = %g\n"
" binSize = %g\n"
" center = %g\n"
"};\n",
hp->phi,
hp->theta,
hp->psi,
hp->startRaw,
hp->endRaw,
hp->binSize,
hp->center))
{
mw_fail("asprintf() failed\n");
}
return buf;
}
/* For debugging. Need to make this go away for release since it uses
* GNU extensions */
char* showPotential(const Potential* p)
{
int rc;
char* buf;
char* sphBuf;
char* diskBuf;
char* haloBuf;
if (!p)
return NULL;
sphBuf = showSpherical(&p->sphere[0]);
diskBuf = showDisk(&p->disk);
haloBuf = showHalo(&p->halo);
rc = asprintf(&buf,
"{\n"
" sphere = %s\n"
" disk = %s\n"
" halo = %s\n"
" rings = { unused pointer %p }\n"
" };\n",
sphBuf,
diskBuf,
haloBuf,
p->rings);
if (rc < 0)
mw_fail("asprintf() failed\n");
free(sphBuf);
free(diskBuf);
free(haloBuf);
return buf;
}
char* showBody(const Body* p)
{
char* buf;
char* vel;
char* pos;
if (!p)
return NULL;
vel = showVector(Vel(p));
pos = showVector(Pos(p));
if (0 > asprintf(&buf,
"body { \n"
" mass = %g\n"
" position = %s\n"
" velocity = %s\n"
" ignore = %s\n"
" };\n",
Mass(p),
pos,
vel,
showBool(ignoreBody(p))))
{
mw_fail("asprintf() failed\n");
}
free(vel);
free(pos);
return buf;
}
char* showCell(const NBodyCell* c)
{
char* buf;
char* posBuf;
if (!c)
return NULL;
posBuf = showVector(Pos(c));
if (0 > asprintf(&buf,
"NBodyCell = {\n"
" cellnode = {\n"
" pos = %s\n"
" next = %p\n"
" mass = %f\n"
" type = %d\n"
" }\n"
" rcrit2 = %f\n"
" more = %p\n"
" stuff = {\n"
" .quad = {\n"
" .xx = %f, .xy = %f, .xz = %f,\n"
" .yy = %f, .yz = %f,\n"
" .zz = %f\n"
" },\n"
"\n"
" .subp = {\n"
" %p, %p, %p, %p,\n"
" %p, %p, %p, %p\n"
" }\n"
" }\n"
"}\n",
posBuf,
(void*) Next(c),
Mass(c),
Type(c),
Rcrit2(c),
(void*) More(c),
Quad(c).xx, Quad(c).xy, Quad(c).xz,
Quad(c).yy, Quad(c).yz,
Quad(c).zz,
(void*) Subp(c)[0], (void*) Subp(c)[1], (void*) Subp(c)[2], (void*) Subp(c)[3],
(void*) Subp(c)[5], (void*) Subp(c)[5], (void*) Subp(c)[6], (void*) Subp(c)[7]
))
{
mw_fail("asprintf() failed\n");
}
free(posBuf);
return buf;
}
mwvector nbExtAcceleration(const Potential* pot, mwvector pos)
{
mwvector acc, acctmp;
const real r = mw_absv(pos);
/*Calculate the Disk Accelerations*/
switch (pot->disk.type)
{
case ExponentialDisk:
acc = exponentialDiskAccel(&pot->disk, pos, r);
break;
case MiyamotoNagaiDisk:
acc = miyamotoNagaiDiskAccel(&pot->disk, pos, r);
break;
case InvalidDisk:
default:
mw_fail("Invalid disk type in external acceleration\n");
}
/*Calculate the Halo Accelerations*/
switch (pot->halo.type)
{
case LogarithmicHalo:
acctmp = logHaloAccel(&pot->halo, pos, r);
break;
case NFWHalo:
acctmp = nfwHaloAccel(&pot->halo, pos, r);
break;
case TriaxialHalo:
acctmp = triaxialHaloAccel(&pot->halo, pos, r);
break;
case CausticHalo:
acctmp = causticHaloAccel(&pot->halo, pos, r);
break;
case InvalidHalo:
default:
mw_fail("Invalid halo type in external acceleration\n");
}
mw_incaddv(acc, acctmp);
/*Calculate the Bulge Accelerations*/
acctmp = sphericalAccel(&pot->sphere[0], pos, r);
mw_incaddv(acc, acctmp);
return acc;
}
/* Most efficient function ever */
char* showNBodyCtx(const NBodyCtx* ctx)
{
char* buf;
char* potBuf;
if (!ctx)
return NULL;
potBuf = showPotential(&ctx->pot);
if (!potBuf)
return NULL;
if (0 > asprintf(&buf,
"ctx = { \n"
" eps2 = %f\n"
" theta = %f\n"
" timestep = %f\n"
" timeEvolve = %f\n"
" treeRSize = %f\n"
" sunGCDist = %f\n"
" criterion = %s\n"
" useQuad = %s\n"
" allowIncest = %s\n"
" checkpointT = %d\n"
" nStep = %u\n"
" potentialType = %s\n"
" pot = %s\n"
"};\n",
ctx->eps2,
ctx->theta,
ctx->timestep,
ctx->timeEvolve,
ctx->treeRSize,
ctx->sunGCDist,
showCriterionT(ctx->criterion),
showBool(ctx->useQuad),
showBool(ctx->allowIncest),
(int) ctx->checkpointT,
ctx->nStep,
showExternalPotentialType(ctx->potentialType),
potBuf
))
{
mw_fail("asprintf() failed\n");
}
free(potBuf);
return buf;
}
static inline void nbMapForceBody(const NBodyCtx* ctx, NBodyState* st)
{
int i;
const int nbody = st->nbody; /* Prevent reload on each loop */
mwvector a, externAcc;
const Body* b;
#ifdef _OPENMP
#pragma omp parallel for private(i, b, a, externAcc) schedule(dynamic)
#endif
for (i = 0; i < nbody; ++i) /* get force on each body */
{
/* Repeat the base hackGrav part in each case or else GCC's
* -funswitch-loops doesn't happen. Without that this constant
* gets checked on every body on every step which is dumb. */
switch (ctx->potentialType)
{
case EXTERNAL_POTENTIAL_DEFAULT:
/* Include the external potential */
b = &st->bodytab[i];
a = nbGravity(ctx, st, b);
externAcc = nbExtAcceleration(&ctx->pot, Pos(b));
mw_incaddv(a, externAcc);
st->acctab[i] = a;
break;
case EXTERNAL_POTENTIAL_NONE:
st->acctab[i] = nbGravity(ctx, st, &st->bodytab[i]);
break;
case EXTERNAL_POTENTIAL_CUSTOM_LUA:
a = nbGravity(ctx, st, &st->bodytab[i]);
nbEvalPotentialClosure(st, Pos(&st->bodytab[i]), &externAcc);
mw_incaddv(a, externAcc)
st->acctab[i] = a;
break;
default:
mw_fail("Bad external potential type: %d\n", ctx->potentialType);
}
}
}
char* showNBodyTree(const NBodyTree* t)
{
char* buf;
if (0 > asprintf(&buf,
" Tree %p = {\n"
" root = %p\n"
" rsize = %g\n"
" cellUsed = %u\n"
" maxDepth = %u\n"
" };\n",
t,
t->root,
t->rsize,
t->cellUsed,
t->maxDepth))
{
mw_fail("asprintf() failed\n");
}
return buf;
}
char* showSpherical(const Spherical* s)
{
char* buf;
if (!s)
return NULL;
if (0 > asprintf(&buf,
"{\n"
" type = %s\n"
" mass = %g\n"
" scale = %g\n"
" };\n",
showSphericalT(s->type),
s->mass,
s->scale))
{
mw_fail("asprintf() failed\n");
}
return buf;
}
char* showNBodyState(const NBodyState* st)
{
char* buf;
char* treeBuf;
treeBuf = showNBodyTree(&st->tree);
if (0 > asprintf(&buf,
"NBodyState %p = {\n"
" tree = %s\n"
" freeCell = %p\n"
" lastCheckpoint = %d\n"
" step = %u\n"
" nbody = %u\n"
" bodytab = %p\n"
" acctab = %p\n"
" treeIncest = %s\n"
"};\n",
st,
treeBuf,
st->freeCell,
(int) st->lastCheckpoint,
st->step,
st->nbody,
st->bodytab,
st->acctab,
showBool(st->treeIncest)
))
{
mw_fail("asprintf() failed\n");
}
free(treeBuf);
return buf;
}
static inline void nbMapForceBody_Exact(const NBodyCtx* ctx, NBodyState* st)
{
int i;
const int nbody = st->nbody; /* Prevent reload on each loop */
mwvector a, externAcc;
const Body* b;
#ifdef _OPENMP
#pragma omp parallel for private(i, b, a, externAcc) schedule(dynamic)
#endif
for (i = 0; i < nbody; ++i) /* get force on each body */
{
switch (ctx->potentialType)
{
case EXTERNAL_POTENTIAL_DEFAULT:
b = &st->bodytab[i];
a = nbGravity_Exact(ctx, st, b);
mw_incaddv(a, nbExtAcceleration(&ctx->pot, Pos(b)));
st->acctab[i] = a;
break;
case EXTERNAL_POTENTIAL_NONE:
st->acctab[i] = nbGravity_Exact(ctx, st, &st->bodytab[i]);
break;
case EXTERNAL_POTENTIAL_CUSTOM_LUA:
a = nbGravity_Exact(ctx, st, &st->bodytab[i]);
nbEvalPotentialClosure(st, Pos(&st->bodytab[i]), &externAcc);
mw_incaddv(a, externAcc);
st->acctab[i] = a;
break;
default:
mw_fail("Bad external potential type: %d\n", ctx->potentialType);
}
}
}
char* showDisk(const Disk* d)
{
char* buf;
if (!d)
return NULL;
if (0 > asprintf(&buf,
"{ \n"
" type = %s\n"
" mass = %g\n"
" scaleLength = %g\n"
" scaleHeight = %g\n"
" };\n",
showDiskT(d->type),
d->mass,
d->scaleLength,
d->scaleHeight))
{
mw_fail("asprintf() failed\n");
}
return buf;
}
char* showHalo(const Halo* h)
{
char* buf;
if (!h)
return NULL;
if (0 > asprintf(&buf,
"{ \n"
" type = %s\n"
" vhalo = %g\n"
" scaleLength = %g\n"
" flattenX = %g\n"
" flattenY = %g\n"
" flattenZ = %g\n"
" c1 = %g\n"
" c2 = %g\n"
" c3 = %g\n"
" triaxAngle = %g\n"
" };\n",
showHaloT(h->type),
h->vhalo,
h->scaleLength,
h->flattenX,
h->flattenY,
h->flattenZ,
h->c1,
h->c2,
h->c3,
h->triaxAngle))
{
mw_fail("asprintf() failed\n");
}
return buf;
}
