void Particles::InitSolid() { //init solidPos solidPos = new float[4]; solidPos[0] = 20.0f; solidPos[1] = 10.0f; solidPos[2] = 150.0f; solidPos[3] = 0.0f; cudaMalloc((void **)&solidPosGpu, 4 * sizeof(float)); copyArrayToDevice(solidPosGpu, solidPos, 0, 4 * sizeof(float)); //init solid vel solidVel = new float[4]; memset(solidVel, 0, sizeof(float)* 4); allocateArray((void **)&solidVelGpu, sizeof(float)* 4); cudaMemset(solidVelGpu, 0, sizeof(float)* 4); //buoyancy buoyancy = new float[4 * numParticles]; memset(buoyancy, 0, sizeof(float)* 4 * numParticles); allocateArray((void **)&buoyancyGpu, sizeof(float)* 4 * numParticles); cudaMemset(buoyancyGpu, 0, sizeof(float)* 4 * numParticles); //buoyancy angular velocity buoyancyAng = new float[4 * numParticles]; memset(buoyancyAng, 0, sizeof(float)* 4 * numParticles); allocateArray((void **)&buoyancyAngGpu, sizeof(float)* 4 * numParticles); cudaMemset(buoyancyAngGpu, 0, sizeof(float)* 4 * numParticles); }
void ParticleSystem::_initialize(int numParticles){ assert(!m_bInitialized); m_numParticles = numParticles; //Allocate host storage m_hPos = (float *)malloc(m_numParticles * 4 * sizeof(float)); m_hVel = (float *)malloc(m_numParticles * 4 * sizeof(float)); m_hReorderedPos = (float *)malloc(m_numParticles * 4 * sizeof(float)); m_hReorderedVel = (float *)malloc(m_numParticles * 4 * sizeof(float)); m_hHash = (uint *)malloc(m_numParticles * sizeof(uint)); m_hIndex = (uint *)malloc(m_numParticles * sizeof(uint)); m_hCellStart = (uint *)malloc(m_numGridCells * sizeof(uint)); m_hCellEnd = (uint *)malloc(m_numGridCells * sizeof(uint)); memset(m_hPos, 0, m_numParticles * 4 * sizeof(float)); memset(m_hVel, 0, m_numParticles * 4 * sizeof(float)); memset(m_hCellStart, 0, m_numGridCells * sizeof(uint)); memset(m_hCellEnd, 0, m_numGridCells * sizeof(uint)); //Allocate GPU data shrLog("Allocating GPU Data buffers...\n\n"); allocateArray(&m_dPos, m_numParticles * 4 * sizeof(float)); allocateArray(&m_dVel, m_numParticles * 4 * sizeof(float)); allocateArray(&m_dReorderedPos, m_numParticles * 4 * sizeof(float)); allocateArray(&m_dReorderedVel, m_numParticles * 4 * sizeof(float)); allocateArray(&m_dHash, m_numParticles * sizeof(uint)); allocateArray(&m_dIndex, m_numParticles * sizeof(uint)); allocateArray(&m_dCellStart, m_numGridCells * sizeof(uint)); allocateArray(&m_dCellEnd, m_numGridCells * sizeof(uint)); if (!m_bQATest) { //Allocate VBO storage m_posVbo = createVBO(m_numParticles * 4 * sizeof(float)); m_colorVBO = createVBO(m_numParticles * 4 * sizeof(float)); //Fill color buffer glBindBufferARB(GL_ARRAY_BUFFER, m_colorVBO); float *data = (float *)glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY); float *ptr = data; for(uint i = 0; i < m_numParticles; i++){ float t = (float)i / (float) m_numParticles; #if 0 *ptr++ = rand() / (float) RAND_MAX; *ptr++ = rand() / (float) RAND_MAX; *ptr++ = rand() / (float) RAND_MAX; #else colorRamp(t, ptr); ptr += 3; #endif *ptr++ = 1.0f; } glUnmapBufferARB(GL_ARRAY_BUFFER); } setParameters(&m_params); setParametersHost(&m_params); m_bInitialized = true; }
int main(){ allocateArray(); fillArray(); printArray(); freeArray(); return 0; }
BBArray *bbArrayConcat( const char *type,BBArray *x,BBArray *y ){ BBArray *arr; char *data; int length=x->scales[0]+y->scales[0]; if( length<=0 ) return &bbEmptyArray; arr=allocateArray( type,1,&length ); data=(char*)BBARRAYDATA( arr,1 ); memcpy( data,BBARRAYDATA( x,1 ),x->size ); memcpy( data+x->size,BBARRAYDATA( y,1 ),y->size ); #ifdef BB_GC_RC if( type[0]==':' || type[0]=='$' || type[0]=='[' ){ int i; BBObject **p=(BBObject**)data; for( i=0;i<length;++i ){ BBObject *o=*p++; BBINCREFS( o ); } } #endif return arr; }
BBArray *bbArrayNew1D( const char *type,int length ){ BBArray *arr=allocateArray( type,1,&length ); initializeArray( arr ); return arr; }
BBArray *bbArrayNewEx( const char *type,int dims,int *lens ){ BBArray *arr=allocateArray( type,dims,lens ); initializeArray( arr ); return arr; }
void Particles::InitMemory() { assert(!initFlag); pos = new float[numParticles * 4]; vel = new float[numParticles * 4]; //density = new float[numParticles]; memset(pos, 0, numParticles * 4 * sizeof(float)); memset(vel, 0, numParticles * 4 * sizeof(float)); //memset(density, 0, numParticles * sizeof(float)); cellStart = new uint[numParticles]; cellEnd = new uint[numParticles]; memset(cellStart, 0, numParticles*sizeof(uint)); memset(cellEnd, 0, numParticles*sizeof(uint)); uint memSize = sizeof(float) * 4 * numParticles; posVbo = CreateVBO(memSize,POSITION); registerGLBufferObject(posVbo, &m_cuda_posvbo_resource); allocateArray((void **)&velGpu, memSize); allocateArray((void **)&sortedPos, memSize); allocateArray((void **)&sortedVel, memSize); allocateArray((void **)&gridParticleHash, numParticles*sizeof(uint)); allocateArray((void **)&gridParticleIndex, numParticles*sizeof(uint)); allocateArray((void **)&cellStart, (mparams.wholeNumCells)*sizeof(uint)); allocateArray((void **)&cellEnd, (mparams.wholeNumCells)*sizeof(uint)); InitColor(); InitSolid(); setParameters(&mparams); initFlag = true; }
TrackArray::TrackArray( int width, int height, int cellSize ): TrackDataContainer( width, height, cellSize ) { // zapewnia, iz zarowno szerokosc, jak i wysokosc, sa potegami dwojki if( !IsPowerOf2(width) || !IsPowerOf2(height) ) throw TrackContainerException(); mpDataMatrix = allocateArray( width, height, cellSize, mCellSizeLogarithm ); }
int main(){ int i; int *vector = NULL; allocateArray(&vector, 5, 45); for(i = 0; i < 5; i++){ printf("%d\n", vector[i]); } free(vector); return 0; }
int main(){ int i; int* vector = allocateArray(5, 45); for(i=0; i<5; i++){ printf("%d\n", vector[i]); } // 使い終わったメモリは解放しましょう。 free(vector); return 0; }
void ArrayList::openGap(int index) { if (isAtCapacity()) { allocateArray(); } for (int i = getCount(); i > index; i--) { array[i] = array[i - 1]; } if (current >= index) { current++; } }
void Foam::MytwoWayMPI::allocateArray ( int**& array, int initVal, int width, const char* length ) const { int len=0; if(strcmp(length,"nparticles")==0) len = particleCloud_.numberOfParticles(); else if (strcmp(length,"nbodies")==0) len = nClumpTypes_; else FatalError<<"*** call allocateArray with length, nparticles or nbodies!\n" << abort(FatalError); allocateArray(array,initVal,width,len); }
BBArray *bbArrayNew( const char *type,int dims,... ){ #if BB_ARGP int *lens=(int*)bbArgp(8); #else int *lens=&dims+1; #endif BBArray *arr=allocateArray( type,dims,lens ); initializeArray( arr ); return arr; }
void Foam::dataExchangeModel::allocateArray ( double**& array, double initVal, int width, const char* length ) const { int len=0; if(strcmp(length,"nparticles")==0) len = particleCloud_.numberOfParticles(); else if (strcmp(length,"nbodies")==0) len = nClumpTypes_; else FatalError<<"call allocateArray with length, nparticles or nbodies!\n" << abort(FatalError); allocateArray(array,initVal,width,len); }
int main (int argc, char *argv[]) { struct timespec tStart; struct timespec tEnd; pthread_t *aThreads; THREAD_PARAMS *aParams; int64_t * aArray = NULL; int64_t iret = 0; int64_t cThreads = 0; int64_t cTasks = 0; bool fBlock = false; bool fSimple = true; bool fRandom = false; iret = parseCommandLine(argc, argv, &cThreads, &cTasks, &fBlock, &fSimple, &fRandom); if (0 == iret) { iret = allocateArray(fRandom, cTasks, &aArray); } if (0 == iret) { iret = clock_gettime(CLOCK_REALTIME, &tStart); } if (0 == iret) { iret = createThreads(cThreads, cTasks, fBlock, fSimple, aArray, &aThreads, &aParams); } if (0 == iret) { iret = joinThreads(cThreads, cTasks, aThreads, aParams); aThreads = NULL; aParams = NULL; } clock_gettime(CLOCK_REALTIME, &tEnd); if (0 == iret) { //test(fSimple, cTasks, aArray); } free(aArray); struct timespec tsDiff = diff(tStart, tEnd); //printf("Elapsed Time: %d.%09d Sec.\n", tsDiff.tv_sec, tsDiff.tv_nsec); printf("%d, %d, %s, %s, %s, %d.%09d\n", cThreads, cTasks, fBlock ? "block":"cyclic", fSimple ? "negation":"factorial", fRandom ? "random":"ramp",tsDiff.tv_sec, tsDiff.tv_nsec); return(iret); }
BBArray *bbArrayFromData( const char *type,int length,void *data ){ int k; BBArray *arr; if( length<=0 ) return &bbEmptyArray; arr=allocateArray( type,1,&length ); if( type[0]=='b' ){ unsigned char *p=BBARRAYDATA( arr,1 ); for( k=0;k<length;++k ) p[k]=((int*)data)[k]; }else if( type[0]=='s' ){ unsigned short *p=BBARRAYDATA( arr,1 ); for( k=0;k<length;++k ) p[k]=((int*)data)[k]; }else{ memcpy( BBARRAYDATA( arr,1 ),data,arr->size ); } return arr; }
int main(int argc, const char* argv[]) { if( argc != 2 ) //checks for the input file name { printf( "error; no input file name\n" ); return 1; } FILE *filePointer; filePointer = fopen( argv[1], "r" ); char **arrayPointer; //char maze[MAX_MAZE_SIZE][MAX_MAZE_SIZE] = { 0 }; int numberOfTestCases = 0; fscanf( filePointer, "%d\n", &numberOfTestCases ); for( int testCaseNumber = 0; testCaseNumber < numberOfTestCases; testCaseNumber++ ) { int size = 0; int * xy; int x; int y; fscanf( filePointer, "%d\n", &size ); printf( "ENTER\n" ); allocateArray(size, &arrayPointer); initializeArray(size, arrayPointer, filePointer); xy = findEntrance(size, arrayPointer); x = xy[0]; y = xy[1]; solveMaze(size, arrayPointer, x ,y); deallocateArray(size, arrayPointer); printf( "EXIT\n***\n" ); } fclose( filePointer ); return 0; }
void TrackArray::changeCellSize( int cellSize ) { double ratio = mCellSize / cellSize; DataMatrix* data_matrix; if( ratio != 1.0 ) { data_matrix = allocateArray( mWidth, mHeight, cellSize, mCellSizeLogarithm ); if( ratio > 1.0 ) { // przypadek zlozony: przepisujemy... /* TODO: poprawic segfaulta int r = static_cast<int>( ratio ); for( int j = mHeight; j != 0; j -= mCellSize ) { for( int i = mWidth; i != 0; i -= mCellSize ) { // przepisujemy komorke (i,j) oryginalnej macierzy do // komorek (i*r,j*r) .. (i*r + r-1,j*r + r-1) int xo = i*r; int yo = j*r; for( int y = r; y != 0; --y ) for( int x = r; x != 0; --x ) data_matrix->set( xo+x, yo+y, mpDataMatrix->get(i,j) ); } } */ } else if( ratio < 1.0 ) { // przypadek prosty: zmniejszamy rozdzieczosc; nic nie przepisujemy //TODO: to nie powinno byc takie proste } delete mpDataMatrix; mpDataMatrix = data_matrix; mCellSize = cellSize; } }
ArrayList::ArrayList(int initCapacity, int addCapacity): capacity(initCapacity), additionalCapacity(addCapacity), array(NULL) { current = getCount(); allocateArray(); }
ArrayList::ArrayList(): capacity(DEFAULT_INITIAL_CAPACITY), additionalCapacity(DEFAULT_ADDITIONAL_CAPACITY), array(NULL) { current = getCount(); allocateArray(); }
void CalculateOrdinaryScore(FlowDist *flowDist, AlleleIdentity &variant_identity, vcf::Variant ** candidate_variant, ControlCallAndFilters &my_controls, bool *isFiltered, int DEBUG) { vector<float>* reflikelihoods = flowDist->getReferenceLikelihoods(); vector<float>* varlikelihoods = flowDist->getVariantLikelihoods(); int totalReads = reflikelihoods->size(); const int totalHypotheses = 2; float **scoreLikelihoods; float refLikelihoods; float varLikelihoods; float scores[totalHypotheses] = {0}; int counts[totalHypotheses] = {0}; float minDiff = 2.0; float minLikelihoods = 3.0; allocateArray(&scoreLikelihoods, totalReads, totalHypotheses); for (int i = 0; i < totalReads; i++) { refLikelihoods = reflikelihoods->at(i); varLikelihoods = varlikelihoods->at(i); if (DEBUG) cout << "ref likelihood = " << refLikelihoods << endl; scoreLikelihoods[i][0] = refLikelihoods; scoreLikelihoods[i][1] = varLikelihoods; } if (variant_identity.status.isSNP || variant_identity.status.isMNV) { minDiff = 1.0; minLikelihoods = 0.5; } calc_score_hyp(totalReads, totalHypotheses, scoreLikelihoods, scores, counts, minDiff, minLikelihoods); float BayesianScore; BayesianScore = scores[1]; //string *filterReason = new string(); //cout << "Bayesian Score = " << BayesianScore << endl; float stdBias = flowDist->summary_stats.getStrandBias(); float refBias = flowDist->summary_stats.getRefStrandBias(); //float baseStdBias = flowDist->summary_stats.getBaseStrandBias(); /* moving filter operation to DecisionTree *isFiltered = filterVariants(filterReason, variant_identity.status.isSNP, variant_identity.status.isMNV, variant_identity.status.isIndel, variant_identity.status.isHPIndel, false, BayesianScore, my_controls, 0, 0, 0, stdBias, refBias, baseStdBias, flowDist->summary_stats.getAltAlleleFreq(), variant_identity.refHpLen, abs(variant_identity.inDelLength)); flowDist->summary_info.isFiltered= *isFiltered; */ flowDist->summary_info.alleleScore = BayesianScore; //flowDist->summary_info.filterReason = *filterReason; //now if the allele is a SNP and a possible overcall/undercall FP SNP, evaluate the score for HP lengths on either side of SNP //we move filtering to final stage so calculate confidence of HP length for all overcall/undercall snps if (variant_identity.status.isSNP && variant_identity.status.isOverCallUnderCallSNP && (variant_identity.underCallLength+1 > 11 || variant_identity.overCallLength-1 > 11) ) { flowDist->summary_info.isFiltered = true; flowDist->summary_info.filterReason = "Overcall/Undercall_HP_SNP"; flowDist->summary_info.alleleScore = 0.0; } if (!flowDist->summary_info.isFiltered && variant_identity.status.isSNP && variant_identity.status.isOverCallUnderCallSNP) { float overCallHPScore = 0.0f; float underCallHPScore = 0.0f; bool isUnderCallRef = false; bool isOverCallRef = false; float underCallFreq = 0.0; float overCallFreq = 0.0; float maxProb = 0; int * peak_finding_tuning_parameters = new int[9]; peak_finding_tuning_parameters[NDX_MIN_FREQUENCY_SMALL_PEAK] = (int)(my_controls.filter_hp_indel.min_allele_freq *100); peak_finding_tuning_parameters[NDX_MIN_FLOW_PEAK_SHORTHP_DISTANCE] = 85; peak_finding_tuning_parameters[NDX_MIN_FLOW_PEAK_LONGHP_DISTANCE] = 85; peak_finding_tuning_parameters[NDX_SHORT_HP_FOR_PEAK] = 8; peak_finding_tuning_parameters[NDX_MAX_PEAK_DEVIATION] = my_controls.control_peak.fpe_max_peak_deviation; peak_finding_tuning_parameters[NDX_PARAM_FIVE_NOT_USED] = 0; peak_finding_tuning_parameters[NDX_CALL_USING_EM_METHOD] = 0; peak_finding_tuning_parameters[NDX_PARAM_SEVEN_NOT_USED] = 0; peak_finding_tuning_parameters[NDX_STRAND_BIAS] = (int)(0.5*100); float * peak_finding_results = new float[13]; int optimization_start, optimization_end; optimization_start = max((variant_identity.underCallLength-3)*100, 0); optimization_end = min((variant_identity.underCallLength+3)*100, MAXSIGDEV); int variation_allowed = variant_identity.underCallLength; runLMS((int*) flowDist->getHomPolyDist(), MAXSIGDEV, peak_finding_tuning_parameters, peak_finding_results, optimization_start, optimization_end, variant_identity.underCallLength+1, variation_allowed, DEBUG); compute_maxProb(peak_finding_results, variant_identity.underCallLength+1, maxProb, isUnderCallRef, refBias); underCallHPScore = compute_bayesian_score(maxProb); underCallFreq = peak_finding_results[5]; delete[] peak_finding_results; //now evaluate the overcall HP length maxProb = 0; peak_finding_results = new float[13]; for (size_t i = 0; i < 13; i++ ) peak_finding_results[i] = 0; optimization_start = max((variant_identity.overCallLength-3)*100, 0); optimization_end = min((variant_identity.overCallLength+3)*100, MAXSIGDEV); variation_allowed = variant_identity.overCallLength; runLMS((int*) flowDist->getHomPolyDist(), MAXSIGDEV, peak_finding_tuning_parameters, peak_finding_results, optimization_start, optimization_end, variant_identity.overCallLength-1, variation_allowed, DEBUG); delete[] peak_finding_tuning_parameters; compute_maxProb(peak_finding_results, variant_identity.overCallLength-1, maxProb, isOverCallRef, refBias); overCallHPScore = compute_bayesian_score(maxProb); overCallFreq = peak_finding_results[5]; //not sure how to move this part to decision tree, leaving it here for now. if (isUnderCallRef || isOverCallRef || underCallHPScore < 5 || overCallHPScore < 5 || overCallFreq < my_controls.filter_snps.min_allele_freq || underCallFreq < my_controls.filter_snps.min_allele_freq) { //filter the variant as possible overcall undercall FP flowDist->summary_info.isFiltered = true; flowDist->summary_info.filterReason = "Overcall/Undercall_HP_SNP"; flowDist->summary_info.alleleScore = 0.0; } } stringstream infoss; infoss << "Score= " << scores[1] << " | STDBIAS= "<< stdBias; flowDist->summary_info.infoString = infoss.str(); //InsertGenericInfoTag(candidate_variant, infoss); //if (filterReason!=NULL) // delete filterReason; deleteArray(&scoreLikelihoods, totalReads, totalHypotheses); }
void ParticleSystem::_initialize(int numParticles) { assert(!m_bInitialized); m_numParticles = numParticles; // allocate host storage m_hPos = new float[m_numParticles*4]; m_hVel = new float[m_numParticles*4]; memset(m_hPos, 0, m_numParticles*4*sizeof(float)); memset(m_hVel, 0, m_numParticles*4*sizeof(float)); m_hCellStart = new uint[m_numGridCells]; memset(m_hCellStart, 0, m_numGridCells*sizeof(uint)); m_hCellEnd = new uint[m_numGridCells]; memset(m_hCellEnd, 0, m_numGridCells*sizeof(uint)); // allocate GPU data unsigned int memSize = sizeof(float) * 4 * m_numParticles; if (m_bUseOpenGL) { m_posVbo = createVBO(memSize); registerGLBufferObject(m_posVbo, &m_cuda_posvbo_resource); } else { checkCudaErrors(cudaMalloc((void **)&m_cudaPosVBO, memSize)) ; } allocateArray((void **)&m_dVel, memSize); allocateArray((void **)&m_dSortedPos, memSize); allocateArray((void **)&m_dSortedVel, memSize); allocateArray((void **)&m_dGridParticleHash, m_numParticles*sizeof(uint)); allocateArray((void **)&m_dGridParticleIndex, m_numParticles*sizeof(uint)); allocateArray((void **)&m_dCellStart, m_numGridCells*sizeof(uint)); allocateArray((void **)&m_dCellEnd, m_numGridCells*sizeof(uint)); if (m_bUseOpenGL) { m_colorVBO = createVBO(m_numParticles*4*sizeof(float)); registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource); // fill color buffer glBindBufferARB(GL_ARRAY_BUFFER, m_colorVBO); float *data = (float *) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY); float *ptr = data; for (uint i=0; i<m_numParticles; i++) { float t = i / (float) m_numParticles; #if 0 *ptr++ = rand() / (float) RAND_MAX; *ptr++ = rand() / (float) RAND_MAX; *ptr++ = rand() / (float) RAND_MAX; #else colorRamp(t, ptr); ptr+=3; #endif *ptr++ = 1.0f; } glUnmapBufferARB(GL_ARRAY_BUFFER); } else { checkCudaErrors(cudaMalloc((void **)&m_cudaColorVBO, sizeof(float)*numParticles*4)); } sdkCreateTimer(&m_timer); setParameters(&m_params); m_bInitialized = true; }
void CudaSystem::init() { unsigned int maxParticles = 65536; unsigned int memSize = sizeof(double)*3*maxParticles; allocateArray((void**)&m_dVel[0], memSize); allocateArray((void**)&m_dVel[1], memSize); allocateArray((void**)&m_dPos[0], memSize); allocateArray((void**)&m_dPos[1], memSize); allocateArray((void**)&m_dMass, sizeof(double)*maxParticles); allocateArray((void**)&m_dParticleRadius, sizeof(double)*maxParticles); allocateArray((void**)&m_dInteractionRadius, sizeof(double)*maxParticles); allocateArray((void**)&m_dSpring, sizeof(double)*maxParticles); allocateArray((void**)&m_dDamping, sizeof(double)*maxParticles); allocateArray((void**)&m_dShear, sizeof(double)*maxParticles); allocateArray((void**)&m_dAttraction, sizeof(double)*maxParticles); m_hPos[0] = new double[maxParticles*3]; m_hVel[0] = new double[maxParticles*3]; m_hPos[1] = new double[maxParticles*3]; m_hVel[1] = new double[maxParticles*3]; m_hForce = new double[maxParticles*3]; m_hColors = new double[maxParticles*4]; m_hMass = new double[maxParticles]; m_hParticleRadius = new double[maxParticles]; m_hInteractionRadius = new double[maxParticles]; m_hSpring = new double[maxParticles]; m_hDamping = new double[maxParticles]; m_hShear = new double[maxParticles]; m_hAttraction = new double[maxParticles]; allocateArray((void**)&voisines.nbVoisines,maxParticles*sizeof(int)); allocateArray((void**)&voisines.listeVoisine,maxParticles*200*sizeof(int)); FExt->_initialize(maxParticles); gridCreated = false; }
void FluidSystem::_initialize(int numParticles) { assert(!m_bInitialized); m_numParticles = numParticles; // allocate host storage m_hPos = new float[m_numParticles * 4]; m_hVel = new float[m_numParticles * 4]; m_hDen = new float[m_numParticles];//new just need 1 float to store density and pressure m_hPre = new float[m_numParticles];//new m_hColorf = new float[m_numParticles];//new buoyancyPos = new float[m_numParticles*3]; memset(m_hPos, 0, m_numParticles * 4 * sizeof(float)); memset(m_hVel, 0, m_numParticles * 4 * sizeof(float)); memset(m_hDen, 0, m_numParticles * sizeof(float));//new just need 1 float to store density and pressure memset(m_hPre, 0, m_numParticles * sizeof(float));//new memset(m_hColorf, 0, m_numParticles * sizeof(float));//new memset(buoyancyPos, 0, m_numParticles*3 * sizeof(float)); m_sortKeys.alloc(m_numParticles); m_indices.alloc(m_numParticles, true, false, true); //create as index buffer ,to sort m_hCellStart = new uint[m_numGridCells]; memset(m_hCellStart, 0, m_numGridCells*sizeof(uint)); m_hCellEnd = new uint[m_numGridCells]; memset(m_hCellEnd, 0, m_numGridCells*sizeof(uint)); // allocate GPU data unsigned int memSize = sizeof(float) * 4 * m_numParticles; unsigned int memSizetwo = sizeof(float) * m_numParticles; unsigned int memSizethree = sizeof(float) *3* m_numParticles; if (m_bUseOpenGL) { m_posVbo = createVBO(memSize); m_velVBO = createVBO(memSize); //obstaclePosVbo[0] = createVBO(memSize); registerGLBufferObject(m_posVbo, &m_cuda_posvbo_resource); registerGLBufferObject(m_velVBO, &m_cuda_velvbo_resource); } else { checkCudaErrors(cudaMalloc((void **)&m_cudaPosVBO, memSize)) ; checkCudaErrors(cudaMalloc((void **)&m_cudaVelVBO, memSize)); } allocateArray((void **)&m_dVel, memSize); allocateArray((void **)&m_dDen, memSizetwo); allocateArray((void **)&m_dPre, memSizetwo); allocateArray((void **)&m_dColorf, memSizetwo); allocateArray((void **)&buoyancyForce, memSizethree); allocateArray((void **)&m_dSortedPos, memSize); allocateArray((void **)&m_dSortedVel, memSize); allocateArray((void **)&m_dSortedDen, memSizetwo); allocateArray((void **)&m_dSortedPre, memSizetwo); allocateArray((void **)&m_dSortedColorf, memSizetwo); allocateArray((void **)&m_dGridParticleHash, m_numParticles*sizeof(uint)); allocateArray((void **)&m_dGridParticleIndex, m_numParticles*sizeof(uint)); allocateArray((void **)&m_dCellStart, m_numGridCells*sizeof(uint)); allocateArray((void **)&m_dCellEnd, m_numGridCells*sizeof(uint)); if (m_bUseOpenGL) { //m_colorVBO = createVBO(m_numParticles*4*sizeof(float)); m_colorVBO = createVBO(memSize); registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource); // fill color buffer glBindBufferARB(GL_ARRAY_BUFFER, m_colorVBO); float *data = (float *) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY); float *ptr = data; for (uint i=0; i<m_numParticles; i++) { if (i < 450000){ float t = i / (float)m_numParticles; colorRamp(0.1, 0.5, 0.7, ptr); ptr += 3; *ptr++ = 0.5f; } /*else if (250000 <= i&&i < 450000){ float t = i / (float)m_numParticles; colorRamp(0, 1, 0, ptr); ptr += 3; *ptr++ = 0.5f; }*/ else{ float t = i / (float)m_numParticles; colorRamp(0, 0, 0, ptr); ptr += 3; *ptr++ = 1.0f; } } glUnmapBufferARB(GL_ARRAY_BUFFER); } else { checkCudaErrors(cudaMalloc((void **)&m_cudaColorVBO, sizeof(float)*numParticles*4)); } plusBuoyancyforce(buoyancyForce, m_numParticles);//initialize this value to 0; sdkCreateTimer(&m_timer); setParameters(&m_params); m_bInitialized = true; }
void PoiseuilleFlowSystem::_initialize(int numParticles){ assert(!IsInitialized); numParticles = numParticles; hPos = new float[numParticles*4]; hVel = new float[numParticles*4]; hVelLeapFrog = new float[numParticles*4]; hMeasures = new float[numParticles*4]; hAcceleration = new float[numParticles*4]; memset(hPos, 0, numParticles*4*sizeof(float)); memset(hVel, 0, numParticles*4*sizeof(float)); memset(hVelLeapFrog, 0, numParticles*4*sizeof(float)); memset(hAcceleration, 0, numParticles*4*sizeof(float)); memset(hMeasures, 0, numParticles*4*sizeof(float)); for(uint i = 0; i < numParticles; i++) //todo: check density approximation hMeasures[4*i+0] = params.restDensity; unsigned int memSize = sizeof(float) * 4 * numParticles; if (IsOpenGL) { posVbo = createVBO(memSize); registerGLBufferObject(posVbo, &cuda_posvbo_resource); } else { checkCudaErrors( cudaMalloc( (void **)&cudaPosVBO, memSize )) ; } allocateArray((void**)&dVel, memSize); allocateArray((void**)&dVelLeapFrog, memSize); allocateArray((void**)&dAcceleration, memSize); allocateArray((void**)&dMeasures, memSize); allocateArray((void**)&dSortedPos, memSize); allocateArray((void**)&dSortedVel, memSize); allocateArray((void**)&dHash, numParticles*sizeof(uint)); allocateArray((void**)&dIndex, numParticles*sizeof(uint)); allocateArray((void**)&dCellStart, numGridCells*sizeof(uint)); allocateArray((void**)&dCellEnd, numGridCells*sizeof(uint)); if (IsOpenGL) { colorVBO = createVBO(numParticles*4*sizeof(float)); registerGLBufferObject(colorVBO, &cuda_colorvbo_resource); // fill color buffer glBindBufferARB(GL_ARRAY_BUFFER, colorVBO); float *data = (float *) glMapBufferARB(GL_ARRAY_BUFFER, GL_WRITE_ONLY); float *ptr = data; uint fluidParticles = params.fluidParticlesSize.x * params.fluidParticlesSize.y * params.fluidParticlesSize.z; for(uint i=0; i < numParticles; i++) { float t = 0.7f; if(i < fluidParticles) t = 0.5f; if(((i % params.gridSize.x) == 0) && i < fluidParticles) t = 0.2f; colorRamp(t, ptr); ptr+=3; *ptr++ = 1.0f; } glUnmapBufferARB(GL_ARRAY_BUFFER); } else { checkCudaErrors( cudaMalloc( (void **)&cudaColorVBO, sizeof(float)*numParticles*4) ); } setParameters(¶ms); IsInitialized = true; }
void ParticleMesh::calculate(LevelsetCollider &LC, int size, float r, float mass) { float scale = 2 * r / (LC.gridStep*(LC.gridSize.x - 4) / size); vec3<double> center = vec3<double>(0, 0, 0); vec3<double> MaxB = LC.MaxBoundary; vec3<double> MinB = LC.MinBoundary; scale = CalScale(MaxB, MinB, r, size); int index_par = 0; par_list = new triple[20000]; sdf_list = new SDF[20000]; float step = r * 2 / scale; for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { for (int k = 0; k <size; k++) { vec3<int> gridPos = vec3<int>(i, j, k); vec3<double> pos = vec3<double>(i + 0.5, j + 0.5, k + 0.5) * (2 * r / scale) + MinB; int gridInd = dot(gridPos, LC.gridSizeOffset); double sdf = 0; LC.getGridDist(pos, sdf); if (sdf < 0 && sdf > -r * 2 / scale * 2) { vec3<double> pos_par = pos - MinB;// -vec3<double>(0.5, 0.5, 0.5) * (2 * r / scale); center += mass*pos_par * scale; par_list[index_par].x[0] = pos_par.x * scale; par_list[index_par].x[1] = pos_par.y * scale; par_list[index_par].x[2] = pos_par.z * scale; sdf_list[index_par].sdf = sdf * scale; vec3<double> gradient; LC.checkCollision(pos, sdf, gradient, -1); sdf_list[index_par].gradient[0] = gradient.x; sdf_list[index_par].gradient[1] = gradient.y; sdf_list[index_par].gradient[2] = gradient.z; index_par++; } } } } center /= index_par*mass; float3 center_f3 = make_float3(center[0], center[1], center[2]); m_totalParticles = index_par; m_totalConnectedPoints = LC.meshModel->m_totalConnectedPoints; m_totalFaces = LC.meshModel->m_totalFaces; float3 vertex,relative; mp_vertexXYZ = new float[m_totalConnectedPoints * 3]; Relative_Vertex = new float3[m_totalConnectedPoints]; mp_vertexNorm = new float[m_totalConnectedPoints * 3]; mp_vertexRGB = new float[m_totalConnectedPoints * 3]; for (int i = 0; i < m_totalConnectedPoints; i++) { vertex.x = LC.meshModel->mp_vertexXYZ[i * 3]; vertex.y = LC.meshModel->mp_vertexXYZ[i * 3 + 1]; vertex.z = LC.meshModel->mp_vertexXYZ[i * 3 + 2]; //vertex *= scale; vertex -= make_float3(MinB[0], MinB[1], MinB[2]);// +make_float3(0.5, 0.5, 0.5) * (2 * r / scale); vertex *= scale; relative = vertex - center_f3; *(float3*)(mp_vertexXYZ + i * 3) = vertex; mp_vertexRGB[i * 3] = LC.meshModel->mp_vertexRGB[i * 3]; mp_vertexRGB[i * 3 + 1] = LC.meshModel->mp_vertexRGB[i * 3 + 1]; mp_vertexRGB[i * 3 + 2] = LC.meshModel->mp_vertexRGB[i * 3 + 2]; mp_vertexNorm[i * 3] = 0; //LC.meshModel->mp_vertexNorm[i * 3]; mp_vertexNorm[i * 3 + 1] = 0; //LC.meshModel->mp_vertexNorm[i * 3 + 1]; mp_vertexNorm[i * 3 + 2] = 0;// LC.meshModel->mp_vertexNorm[i * 3 + 2]; Relative_Vertex[i] = relative; } FaceVerInd = new uint[3 * m_totalFaces]; //memcpy(FaceVerInd, LC.meshModel->mp_face, 9 * m_totalFaces * sizeof(uint)); float3 n; for (int i = 0; i < m_totalFaces; i++) { uint i_1 = FaceVerInd[3 * i] = LC.meshModel->mp_face[3 * i]; uint i_2 = FaceVerInd[3 * i + 1] = LC.meshModel->mp_face[3 * i + 1]; uint i_3 = FaceVerInd[3 * i + 2] = LC.meshModel->mp_face[3 * i + 2]; float3 v1 = make_float3(mp_vertexXYZ[i_1 * 3], mp_vertexXYZ[i_1 * 3 + 1], mp_vertexXYZ[i_1 * 3 + 2]); float3 v2 = make_float3(mp_vertexXYZ[i_2 * 3], mp_vertexXYZ[i_2 * 3 + 1], mp_vertexXYZ[i_2 * 3 + 2]); float3 v3 = make_float3(mp_vertexXYZ[i_3 * 3], mp_vertexXYZ[i_3 * 3 + 1], mp_vertexXYZ[i_3 * 3 + 2]); float3 e12 = v2 - v1; float3 e13 = v3 - v1; n = cross(e12, e13); n /= length(n); mp_vertexNorm[i_1 * 3] += n.x; mp_vertexNorm[i_1 * 3 + 1] += n.y; mp_vertexNorm[i_1 * 3 + 2] += n.z; //atomicAdd(&num_tri_per_point[i_1], 1); float3 e21 = -e12; float3 e23 = v3 - v2; n = cross(e23, e21); n /= length(n); mp_vertexNorm[i_2 * 3] += n.x; mp_vertexNorm[i_2 * 3 + 1] += n.y; mp_vertexNorm[i_2 * 3 + 2] += n.z; //atomicAdd(&num_tri_per_point[i_2], 1); float3 e31 = -e13; float3 e32 = -e23; n = cross(e31, e32); n /= length(n); mp_vertexNorm[i_3 * 3] += n.x; mp_vertexNorm[i_3 * 3 + 1] += n.y; mp_vertexNorm[i_3 * 3 + 2] += n.z; } for (int i = 0; i < m_totalConnectedPoints; i++) { float3 n = make_float3(mp_vertexNorm[i * 3], mp_vertexNorm[i * 3 + 1], mp_vertexNorm[i * 3 + 2]); mp_vertexNorm[i * 3] /= length(n); mp_vertexNorm[i * 3 + 1] /= length(n); mp_vertexNorm[i * 3 + 2] /= length(n); } m_vertexVbo = createVBO(m_totalConnectedPoints * 3 * sizeof(float)); registerGLBufferObject(m_vertexVbo, &m_cuda_vertexvbo_resource); m_indexVBO = createVBO(3 * m_totalFaces * sizeof(uint)); registerGLBufferObject(m_indexVBO, &m_cuda_indexvbo_resource); m_colorVBO = createVBO(m_totalConnectedPoints * 3 * sizeof(float)); registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource); m_NorVBO = createVBO(m_totalConnectedPoints * 3 * sizeof(float)); registerGLBufferObject(m_NorVBO, &m_cuda_normalvbo_resource); unregisterGLBufferObject(m_cuda_vertexvbo_resource); glBindBuffer(GL_ARRAY_BUFFER, m_vertexVbo); glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexXYZ); glBindBuffer(GL_ARRAY_BUFFER, 0); registerGLBufferObject(m_vertexVbo, &m_cuda_vertexvbo_resource); unregisterGLBufferObject(m_cuda_indexvbo_resource); glBindBuffer(GL_ARRAY_BUFFER, m_indexVBO); glBufferSubData(GL_ARRAY_BUFFER, 0, 3 * m_totalFaces * sizeof(uint), FaceVerInd); glBindBuffer(GL_ARRAY_BUFFER, 0); registerGLBufferObject(m_indexVBO, &m_cuda_indexvbo_resource); unregisterGLBufferObject(m_cuda_colorvbo_resource); glBindBuffer(GL_ARRAY_BUFFER, m_colorVBO); glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexRGB); glBindBuffer(GL_ARRAY_BUFFER, 0); registerGLBufferObject(m_colorVBO, &m_cuda_colorvbo_resource); unregisterGLBufferObject(m_cuda_normalvbo_resource); glBindBuffer(GL_ARRAY_BUFFER, m_NorVBO); glBufferSubData(GL_ARRAY_BUFFER, 0, m_totalConnectedPoints * 3 * sizeof(float), mp_vertexNorm); glBindBuffer(GL_ARRAY_BUFFER, 0); registerGLBufferObject(m_NorVBO, &m_cuda_normalvbo_resource); allocateArray((void**)&dRelative_Vertex, m_totalConnectedPoints * 3 * sizeof(float)); copyArrayToDevice(dRelative_Vertex, Relative_Vertex, 0, m_totalConnectedPoints * 3 * sizeof(float)); hasMesh = true; }
/* create the vertices array: vertex */ void createGeometry(int type, Geometry* geo, int cols, int rows) { #ifdef DEBUG_GEOMETRY fprintf(stderr, "new geometry %i %i\n", cols, rows); #endif geo->rows = rows; geo->cols = cols; allocateArray(geo); float u = 0.0; float v = 0.0; int i , j, index; float gridStep = GRID_LENGTH/cols; float start = -1.0; index = 0; switch (type) { case SHAPE_IMM_GRID: case SHAPE_GRID: for(j = 0; j <= cols; j++) { for(i = 0; i <= rows ; i++) { geo->vertex[index].x = start + gridStep * i; geo->vertex[index].y = start + gridStep * j; geo->vertex[index].z = 0; index++; } } break; case SHAPE_IMM_SPHERE: case SHAPE_SPHERE: for(j = 0; j <= cols; j++) { v = M_PI * j / rows; for(i = 0; i <= rows; i++) { u = 2.0*M_PI * i / rows; geo->vertex[index].x = 1.0 * cos(u) * sin(v); geo->vertex[index].y = 1.0 * sin(u) * sin(v); geo->vertex[index].z = 1.0 * cos(v); index++; } } break; case SHAPE_IMM_TORUS: case SHAPE_TORUS: for(j = 0; j <= cols; j++) { u = 2.0 * M_PI / rows * j ; for(i = 0; i <= rows; i++) { v = 2.0*M_PI / rows * i ; geo->vertex[index].x = (TORUS_EX_RADIUS + TORUS_IN_RADIUS * cos(u)) * cos(v); geo->vertex[index].y = (TORUS_EX_RADIUS + TORUS_IN_RADIUS * cos(u)) * sin(v); geo->vertex[index].z = TORUS_IN_RADIUS * sin(u); index++; } } break; case SHAPE_INNER_GRID: uInnerShapeType = GPU_GRID; createInnerGeometry(geo,cols,rows); break; case SHAPE_INNER_SHPERE: uInnerShapeType = GPU_SPHERE; createInnerGeometry(geo,cols,rows); break; case SHAPE_INNER_TORUS: uInnerShapeType = GPU_TORUS; createInnerGeometry(geo,cols,rows); break; } }
BBArray *bbArraySlice( const char *type,BBArray *inarr,int beg,int end ){ char *p; void *init; BBArray *arr; int n,k,el_size; int length=end-beg; if( length<=0 ) return &bbEmptyArray; arr=allocateArray( type,1,&length ); el_size=arr->size/length; init=arrayInitializer( arr ); p=(char*)BBARRAYDATA( arr,1 ); n=-beg; if( n>0 ){ if( beg+n>end ) n=end-beg; if( init ){ void **dst=(void**)p; for( k=0;k<n;++k ) *dst++=init; p=(char*)dst; }else{ memset( p,0,n*el_size ); p+=n*el_size; } beg+=n; if( beg==end ) return arr; } n=inarr->scales[0]-beg; if( n>0 ){ if( beg+n>end ) n=end-beg; #ifdef BB_GC_RC if( type[0]==':' || type[0]=='$' || type[0]=='[' ){ BBObject **dst=(BBObject**)p; BBObject **src=(BBObject**)BBARRAYDATA(inarr,inarr->dims)+beg; for( k=0;k<n;++k ){ BBObject *o=*src++; BBINCREFS( o ); *dst++=o; } p=(char*)dst; }else{ memcpy( p,(char*)BBARRAYDATA(inarr,inarr->dims)+beg*el_size,n*el_size ); p+=n*el_size; } #else memcpy( p,(char*)BBARRAYDATA(inarr,inarr->dims)+beg*el_size,n*el_size ); p+=n*el_size; #endif beg+=n; if( beg==end ) return arr; } n=end-beg; if( n>0 ){ if( init ){ void **dst=(void**)p; for( k=0;k<n;++k ) *dst++=init; }else{ memset( p,0,n*el_size ); } } return arr; }