static void SamplesAlloc(cThis *t, Samples *samples)
{
#define FIRST -INT_MAX
#define MarkLast(x) (x | Marked(INT_MAX))
#include "KorobovCoeff.c"
number nx, nf;
if( samples->sampler == SampleKorobov ) {
enum { max = Elements(prime) - 2 };
cint n = IMin(2*samples->n - 1, MAXPRIME);
int i = Hash(n), p;
count shift = 2 + NegQ(n - 1000);
while( i = IMin(IDim(i), max),
n > (p = prime[i + 1]) || n <= prime[i] ) {
cint d = (n - Unmark(p)) >> ++shift;
i += Min1(d);
}
samples->coeff = coeff[i][t->ndim - KOROBOV_MINDIM];
samples->neff = p = Unmark(p);
samples->n = p/2 + 1;
}
nx = t->ndim*(samples->n + 1); /* need 1 for extrapolation */
nf = t->ncomp*(samples->n + 1);
Alloc(samples->x, nx + nf + t->ncomp + t->ncomp);
samples->f = samples->x + nx;
}
void CMask::RemoveMask ( PCMask Mask ) {
int i,l;
if (Mask) {
l = IMin(mlen,Mask->mlen);
for (i=0;i<l;i++)
m[i] &= ~Mask->m[i];
}
}
Boolean CMask::CheckMask ( PCMask Mask ) {
int i,l;
if (Mask) {
i = 0;
l = IMin(mlen,Mask->mlen);
while ((i<l) && (!(m[i] & Mask->m[i]))) i++;
return (i<l);
} else
return False;
}
void CMask::SelMask ( PCMask Mask ) {
int i,l;
if (Mask) {
l = IMin(mlen,Mask->mlen);
for (i=0;i<l;i++)
m[i] &= Mask->m[i];
for (i=l;i<mlen;i++)
m[i] = 0;
} else
ClearMask();
}
static void SamplesAlloc(Samples *samples)
{
#define FIRST -INT_MAX
#define MarkLast(x) (x | Marked(INT_MAX))
#include "KorobovCoeff.c"
count nx, nf;
if( samples->sampler == SampleKorobov ) {
enum { max = Elements(prime) - 2 };
cint n = IMin(2*samples->n - 1, MAXPRIME);
int i = Hash(n), p;
count shift = 2 + NegQ(n - 1000);
while( i = IMin(IDim(i), max),
n > (p = prime[i + 1]) || n <= prime[i] ) {
cint d = (n - Unmark(p)) >> ++shift;
i += Min1(d);
}
samples->coeff = coeff[i][ndim_ - KOROBOV_MINDIM];
samples->neff = p = Unmark(p);
samples->n = p/2 + 1;
}
nx = ndim_*(samples->n + 1); /* need 1 for extrapolation */
nf = ncomp_*(samples->n + 1);
Allocate(samples->x, nx + nf + ncomp_ + ncomp_);
samples->f = samples->x + nx;
samples->avg = samples->f + nf;
samples->err = samples->avg + ncomp_;
ResClear(samples->err);
samples->weight = 1./samples->neff;
}
static count SamplesLookup(Samples *samples, int key,
ccount nwant, ccount nmax, count nmin)
{
count n;
if( key == 13 && ndim_ == 2 ) {
if( rule13_.first == NULL ) Rule13Alloc(&rule13_);
samples->rule = &rule13_;
samples->n = n = nmin = rule13_.n;
samples->sampler = SampleRule;
}
else if( key == 11 && ndim_ == 3 ) {
if( rule11_.first == NULL ) Rule11Alloc(&rule11_);
samples->rule = &rule11_;
samples->n = n = nmin = rule11_.n;
samples->sampler = SampleRule;
}
else if( key == 9 ) {
if( rule9_.first == NULL ) Rule9Alloc(&rule9_);
samples->rule = &rule9_;
samples->n = n = nmin = rule9_.n;
samples->sampler = SampleRule;
}
else if( key == 7 ) {
if( rule7_.first == NULL ) Rule7Alloc(&rule7_);
samples->rule = &rule7_;
samples->n = n = nmin = rule7_.n;
samples->sampler = SampleRule;
}
else {
n = Abs1(key);
if( n < 40 ) n *= nwant;
samples->sampler = (key < 0) ? SampleSobol :
(n = n/2 + 1, SampleKorobov);
samples->n = IMin(n, nmax);
}
samples->neff = samples->n;
return IDim(n - nmax) | Marked(nmax - nmin);
}
static count SamplesLookup(This *t, Samples *samples, cint key,
cnumber nwant, cnumber nmax, number nmin)
{
number n;
if( key == 13 && t->ndim == 2 ) {
samples->rule = &t->rule13;
samples->n = n = nmin = t->rule13.n;
samples->sampler = SampleRule;
}
else if( key == 11 && t->ndim == 3 ) {
samples->rule = &t->rule11;
samples->n = n = nmin = t->rule11.n;
samples->sampler = SampleRule;
}
else if( key == 9 ) {
samples->rule = &t->rule9;
samples->n = n = nmin = t->rule9.n;
samples->sampler = SampleRule;
}
else if( key == 7 ) {
samples->rule = &t->rule7;
samples->n = n = nmin = t->rule7.n;
samples->sampler = SampleRule;
}
else {
n = Abs1(key);
if( n < 40 ) n *= nwant;
samples->sampler = (key < 0) ? SampleSobol :
(n = n/2 + 1, SampleKorobov);
samples->n = IMin(n, nmax);
}
samples->neff = samples->n;
return IDim(n - nmax) | Marked(nmax - nmin);
}
static int Integrate(This *t, real *integral, real *error, real *prob)
{
bin_t *bins;
count dim, comp;
int fail;
StateDecl;
csize_t statesize = sizeof(State) +
NCOMP*sizeof(Cumulants) + NDIM*sizeof(Grid);
Sized(State, state, statesize);
Cumulants *c, *C = state->cumul + t->ncomp;
Grid *state_grid = (Grid *)C;
Array(Grid, margsum, NCOMP, NDIM);
Vector(char, out, 128*NCOMP + 256);
if( VERBOSE > 1 ) {
sprintf(out, "Vegas input parameters:\n"
" ndim " COUNT "\n ncomp " COUNT "\n"
" epsrel " REAL "\n epsabs " REAL "\n"
" flags %d\n seed %d\n"
" mineval " NUMBER "\n maxeval " NUMBER "\n"
" nstart " NUMBER "\n nincrease " NUMBER "\n"
" nbatch " NUMBER "\n gridno %d\n"
" statefile \"%s\"",
t->ndim, t->ncomp,
t->epsrel, t->epsabs,
t->flags, t->seed,
t->mineval, t->maxeval,
t->nstart, t->nincrease, t->nbatch,
t->gridno, t->statefile);
Print(out);
}
if( BadComponent(t) ) return -2;
if( BadDimension(t) ) return -1;
FrameAlloc(t, ShmRm(t));
ForkCores(t);
Alloc(bins, t->nbatch*t->ndim);
if( (fail = setjmp(t->abort)) ) goto abort;
IniRandom(t);
StateSetup(t);
if( StateReadTest(t) ) {
StateReadOpen(t, fd) {
if( read(fd, state, statesize) != statesize ||
state->signature != StateSignature(t, 1) ) break;
} StateReadClose(t, fd);
t->neval = state->neval;
t->rng.skiprandom(t, t->neval);
}
if( ini ) {
state->niter = 0;
state->nsamples = t->nstart;
FClear(state->cumul);
GetGrid(t, state_grid);
t->neval = 0;
}
/* main iteration loop */
for( ; ; ) {
number nsamples = state->nsamples;
creal jacobian = 1./nsamples;
FClear(margsum);
for( ; nsamples > 0; nsamples -= t->nbatch ) {
cnumber n = IMin(t->nbatch, nsamples);
real *w = t->frame;
real *x = w + n;
real *f = x + n*t->ndim;
real *lastf = f + n*t->ncomp;
bin_t *bin = bins;
while( x < f ) {
real weight = jacobian;
t->rng.getrandom(t, x);
for( dim = 0; dim < t->ndim; ++dim ) {
creal pos = *x*NBINS;
ccount ipos = (count)pos;
creal prev = (ipos == 0) ? 0 : state_grid[dim][ipos - 1];
creal diff = state_grid[dim][ipos] - prev;
*x++ = prev + (pos - ipos)*diff;
*bin++ = ipos;
weight *= diff*NBINS;
}
*w++ = weight;
}
DoSample(t, n, w, f, t->frame, state->niter + 1);
bin = bins;
w = t->frame;
while( f < lastf ) {
creal weight = *w++;
Grid *m = &margsum[0][0];
for( c = state->cumul; c < C; ++c ) {
real wfun = weight*(*f++);
if( wfun ) {
c->sum += wfun;
c->sqsum += wfun *= wfun;
for( dim = 0; dim < t->ndim; ++dim )
m[dim][bin[dim]] += wfun;
}
m += t->ndim;
}
bin += t->ndim;
}
}
fail = 0;
/* compute the integral and error values */
for( c = state->cumul; c < C; ++c ) {
real w = Weight(c->sum, c->sqsum, state->nsamples);
real sigsq = 1/(c->weightsum += w);
real avg = sigsq*(c->avgsum += w*c->sum);
c->avg = LAST ? (sigsq = 1/w, c->sum) : avg;
c->err = sqrt(sigsq);
fail |= (c->err > MaxErr(c->avg));
if( state->niter == 0 ) c->guess = c->sum;
else {
c->chisum += w *= c->sum - c->guess;
c->chisqsum += w*c->sum;
}
c->chisq = c->chisqsum - avg*c->chisum;
c->sum = c->sqsum = 0;
}
if( VERBOSE ) {
char *oe = out + sprintf(out, "\n"
"Iteration " COUNT ": " NUMBER " integrand evaluations so far",
state->niter + 1, t->neval);
for( c = state->cumul, comp = 0; c < C; ++c )
oe += sprintf(oe, "\n[" COUNT "] "
REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)",
++comp, c->avg, c->err, c->chisq, state->niter);
Print(out);
}
if( fail == 0 && t->neval >= t->mineval ) break;
if( t->neval >= t->maxeval && !StateWriteTest(t) ) break;
if( t->ncomp == 1 )
for( dim = 0; dim < t->ndim; ++dim )
RefineGrid(t, state_grid[dim], margsum[0][dim]);
else {
for( dim = 0; dim < t->ndim; ++dim ) {
Grid wmargsum;
Zap(wmargsum);
for( comp = 0; comp < t->ncomp; ++comp ) {
real w = state->cumul[comp].avg;
if( w != 0 ) {
creal *m = margsum[comp][dim];
count bin;
w = 1/Sq(w);
for( bin = 0; bin < NBINS; ++bin )
wmargsum[bin] += w*m[bin];
}
}
RefineGrid(t, state_grid[dim], wmargsum);
}
}
++state->niter;
state->nsamples += t->nincrease;
if( StateWriteTest(t) ) {
state->signature = StateSignature(t, 1);
state->neval = t->neval;
StateWriteOpen(t, fd) {
StateWrite(fd, state, statesize);
} StateWriteClose(t, fd);
if( t->neval >= t->maxeval ) break;
}
}
void SVDCMP(REAL **a, int m, int n, REAL *w, REAL **v) {
/*-------------------------------------------------------------------------------------
! Given a matrix a(1:m,1:n), this routine computes its singular value decomposition,
! A = U · W · Vt. The matrix U replaces a on output. The diagonal matrix of singular
! values W is output as a vector w(1:n). The matrix V (not the transpose Vt) is output
! as v(1:n,1:n).
!------------------------------------------------------------------------------------*/
//Labels: e1, e2, e3
int i,its,j,jj,k,l,nm;
REAL anorm,c,f,g,h,s,scale,x,y,z;
REAL rv1[NMAX];
g=0.0; //Householder reduction to bidiagonal form
scale=0.0;
anorm=0.0;
for (i=1; i<=n; i++) {
l=i+1;
rv1[i]=scale*g;
g=0.0;
s=0.0;
scale=0.0;
if (i <= m) {
for (k=i; k<=m; k++) scale += fabs(a[k][i]);
if (scale != 0.0) {
for (k=i; k<=m; k++) {
a[k][i] /= scale;
s += a[k][i]*a[k][i];
}
f=a[i][i];
g=-Sign(sqrt(s),f);
h=f*g-s;
a[i][i]=f-g;
for (j=l; j<=n; j++) {
s=0.0;
for (k=i; k<=m; k++) s += a[k][i]*a[k][j];
f=s/h;
for (k=i; k<=m; k++) a[k][j] += f*a[k][i];
}
for (k=i; k<=m; k++) a[k][i] *= scale;
}
}
w[i]=scale*g;
g=0.0;
s=0.0;
scale=0.0;
if (i <= m && i != n) {
for (k=l; k<=n; k++) scale += fabs(a[i][k]);
if (scale != 0.0) {
for (k=l; k<=n; k++) {
a[i][k] /= scale;
s += a[i][k]*a[i][k];
}
f=a[i][l];
g=-Sign(sqrt(s),f);
h=f*g-s;
a[i][l]=f-g;
for (k=l; k<=n; k++) rv1[k]=a[i][k]/h;
for (j=l; j<=m; j++) {
s=0.0;
for (k=l; k<=n; k++) s += a[j][k]*a[i][k];
for (k=l; k<=n; k++) a[j][k] += s*rv1[k];
}
for (k=l; k<=n; k++) a[i][k] *= scale;
}
}
anorm=Max(anorm,(fabs(w[i])+fabs(rv1[i])));
} // i loop
for (i=n; i>0; i--) { //Accumulation of right-hand transformations
if (i < n) {
if (g != 0.0) {
for (j=l; j<=n; j++) //Double division to avoid possible underflow
v[j][i]=(a[i][j]/a[i][l])/g;
for (j=l; j<=n; j++) {
s=0.0;
for (k=l; k<=n; k++) s += a[i][k]*v[k][j];
for (k=l; k<=n; k++) v[k][j] += s*v[k][i];
}
}
for (j=l; j<=n; j++) {
v[i][j]=0.0;
v[j][i]=0.0;
}
}
v[i][i]=1.0;
g=rv1[i];
l=i;
}
for (i=IMin(m,n); i>0; i--) { //Accumulation of left-hand transformations
l=i+1;
g=w[i];
for (j=l; j<=n; j++) a[i][j]=0.0;
if (g != 0.0) {
g=1.0/g;
for (j=l; j<=n; j++) {
s=0.0;
for (k=l; k<=m; k++) s += a[k][i]*a[k][j];
f=(s/a[i][i])*g;
for (k=i; k<=m; k++) a[k][j] += f*a[k][i];
}
for (j=i; j<=m; j++) a[j][i] *= g;
}
else
for (j=i; j<=m; j++) a[j][i]=0.0;
a[i][i] += 1.0;
}
for (k=n; k>0; k--) { //Diagonalization of the bidiagonal form: Loop over
//singular values, and over allowed iterations
for (its=1; its<=30; its++) {
for (l=k; l>0; l--) { //Test for splitting
nm=l-1; //Note that rv1(1) is always zero
if ((fabs(rv1[l])+anorm) == anorm) goto e2;
if ((fabs(w[nm])+anorm) == anorm) goto e1;
}
e1: c=0.0; //Cancellation of rv1(l), if l > 1
s=1.0;
for (i=l; i<=k; i++) {
f=s*rv1[i];
rv1[i]=c*rv1[i];
if ((fabs(f)+anorm) == anorm) goto e2;
g=w[i];
h=pythag(f,g);
w[i]=h;
h=1.0/h;
c=g*h;
s=-(f*h);
for (j=1; j<=m; j++) {
y=a[j][nm];
z=a[j][i];
a[j][nm]=(y*c)+(z*s);
a[j][i]=-(y*s)+(z*c);
}
}
e2: z=w[k];
if (l == k) { //Convergence
if (z < 0.0) { //Singular value is made nonnegative
w[k]=-z;
for (j=1; j<=n; j++) v[j][k]=-v[j][k];
}
goto e3;
}
if (its == 30) printf(" No convergence in svdcmp\n");
x=w[l]; //Shift from bottom 2-by-2 minor
nm=k-1;
y=w[nm];
g=rv1[nm];
h=rv1[k];
f=((y-z)*(y+z)+(g-h)*(g+h))/(2.0*h*y);
g=pythag(f,1.0);
f=((x-z)*(x+z)+h*((y/(f+Sign(g,f)))-h))/x;
c=1.0; //Next QR transformation:
s=1.0;
for (j=l; j<=nm; j++) {
i=j+1;
g=rv1[i];
y=w[i];
h=s*g;
g=c*g;
z=pythag(f,h);
rv1[j]=z;
c=f/z;
s=h/z;
f= (x*c)+(g*s);
g=-(x*s)+(g*c);
h=y*s;
y=y*c;
for (jj=1; jj<=n; jj++) {
x=v[jj][j];
z=v[jj][i];
v[jj][j]= (x*c)+(z*s);
v[jj][i]=-(x*s)+(z*c);
}
z=pythag(f,h);
w[j]=z; //Rotation can be arbitrary if z = 0
if (z != 0.0) {
z=1.0/z;
c=f*z;
s=h*z;
}
f= (c*g)+(s*y);
x=-(s*g)+(c*y);
for (jj=1; jj<=m; jj++) {
y=a[jj][j];
z=a[jj][i];
a[jj][j]= (y*c)+(z*s);
a[jj][i]=-(y*s)+(z*c);
}
} //for j=l to nm
rv1[l]=0.0;
rv1[k]=f;
w[k]=x;
} //its loop
e3:;} //k loop
} //svdcmp()
void CSymbolTypeComboBox::DrawItem(LPDRAWITEMSTRUCT pDIStruct)
{
CRect rItemRect = pDIStruct->rcItem;
COLORREF clrNormal = ::GetSysColor(COLOR_WINDOW);
COLORREF clrSelected = ::GetSysColor(COLOR_HIGHLIGHT);
COLORREF drawColor = symColor;
CDC dcContext;
if (!dcContext.Attach(pDIStruct->hDC)) {
return;
}
int iState = pDIStruct->itemState;
if (iState & ODS_SELECTED)
{
drawColor = 0x00FFFFFF & ~(drawColor);
dcContext.SetBkColor(clrSelected);
dcContext.FillSolidRect(&rItemRect, clrSelected);
}
else
{
dcContext.SetBkColor(clrNormal);
dcContext.FillSolidRect(&rItemRect, clrNormal);
}
if (iState & ODS_FOCUS) {
dcContext.DrawFocusRect(&rItemRect);
}
int iItem = pDIStruct->itemID;
if (iItem != -1)
{
dcContext.SetBkMode(TRANSPARENT);
if (iState & ODS_DISABLED)
{
drawColor = ::GetSysColor(COLOR_INACTIVECAPTIONTEXT);
}
PlotSymbol currSym = PlotSymbol(iItem);
bool filledSym = PlotSymbolOps::SymbolIsFilled(currSym);
rItemRect.DeflateRect(4, 0);
int lThick = IMin(rItemRect.bottom - rItemRect.top - 2, symLThick);
if (filledSym)
lThick = 1;
CPen drawPen(PS_SOLID, lThick, drawColor);
CPen* pOldPen = dcContext.SelectObject(&drawPen);
CBrush brush(drawColor);
CBrush* pOldBrush = dcContext.SelectObject(&brush);
int drawSymSize = IMin((rItemRect.bottom - rItemRect.top), symSize);
int rectMidY = (rItemRect.top + rItemRect.bottom) / 2;
int rectMidX = (rItemRect.left + rItemRect.right) / 2;
switch (currSym) {
case ps_X : {
drawSymSize /= 2;
dcContext.MoveTo(rectMidX - drawSymSize, rectMidY - drawSymSize);
dcContext.LineTo(rectMidX + drawSymSize, rectMidY + drawSymSize);
dcContext.MoveTo(rectMidX + drawSymSize, rectMidY - drawSymSize);
dcContext.LineTo(rectMidX - drawSymSize, rectMidY + drawSymSize);
break;
}
case ps_Plus : {
drawSymSize /= 2;
dcContext.MoveTo(rectMidX - drawSymSize, rectMidY);
dcContext.LineTo(rectMidX + drawSymSize, rectMidY);
dcContext.MoveTo(rectMidX, rectMidY - drawSymSize);
dcContext.LineTo(rectMidX, rectMidY + drawSymSize);
break;
}
case ps_Square : case ps_FSquare :{
drawSymSize /= 2;
CPoint pts[4];
pts[0].x = rectMidX - drawSymSize;
pts[0].y = rectMidY - drawSymSize;
pts[1].x = rectMidX + drawSymSize;
pts[1].y = rectMidY - drawSymSize;
pts[2].x = rectMidX + drawSymSize;
pts[2].y = rectMidY + drawSymSize;
pts[3].x = rectMidX - drawSymSize;
pts[3].y = rectMidY + drawSymSize;
DrawSymbol(dcContext, pts, 4, filledSym);
break;
}
case ps_Circle : case ps_FCircle: {
static const Point2D cicoords[] = {Point2D(0.00000 ,0.50000),
Point2D(0.25000 ,0.43301),
Point2D(0.43301 ,0.25000),
Point2D(0.50000 ,0.00000),
Point2D(0.43301 ,-0.25000),
Point2D(0.25000 ,-0.43301),
Point2D(0.00000 ,-0.50000),
Point2D(-0.25000,-0.43301),
Point2D(-0.43301,-0.25000),
Point2D(-0.50000,0.00000),
Point2D(-0.43301,0.25000),
Point2D(-0.25000,0.43301)};
CPoint pts[12];
for (int i = 0; i < 12; i++)
{
int offX = int(double(drawSymSize) * cicoords[i].pX);
int offY = int(double(drawSymSize) * cicoords[i].pY);
pts[i].x = rectMidX + offX;
pts[i].y = rectMidY + offY;
}
DrawSymbol(dcContext, pts, 12, filledSym);
break;
}
case ps_Triangle : case ps_FTriangle : {
int offX = int(double(drawSymSize) * 0.4330);
int offY = int(double(drawSymSize) * 0.25);
CPoint pts[3];
pts[0].x = rectMidX - offX;
pts[0].y = rectMidY + offY;
pts[1].x = rectMidX + offX;
pts[1].y = rectMidY + offY;
pts[2].x = rectMidX;
pts[2].y = rectMidY - drawSymSize / 2;
DrawSymbol(dcContext, pts, 3, filledSym);
break;
}
case ps_Diamond : case ps_FDiamond : {
drawSymSize /= 2;
CPoint pts[4];
pts[0].x = rectMidX;
pts[0].y = rectMidY - drawSymSize;
pts[1].x = rectMidX + drawSymSize;
pts[1].y = rectMidY;
pts[2].x = rectMidX;
pts[2].y = rectMidY + drawSymSize;
pts[3].x = rectMidX - drawSymSize;
pts[3].y = rectMidY;
DrawSymbol(dcContext, pts, 4, filledSym);
break;
}
}
}
dcContext.Detach();
}
static int Integrate(This *t, real *integral, real *error, real *prob)
{
bin_t *bins;
count dim, comp;
int fail;
struct {
count niter;
number nsamples, neval;
Cumulants cumul[NCOMP];
Grid grid[NDIM];
} state;
int statemsg = VERBOSE;
struct stat st;
if( VERBOSE > 1 ) {
char s[512];
sprintf(s, "Vegas input parameters:\n"
" ndim " COUNT "\n ncomp " COUNT "\n"
" epsrel " REAL "\n epsabs " REAL "\n"
" flags %d\n seed %d\n"
" mineval " NUMBER "\n maxeval " NUMBER "\n"
" nstart " NUMBER "\n nincrease " NUMBER "\n"
" nbatch " NUMBER "\n gridno %d\n"
" statefile \"%s\"",
t->ndim, t->ncomp,
t->epsrel, t->epsabs,
t->flags, t->seed,
t->mineval, t->maxeval,
t->nstart, t->nincrease, t->nbatch,
t->gridno, t->statefile);
Print(s);
}
if( BadComponent(t) ) return -2;
if( BadDimension(t) ) return -1;
FrameAlloc(t, ShmRm(t));
ForkCores(t);
Alloc(bins, t->nbatch*t->ndim);
if( (fail = setjmp(t->abort)) ) goto abort;
IniRandom(t);
if( t->statefile && *t->statefile == 0 ) t->statefile = NULL;
if( t->statefile &&
stat(t->statefile, &st) == 0 &&
st.st_size == sizeof state && (st.st_mode & 0400) ) {
cint h = open(t->statefile, O_RDONLY);
read(h, &state, sizeof state);
close(h);
t->rng.skiprandom(t, t->neval = state.neval);
if( VERBOSE ) {
char s[256];
sprintf(s, "\nRestoring state from %s.", t->statefile);
Print(s);
}
}
else {
state.niter = 0;
state.nsamples = t->nstart;
Zap(state.cumul);
GetGrid(t, state.grid);
}
/* main iteration loop */
for( ; ; ) {
number nsamples = state.nsamples;
creal jacobian = 1./nsamples;
Grid margsum[NCOMP][NDIM];
Zap(margsum);
for( ; nsamples > 0; nsamples -= t->nbatch ) {
cnumber n = IMin(t->nbatch, nsamples);
real *w = t->frame;
real *x = w + n;
real *f = x + n*t->ndim;
real *lastf = f + n*t->ncomp;
bin_t *bin = bins;
while( x < f ) {
real weight = jacobian;
t->rng.getrandom(t, x);
for( dim = 0; dim < t->ndim; ++dim ) {
creal pos = *x*NBINS;
ccount ipos = (count)pos;
creal prev = (ipos == 0) ? 0 : state.grid[dim][ipos - 1];
creal diff = state.grid[dim][ipos] - prev;
*x++ = prev + (pos - ipos)*diff;
*bin++ = ipos;
weight *= diff*NBINS;
}
*w++ = weight;
}
DoSample(t, n, w, f, t->frame, state.niter + 1);
bin = bins;
w = t->frame;
while( f < lastf ) {
creal weight = *w++;
for( comp = 0; comp < t->ncomp; ++comp ) {
real wfun = weight*(*f++);
if( wfun ) {
Cumulants *c = &state.cumul[comp];
Grid *m = margsum[comp];
c->sum += wfun;
c->sqsum += wfun *= wfun;
for( dim = 0; dim < t->ndim; ++dim )
m[dim][bin[dim]] += wfun;
}
}
bin += t->ndim;
}
}
fail = 0;
/* compute the integral and error values */
for( comp = 0; comp < t->ncomp; ++comp ) {
Cumulants *c = &state.cumul[comp];
real avg, sigsq;
real w = Weight(c->sum, c->sqsum, state.nsamples);
sigsq = 1/(c->weightsum += w);
avg = sigsq*(c->avgsum += w*c->sum);
c->avg = LAST ? (sigsq = 1/w, c->sum) : avg;
c->err = sqrt(sigsq);
fail |= (c->err > MaxErr(c->avg));
if( state.niter == 0 ) c->guess = c->sum;
else {
c->chisum += w *= c->sum - c->guess;
c->chisqsum += w*c->sum;
}
c->chisq = c->chisqsum - avg*c->chisum;
c->sum = c->sqsum = 0;
}
if( VERBOSE ) {
char s[128 + 128*NCOMP], *p = s;
p += sprintf(p, "\n"
"Iteration " COUNT ": " NUMBER " integrand evaluations so far",
state.niter + 1, t->neval);
for( comp = 0; comp < t->ncomp; ++comp ) {
cCumulants *c = &state.cumul[comp];
p += sprintf(p, "\n[" COUNT "] "
REAL " +- " REAL " \tchisq " REAL " (" COUNT " df)",
comp + 1, c->avg, c->err, c->chisq, state.niter);
}
Print(s);
}
if( fail == 0 && t->neval >= t->mineval ) {
if( t->statefile && KEEPFILE == 0 ) unlink(t->statefile);
break;
}
if( t->neval >= t->maxeval && t->statefile == NULL ) break;
if( t->ncomp == 1 )
for( dim = 0; dim < t->ndim; ++dim )
RefineGrid(t, state.grid[dim], margsum[0][dim]);
else {
for( dim = 0; dim < t->ndim; ++dim ) {
Grid wmargsum;
Zap(wmargsum);
for( comp = 0; comp < t->ncomp; ++comp ) {
real w = state.cumul[comp].avg;
if( w != 0 ) {
creal *m = margsum[comp][dim];
count bin;
w = 1/Sq(w);
for( bin = 0; bin < NBINS; ++bin )
wmargsum[bin] += w*m[bin];
}
}
RefineGrid(t, state.grid[dim], wmargsum);
}
}
++state.niter;
state.nsamples += t->nincrease;
if( t->statefile ) {
cint h = creat(t->statefile, 0666);
if( h != -1 ) {
state.neval = t->neval;
write(h, &state, sizeof state);
close(h);
if( statemsg ) {
char s[256];
sprintf(s, "\nSaving state to %s.", t->statefile);
Print(s);
statemsg = false;
}
}
if( t->neval >= t->maxeval ) break;
}
}
for( comp = 0; comp < t->ncomp; ++comp ) {
cCumulants *c = &state.cumul[comp];
integral[comp] = c->avg;
error[comp] = c->err;
prob[comp] = ChiSquare(c->chisq, state.niter);
}
abort:
PutGrid(t, state.grid);
free(bins);
WaitCores(t);
FrameFree(t);
return fail;
}
void InitializeSynchrotron(const double B_0, const dCVector* pEnergy,
const dCVector* pEnergyWidth,
dCVector* synchrotronLoss, DiffRate* syncRate,
string aDirTables)
/* this function calculates the synchrotron loss rate for the electron
and the synchrotron radiation spectrum for photons
The radom direction of the magnetic field requires me to do an
average over the pitch angle, and it results in an extra factor of
2/3, and slightly modifies the functional form of F(x) from the
purely perpendicular case */
/* The above comment is from the stand alone version. Compared to this version the constants seem to be fixed to correct for a perpendicular field as input. JK, 2011*/
{
const int SYNC_TABLE_SIZE = 161;
int i;
double offset; /* parameter to compute bounds correctly */
dCVector syncTable;
double x0;
double ECrit;
double EMin;
double EMax;
int jMin;
int jMax;
int j;
double xx;
double function;
int iTable;
double eLower;
double eUpper;
int num_main_bins;
num_main_bins = pEnergy->dimension;
if ((num_main_bins != pEnergyWidth->dimension) ||
(num_main_bins != syncRate->mainDimension) ||
(num_main_bins != synchrotronLoss->dimension))
{
Error("InitializeSynchrotron: inconsistent dimensions", PROGRAM_ERROR);
}
New_dCVector(&syncTable, SYNC_TABLE_SIZE);
/* read in table */
LoadSyncTable(&syncTable, aDirTables);
/* calculate the rates */
offset = BINS_PER_DECADE*(log10(ELECTRON_MASS) - MAX_ENERGY_EXP) +
num_main_bins + 0.5;
x0 = B_0*5.86667629e-4*DISTANCE_UNIT;
/* x0: eB/m_e in inverse pc */
for (i = 0; i < num_main_bins; i++)
{
/* electron loss rate */
(synchrotronLoss->vector)[i] = -B_0*B_0*(pEnergy->vector)[i]*
(pEnergy->vector)[i]*2.*4.86037e4*VOLUME_UNIT;
/* calculate the radiation spectrum */
ECrit = 3./2.*B_0/4.414034e13*(pEnergy->vector)[i]*
(pEnergy->vector)[i];
/* ECrit: critical energy in electron mass */
EMin = 2./3./((pEnergy->vector)[i]*(pEnergy->vector)[i]*
(pEnergy->vector)[i])*ECrit;
EMax = 5.*ECrit;
/* EMin/EMax: useful range for x (in electron mass) */
/* set up the range for photons -> determine bounds */
jMin = IMax((int)(BINS_PER_DECADE*log10(EMin) + offset), 0);
jMax = IMin((int)(BINS_PER_DECADE*log10(EMax) + offset),
num_main_bins - 1);
if (jMax >= 0) /* normal case */
{
(syncRate->bound)[i][0] = jMin;
(syncRate->bound)[i][1] = jMax;
for (j = (syncRate->bound)[i][0];
j <= (syncRate->bound)[i][1]; j++)
{
xx = (pEnergy->vector)[j]/ECrit;
if (log10(xx) < -7.)
{
function = pow(xx, 1./3.)*2.1809736;
/* use an approximation for x below 10^-7 */
}
else
{
/* compute F(x) at given photon energy by linear
extrapolation in logarithm */
iTable = (int)(log10(xx)*20. + 140);
eLower = (double)(iTable - 140)/20.;
eUpper = (double)(iTable - 139)/20.;
/* numbers 140, 139, and 20 are properties of table */
function = exp(log(syncTable.vector[iTable]) + (log10(xx) -
eLower)/(eUpper - eLower)*
(log(syncTable.vector[iTable+1]) -
log(syncTable.vector[iTable])));
}
(syncRate->diffRate)[i][j] = 2.756644477e-1/137.036*x0*
function/(pEnergy->vector)[j]*(pEnergyWidth->vector)[j];
/* 2.7566...: sqtr(3)/(2pi), 1/137: e^2, x0: eB/m_e */
}
}
}
Delete_dCVector(&syncTable) ;
}
void CXMLObject::WriteObject ( RCFile f, int pos, int indent ) {
int i,pos1,lm,rm,tl;
pstr indstr,p,p1,q;
Boolean sngline;
if (objTag) {
pos1 = pos + indent;
indstr = new char[pos1+1];
for (i=0;i<pos1;i++) indstr[i] = ' ';
indstr[pos1] = char(0);
indstr[pos] = char(0);
f.Write ( indstr );
f.Write ( pstr("<") );
f.Write ( objTag );
if ((!objData) && (nObjects<=0)) {
f.WriteLine ( pstr("/>") );
delete[] indstr;
return;
}
f.Write ( pstr(">") );
sngline = False;
if (objData) {
rm = 72; // right margin
lm = IMin ( pos1,36 ); // left margin
tl = strlen(objTag);
if ((pos+tl+2+strlen(objData)<rm-tl-2) &&
(nObjects<=0)) {
// single-line output
sngline = True;
f.Write ( objData );
} else {
// multiple-line output with indentation
indstr[pos] = ' ';
indstr[lm] = char(0);
f.LF();
p = objData;
do {
p1 = p;
i = lm;
q = NULL;
while ((*p1) && ((i<rm) || (!q))) {
if (*p1==' ') q = p1;
p1++;
i++;
}
f.Write ( indstr );
if (*p1) { // wrap data
*q = char(0);
f.WriteLine ( p );
*q = ' ';
p = q;
while (*p==' ') p++;
if (*p==char(0)) p = NULL;
} else { // data exchausted
f.WriteLine ( p );
p = NULL;
}
} while (p);
indstr[lm] = ' ';
indstr[pos] = char(0);
}
} else
f.LF();
for (i=0;i<nObjects;i++)
if (object[i])
object[i]->WriteObject ( f,pos+indent,indent );
if (!sngline) f.Write ( indstr );
f.Write ( pstr("</") );
f.Write ( objTag );
f.WriteLine ( pstr(">") );
delete[] indstr;
}
}
void FoldDiffRate(const dCVector* pBgPhotonDensity,
const RawDiffRate* pRawDiffRate,
DiffRate* pDiffRate, const int scatSwitch, ...)
{
int i;
int j;
int k;
int offset = 0;
int jLower;
int jUpper;
int num_main_bins;
int num_bg_bins;
num_main_bins = pRawDiffRate->mainDimension;
num_bg_bins = pRawDiffRate->bgDimension;
if ((pBgPhotonDensity->dimension != num_bg_bins) ||
(num_main_bins != pDiffRate->mainDimension))
{
Error("FoldDiffRate: inconsistent dimensions", PROGRAM_ERROR);
}
if (scatSwitch != 0)
/* scattering type: adjustment of total rate(s) needed */
{
va_list pArg;
// TotalRate* totalRateArray[scatSwitch];
TotalRate* totalRateArray[3];
va_start(pArg, scatSwitch);
for (i = 0; i < scatSwitch; i++)
totalRateArray[i] = va_arg(pArg, TotalRate*);
/* Let totalRateArray[i] point to the totalRate* we will modify; we do
not need to update the arguments later
(i.e. va_arg(...) = totalRateArray[i];) because the actual values
they point to have been properly updated */
for (i = 0; i < num_main_bins; i++)
{
jLower = num_main_bins - 1;
jUpper = 0;
for (j = 0; j < num_bg_bins; j++)
{
if (pRawDiffRate->bound[i][j][0] != -1)
/* above threshold */
{
offset += -(pRawDiffRate->bound)[i][j][0];
jLower = IMin(jLower, (pRawDiffRate->bound)[i][j][0]);
jUpper = IMax(jUpper, (pRawDiffRate->bound)[i][j][1]);
for (k = (pRawDiffRate->bound)[i][j][0];
k <= (pRawDiffRate->bound)[i][j][1]; k++)
{
#ifdef DEBUG
CheckIndex(0, i+1, k, "FoldDiffRate");
CheckIndex(0, pRawDiffRate->numberOfElements, k+offset,
"FoldDiffRate");
#endif
(pDiffRate->diffRate)[i][k] +=
(pBgPhotonDensity->vector)[j]*
(pRawDiffRate->diffRate)[k+offset];
}
/* these lines take care of the appropriate subtractions
made in the main implicit formula */
if ((pRawDiffRate->bound)[i][j][1] == i)
/* if (((pRawDiffRate->bound)[i][j][0] <= i) &&
((pRawDiffRate->bound)[i][j][1] >= i)) */
{
int l;
for (l = 0; l < scatSwitch; l++)
{
(totalRateArray[l]->totalRate)[i] +=
-(pRawDiffRate->diffRate)[i+offset]*
(pBgPhotonDensity->vector)[j];
}
(pDiffRate->diffRate)[i][i] +=
-(pRawDiffRate->diffRate)[i+offset]*
(pBgPhotonDensity->vector)[j];
}
offset += (pRawDiffRate->bound)[i][j][1] + 1;
/* reset the offset index */
}
}
(pDiffRate->bound)[i][0] = IMin((pDiffRate->bound)[i][0], jLower);
(pDiffRate->bound)[i][1] = IMax((pDiffRate->bound)[i][1], jUpper);
}
va_end(pArg);
}
