/*
** _pullIterate
**
** (documentation)
**
** NB: this implements the body of thread 0, the master thread
*/
int
_pullIterate(pullContext *pctx) {
char me[]="_pullIterate", err[BIFF_STRLEN];
double time0;
int myError;
unsigned int thi;
if (!pctx) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(PULL, err); return 1;
}
if (pctx->verbose) {
fprintf(stderr, "%s: start iter %d w/ %u threads; energy = %g\n",
me, pctx->iter, pctx->threadNum, _pullEnergyTotal(pctx));
}
time0 = airTime();
/* the _pullWorker checks finished after iterBarrierA */
pctx->finished = AIR_FALSE;
/* initialize index of next bin to be doled out to threads */
pctx->binNextIdx=0;
if (pctx->threadNum > 1) {
airThreadBarrierWait(pctx->iterBarrierA);
}
myError = AIR_FALSE;
if (_pullProcess(pctx->task[0])) {
sprintf(err, "%s: master thread trouble w/ iter %u", me, pctx->iter);
biffAdd(PULL, err);
pctx->finished = AIR_TRUE;
myError = AIR_TRUE;
}
if (pctx->threadNum > 1) {
airThreadBarrierWait(pctx->iterBarrierB);
}
if (pctx->finished) {
if (!myError) {
/* we didn't set finished- one of the workers must have */
sprintf(err, "%s: worker error on iter %u", me, pctx->iter);
biffAdd(PULL, err);
}
return 1;
}
pctx->stuckNum = 0;
for (thi=0; thi<pctx->threadNum; thi++) {
pctx->stuckNum += pctx->task[thi]->stuckNum;
}
_pullPointNixMeRemove(pctx);
if (pullRebin(pctx)) {
sprintf(err, "%s: problem with new point locations", me);
biffAdd(PULL, err); return 1;
}
pctx->timeIteration = airTime() - time0;
return 0;
}
/*
******** coilIterate
**
** (documentation)
**
** NB: this implements the body of thread 0
*/
int
coilIterate(coilContext *cctx, int numIterations) {
char me[]="coilIterate", err[BIFF_STRLEN];
int iter;
double time0, time1;
if (!cctx) {
sprintf(err, "%s: got NULL pointer", me);
biffAdd(COIL, err); return 1;
}
time0 = airTime();
for (iter=0; iter<numIterations; iter++) {
cctx->iter = iter;
if (cctx->verbose) {
fprintf(stderr, "%s: starting iter %d (of %d)\n", me, iter,
numIterations);
}
cctx->finished = AIR_FALSE;
if (cctx->numThreads > 1) {
airThreadBarrierWait(cctx->filterBarrier);
}
/* first: filter */
if (cctx->verbose > 1) {
fprintf(stderr, "%s: filtering ... \n", me);
}
_coilProcess(cctx->task[0], AIR_TRUE);
/* second: update */
if (cctx->verbose > 1) {
fprintf(stderr, "%s: updating ... \n", me);
}
if (cctx->numThreads > 1) {
airThreadBarrierWait(cctx->updateBarrier);
}
_coilProcess(cctx->task[0], AIR_FALSE);
}
time1 = airTime();
if (cctx->verbose) {
fprintf(stderr, "%s: elapsed time = %g (%g/iter)\n", me,
time1 - time0, (time1 - time0)/numIterations);
}
return 0;
}
void
makeSceneBVH(limnCamera *cam, echoRTParm *parm, echoObject **sceneP) {
echoObject *sphere;
int i, N;
float r, g, b;
echoObject *scene;
double time0, time1;
*sceneP = scene = echoObjectNew(echoList);
ELL_3V_SET(cam->from, 9, 6, 0);
ELL_3V_SET(cam->at, 0, 0, 0);
ELL_3V_SET(cam->up, 0, 0, 1);
cam->uRange[0] = -3;
cam->uRange[1] = 3;
cam->vRange[0] = -3;
cam->vRange[1] = 3;
parm->jitterType = echoJitterNone;
parm->numSamples = 1;
parm->imgResU = 500;
parm->imgResV = 500;
parm->aperture = 0.0;
parm->renderLights = AIR_TRUE;
parm->renderBoxes = AIR_FALSE;
parm->seedRand = AIR_FALSE;
parm->maxRecDepth = 10;
parm->shadow = 0.0;
N = 1000000;
airArrayLenSet(LIST(scene)->objArr, N);
for (i=0; i<N; i++) {
sphere = echoObjectNew(echoSphere);
echoSphereSet(sphere,
4*airDrandMT()-2, 4*airDrandMT()-2, 4*airDrandMT()-2, 0.005);
_dyeHSVtoRGB(&r, &g, &b, AIR_AFFINE(0, i, N, 0.0, 1.0), 1.0, 1.0);
echoMatterPhongSet(sphere, r, g, b, 1.0,
1.0, 0.0, 0.0, 50);
LIST(scene)->obj[i] = sphere;
}
time0 = airTime();
*sceneP = scene = echoListSplit3(scene, 8);
time1 = airTime();
printf("BVH build time = %g seconds\n", time1 - time0);
}
int
main(int argc, const char *argv[]) {
airArray *mop;
hestOpt *hopt=NULL;
int i, N, M, P, yes, *year;
unsigned int E;
const char *me;
double crct;
me = argv[0];
mop = airMopNew();
hestOptAdd(&hopt, "N", "days", airTypeInt, 1, 1, &N, "365",
"# of days in year");
/* E != P */
hestOptAdd(&hopt, "E", "exps", airTypeInt, 1, 1, &P, "100000",
"number of experiments after which to print out newly "
"computed probability");
hestOptAdd(&hopt, NULL, "people", airTypeInt, 1, 1, &M, NULL,
"# of people in room");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, info, AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
if (!( N > 1 && M > 0 && P > 1)) {
fprintf(stderr, "%s: need both M, P all > 1, M > 0\n", me);
airMopError(mop); exit(1);
}
if (!(year = (int*)calloc(N, sizeof(int)))) {
fprintf(stderr, "%s: couldn't calloc(%d,sizeof(int))\n", me, N);
airMopError(mop); exit(1);
}
airMopMem(mop, year, airMopAlways);
crct = 1;
for (i=0; i<M; i++) {
crct *= (double)(N-i)/N;
}
crct = 1-crct;
yes = 0;
E = 1;
airSrandMT((int)airTime());
while (E) {
yes += runexp(year, N, M);
if (!(E % P)) {
printf("P = %10d/%10d = %22.20f =?= %22.20f\n",
yes, E, (double)yes/E, crct);
}
E++;
}
airMopOkay(mop);
exit(0);
}
int
miteRenderEnd(miteRender *mrr, miteUser *muu) {
unsigned int thr;
double samples;
muu->rendTime = airTime() - mrr->time0;
samples = 0;
for (thr=0; thr<muu->hctx->numThreads; thr++) {
samples += mrr->tt[thr]->samples;
}
muu->sampRate = samples/(1000.0*muu->rendTime);
_miteRenderNix(mrr);
return 0;
}
int
miteRenderBegin(miteRender **mrrP, miteUser *muu) {
static const char me[]="miteRenderBegin";
gagePerVolume *pvl;
int E, T, pvlIdx;
gageQuery queryScl, queryVec, queryTen;
gageItemSpec isp;
unsigned int axi, thr;
if (!(mrrP && muu)) {
biffAddf(MITE, "%s: got NULL pointer", me);
return 1;
}
if (_miteUserCheck(muu)) {
biffAddf(MITE, "%s: problem with user-set parameters", me);
return 1;
}
if (!( *mrrP = _miteRenderNew() )) {
biffAddf(MITE, "%s: couldn't alloc miteRender", me);
return 1;
}
if (_miteNtxfAlphaAdjust(*mrrP, muu)) {
biffAddf(MITE, "%s: trouble copying and alpha-adjusting txfs", me);
return 1;
}
GAGE_QUERY_RESET(queryScl);
GAGE_QUERY_RESET(queryVec);
GAGE_QUERY_RESET(queryTen);
GAGE_QUERY_RESET((*mrrP)->queryMite);
for (T=0; T<muu->ntxfNum; T++) {
for (axi=1; axi<muu->ntxf[T]->dim; axi++) {
miteVariableParse(&isp, muu->ntxf[T]->axis[axi].label);
miteQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite, &isp);
}
}
miteVariableParse((*mrrP)->normalSpec, muu->normalStr);
miteQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite,
(*mrrP)->normalSpec);
miteShadeSpecParse((*mrrP)->shadeSpec, muu->shadeStr);
miteShadeSpecQueryAdd(queryScl, queryVec, queryTen, (*mrrP)->queryMite,
(*mrrP)->shadeSpec);
(*mrrP)->queryMiteNonzero = GAGE_QUERY_NONZERO((*mrrP)->queryMite);
E = 0;
pvlIdx = 0;
if (muu->nsin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->nsin, gageKindScl));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryScl);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->sclPvlIdx = pvlIdx++;
}
if (muu->nvin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->nvin, gageKindVec));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryVec);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->vecPvlIdx = pvlIdx++;
}
if (muu->ntin) {
if (!E) E |= !(pvl = gagePerVolumeNew(muu->gctx0, muu->ntin, tenGageKind));
if (!E) E |= gageQuerySet(muu->gctx0, pvl, queryTen);
if (!E) E |= gagePerVolumeAttach(muu->gctx0, pvl);
if (!E) (*mrrP)->tenPvlIdx = pvlIdx++;
}
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel00,
muu->ksp[gageKernel00]->kernel,
muu->ksp[gageKernel00]->parm);
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel11,
muu->ksp[gageKernel11]->kernel,
muu->ksp[gageKernel11]->parm);
if (!E) E |= gageKernelSet(muu->gctx0, gageKernel22,
muu->ksp[gageKernel22]->kernel,
muu->ksp[gageKernel22]->parm);
if (!E) E |= gageUpdate(muu->gctx0);
if (E) {
biffMovef(MITE, GAGE, "%s: gage trouble", me);
return 1;
}
fprintf(stderr, "!%s: kernel support = %d^3 samples\n",
me, 2*muu->gctx0->radius);
if (nrrdMaybeAlloc_va(muu->nout, mite_nt, 3,
AIR_CAST(size_t, 5) /* RGBAZ */ ,
AIR_CAST(size_t, muu->hctx->imgSize[0]),
AIR_CAST(size_t, muu->hctx->imgSize[1]))) {
biffMovef(MITE, NRRD, "%s: nrrd trouble", me);
return 1;
}
muu->nout->axis[1].center = nrrdCenterCell;
muu->nout->axis[1].min = muu->hctx->cam->uRange[0];
muu->nout->axis[1].max = muu->hctx->cam->uRange[1];
muu->nout->axis[2].center = nrrdCenterCell;
muu->nout->axis[2].min = muu->hctx->cam->vRange[0];
muu->nout->axis[2].max = muu->hctx->cam->vRange[1];
for (thr=0; thr<muu->hctx->numThreads; thr++) {
(*mrrP)->tt[thr] = miteThreadNew();
if (!((*mrrP)->tt[thr])) {
biffAddf(MITE, "%s: couldn't allocate thread[%d]", me, thr);
return 1;
}
airMopAdd((*mrrP)->rmop, (*mrrP)->tt[thr],
(airMopper)miteThreadNix, airMopAlways);
}
(*mrrP)->time0 = airTime();
return 0;
}
int
main(int argc, char *argv[]) {
int i;
Nrrd *nrrd;
double diff, idx, idx2, idx3, idx4, lo, hi, pos, pos2, pos3, pos4;
AIR_UNUSED(argc);
AIR_UNUSED(argv);
if (nrrdAlloc_va(nrrd=nrrdNew(), nrrdTypeFloat, 2,
AIR_CAST(size_t, 4),
AIR_CAST(size_t, 4))) {
printf("trouble:\n%s\n", biffGet(NRRD));
exit(1);
}
nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMin, 10.0, 10.0);
nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMax, 12.0, 12.0);
nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoCenter, nrrdCenterNode, nrrdCenterCell);
idx = 0;
printf("\n");
pos = nrrdAxisInfoPos(nrrd, 0, idx);
printf("pos(0, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos));
pos = nrrdAxisInfoPos(nrrd, 1, idx);
printf("pos(1, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos));
idx = 1;
printf("\n");
pos = nrrdAxisInfoPos(nrrd, 0, idx);
printf("pos(0, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos));
pos = nrrdAxisInfoPos(nrrd, 1, idx);
printf("pos(1, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos));
idx = 2;
printf("\n");
pos = nrrdAxisInfoPos(nrrd, 0, idx);
printf("pos(0, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos));
pos = nrrdAxisInfoPos(nrrd, 1, idx);
printf("pos(1, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos));
idx = 0; idx2 = 0;
printf("\n");
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi);
printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi);
printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
idx = 0; idx2 = 1;
printf("\n");
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi);
printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi);
printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
idx = 1; idx2 = 0;
printf("\n");
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi);
printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi);
printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMin, 12.0, 12.0);
nrrdAxisInfoSet_va(nrrd, nrrdAxisInfoMax, 10.0, 10.0);
printf("\n(axis min,max flipped)\n");
idx = 0;
printf("\n");
pos = nrrdAxisInfoPos(nrrd, 0, idx);
printf("pos(0, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos));
pos = nrrdAxisInfoPos(nrrd, 1, idx);
printf("pos(1, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos));
idx = 1;
printf("\n");
pos = nrrdAxisInfoPos(nrrd, 0, idx);
printf("pos(0, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos));
pos = nrrdAxisInfoPos(nrrd, 1, idx);
printf("pos(1, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos));
idx = 2;
printf("\n");
pos = nrrdAxisInfoPos(nrrd, 0, idx);
printf("pos(0, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 0, pos));
pos = nrrdAxisInfoPos(nrrd, 1, idx);
printf("pos(1, %g) == %g --> %g\n",
idx, pos, nrrdAxisInfoIdx(nrrd, 1, pos));
idx = 0; idx2 = 0;
printf("\n");
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi);
printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi);
printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
idx = 0; idx2 = 2;
printf("\n");
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi);
printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi);
printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
idx = 2; idx2 = 0;
printf("\n");
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 0, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, lo, hi);
printf("range(0, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
nrrdAxisInfoPosRange(&lo, &hi, nrrd, 1, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 1, lo, hi);
printf("range(1, %g -- %g) == (%g -- %g) --> (%g -- %g)\n",
idx, idx2, lo, hi, idx3, idx4);
nrrd->axis[0].center = nrrdCenterCell;
nrrd->axis[0].size = 4;
nrrd->axis[0].min = -4;
nrrd->axis[0].max = 4;
pos = 0;
pos2 = 1;
nrrdAxisInfoIdxRange(&idx, &idx2, nrrd, 0, pos, pos2);
nrrdAxisInfoPosRange(&pos3, &pos4, nrrd, 0, idx, idx2);
printf("min, max = %g, %g\n", nrrd->axis[0].min, nrrd->axis[0].max);
printf("pos, pos2 = %g, %g\n", pos, pos2);
printf("idx, idx2 = %g, %g\n", idx, idx2);
printf("pos3, pos4 = %g, %g\n", pos3, pos4);
exit(1);
/* and now for random-ness */
airSrandMT((int)airTime());
nrrd->axis[0].center = nrrdCenterNode;
nrrd->axis[0].center = nrrdCenterCell;
for (i=0; i<=1000000; i++) {
nrrd->axis[0].min = frand(-3.0, 3.0);
nrrd->axis[0].max = frand(-3.0, 3.0);
idx = frand(-3.0, 3.0);
pos = nrrdAxisInfoPos(nrrd, 0, idx);
diff = idx - nrrdAxisInfoIdx(nrrd, 0, pos);
if (AIR_ABS(diff) > 0.00000001) { printf("PANIC 0\n"); exit(2); }
pos = frand(-3.0, 3.0);
idx = nrrdAxisInfoIdx(nrrd, 0, pos);
diff = pos - nrrdAxisInfoPos(nrrd, 0, idx);
if (AIR_ABS(diff) > 0.00000001) { printf("PANIC 1\n"); exit(2); }
nrrd->axis[0].min = (int)frand(-3.0, 3.0);
nrrd->axis[0].max = (int)frand(-3.0, 3.0);
idx = (int)frand(-10.0, 10.0);
idx2 = (int)frand(-10.0, 10.0);
nrrdAxisInfoPosRange(&pos, &pos2, nrrd, 0, idx, idx2);
nrrdAxisInfoIdxRange(&idx3, &idx4, nrrd, 0, pos, pos2);
diff = AIR_ABS(idx - idx3) + AIR_ABS(idx2 - idx4);
if (AIR_ABS(diff) > 0.00000001) { printf("PANIC 2\n"); exit(2); }
pos = (int)frand(-3.0, 3.0);
pos2 = (int)frand(-3.0, 3.0);
nrrdAxisInfoIdxRange(&idx, &idx2, nrrd, 0, pos, pos2);
nrrdAxisInfoPosRange(&pos3, &pos4, nrrd, 0, idx, idx2);
diff = AIR_ABS(pos - pos3) + AIR_ABS(pos2 - pos4);
if (AIR_ABS(diff) > 0.00000001) {
printf("min, max = %g, %g\n", nrrd->axis[0].min, nrrd->axis[0].max);
printf("pos, pos2 = %g, %g\n", pos, pos2);
printf("idx, idx2 = %g, %g\n", idx, idx2);
printf("pos3, pos4 = %g, %g\n", pos3, pos4);
printf("PANIC (%d) 3 %g\n", (int)nrrd->axis[0].size, diff); exit(2);
}
}
exit(0);
}
ell_3m_mul_d(mat1, mat2, rA);
TEN_M2T(tA, mat1);
TEN_T2M(mat1, tB);
ell_3m_mul_d(mat2, rB, mat1);
ELL_3M_TRANSPOSE_IP(rB, tmp);
ell_3m_mul_d(mat1, mat2, rB);
TEN_M2T(tB, mat1);
/*
fprintf(stderr, "!%s: tA = (%g) %g %g %g\n %g %g\n %g\n", me,
tA[0], tA[1], tA[2], tA[3], tA[4], tA[5], tA[6]);
fprintf(stderr, "!%s: tB = (%g) %g %g %g\n %g %g\n %g\n", me,
tB[0], tB[1], tB[2], tB[3], tB[4], tB[5], tB[6]);
*/
time0 = airTime();
if (tenInterpTwoDiscrete_d(nout, tA, tB, ptype, NN, tip)) {
airMopAdd(mop, err = biffGetDone(TEN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble computing path:\n%s\n",
me, err);
airMopError(mop);
return 1;
}
fprintf(stderr, "!%s: ------- # iter = %u, conv = %g\n", me,
tip->numIter, tip->convFinal);
time1 = airTime();
fprintf(stderr, "%s: geodesic length = %g; time = %g\n",
me, tenInterpPathLength(nout, AIR_FALSE, AIR_FALSE, AIR_FALSE),
time1 - time0);
if (1) {
int
pullRun(pullContext *pctx) {
char me[]="pullRun", err[BIFF_STRLEN],
poutS[AIR_STRLEN_MED];
Nrrd *npos;
double time0, time1, enrLast,
enrNew=AIR_NAN, enrImprov=AIR_NAN, enrImprovAvg=AIR_NAN;
int converged;
unsigned firstIter;
if (pctx->verbose) {
fprintf(stderr, "%s: hello\n", me);
}
time0 = airTime();
firstIter = pctx->iter;
if (_pullIterate(pctx)) {
sprintf(err, "%s: trouble on priming iter %u", me, pctx->iter);
biffAdd(PULL, err); return 1;
}
pctx->iter += 1;
enrLast = enrNew = _pullEnergyTotal(pctx);
fprintf(stderr, "!%s: starting system energy = %g\n", me, enrLast);
enrImprov = enrImprovAvg = 0;
converged = AIR_FALSE;
while (pctx->iter < pctx->iterMax && !converged) {
if (pctx->snap && !(pctx->iter % pctx->snap)) {
npos = nrrdNew();
sprintf(poutS, "snap.%06d.pos.nrrd", pctx->iter);
if (pullOutputGet(npos, NULL, pctx)) {
sprintf(err, "%s: couldn't get snapshot for iter %d", me, pctx->iter);
biffAdd(PULL, err); return 1;
}
if (nrrdSave(poutS, npos, NULL)) {
sprintf(err, "%s: couldn't save snapshot for iter %d", me, pctx->iter);
biffMove(PULL, err, NRRD); return 1;
}
npos = nrrdNuke(npos);
}
if (_pullIterate(pctx)) {
sprintf(err, "%s: trouble on iter %d", me, pctx->iter);
biffAdd(PULL, err); return 1;
}
pctx->iter += 1;
enrNew = _pullEnergyTotal(pctx);
enrImprov = _PULL_IMPROV(enrLast, enrNew);
if (firstIter + 1 == pctx->iter) {
/* we need some way of artificially boosting enrImprovAvg when
we're just starting, so that we thwart the convergence test,
which we do because we don't have the history of iterations
that enrImprovAvg is supposed to describe. Using some scaling
of enrImprov is one possible hack. */
enrImprovAvg = 3*enrImprov;
} else {
enrImprovAvg = (2*enrImprovAvg + enrImprov)/3;
}
if (pctx->verbose > 1) {
fprintf(stderr, "%s: iter %u: e=%g,%g, de=%g,%g, s=%g,%g\n",
me, pctx->iter, enrLast, enrNew, enrImprov, enrImprovAvg,
_pullStepInterAverage(pctx), _pullStepConstrAverage(pctx));
}
enrLast = enrNew;
converged = AIR_IN_OP(0, enrImprovAvg, pctx->energyImprovMin);
if (converged && pctx->verbose) {
fprintf(stderr, "%s: %g < %g: converged!!\n", me,
enrImprovAvg, pctx->energyImprovMin);
}
_pullPointStepEnergyScale(pctx, pctx->opporStepScale);
}
fprintf(stderr, "%s: done (%d,%d) @ iter %u enr = %g enrImprov = %g,%g "
"stuck %u\n",
me, !(pctx->iter < pctx->iterMax), converged,
pctx->iter, enrNew, enrImprov, enrImprovAvg, pctx->stuckNum);
time1 = airTime();
pctx->timeRun += time1 - time0;
pctx->energy = enrNew;
return 0;
}
int
main(int argc, char *argv[]) {
#if TEEM_DIO == 0
AIR_UNUSED(argc);
fprintf(stderr, "%s: no direct-io testing for you\n", argv[0]);
return 1;
#else
char *me, *fname, *multS, *data;
FILE *file;
double time0, time1, time2;
int fd, align, mult, min, max, ret;
size_t size;
airArray *mop;
me = argv[0];
if (3 != argc) {
/* 0 1 2 (3) */
fprintf(stderr, "usage: %s <filename> <mult>\n", me);
return 1;
}
fname = argv[1];
multS = argv[2];
if (1 != sscanf(multS, "%d", &mult)) {
fprintf(stderr, "%s: couln't parse mult %s as int\n", me, multS);
return 1;
}
mop = airMopNew();
if (!(file = fopen(fname, "w"))) {
fprintf(stderr, "%s: couldn't open %s for writing\n", me, fname);
airMopError(mop); return 1;
}
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
fd = fileno(file);
if (-1 == fd) {
fprintf(stderr, "%s: couldn't get underlying descriptor\n", me);
airMopError(mop); return 1;
}
fprintf(stderr, "%s: fd(%s) = %d\n", me, fname, fd);
ret = airDioTest(fd, NULL, 0);
if (airNoDio_okay != ret) {
fprintf(stderr, "%s: no good: \"%s\"\n", me, airNoDioErr(ret));
airMopError(mop); return 1;
}
airDioInfo(&align, &min, &max, fd);
fprintf(stderr, "%s: --> align=%d, min=%d, max=%d\n", me, align, min, max);
size = (size_t)max*mult;
data = airDioMalloc(size, fd);
if (!data) {
fprintf(stderr, "%s: airDioMalloc(" _AIR_SIZE_T_CNV ") failed\n", me,
size);
airMopError(mop); return 1;
}
airMopAdd(mop, data, airFree, airMopAlways);
fprintf(stderr, "\ndata size = %g MB\n", (double)size/(1024*1024));
/* -------------------------------------------------------------- */
fprintf(stderr, "(1) non-aligned memory, regular write:\n");
time0 = airTime();
if (size-1 != write(fd, data+1, size-1)) {
fprintf(stderr, "%s: write failed\n", me);
airMopError(mop); return 1;
}
time1 = airTime();
fsync(fd);
time2 = airTime();
fprintf(stderr, " time = %g + %g = %g (%g MB/sec)\n",
time1 - time0, time2 - time1, time2 - time0,
(size/(1024*1024)) / (time2 - time0));
airMopSub(mop, file, (airMopper)airFclose);
fclose(file);
/* -------------------------------------------------------------- */
/* -------------------------------------------------------------- */
fprintf(stderr, "(2) aligned memory, regular write:\n");
file = fopen(fname, "w");
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
fd = fileno(file);
time0 = airTime();
if (size != write(fd, data, size)) {
fprintf(stderr, "%s: write failed\n", me);
airMopError(mop); return 1;
}
time1 = airTime();
fsync(fd);
time2 = airTime();
fprintf(stderr, " time = %g + %g = %g (%g MB/sec)\n",
time1 - time0, time2 - time1, time2 - time0,
(size/(1024*1024)) / (time2 - time0));
airMopSub(mop, file, (airMopper)airFclose);
fclose(file);
/* -------------------------------------------------------------- */
/* -------------------------------------------------------------- */
fprintf(stderr, "(3) aligned memory, air's direct IO:\n");
file = fopen(fname, "w");
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
fd = fileno(file);
time0 = airTime();
if (size != airDioWrite(fd, data, size)) {
fprintf(stderr, "%s: write failed\n", me);
airMopError(mop); return 1;
}
time1 = airTime();
fsync(fd);
time2 = airTime();
fprintf(stderr, " time = %g + %g = %g (%g MB/sec)\n",
time1 - time0, time2 - time1, time2 - time0,
(size/(1024*1024)) / (time2 - time0));
airMopSub(mop, file, (airMopper)airFclose);
fclose(file);
/* -------------------------------------------------------------- */
/* -------------------------------------------------------------- */
fprintf(stderr, "(4) aligned memory, direct IO by hand:\n");
{
/* "input": fname, size, data */
int flags;
struct dioattr dio;
char *ptr;
size_t remain, totalrit, rit, part;
file = fopen(fname, "w");
if (-1 == (fd = fileno(file))) {
fprintf(stderr, "%s: couldn't get underlying descriptor\n", me);
airMopError(mop); return 1;
}
airMopAdd(mop, file, (airMopper)airFclose, airMopAlways);
flags = fcntl(fd, F_GETFL);
if (-1 == fcntl(fd, F_SETFL, flags | FDIRECT)) {
fprintf(stderr, "%s: couldn't turn on direct IO\n", me);
airMopError(mop); return 1;
}
if (0 != fcntl(fd, F_DIOINFO, &dio)) {
fprintf(stderr, "%s: couldn't learn direct IO specifics", me);
airMopError(mop); return 1;
}
remain = size;
totalrit = 0;
ptr = data;
time0 = airTime();
do {
part = remain > dio.d_maxiosz ? dio.d_maxiosz : remain;
rit = write(fd, ptr, part);
if (rit != part) {
fprintf(stderr, "%s: write failed\n", me);
airMopError(mop); return 1;
}
totalrit += rit;
ptr += rit;
remain -= rit;
} while (remain);
time1 = airTime();
fsync(fd);
time2 = airTime();
fprintf(stderr, " time = %g + %g = %g (%g MB/sec)\n",
time1 - time0, time2 - time1, time2 - time0,
(size/(1024*1024)) / (time2 - time0));
airMopSub(mop, file, (airMopper)airFclose);
fclose(file);
}
/* -------------------------------------------------------------- */
airMopError(mop);
exit(0);
#endif
}
int
main(int argc, const char **argv) {
/* stock variables */
char me[] = BKEY;
hestOpt *hopt=NULL;
hestParm *hparm;
airArray *mop;
/* variables specific to this program */
int negskip, progress;
Nrrd *nref, *nin;
size_t *size, ii, nn, tick, pad[2];
unsigned int axi, refCRC, gotCRC, sizeNum;
char *berr, *outS[2], stmp[AIR_STRLEN_SMALL], doneStr[AIR_STRLEN_SMALL];
airRandMTState *rng;
unsigned int seed, *rdata, printbytes;
unsigned char *dataUC;
double time0, time1;
FILE *fout;
/* start-up */
mop = airMopNew();
hparm = hestParmNew();
airMopAdd(mop, hparm, (airMopper)hestParmFree, airMopAlways);
/* learn things from hest */
hestOptAdd(&hopt, "seed", "N", airTypeUInt, 1, 1, &seed, "42",
"seed for RNG");
hestOptAdd(&hopt, "s", "sz0", airTypeSize_t, 1, -1, &size, NULL,
"sizes of desired output", &sizeNum);
hestOptAdd(&hopt, "p", "pb pa", airTypeSize_t, 2, 2, pad, "0 0",
"bytes of padding before, and after, the data segment "
"in the written data");
hestOptAdd(&hopt, "ns", "bool", airTypeInt, 0, 0, &negskip, NULL,
"skipping should be relative to end of file");
hestOptAdd(&hopt, "pb", "print", airTypeUInt, 1, 1, &printbytes, "0",
"bytes to print at beginning and end of data, to help "
"debug problems");
hestOptAdd(&hopt, "o", "out.data out.nhdr", airTypeString, 2, 2,
outS, NULL, "output filenames of data and header");
hestParseOrDie(hopt, argc-1, argv+1, hparm, me, tskipInfo,
AIR_TRUE, AIR_TRUE, AIR_TRUE);
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
/* generate reference nrrd data */
nref = nrrdNew();
airMopAdd(mop, nref, (airMopper)nrrdNuke, airMopAlways);
if (nrrdMaybeAlloc_nva(nref, nrrdTypeUInt, sizeNum, size)) {
airMopAdd(mop, berr=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error allocating data: %s\n", me, berr);
airMopError(mop); return 1;
}
rng = airRandMTStateNew(seed);
airMopAdd(mop, rng, (airMopper)airRandMTStateNix, airMopAlways);
nn = nrrdElementNumber(nref);
rdata = AIR_CAST(unsigned int *, nref->data);
fprintf(stderr, "generating data: . . . "); fflush(stderr);
time0 = airTime();
progress = AIR_FALSE;
tick = nn/100;
for (ii=0; ii<nn; ii++) {
rdata[ii] = airUIrandMT_r(rng);
if (ii && tick && !(ii % tick)) {
time1 = airTime();
if (time1 - time0 > 1.0) {
/* if it took more than a second to do 1% of the thing,
would be good to generate some progress indication */
progress = AIR_TRUE;
}
if (progress) {
fprintf(stderr, "%s", airDoneStr(0, ii, nn, doneStr)); fflush(stderr);
}
}
}
if (progress) {
fprintf(stderr, "%s\n", airDoneStr(0, ii, nn, doneStr)); fflush(stderr);
} else {
fprintf(stderr, "\n");
}
fprintf(stderr, "finding reference (big-endian) CRC: "); fflush(stderr);
refCRC = nrrdCRC32(nref, airEndianBig);
fprintf(stderr, "%u\n", refCRC);
/* write data, with padding */
fprintf(stderr, "saving data . . . "); fflush(stderr);
if (!(fout = fopen(outS[0], "wb" COMMIT))) {
fprintf(stderr, "\n%s: couldn't open %s for writing: %s\n", me,
outS[0], strerror(errno));
airMopError(mop); return 1;
}
airMopAdd(mop, fout, (airMopper)airFclose, airMopAlways);
for (ii=0; ii<pad[0]; ii++) {
if (EOF == fputc(1, fout)) {
fprintf(stderr, "\n%s: error doing pre-padding\n", me);
airMopError(mop); return 1;
}
}
if (nn != fwrite(nref->data, nrrdElementSize(nref), nn, fout)) {
fprintf(stderr, "\n%s: error writing data\n", me);
airMopError(mop); return 1;
}
for (ii=0; ii<pad[1]; ii++) {
if (EOF == fputc(2, fout)) {
fprintf(stderr, "\n%s: error doing post-padding\n", me);
airMopError(mop); return 1;
}
}
if (EOF == fflush(fout)) {
fprintf(stderr, "\n%s: error fflushing data: %s\n", me,
strerror(errno));
}
fprintf(stderr, "\n");
if (printbytes) {
size_t bi, rpb, nn;
char stmp[AIR_STRLEN_SMALL];
nn = nrrdElementSize(nref)*nrrdElementNumber(nref);
rpb = AIR_MIN(printbytes, nn);
dataUC = AIR_CAST(unsigned char *, nref->data);
fprintf(stderr, "CORRECT %s bytes at beginning:\n",
airSprintSize_t(stmp, rpb));
for (bi=0; bi<rpb; bi++) {
fprintf(stderr, "%x ", dataUC[bi]);
}
fprintf(stderr, "...\n");
fprintf(stderr, "CORRECT %s bytes at end:\n",
airSprintSize_t(stmp, rpb));
fprintf(stderr, "...");
for (bi=nn - rpb; bi<nn; bi++) {
fprintf(stderr, " %x", dataUC[bi]);
}
fprintf(stderr, "\n");
}
airMopSingleOkay(mop, fout);
airMopSingleOkay(mop, nref); nref = NULL;
/* write header; for now just writing the header directly */
fprintf(stderr, "writing header . . . \n");
if (!(fout = fopen(outS[1], "w"))) {
fprintf(stderr, "%s: couldn't open %s for writing: %s\n", me,
outS[1], strerror(errno));
airMopError(mop); return 1;
}
airMopAdd(mop, fout, (airMopper)airFclose, airMopAlways);
fprintf(fout, "NRRD0005\n");
fprintf(fout, "type: unsigned int\n");
fprintf(fout, "dimension: %u\n", sizeNum);
fprintf(fout, "sizes:");
for (axi=0; axi<sizeNum; axi++) {
fprintf(fout, " %s", airSprintSize_t(stmp, size[axi]));
}
fprintf(fout, "\n");
fprintf(fout, "endian: %s\n", airEnumStr(airEndian, airMyEndian()));
fprintf(fout, "encoding: %s\n", airEnumStr(nrrdEncodingType,
nrrdEncodingTypeRaw));
if (!negskip) {
if (pad[0]) {
fprintf(fout, "byte skip: %s\n", airSprintSize_t(stmp, pad[0]));
}
} else {
fprintf(fout, "byte skip: -%s\n", airSprintSize_t(stmp, pad[1]+1));
}
fprintf(fout, "data file: %s\n", outS[0]);
airMopSingleOkay(mop, fout);
/* read it in, make sure it checks out */
fprintf(stderr, "reading data . . . \n");
nin = nrrdNew();
airMopAdd(mop, nin, (airMopper)nrrdNuke, airMopAlways);
if (nrrdLoad(nin, outS[1], NULL)) {
airMopAdd(mop, berr=biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: error reading back in: %s\n", me, berr);
airMopError(mop); return 1;
}
if (printbytes) {
size_t bi, rpb, nn;
char stmp[AIR_STRLEN_SMALL];
nn = nrrdElementSize(nin)*nrrdElementNumber(nin);
rpb = AIR_MIN(printbytes, nn);
dataUC = AIR_CAST(unsigned char *, nin->data);
fprintf(stderr, "FOUND %s bytes at beginning:\n",
airSprintSize_t(stmp, rpb));
for (bi=0; bi<rpb; bi++) {
fprintf(stderr, "%x ", dataUC[bi]);
}
fprintf(stderr, "...\n");
fprintf(stderr, "FOUND %s bytes at end:\n",
airSprintSize_t(stmp, rpb));
fprintf(stderr, "...");
for (bi=nn - rpb; bi<nn; bi++) {
fprintf(stderr, " %x", dataUC[bi]);
}
fprintf(stderr, "\n");
}
fprintf(stderr, "finding new CRC . . . \n");
gotCRC = nrrdCRC32(nin, airEndianBig);
if (refCRC != gotCRC) {
fprintf(stderr, "%s: got CRC %u but wanted %u\n", me, gotCRC, refCRC);
airMopError(mop); return 1;
}
fprintf(stderr, "(all ok)\n");
/* HEY: to test gzip reading, we really want to do a system call to
gzip compress the data, and write a new header to point to the
compressed data, and make sure we can read in that just the same */
airMopOkay(mop);
return 0;
}
int
main(int argc, const char *argv[]) {
const char *me;
char *err;
hestOpt *hopt = NULL;
airArray *mop;
char *outS;
alanContext *actx;
int *size, sizeLen, fi, si, wrap, nt, cfn, ha, maxi;
unsigned int srnd;
double deltaT, mch, xch, alphabeta[2], time0, time1, deltaX, react, rrange;
Nrrd *ninit=NULL, *nten=NULL, *nparm=NULL;
me = argv[0];
hestOptAdd(&hopt, "s", "sx sy", airTypeInt, 2, 3, &size, "128 128",
"size of texture, and also determines its dimension",
&sizeLen);
hestOptAdd(&hopt, "srand", "N", airTypeUInt, 1, 1, &srnd, "42",
"number to seed random number generator with. This uses "
"airDrandMT(), so it should be portable.");
hestOptAdd(&hopt, "i", "tensors", airTypeOther, 1, 1, &nten, "",
"diffusion tensors to use for guiding the texture generation. "
"If used, over-rides the \"-s\" option, both for setting "
"texture dimension and size. If you want upsampling, you "
"do it yourself before sending it here.",
NULL, NULL, nrrdHestNrrd);
hestOptAdd(&hopt, "ha", NULL, airTypeInt, 0, 0, &ha, NULL,
"use the homogenous anisotropy assumption- that the spatial "
"derivative of the diffusion tensor is negligible when "
"computing the diffusive term ");
hestOptAdd(&hopt, "wrap", NULL, airTypeInt, 0, 0, &wrap, NULL,
"wrap edges of texture around a topological torus (which "
"makes a texture suitable for tiling)");
hestOptAdd(&hopt, "ab", "alpha beta", airTypeDouble, 2, 2, alphabeta,
"16.0 12.0",
"the growth and decay parameters appearing in the reaction "
"terms of the reaction-diffusion equations. The default "
"values were the ones published by Turing.");
hestOptAdd(&hopt, "sr", "react", airTypeDouble, 1, 1, &react, "1.0",
"scaling of reaction term");
hestOptAdd(&hopt, "rr", "range range", airTypeDouble, 1, 1, &rrange, "4.0",
"amount of random noise to add to inital textures");
hestOptAdd(&hopt, "dt", "time", airTypeDouble, 1, 1, &deltaT, "1.0",
"time-step size in Euler integration. Can be larger, at "
"risk of hitting divergent instability.");
hestOptAdd(&hopt, "dx", "size", airTypeDouble, 1, 1, &deltaX, "1.3",
"nominal size of simulation grid element.");
hestOptAdd(&hopt, "mch", "change", airTypeDouble, 1, 1, &mch, "0.00001",
"the minimum significant change (averaged over the whole "
"texture) in the first morphogen: to signify convergence");
hestOptAdd(&hopt, "xch", "change", airTypeDouble, 1, 1, &xch, "6",
"the maximum allowable change (averaged over the whole "
"texture) in the first morphogen: to signify divergence");
hestOptAdd(&hopt, "maxi", "# iter", airTypeInt, 1, 1, &maxi, "0",
"maximum number of iterations to run for, or \"0\" to have "
"no limit based on iteration count");
hestOptAdd(&hopt, "fi", "frame inter", airTypeInt, 1, 1, &fi, "0",
"the number of iterations between which to save out an 8-bit "
"image of the texture, or \"0\" to disable such action");
hestOptAdd(&hopt, "si", "snap inter", airTypeInt, 1, 1, &si, "0",
"the number of iterations between which to save out a complete "
"floating-point snapshot of the morphogen state, suitable for "
"later re-initialization, or \"0\" to disable such action");
hestOptAdd(&hopt, "cfn", NULL, airTypeInt, 0, 0, &cfn, NULL,
"when saving out frames or snapshots, use a constant filename, "
"instead of incrementing it each save");
hestOptAdd(&hopt, "nt", "# threads", airTypeInt, 1, 1, &nt, "1",
(airThreadCapable
? "number of threads to use in computation"
: "number of \"threads\" to use in computation, which is "
"moot here because this Teem build doesn't support "
"multi-threading. "));
hestOptAdd(&hopt, "o", "nout", airTypeString, 1, 1, &outS, NULL,
"filename for output of final converged (two-channel) texture");
hestParseOrDie(hopt, argc-1, argv+1, NULL,
me, spotsInfo, AIR_TRUE, AIR_TRUE, AIR_TRUE);
mop = airMopNew();
airMopAdd(mop, hopt, (airMopper)hestOptFree, airMopAlways);
airMopAdd(mop, hopt, (airMopper)hestParseFree, airMopAlways);
actx = alanContextNew();
airMopAdd(mop, actx, (airMopper)alanContextNix, airMopAlways);
if (nten) {
if (alanDimensionSet(actx, nten->dim - 1)
|| alanTensorSet(actx, nten, 1)) {
airMopAdd(mop, err = biffGetDone(ALAN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble setting parameters:\n%s\n", me, err);
airMopError(mop);
return 1;
}
} else {
alanDimensionSet(actx, sizeLen);
if (2 == sizeLen) {
alan2DSizeSet(actx, size[0], size[1]);
} else {
alan3DSizeSet(actx, size[0], size[1], size[2]);
}
}
airSrandMT(srnd);
if (alanParmSet(actx, alanParmVerbose, 1)
|| alanParmSet(actx, alanParmTextureType, alanTextureTypeTuring)
|| alanParmSet(actx, alanParmK, 0.0125)
|| alanParmSet(actx, alanParmAlpha, alphabeta[0])
|| alanParmSet(actx, alanParmBeta, alphabeta[1])
|| alanParmSet(actx, alanParmDeltaX, deltaX)
|| alanParmSet(actx, alanParmDeltaT, deltaT)
|| alanParmSet(actx, alanParmReact, react)
|| alanParmSet(actx, alanParmMinAverageChange, mch)
|| alanParmSet(actx, alanParmMaxPixelChange, xch)
|| alanParmSet(actx, alanParmMaxIteration, maxi)
|| alanParmSet(actx, alanParmRandRange, rrange)
|| alanParmSet(actx, alanParmSaveInterval, si)
|| alanParmSet(actx, alanParmFrameInterval, fi)
|| alanParmSet(actx, alanParmConstantFilename, cfn)
|| alanParmSet(actx, alanParmWrapAround, wrap)
|| alanParmSet(actx, alanParmHomogAniso, ha)
|| alanParmSet(actx, alanParmNumThreads, nt)) {
airMopAdd(mop, err = biffGetDone(ALAN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble setting parameters:\n%s\n", me, err);
airMopError(mop);
return 1;
}
if (alanUpdate(actx) || alanInit(actx, ninit, nparm)) {
airMopAdd(mop, err = biffGetDone(ALAN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble initializing texture: %s\n", me, err);
airMopError(mop);
return 1;
}
fprintf(stderr, "%s: going to run (%d threads) ...\n", me, actx->numThreads);
time0 = airTime();
if (alanRun(actx)) {
airMopAdd(mop, err = biffGetDone(ALAN), airFree, airMopAlways);
fprintf(stderr, "%s: trouble generating texture: %s\n", me, err);
airMopError(mop);
return 1;
}
time1 = airTime();
fprintf(stderr, "%s: stopped after %d iterations (%g seconds): %s\n",
me, actx->iter, time1 - time0,
airEnumDesc(alanStop, actx->stop));
if (nrrdSave(outS, actx->nlev, NULL)) {
airMopAdd(mop, err = biffGetDone(NRRD), airFree, airMopAlways);
fprintf(stderr, "%s: trouble saving output:\n%s\n", me, err);
airMopError(mop);
return 1;
}
airMopOkay(mop);
return 0;
}
int
pushRun(pushContext *pctx) {
char me[]="pushRun", err[BIFF_STRLEN],
poutS[AIR_STRLEN_MED], toutS[AIR_STRLEN_MED], soutS[AIR_STRLEN_MED];
Nrrd *npos, *nten, *nstn;
double vel[2], meanVel=0;
pctx->iter = 0;
pctx->time0 = airTime();
vel[0] = AIR_NAN;
vel[1] = AIR_NAN;
do {
if (400 == pctx->iter) {
unsigned int bi, ti;
pushBin *bin;
for (bi=0; bi<pctx->numBin; bi++) {
bin = pctx->bin + bi;
for (ti=0; ti<bin->numThing; ti++) {
ELL_3V_SET(bin->thing[ti]->point.vel, 0, 0, 0);
}
}
}
if (pushIterate(pctx)) {
sprintf(err, "%s: trouble on iter %d", me, pctx->iter);
biffAdd(PUSH, err); return 1;
}
if (pctx->snap && !(pctx->iter % pctx->snap)) {
nten = nrrdNew();
npos = nrrdNew();
nstn = nrrdNew();
sprintf(poutS, "snap.%06d.pos.nrrd", pctx->iter);
sprintf(toutS, "snap.%06d.ten.nrrd", pctx->iter);
sprintf(soutS, "snap.%06d.stn.nrrd", pctx->iter);
if (pushOutputGet(npos, nten, nstn, pctx)) {
sprintf(err, "%s: couldn't get snapshot for iter %d", me, pctx->iter);
biffAdd(PUSH, err); return 1;
}
fprintf(stderr, "%s: %s, meanVel=%g, %g iter/sec\n", me,
poutS, meanVel, pctx->iter/(airTime()-pctx->time0));
if (nrrdSave(poutS, npos, NULL)
|| nrrdSave(toutS, nten, NULL)
|| nrrdSave(soutS, nstn, NULL)) {
sprintf(err, "%s: couldn't save snapshot for iter %d", me, pctx->iter);
biffMove(PUSH, err, NRRD); return 1;
}
nten = nrrdNuke(nten);
npos = nrrdNuke(npos);
nstn = nrrdNuke(nstn);
}
/* this goofiness is because it seems like my stupid Euler
integration can lead to real motion only happening on
every other iteration ... */
if (0 == pctx->iter) {
vel[0] = pctx->meanVel;
meanVel = pctx->meanVel;
} else if (1 == pctx->iter) {
vel[1] = pctx->meanVel;
meanVel = (vel[0] + vel[1])/2;
} else {
vel[0] = vel[1];
vel[1] = pctx->meanVel;
meanVel = (vel[0] + vel[1])/2;
}
pctx->iter++;
} while ( (pctx->iter < pctx->minIter)
|| (meanVel > pctx->minMeanVel
&& (0 == pctx->maxIter
|| pctx->iter < pctx->maxIter)) );
pctx->time1 = airTime();
pctx->time = pctx->time1 - pctx->time0;
return 0;
}
