source: proiecte/NBody/NBody 2.0/SetupNBody.cpp @ 35

#include "NBody.hpp"

int numBodies;                  // No. of particles. This will show the same number as numParticles
                                                // class member variable of NBody, but it is used outside the class,
                                                // whitout being necessary to have a pointer to the class;
extern FILE *inputDataFile;
extern void* me;

/////////////////////////////////// NBody::setupNBody Func \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//
// Initialize the particles in the system : 
//      - their initial positions;
//      - their initial velocities.
// The data is read from a file or randomly generated.
//
/////////////////////////////////// NBody::setupNBody Func \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

int NBody::setupNBody()
{
        //--------------------------------------------
    // Make sure numParticles is multiple of group size
    numParticles = (numParticles < GROUP_SIZE) ? GROUP_SIZE : numParticles;
    numParticles = (numParticles / GROUP_SIZE) * GROUP_SIZE;

    numBodies = numParticles;
        
        //--------------------------------------------
        // First we will use initPos and initVel vectors to generate the
        // input data. They will be used in this function to
        // initialize the other vectors: the pos and vel vectors.
        
    initPos = (cl_float*)malloc(numBodies * sizeof(cl_float4));
    if(initPos == NULL) 
        { 
                std::cout << "Failed to allocate host memory. (initPos)" << std::endl;
                return 1;
        }

    initVel = (cl_float*)malloc(numBodies * sizeof(cl_float4));
        if(initVel == NULL)     
        { 
                std::cout << "Failed to allocate host memory. (initVel)" << std::endl;
                return 1;
        }

        //--------------------------------------------
        // Initialization of inputs (positions and velocities). As we 
        // can see, each particle will occupy 4 elements in the 
        // pos and vel vectors. This is because the position and 
        // velocity is represented by their 3 components x, y, z.
        // Because we work with OpenCL we use cl_float4 vectors, so
        // vectors with four elements. We put the mass of the particle
        // on the 4th position occupied by a particle in the pos vector.

        // If the particles data is read from a file:
        if (readInputData){     
                
                if (inputDataFile == NULL){
                        std::cout << "Error: inputData file not opened." << std::endl;
                        ((NBody*)me)->cleanup();
                        exit(1);
                }

                for (int i = 0; i < numBodies ; i++){
                        int idx = i*4;

                        fscanf(inputDataFile, "%f", &initPos[idx+3]);           // Mass of particle i;
                        
                        for (int k = 0; k < 3; k++)
                                fscanf(inputDataFile, "%f", &initPos[idx+k]);   // Position of particle i;
                                             
                        for (int k = 0; k < 3; k++)
                                fscanf(inputDataFile, "%f", &initVel[idx+k]);   // Velocity of particle i;

                        initVel[idx+3] = 0.0f; // Unused;

                }
  
        }else{
        // If the particles data is generated randomly:
                for(int i = 0; i < numBodies; ++i)
                {
                        int index = 4 * i;

                        // First 3 values are position in x,y and z direction
                        for(int j = 0; j < 3; ++j)
                        {
                                initPos[index + j] = random(3, 50);
                        }

                        // Mass value
                        initPos[index + 3] = random(1, 1000);
                        //initPos[index + 3] = random(0.1, 1.0);
                        //initPos[index + 3] = 0.04;

                        // First 3 values are velocity in x,y and z direction
                        for(int j = 0; j < 3; ++j)
                        {
                                initVel[index + j] = 0.0f;
                        }

                        // unused
                        initVel[3] = 0.0f;
                }
        }

        //================================================
        // Resources common to all integrators:
        
        //--------------------------------------------
        // Allocate memory for pos and vel vectors.

        #if defined (_WIN32)
                pos = (cl_float*)_aligned_malloc(numBodies * sizeof(cl_float4), 16);
        #else
                pos = (cl_float*)memalign(16, numBodies * sizeof(cl_float4));
        #endif

        if(pos == NULL) 
        { 
                std::cout << "Failed to allocate host memory. (pos)" << std::endl;
                return 1;
        }

        #if defined (_WIN32)
                vel = (cl_float*)_aligned_malloc(numBodies * sizeof(cl_float4), 16);
        #else
                vel = (cl_float*)memalign(16, numBodies * sizeof(cl_float4));
        #endif

        if(vel == NULL) 
        { 
                std::cout << "Failed to allocate host memory. (vel)" << std::endl;
                return 1;
        }

        //--------------------------------------------
        // Copy the auxiliary vectors into the pos and vel ones:
        memcpy(pos, initPos, 4 * numBodies * sizeof(cl_float));
        memcpy(vel, initVel, 4 * numBodies * sizeof(cl_float));

        //================================================
        // Resources specific only for Leapfrog integrator:

        if (integrator == LEAPFROG){
                #if defined (_WIN32)
                        acc = (cl_float*)_aligned_malloc(numBodies * sizeof(cl_float4), 16);
                #else
                        acc = (cl_float*)memalign(16, numBodies * sizeof(cl_float4));
                #endif

                if(acc == NULL) 
                { 
                        std::cout << "Failed to allocate host memory. (acc)" << std::endl;
                        return 1;
                }

                #if defined (_WIN32)
                        collTime = (cl_float*)_aligned_malloc(numBodies * sizeof(cl_float), 16);
                #else
                        collTime = (cl_float*)memalign(16, numBodies * sizeof(cl_float));
                #endif

                if(collTime == NULL)    
                { 
                        std::cout << "Failed to allocate host memory. (collTime)" << std::endl;
                        return 1;
                }
        }

        return 0;
}

/////////////////////////////////// NBody::random Func \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\
//
// Generates random values in the interval [randMax, randMin]
//
/////////////////////////////////// NBody::random Func \\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\

float NBody::random(float randMax, float randMin)
{
    float result;
    result =(float)rand()/(float)RAND_MAX;

    return ((1.0f - result) * randMin + result *randMax);
}