void initMat(matrix *x, unint r, unint c){
x->r = r;
x->pr = CPAD(r);
x->c = c;
x->pc = PAD(c);
x->ld = x->pc;
}
void dimEst(matrix x, unint s){
unint n = x.r;
unint i,j ;
int t = 3;
long unsigned int curMax, oldMax;
matrix r;
r.c=x.c; r.pc=x.pc; r.r=s; r.pr=CPAD(s); r.ld=r.pc;
r.mat = (real*)calloc( r.pc*r.pr, sizeof(*r.mat) );
size_t** NNs = (size_t**)calloc(r.r, sizeof(*NNs));
real** dToNNs = (real**)calloc(r.r, sizeof(*dToNNs));
for(i=0;i<r.pr;i++){
NNs[i] = (size_t*)calloc(t, sizeof(**NNs));
dToNNs[i] = (real*)calloc(t, sizeof(**dToNNs));
}
real* ranges = (real*)calloc(r.pr, sizeof(*ranges));
unint *counts = (unint*)calloc(r.pr,sizeof(*counts));
size_t *p = (size_t*)calloc(r.pr, sizeof(*p));
//pick r random reps
pickReps(x,&r);
//printf("calling bruteKdists\n");
bruteKDists(x,r,NNs,dToNNs,t);
// printf("done\n");
for(i=0;i<r.r;i++)
ranges[i] = dToNNs[i][t-1];
for(i=0; i<10; i++){
rangeCount(x,r,ranges,counts);
//gsl_sort_uint_index(p,counts,1,r.r);
//printf("80 = %u \n",counts[p[5*r.r/10]]);
for(j=0; j<r.r; j++)
ranges[j]*=2.0;
curMax = 0;
unint avg = 0;
for(j=0; j<r.r; j++){
// printf("%u ",counts[j]);
curMax = MAX(counts[j],curMax);
avg +=counts[j];
}
// printf("\n");
// printf("avg = %6.4f \n",((double)avg)/((double)r.r));
// printf("%lu \n",curMax);
}
for(i=0;i<r.r;i++){
free(NNs[i]);
free(dToNNs[i]);
}
free(NNs);
free(dToNNs);
free(r.mat);
free(ranges);
free(counts);
free(p);
}
//Builds the RBC for the One-shot (inexact) method.
//Note: allocates memory for r and ri that must be freed
//externally. Use freeRBC.
void buildOneShot(matrix x, matrix *r, rep *ri, unint numReps){
unint s = numReps; //number of points per rep. Set equal to numReps
//as suggested by theory.
unint ps = CPAD(s);
unint i, j;
if( numReps > x.r ){
fprintf( stderr, "number of representatives must be less than the DB size\n");
exit(1);
}
initMat( r, numReps, x.c );
r->mat = (real*)calloc( sizeOfMat(*r), sizeof(*r->mat));
//pick r random reps
pickReps(x,r);
//Compute the ownership lists
unint **repID = (unint**)calloc(r->pr, sizeof(*repID));
real **dToNNs = (real**)calloc(r->pr, sizeof(*dToNNs));
for( i=0; i<r->pr; i++){
repID[i] = (unint*)calloc(CPAD(ps), sizeof(**repID));
dToNNs[i] = (real*)calloc(CPAD(ps), sizeof(**dToNNs));
}
//need to find the radius such that each rep contains s points
bruteKHeap(x,*r,repID,dToNNs,s);
for( i=0; i<r->pr; i++){
ri[i].lr = (unint*)calloc(ps, sizeof(*ri[i].lr));
ri[i].dists = (real*)calloc(ps, sizeof(*ri[i].dists));
ri[i].len = s;
for (j=0; j<s; j++){
ri[i].lr[j] = repID[i][j];
}
//ri[i].radius = distVec( *r, x, i, ri[i].lr[s-1]); //Not actually needed by one-shot alg
}
for( i=0; i<r->pr; i++){
free(dToNNs[i]);
free(repID[i]);
}
free(dToNNs);
free(repID);
}
//note: allocates R, ri
void loadRBC( matrix *R, rep **ri, char* filename ){
size_t i;
unint nr, len, plen;
FILE *fp = fopen(filename, "rb");
if( !fp ){
fprintf(stderr, "unable to open output file\n");
exit(1);
}
safeRead( &nr, sizeof(unint), 1, fp );
(*ri) = (rep*)calloc( CPAD(nr), sizeof(rep) );
for( i=0; i<nr; i++ ){
safeRead( &len, sizeof(unint), 1, fp );
plen = CPAD( len );
(*ri)[i].lr = (unint*)calloc( plen, sizeof(unint) );
(*ri)[i].dists = (real*)calloc( plen, sizeof(real) );
(*ri)[i].len = len;
safeRead( (*ri)[i].lr, sizeof(unint), len, fp );
safeRead( (*ri)[i].dists, sizeof(real), len, fp );
safeRead( &((*ri)[i].start), sizeof(unint), 1, fp );
safeRead( &((*ri)[i].radius), sizeof(real), 1, fp );
}
unint r,c;
safeRead( &r, sizeof(unint), 1, fp );
safeRead( &c, sizeof(unint), 1, fp );
initMat( R, r, c );
R->mat = (real*)calloc( sizeOfMat(*R), sizeof(real) );
safeRead( R->mat, sizeof(real), sizeOfMat(*R), fp );
fclose(fp);
}
System *CreateSystem(const int dim,
const int nx,
const int ny,
const double Lx,
const double Ly,
const double alpha,
const double SpeedOfSound,
const double rho0,
const double AdiabaticConstant,
const int NearestNeighbor,
const int HowManyNeighbors,
const int numReps)
{
System *a = (System *)malloc(sizeof(System));
memset(a, 0, sizeof(System));
a->nx = nx;
a->ny = ny;
a->Lx = Lx;
a->Ly = Ly;
a->dx = Lx / nx;
a->dy = Ly / ny;
a->dim = dim;
// a->ntotal = nx*ny;
// a->nvirt = nvirt;
a->MaxNumberOfParticles = 0.1995 * 0.1995 * 3.14 / (a->dx*a->dy);
a->MaxNumberOfParticles += 10;
a->MaxNumberOfParticles *= 2*a->nx*ny;
a->alpha = alpha;
a->NearestNeighbor = NearestNeighbor;
a->zeta = sqrt(NearestNeighbor/(4*M_PI));
a->Position = CreateMatrix(a->MaxNumberOfParticles, dim);
a->Velocity = CreateMatrix(a->MaxNumberOfParticles, dim);
a->Velocity_xsph = CreateMatrix(a->MaxNumberOfParticles, dim);
a->Velocity_min = CreateMatrix(a->MaxNumberOfParticles, dim);
a->dvdt = CreateMatrix(a->MaxNumberOfParticles, dim);
a->av = CreateMatrix(a->MaxNumberOfParticles, dim);
a->dwdx = CreateMatrix(a->MaxNumberOfParticles, dim);
a->dwdx_r = CreateMatrix(a->MaxNumberOfParticles, dim);
a->dummyVelocity = CreateMatrix(a->MaxNumberOfParticles, dim);
a->dummyAcceleration = CreateMatrix(a->MaxNumberOfParticles, dim);
a->fluctuation = CreateMatrix(a->MaxNumberOfParticles, dim);
a->temps = CreateMatrix(a->MaxNumberOfParticles, dim);
posix_memalign(&a->Energy, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->hsml, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->Pressure, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->itype, 16, sizeof(int)*a->MaxNumberOfParticles);
posix_memalign(&a->rho, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->rho_min, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->drhodt, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->mass, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->i_pair, 16, sizeof(int)*a->MaxNumberOfParticles);
posix_memalign(&a->j_pair, 16, sizeof(int)*a->MaxNumberOfParticles);
posix_memalign(&a->rij2, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->w, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->w_r, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->i_inflow, 16, sizeof(int)*a->MaxNumberOfParticles);
posix_memalign(&a->gradVxx, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->gradVxy, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->gradVyx, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->gradVyy, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->strainRatexx, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->strainRatexy, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->strainRateyx, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->strainRateyy, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->deviatoricxx, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->deviatoricxy, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->deviatoricyx, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->deviatoricyy, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->divV, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->KinVisc, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->numberDensity, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->dummyPressure, 16, sizeof(double)*a->MaxNumberOfParticles);
posix_memalign(&a->vorticity, 16, sizeof(double)*a->MaxNumberOfParticles);
a->alpha_cubic = 0;
a->alpha_quintic = 0;
a->alpha_wendland = 0;
a->SpeedOfSound = SpeedOfSound;
a->NumberOfInteractingParticles = 0;
a->CompressionFactor = (1./AdiabaticConstant) * rho0 * SpeedOfSound * SpeedOfSound;
a->AdiabaticConstant = AdiabaticConstant;
a->rho0 = rho0;
// We only need to calculate the neighbors of the particles in the box
a->HowManyNeighbors = HowManyNeighbors;
a->Neighbors = CreateMatrixInt(a->ntotal, a->HowManyNeighbors);
a->DistanceNeighbors = CreateMatrixInt(a->ntotal, HowManyNeighbors);
a->numReps = numReps;
a->ri = (rep*)calloc( CPAD(a->numReps), sizeof(*a->ri) ); //data struct for RBC
initMat( &a->q, a->ntotal, 2);
a->q.mat=a->Position[0];
return a;
}
int main(int argc, char**argv){
matrix x, q;
unint i;
struct timeval tvB,tvE;
printf("********************************\n");
printf("RANDOM BALL COVER -- CPU version\n");
printf("********************************\n");
parseInput(argc,argv);
int threadMax = omp_get_max_threads();
printf("number of threads = %d \n",threadMax);
initMat( &x, n, d );
initMat( &q, m, d );
x.mat = (real*)calloc( sizeOfMat(x), sizeof(*(x.mat)) );
q.mat = (real*)calloc( sizeOfMat(q), sizeof(*(q.mat)) );
if( !x.mat || !q.mat ){
fprintf(stderr, "memory allocation failure .. exiting \n");
exit(1);
}
// Read data:
if(dataFileXtxt)
readDataText(dataFileXtxt, x);
else
readData(dataFileX, x);
if(dataFileQtxt)
readDataText(dataFileQtxt, q);
else
readData(dataFileQ, q);
unint **NNs = (unint**)calloc( m, sizeof(*NNs) ); //indices of NNs
real **dNNs = (real**)calloc( m, sizeof(*dNNs) ); //dists to NNs
for(i=0;i<m; i++){
NNs[i] = (unint*)calloc(K, sizeof(**NNs));
dNNs[i] = (real*)calloc(K, sizeof(**dNNs) );
}
matrix rE; //matrix of representatives
rep *riE = (rep*)calloc( CPAD(numReps), sizeof(*riE) ); //data struct for RBC
// ******** builds the RBC
gettimeofday(&tvB,NULL);
buildExact(x, &rE, riE, numReps);
gettimeofday(&tvE,NULL);
double buildTime = timeDiff(tvB,tvE);
printf("exact build time elapsed = %6.4f \n", buildTime );
// ******** queries the RBC
gettimeofday(&tvB,NULL);
if( threadMax<8 )
searchExactK(q, x, rE, riE, NNs, dNNs, K);
else
searchExactManyCoresK(q, x, rE, riE, NNs, dNNs, K);
gettimeofday(&tvE,NULL);
double searchTime = timeDiff(tvB,tvE);
printf("exact k-nn search time elapsed = %6.4f \n", searchTime );
// ******** runs brute force search.
if(runBrute){
printf("running brute force search..\n");
unint **NNsBrute = (unint**)calloc( m, sizeof(*NNsBrute) );
real **dToNNsBrute = (real**)calloc( m, sizeof(*dToNNsBrute) );;
for(i=0; i<m; i++){
NNsBrute[i] = (unint*)calloc( K, sizeof(**NNsBrute) );
dToNNsBrute[i] = (real*)calloc( K, sizeof(**dToNNsBrute) );
}
gettimeofday(&tvB,NULL);
bruteK(x,q,NNsBrute,dToNNsBrute,K);
gettimeofday(&tvE,NULL);
double bruteTime = timeDiff(tvB,tvE);
printf("brute time elapsed = %6.4f \n", bruteTime );
free(NNsBrute);
free(dToNNsBrute);
}
if( outFile || outFiletxt )
writeNeighbs( outFile, outFiletxt, NNs, dNNs );
//clean up
freeRBC( rE, riE );
for(i=0;i<m; i++){
free(NNs[i]); free(dNNs[i]);
}
free(NNs); free(dNNs);
free(x.mat);
free(q.mat);
return 0;
}
int main(int argc, char**argv){
matrix x, q;
unint i;
struct timeval tvB,tvE;
printf("********************************\n");
printf("RANDOM BALL COVER -- CPU version\n");
printf("********************************\n");
parseInput(argc,argv);
int threadMax = omp_get_max_threads();
printf("number of threads = %d \n",threadMax);
initMat( &x, n, d );
initMat( &q, m, d );
x.mat = (real*)calloc( sizeOfMat(x), sizeof(*(x.mat)) );
q.mat = (real*)calloc( sizeOfMat(q), sizeof(*(q.mat)) );
if( !x.mat || !q.mat ){
fprintf(stderr, "memory allocation failure .. exiting \n");
exit(1);
}
// Read data:
if(dataFileXtxt)
readDataText(dataFileXtxt, x);
else
readData(dataFileX, x);
if(dataFileQtxt)
readDataText(dataFileQtxt, q);
else
readData(dataFileQ, q);
unint **NNs = (unint**)calloc( m, sizeof(*NNs) ); //indices of NNs
real **dNNs = (real**)calloc( m, sizeof(*dNNs) ); //dists to NNs
for(i=0;i<m; i++){
NNs[i] = (unint*)calloc(K, sizeof(**NNs));
dNNs[i] = (real*)calloc(K, sizeof(**dNNs) );
}
matrix r; //matrix of representatives
rep *ri = (rep*)calloc( CPAD(numReps), sizeof(*ri) ); //data struct for RBC
// ******** builds the RBC
gettimeofday(&tvB,NULL);
buildOneShot(x, &r, ri, numReps);
gettimeofday(&tvE,NULL);
double buildTime = timeDiff(tvB,tvE);
printf("one-shot build time elapsed = %6.4f \n", buildTime );
// ******** queries the RBC
gettimeofday(&tvB,NULL);
searchOneShotK(q, x, r, ri, NNs, dNNs, K);
gettimeofday(&tvE,NULL);
double searchTime = timeDiff(tvB,tvE);
printf("one-shot k-nn search time elapsed = %6.4f \n", searchTime );
if( runEval )
evalApproxK(q, x, NNs, K);
// ******** runs brute force search.
if(runBrute){
printf("running brute force search..\n");
unint **NNsBrute = (unint**)calloc( m, sizeof(*NNsBrute) );
real **dToNNsBrute = (real**)calloc( m, sizeof(*dToNNsBrute) );;
for(i=0; i<m; i++){
NNsBrute[i] = (unint*)calloc( K, sizeof(**NNsBrute) );
dToNNsBrute[i] = (real*)calloc( K, sizeof(**dToNNsBrute) );
}
gettimeofday(&tvB,NULL);
bruteK(x,q,NNsBrute,dToNNsBrute,K);
gettimeofday(&tvE,NULL);
double bruteTime = timeDiff(tvB,tvE);
printf("brute time elapsed = %6.4f \n", bruteTime );
free(NNsBrute);
free(dToNNsBrute);
}
if( outFile || outFiletxt )
writeNeighbs( outFile, outFiletxt, NNs, dNNs );
//try out reading/writing functions
/* printf("writing .. \n"); fflush(NULL); */
/* char filename[100] = "tempOut.bin"; \ */
/* saveRBC( &r, ri, filename ); */
/* printf("done \n"); fflush(NULL); */
/* freeRBC( r, ri ); */
/* printf("loading ..\n"); fflush(NULL); */
/* loadRBC( &r, &ri, filename ); */
/* printf("done \n"); fflush(NULL); */
/* printf("R = %d, %d \n", r.r, r.c ); */
/* gettimeofday(&tvB,NULL); */
/* searchOneShotK(q, x, r, ri, NNs, dNNs, K); */
/* gettimeofday(&tvE,NULL); */
/* searchTime = timeDiff(tvB,tvE); */
/* printf("one-shot k-nn search time elapsed = %6.4f \n", searchTime ); */
/* evalApproxK(q, x, NNs, K); */
//clean up
freeRBC( r, ri );
for(i=0;i<m; i++){
free(NNs[i]); free(dNNs[i]);
}
free(NNs); free(dNNs);
free(x.mat);
free(q.mat);
return 0;
}
