/*Performs inner loop of association analysis confidence interval, including
*bootstrapping and summing on the bootstraps.
*n_assoc: number of associations for each lag, each time in process1
* (n_lags * n_p1)
*surr_assoc_total: (out) total number of associations for each lag, each
* surrogate series (n_lags * n_surr)
*n_lags: number of time lags
*n_p1: number of times in process 1, i.e. number of association numbers for
* each lag
*n_surr: number of surrogate series, i.e. number of times to execute the
* bootstrap for each lag
*seeds: numbers to seed RNG, reseeded each lag (n_lags)
*clock_seed: if true, seed RNG from the clock, ignore seeds
*/
void aa_ci(unsigned long *n_assoc, unsigned long *surr_assoc_total,
unsigned long n_lags, unsigned long n_p1, unsigned long n_surr,
unsigned long *seeds, int clock_seed)
{
unsigned long sample; /*Sample number*/
unsigned long *curr_assoc; /*Association numbers for the current lag*/
unsigned long *max_assoc; /*Just past last value of association numbers*/
unsigned long *totalp; /*Point to total assoc. no.; current lag, surrogate*/
unsigned long *max_total; /*Just past last value of total for this lag*/
rk_state state;
unsigned long max = n_p1 - 1;
if(clock_seed)
rk_randomseed(&state);
max_assoc = n_assoc + n_p1 * n_lags;
totalp = surr_assoc_total;
/*Looping over every lag*/
for(curr_assoc=n_assoc; curr_assoc<max_assoc; curr_assoc += n_p1, seeds++) {
if(!clock_seed)
rk_seed(*seeds, &state);
max_total = totalp + n_surr;
/*Looping over every desired surrogate for this lag*/
for(; totalp<max_total; totalp++) {
*totalp = 0;
/*Sample with replacement the original distribution, to the same size,
*and calculate the total of this resampling
*/
for(sample=0; sample<n_p1; sample++)
*totalp += curr_assoc[rk_interval(max, &state)];
}
}
}
/*Performs inner loop of bootstrapping
*Bootstraps n_els elements of data, n times
*surrogates: list of surrogates (n * n_els)
*data: list of original data (n_els)
*n: number of bootstraps
*n_els: number of elements
*seed: number to seed RNG
*clock_seed: if true, seed RNG from the clock, ignore seed
*/
void boots(double* surrogates, double* data,
unsigned long n, unsigned long n_els,
unsigned long sample_size,
unsigned long seed, int clock_seed)
{
rk_state state;
double *curr_surr, *last_surr;
unsigned long max = n_els - 1;
if(clock_seed)
rk_randomseed(&state);
else
rk_seed(seed, &state);
curr_surr = surrogates;
last_surr = surrogates + (n * sample_size);
for(curr_surr=surrogates; curr_surr < last_surr; curr_surr++)
*curr_surr = data[rk_interval(max, &state)];
}
void
montecarlo_main_loop(storage_model_t * storage, int64_t virtual_packet_flag, int nthreads, unsigned long seed)
{
int64_t finished_packets = 0;
storage->virt_packet_count = 0;
#ifdef WITH_VPACKET_LOGGING
storage->virt_packet_nus = (double *)safe_malloc(sizeof(double) * storage->no_of_packets);
storage->virt_packet_energies = (double *)safe_malloc(sizeof(double) * storage->no_of_packets);
storage->virt_packet_last_interaction_in_nu = (double *)safe_malloc(sizeof(double) * storage->no_of_packets);
storage->virt_packet_last_interaction_type = (int64_t *)safe_malloc(sizeof(int64_t) * storage->no_of_packets);
storage->virt_packet_last_line_interaction_in_id = (int64_t *)safe_malloc(sizeof(int64_t) * storage->no_of_packets);
storage->virt_packet_last_line_interaction_out_id = (int64_t *)safe_malloc(sizeof(int64_t) * storage->no_of_packets);
storage->virt_array_size = storage->no_of_packets;
#endif // WITH_VPACKET_LOGGING
#ifdef WITHOPENMP
omp_set_dynamic(0);
if (nthreads > 0)
{
omp_set_num_threads(nthreads);
}
#pragma omp parallel firstprivate(finished_packets)
{
rk_state mt_state;
rk_seed (seed + omp_get_thread_num(), &mt_state);
#pragma omp master
{
fprintf(stderr, "Running with OpenMP - %d threads\n", omp_get_num_threads());
print_progress(0, storage->no_of_packets);
}
#pragma omp for
#else
rk_state mt_state;
rk_seed (seed, &mt_state);
fprintf(stderr, "Running without OpenMP\n");
#endif
for (int64_t packet_index = 0; packet_index < storage->no_of_packets; ++packet_index)
{
int reabsorbed = 0;
rpacket_t packet;
rpacket_set_id(&packet, packet_index);
rpacket_init(&packet, storage, packet_index, virtual_packet_flag);
if (virtual_packet_flag > 0)
{
reabsorbed = montecarlo_one_packet(storage, &packet, -1, &mt_state);
}
reabsorbed = montecarlo_one_packet(storage, &packet, 0, &mt_state);
storage->output_nus[packet_index] = rpacket_get_nu(&packet);
if (reabsorbed == 1)
{
storage->output_energies[packet_index] = -rpacket_get_energy(&packet);
}
else
{
storage->output_energies[packet_index] = rpacket_get_energy(&packet);
}
if ( ++finished_packets%100 == 0 )
{
#ifdef WITHOPENMP
// WARNING: This only works with a static sheduler and gives an approximation of progress.
// The alternative would be to have a shared variable but that could potentially decrease performance when using many threads.
if (omp_get_thread_num() == 0 )
print_progress(finished_packets * omp_get_num_threads(), storage->no_of_packets);
#else
print_progress(finished_packets, storage->no_of_packets);
#endif
}
}
#ifdef WITHOPENMP
}
#endif
print_progress(storage->no_of_packets, storage->no_of_packets);
fprintf(stderr,"\n");
}
void joint_histogram(double* H,
unsigned int clampI,
unsigned int clampJ,
PyArrayIterObject* iterI,
const PyArrayObject* imJ_padded,
const double* Tvox,
int affine,
int interp)
{
const signed short* J=(signed short*)imJ_padded->data;
size_t dimJX=imJ_padded->dimensions[0]-2;
size_t dimJY=imJ_padded->dimensions[1]-2;
size_t dimJZ=imJ_padded->dimensions[2]-2;
signed short Jnn[8];
double W[8];
signed short *bufI, *bufJnn;
double *bufW;
signed short i, j;
size_t off;
size_t u2 = imJ_padded->dimensions[2];
size_t u3 = u2+1;
size_t u4 = imJ_padded->dimensions[1]*u2;
size_t u5 = u4+1;
size_t u6 = u4+u2;
size_t u7 = u6+1;
double wx, wy, wz, wxwy, wxwz, wywz;
double W0, W2, W3, W4;
size_t x, y, z;
int nn, nx, ny, nz;
double Tx, Ty, Tz;
double *bufTvox = (double*)Tvox;
void (*interpolate)(unsigned int, double*, unsigned int, const signed short*, const double*, int, void*);
void* interp_params = NULL;
rk_state rng;
/* Reset the source image iterator */
PyArray_ITER_RESET(iterI);
/* Make sure the iterator the iterator will update coordinate values */
UPDATE_ITERATOR_COORDS(iterI);
/* Set interpolation method */
if (interp==0)
interpolate = &_pv_interpolation;
else if (interp>0)
interpolate = &_tri_interpolation;
else { /* interp < 0 */
interpolate = &_rand_interpolation;
rk_seed(-interp, &rng);
interp_params = (void*)(&rng);
}
/* Re-initialize joint histogram */
memset((void*)H, 0, clampI*clampJ*sizeof(double));
/* Looop over source voxels */
while(iterI->index < iterI->size) {
/* Source voxel intensity */
bufI = (signed short*)PyArray_ITER_DATA(iterI);
i = bufI[0];
/* Compute the transformed grid coordinates of current voxel */
if (affine) {
/* Get voxel coordinates and apply transformation on-the-fly*/
x = iterI->coordinates[0];
y = iterI->coordinates[1];
z = iterI->coordinates[2];
_affine_transform(&Tx, &Ty, &Tz, Tvox, x, y, z);
}
else
/* Use precomputed transformed coordinates */
bufTvox = _precomputed_transform(&Tx, &Ty, &Tz, (const double*)bufTvox);
/* Test whether the current voxel is below the intensity
threshold, or the transformed point is completly outside
the reference grid */
if ((i>=0) &&
(Tx>-1) && (Tx<dimJX) &&
(Ty>-1) && (Ty<dimJY) &&
(Tz>-1) && (Tz<dimJZ)) {
/*
Nearest neighbor (floor coordinates in the padded
image, hence +1).
Notice that using the floor function doubles excetution time.
FIXME: see if we can replace this with assembler instructions.
*/
nx = FLOOR(Tx) + 1;
ny = FLOOR(Ty) + 1;
nz = FLOOR(Tz) + 1;
/* The convention for neighbor indexing is as follows:
*
* Floor slice Ceil slice
*
* 2----6 3----7 y
* | | | | ^
* | | | | |
* 0----4 1----5 ---> x
*/
/*** Trilinear interpolation weights.
Note: wx = nnx + 1 - Tx, where nnx is the location in
the NON-PADDED grid */
wx = nx - Tx;
wy = ny - Ty;
wz = nz - Tz;
wxwy = wx*wy;
wxwz = wx*wz;
wywz = wy*wz;
/*** Prepare buffers */
bufJnn = Jnn;
bufW = W;
/*** Initialize neighbor list */
off = nx*u4 + ny*u2 + nz;
nn = 0;
/*** Neighbor 0: (0,0,0) */
W0 = wxwy*wz;
APPEND_NEIGHBOR(off, W0);
/*** Neighbor 1: (0,0,1) */
APPEND_NEIGHBOR(off+1, wxwy-W0);
/*** Neighbor 2: (0,1,0) */
W2 = wxwz-W0;
APPEND_NEIGHBOR(off+u2, W2);
/*** Neightbor 3: (0,1,1) */
W3 = wx-wxwy-W2;
APPEND_NEIGHBOR(off+u3, W3);
/*** Neighbor 4: (1,0,0) */
W4 = wywz-W0;
APPEND_NEIGHBOR(off+u4, W4);
/*** Neighbor 5: (1,0,1) */
APPEND_NEIGHBOR(off+u5, wy-wxwy-W4);
/*** Neighbor 6: (1,1,0) */
APPEND_NEIGHBOR(off+u6, wz-wxwz-W4);
/*** Neighbor 7: (1,1,1) */
APPEND_NEIGHBOR(off+u7, 1-W3-wy-wz+wywz);
/* Update the joint histogram using the desired interpolation technique */
interpolate(i, H, clampJ, Jnn, W, nn, interp_params);
} /* End of IF TRANSFORMS INSIDE */
/* Update source index */
PyArray_ITER_NEXT(iterI);
} /* End of loop over voxels */
return;
}
