Я работаю над моделированием модели переноса нейтронов с использованием метода Монте-Карло. Сначала я реализую последовательный алгоритм, приведенный в книге М. Дж. Куинна параллельное программирование с openmp и MPI .

Приведенный ниже (последовательный) код представляет собой моделирование модели переноса нейтронов. когда я запускаю исполняемый файл в первый раз, он работает в бесконечном цикле. Когда я остановился и снова побежал, результат, который я получаю, равен 0, 0, 0 и не является ожидаемым результатом для всех возможных значений входных параметров, указанных в вопросе, как указано в руководстве по решению параллельного программирования MJQuinn с openmp и MPI (Вопрос № 10.8).

Электронная копия книги представлена ​​ниже: https://docs.google.com/document/d/193GVTC6X2C02C05C05C03/d/193GV3C05X5

Ожидаемый результат: количество отраженных, поглощенных и переданных скоростей: 25,31, 46,13, 28,56. При компиляции кода ошибки не было. пожалуйста, помогите мне. вот следующий код, который я написал:

struct neutron
{
    long double d    ;  // Direction of the neutron (measured in radians between 0 and pi)
    long double x    ;  // Position of particle in plate(0<=x<=H)where H is the thickness of the plate
};
typedef struct neutron neutron;


int  main()
{
    srand(time(NULL));
    double C ;   // mean distance between neutron/atom interactions is 1/C
    double C_s;  // Scattering component of C
    double C_c;  // Absorbing  component of C
    int r=0, b=0, t=0; //Counts of reflected, absorbed, transmitted neutrons
    int i=0;
    int n;                   // Number of Samples

    //double d;                //Direction of the neutron (measured in radians between 0 and pi)
    int a;                   //a==0 implies false 1 otherwise
    double u;                // Uniform random number
    double L;                // Distance neutron travels before collision
    neutron nt;
    double H;
    double p,q,o;


    printf("\n Enter the value of C_s:\n");
    scanf("%lf",&C_s);
    printf("\nEnter the value of C_c:\n");
    scanf("%lf",&C_c);
    //printf("\nEnter the value of L:\n");
    //scanf("%lf",&L);
    printf("\nEnter the value of H (Thickness of the plate):\n");
    scanf("%lf",&H);
    printf("\n Enter the number of samples you want to simulate for....\n");
    scanf("%d",&n);
    for(i=1;i<=n;i++)
    {
        u=rand()%n;
        u=1/u;
        nt.d=0;
        nt.x=0;
        a=1;
        while(a)
        {
            L=-(1/C)*log(u);
            nt.x=nt.x+L*cos(nt.d);
            if (nt.x<0)
            {
                //      printf("\nparticle %d got reflected\n",i);
                r++;
                a=0;
            }
            else
            {
                if(nt.x>=H)
                {
                    //      printf("\n particle %d got transmitted\n",i);
                    t++;
                    a=0;
                }
                else
                {
                    if(u<C_c/C)
                    {
                        //      printf("\n the particle %d got absorbed\n",i);
                        b++;
                        a=0;
                    }
                    else
                        nt.d=u*(22/7);
                }
            }
        }
    }
    o=(r/n)*100;
    p=(a/n)*100;
    q=(t/n)*100;
    printf("\nthe amount of reflected, absorbed and transmitted rates are: %lf, %lf, %lf\n", o, p, q);
    return 0;
}
c parallel-processing mpi
3
R.Anush 7 Сен 2016 в 18:57

3 ответа

Лучший ответ

У тебя есть

o=(r/n)*100;

Который выполняет целочисленное деление перед умножением. Поскольку ваш ожидаемый результат равен 25.31, это будет означать, что результатом r / n должно быть 0.2531, но результатом такого целочисленного деления будет 0, который поддерживает {{X4} } вы получаете.

Я предлагаю это

o = 100.0 * r / n
p = 100.0 * a / n;
q = 100.0 * t / n;

Это позволит выполнить правильную арифметику.

Кроме того, вы используете неинициализированные переменные .

2
Weather Vane 7 Сен 2016 в 16:19

У вас есть хотя бы одна неинициализированная переменная, поэтому ваш код - UB (неопределенное поведение).

L=-(1/C)*log(u);
      ^
      uninitialized

Далее это выглядит странно:

while(a)
{
    ....
}

Таким образом, a всегда будет нулевым при выходе из while. Но все же вы делаете:

p=(a/n)*100;

Что заставит p всегда быть нулевым. Вероятно, это не то, что вам нужно.

Однако я вижу эту строку:

b++;

Но я не могу найти код, в котором вы используете b.

Вы действительно хотели сделать это вот так?

p=(b/n)*100;  // b instead of a
2
4386427 7 Сен 2016 в 16:22

Я нашел ошибки в своем коде, обсудив с одноклассниками, исправил их и распараллелил код, вот следующий код:

/**
    To compile the program:         gcc sequential.c -lm
    To run the program:         ./a.out
**/
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>

#define TOTAL_NUMBER_OF_NEUTRONS 10000000                               //Total number of neutrons
#define SCATTERING_COMPONENT 0.7                                    // Scattering component of C
#define ABSORBING_COMPONENT  0.3                                    // Absorbing  component of C
#define THICKNESS_OF_THE_PLATE 8                                    //Thickness of the Plate
#define NUMBER_OF_ITERATIONS 1000
int no_of_particles_reflected=0, no_of_particles_absorbed=0, no_of_particles_transmitted=0;
double total_amount_absorbed,total_amount_reflected,total_amount_transmitted;
double distance_travelled_before_collision;                                     // Distance travelled by neutron before colliding from the plate
double C ;                                              // mean distance between neutron/atom interactions is 1/C
int flag= 1;                                                                                           int counter= 0;
struct neutron
{
    double d;                                           // Direction of the neutron (measured in radians between 0 and pi)
    double x;                                           // Position of particle in plate(0<=x<=H),H is the thickness of the plate
};
struct neutron nt;
void neutron_model()
{
    double random_number_generator;                                         // Uniform random number generator
    total_amount_absorbed=0,total_amount_reflected=0,total_amount_transmitted=0;
    for(int i=1;i<=TOTAL_NUMBER_OF_NEUTRONS;i++)
    {
        random_number_generator=rand()%TOTAL_NUMBER_OF_NEUTRONS;
        random_number_generator=1/random_number_generator;
        nt.d=0;
        nt.x=0;
        flag=1;
        while(flag)
                {
            distance_travelled_before_collision=-(1/C)*log(random_number_generator);
            nt.x=distance_travelled_before_collision*cos(nt.d);

            if (nt.x<0)
            {
                no_of_particles_reflected++;
                flag=0;
            }
            else if(nt.x>=THICKNESS_OF_THE_PLATE)
            {
                no_of_particles_transmitted++;
                flag=0;
            }
            else
            {
                if(random_number_generator<(ABSORBING_COMPONENT/C))
                {
                    no_of_particles_absorbed++;
                    flag=0;
                }
                else
                {
                    nt.d=random_number_generator*(22.0/7.0);
                    counter++;
                    if(counter==NUMBER_OF_ITERATIONS)
                    {
                        no_of_particles_absorbed++;
                        flag=0;
                        counter=0;
                    }
                }
            }
        }
    }
}
int main(int argc, char *argv[])
{
    C=SCATTERING_COMPONENT + ABSORBING_COMPONENT;   


    clock_t start, end;
    double diff_t;
    diff_t = 0.0;
    //start the clock
    start= clock();
    neutron_model();
    //stop the clock
    end = clock();
    diff_t = ((double) (end - start)) / CLOCKS_PER_SEC;
    total_amount_reflected=((double)no_of_particles_reflected/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;
    total_amount_absorbed=((double)no_of_particles_absorbed/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;
    total_amount_transmitted=((double)no_of_particles_transmitted/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;

    printf("\nDATA VALUE ASSUMED:-\n");
    printf("***********************************************************************\n");
    printf("TOTAL_NUMBER_OF_NEUTRONS:  %d\n",TOTAL_NUMBER_OF_NEUTRONS);
    printf("SCATTERING_COMPONENT: %f\n",SCATTERING_COMPONENT);
    printf("ABSORBING_COMPONENT: %f\n",ABSORBING_COMPONENT);
    printf("THICKNESS_OF_THE_PLATE: %d\n",THICKNESS_OF_THE_PLATE);
    printf("***********************************************************************\n\n");
    printf("Total particles reflected,absorbed and transmitted respectively are: %d, %d, %d     \n",no_of_particles_reflected,no_of_particles_absorbed,no_of_particles_transmitted);
        printf("Percentage of particles reflected,absorbed and transmitted respectively are: %lf, %lf, %lf\n", total_amount_reflected, total_amount_absorbed, total_amount_transmitted);
    printf("Total time taken in sec %10.6lf\n",diff_t);
    return 0;
}

Версия MPI:

/**
    To compile the program:         mpicc -o neutron_transport with_MPI.c -lm
    To run the program:         mpirun -np <specify no. of processes> neutron_transport 
**/
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>
#include<mpi.h>

#define TOTAL_NUMBER_OF_NEUTRONS 1000                       //Total number of neutrons
#define SCATTERING_COMPONENT 0.7                            // Scattering component of C
#define ABSORBING_COMPONENT  0.3                            // Absorbing  component of C
#define THICKNESS_OF_THE_PLATE 4                            //Thickness of the Plate
#define NUMBER_OF_ITERATIONS 1000
#define BLOCK_LOW(id,p,n)   ((id)*(n)/(p))
#define BLOCK_HIGH(id,p,n)  (BLOCK_LOW((id)+1,p,n)-1)
#define BLOCK_SIZE(id,p,n)  (BLOCK_LOW((id)+1,p,n)-BLOCK_LOW(id,p,n))       //Block Size for each process

struct neutron
{
    long double d;                                  // Direction of the neutron (measured in radians between 0 and pi)
    long double x;                                  // Position of particle in plate(0<=x<=H) where H is the thickness of the plate
};

int main(int argc, char *argv[])
{
    int process_id;                                 //Process Identifier
    int number_of_processes;                            //Number of Processes in the communicator
    MPI_Init(&argc,&argv);                              //Starting of MPI program
    MPI_Comm_rank(MPI_COMM_WORLD,&process_id);                  //Determine the process ID number in the communicator
    MPI_Comm_size(MPI_COMM_WORLD,&number_of_processes);             //Determine the number of processes in the communicator
    int i=0;                                    //Loop iterator
    int counter=0;
    int buffer_share_for_each_process=0;
    double C ;                                      // mean distance between neutron/atom interactions is 1/C
    C=SCATTERING_COMPONENT + ABSORBING_COMPONENT;   
    int flag= 1;                                                    
    double random_number_generator;                                 // Uniform random number
    double distance_travelled_before_collision;                         // Distance travelled by neutron before collision
    struct neutron nt;
    double total_amount_absorbed,total_amount_reflected,total_amount_transmitted;
    int count_of_reflected_absorbed_transmitted[3];
    count_of_reflected_absorbed_transmitted[0]=0;
    count_of_reflected_absorbed_transmitted[1]=0;
    count_of_reflected_absorbed_transmitted[2]=0;
    int global_count_of_reflected_absorbed_transmitted[3];
    buffer_share_for_each_process= BLOCK_SIZE(process_id,number_of_processes,TOTAL_NUMBER_OF_NEUTRONS);
    double elapsed_time1;                   //Timer variables
    elapsed_time1= -MPI_Wtime();
    if(number_of_processes > TOTAL_NUMBER_OF_NEUTRONS)
    {
        if(!process_id) 
            printf("Too many processes. Kindly provide lesser number of processes.\n");
        MPI_Finalize();
        exit(1);
    }

    for(int i=1;i<=buffer_share_for_each_process;i++)
    {
        random_number_generator=rand()%TOTAL_NUMBER_OF_NEUTRONS;
        random_number_generator=1/random_number_generator;
        nt.d=0;
        nt.x=0;
        flag=1;
        distance_travelled_before_collision=-(1/C)*log(random_number_generator);
        nt.x=distance_travelled_before_collision*cos(nt.d);

        while(flag)
                {
            distance_travelled_before_collision=-(1/C)*log(random_number_generator);
            nt.x=distance_travelled_before_collision*cos(nt.d);

            if (nt.x<0)
            {
                count_of_reflected_absorbed_transmitted[0]++;
                flag=0;
            }
            else if(nt.x>=THICKNESS_OF_THE_PLATE)
            {
                count_of_reflected_absorbed_transmitted[2]++;
                flag=0;
            }
            else
            {
                if(random_number_generator<(ABSORBING_COMPONENT/C))
                {
                    count_of_reflected_absorbed_transmitted[1]++;
                    flag=0;
                }
                else
                {
                    nt.d=random_number_generator*(22.0/7.0);
                    counter++;
                    if(counter==NUMBER_OF_ITERATIONS)
                    {
                        count_of_reflected_absorbed_transmitted[1]++;
                        flag=0;
                        counter=0;
                    }
                }
            }
        }
    }
    for(int i= 0 ; i < 3 ; i ++)
        MPI_Reduce(&count_of_reflected_absorbed_transmitted[i], &global_count_of_reflected_absorbed_transmitted[i], 1, MPI_INT,MPI_SUM,0, MPI_COMM_WORLD) ; 
    elapsed_time1+= MPI_Wtime();
    MPI_Barrier(MPI_COMM_WORLD);
    if(!process_id)
    {
        total_amount_reflected=((double)global_count_of_reflected_absorbed_transmitted[0]/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;
        total_amount_absorbed=((double)global_count_of_reflected_absorbed_transmitted[1]/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;
        total_amount_transmitted=((double)global_count_of_reflected_absorbed_transmitted[2]/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;

        printf("\nDATA VALUE ASSUMED:-\n");
        printf("*****************************************************************************************\n");
        printf("TOTAL_NUMBER_OF_NEUTRONS:  %d\n",TOTAL_NUMBER_OF_NEUTRONS);
        printf("SCATTERING_COMPONENT: %f\n",SCATTERING_COMPONENT);
        printf("ABSORBING_COMPONENT: %f\n",ABSORBING_COMPONENT);
        printf("THICKNESS_OF_THE_PLATE: %d\n",THICKNESS_OF_THE_PLATE);
        printf("TOTAL NUMBER OF PROCESSES: %d\n",number_of_processes);
        printf("*****************************************************************************************\n\n");
        printf("Total particles reflected,absorbed and transmitted respectively are: %d, %d, %d \n",global_count_of_reflected_absorbed_transmitted[0],global_count_of_reflected_absorbed_transmitted[1],global_count_of_reflected_absorbed_transmitted[2]);
            printf("Percentage of particles reflected,absorbed and transmitted respectively are: %lf, %lf, %lf\n", total_amount_reflected, total_amount_absorbed,   total_amount_transmitted);
        printf("Total time taken in sec %10.6f\n",elapsed_time1);
    }
    MPI_Finalize();
    return 0;
}

Версия OpenMP:

 /**
    To compile the program:         gcc -fopenmp with_open_mp.c -lm
    To run the program:         ./a.out
**/
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>
#include<omp.h>

#define TOTAL_NUMBER_OF_NEUTRONS 10000000                               //Total number of neutrons
#define SCATTERING_COMPONENT 0.7                                    // Scattering component of C
#define ABSORBING_COMPONENT  0.3                                    // Absorbing  component of C
#define THICKNESS_OF_THE_PLATE 5                                    //Thickness of the Plate
#define NUMBER_OF_ITERATIONS 1000
#define TOTAL_NUMBER_OF_THREADS 500
struct neutron
{
    double d;                                           // Direction of the neutron (measured in radians between 0 and pi)
    double x;                                         // Position of particle in plate(0<=x<=H) where H is the thickness of the plate
};

int main(int argc, char *argv[])
{
    double C ;                                              // mean distance between neutron/atom interactions is 1/C
    C=SCATTERING_COMPONENT + ABSORBING_COMPONENT;   
    int no_of_particles_reflected=0, no_of_particles_absorbed=0, no_of_particles_transmitted=0;
    int flag= 1;                                                    
    double random_number_generator;                                         // Uniform random number
    double distance_travelled_before_collision;                                 // Distance travelled by neutron before collision
    struct neutron nt;
    double total_amount_absorbed,total_amount_reflected,total_amount_transmitted;
    int counter= 0;
        srand(time(NULL));
    clock_t start, end;
    double diff_t;
    diff_t = 0.0;
    //start the clock
    start= clock();
    //int t=omp_get_num_procs();
    omp_set_num_threads(TOTAL_NUMBER_OF_THREADS);
    #pragma omp parallel for reduction(+:no_of_particles_reflected,no_of_particles_absorbed,no_of_particles_transmitted)
    for(int i=1;i<=TOTAL_NUMBER_OF_NEUTRONS;i++)
    {
        random_number_generator=rand()%TOTAL_NUMBER_OF_NEUTRONS;
        random_number_generator=1/random_number_generator;
        nt.d=0;
        nt.x=0;
        flag=1;
        while(flag)
                {
            distance_travelled_before_collision=-(1/C)*log(random_number_generator);
            nt.x=distance_travelled_before_collision*cos(nt.d);

            if (nt.x<0)
            {
                no_of_particles_reflected++;
                flag=0;
            }
            else if(nt.x>=THICKNESS_OF_THE_PLATE)
            {
                no_of_particles_transmitted++;
                flag=0;
            }
            else
            {
                if(random_number_generator<(ABSORBING_COMPONENT/C))
                {
                    no_of_particles_absorbed++;
                    flag=0;
                }
                else
                {
                    nt.d=random_number_generator*(22.0/7.0);
                    counter++;
                    if(counter==NUMBER_OF_ITERATIONS)
                    {

                        no_of_particles_absorbed++;
                        flag=0;
                        counter=0;
                    }
                }
            }
        }
    }
    //stop the clock
    end = clock();
    diff_t = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("\nDATA VALUE ASSUMED:-\n");
    printf("*****************************************************************************************\n");
    printf("TOTAL_NUMBER_OF_NEUTRONS:  %d\n",TOTAL_NUMBER_OF_NEUTRONS);
    printf("SCATTERING_COMPONENT: %f\n",SCATTERING_COMPONENT);
    printf("ABSORBING_COMPONENT: %f\n",ABSORBING_COMPONENT);
    printf("THICKNESS_OF_THE_PLATE: %d\n",THICKNESS_OF_THE_PLATE);
    printf("TOTAL NUMBER OF THREADS: %d\n",TOTAL_NUMBER_OF_THREADS);
    printf("*****************************************************************************************\n\n");
    total_amount_reflected=((double)no_of_particles_reflected/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;
    total_amount_absorbed=((double)no_of_particles_absorbed/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;
    total_amount_transmitted=((double)no_of_particles_transmitted/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;
printf("Total particles reflected,absorbed and transmitted respectively are: %d, %d, %d \n",no_of_particles_reflected,no_of_particles_absorbed,no_of_particles_transmitted);
        printf("The amount reflected,absorbed and transmitted respectively are: %lf, %lf, %lf\n", total_amount_reflected, total_amount_absorbed, total_amount_transmitted);
    printf("Total time taken in sec %10.6lf\n",diff_t);
    return 0;
}

Гибридная версия MPI и OpenMP:

/**
    To compile the program:         mpicc -fopenmp mpi_openmp.c -o hybrid -lm
    To run the program:         mpirun -np <specify number of processes> ./hybrid
**/
#include<stdio.h>
#include<math.h>
#include<stdlib.h>
#include<time.h>
#include<omp.h>
#include<mpi.h>

#define TOTAL_NUMBER_OF_NEUTRONS 10000000                               //Total number of neutrons
#define SCATTERING_COMPONENT 0.7                                    // Scattering component of C
#define ABSORBING_COMPONENT  0.3                                    // Absorbing  component of C
#define THICKNESS_OF_THE_PLATE 3                                    //Thickness of the Plate
#define BLOCK_LOW(id,p,n)   ((id)*(n)/(p))
#define BLOCK_HIGH(id,p,n)  (BLOCK_LOW((id)+1,p,n)-1)
#define BLOCK_SIZE(id,p,n)  (BLOCK_LOW((id)+1,p,n)-BLOCK_LOW(id,p,n))               //Block Size for each process
#define NUMBER_OF_ITERATIONS 1000
#define TOTAL_NUMBER_OF_THREADS 500                                 //Total number of threads
struct neutron
{
    double d;                                           // Direction of the neutron (measured in radians between 0 and pi)
    double x;                                         // Position of particle in plate(0<=x<=H) where H is the thickness of the plate
};

int main(int argc, char *argv[])
{
    struct neutron nt;
    int process_id;                                         //Process Identifier
    int number_of_processes;                                    //Number of Processes in the communicator
    MPI_Init(&argc,&argv);                                      //Starting of MPI program
    MPI_Comm_rank(MPI_COMM_WORLD,&process_id);                          //Determine the process ID number in the communicator
    MPI_Comm_size(MPI_COMM_WORLD,&number_of_processes);                     //Determine the number of processes in the communicator

    double C ;                                              // mean distance between neutron/atom interactions is 1/C
    C=SCATTERING_COMPONENT + ABSORBING_COMPONENT;   
    int flag= 1;                                                    
    double random_number_generator;                                         // Uniform random number
    double distance_travelled_before_collision;                                 // Distance travelled by neutron before collision
    int no_of_particles_reflected=0, no_of_particles_absorbed=0, no_of_particles_transmitted=0;
    double total_amount_absorbed,total_amount_reflected,total_amount_transmitted;

    int counter= 0;
    int buffer_share_for_each_process=0;
        srand(time(NULL));

    int count_of_reflected_absorbed_transmitted[3];
    count_of_reflected_absorbed_transmitted[0]=0;
    count_of_reflected_absorbed_transmitted[1]=0;
    count_of_reflected_absorbed_transmitted[2]=0;
    int global_count_of_reflected_absorbed_transmitted[3];
    buffer_share_for_each_process= BLOCK_SIZE(process_id,number_of_processes,TOTAL_NUMBER_OF_NEUTRONS);
    double elapsed_time1;                   //Timer variables
    elapsed_time1= -MPI_Wtime();

    //int t=omp_get_num_procs();
    omp_set_num_threads(TOTAL_NUMBER_OF_THREADS);
    if((number_of_processes) > TOTAL_NUMBER_OF_NEUTRONS)
    {
        if(!process_id) 
            printf("Too many processes. Kindly provide lesser number of processes.\n");
        MPI_Finalize();
        exit(1);
    }

    #pragma omp parallel for 
    for(int i=1;i<=buffer_share_for_each_process;i++)
    {
        //printf("Buffer_Share= %d by process %d (thread %d out of %d)\n",buffer_share_for_each_process,process_id,omp_get_thread_num(),omp_get_num_threads());
        random_number_generator=rand()%TOTAL_NUMBER_OF_NEUTRONS;
        random_number_generator=1/random_number_generator;
        nt.d=0;
        nt.x=0;
        flag=1;
        while(flag)
                {
            distance_travelled_before_collision=-(1/C)*log(random_number_generator);
            nt.x=distance_travelled_before_collision*cos(nt.d);

            if (nt.x<0)
            {
                count_of_reflected_absorbed_transmitted[0]++;
                flag=0;
            }
            else if(nt.x>=THICKNESS_OF_THE_PLATE)
            {
                count_of_reflected_absorbed_transmitted[2]++;
                flag=0;
            }
            else
            {
                if(random_number_generator<(ABSORBING_COMPONENT/C))
                {
                    count_of_reflected_absorbed_transmitted[1]++;
                    flag=0;
                }
                else
                {
                    nt.d=random_number_generator*(22.0/7.0);
                    counter++;
                    if(counter==NUMBER_OF_ITERATIONS)
                    {
                        count_of_reflected_absorbed_transmitted[1]++;
                        flag=0;
                        counter=0;
                    }
                }
            }
        }
    }
    for(int i= 0 ; i < 3 ; i ++)
        MPI_Reduce(&count_of_reflected_absorbed_transmitted[i], &global_count_of_reflected_absorbed_transmitted[i], 1, MPI_INT,MPI_SUM,0, MPI_COMM_WORLD) ; 
    elapsed_time1+= MPI_Wtime();
    MPI_Barrier(MPI_COMM_WORLD);
    if(!process_id)
    {
        total_amount_reflected=((double)global_count_of_reflected_absorbed_transmitted[0]/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;
        total_amount_absorbed=((double)global_count_of_reflected_absorbed_transmitted[1]/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;
        total_amount_transmitted=((double)global_count_of_reflected_absorbed_transmitted[2]/(double)TOTAL_NUMBER_OF_NEUTRONS)*100.0;

        printf("\nDATA VALUE ASSUMED:-\n");
        printf("*****************************************************************************************\n");
        printf("TOTAL_NUMBER_OF_NEUTRONS:  %d\n",TOTAL_NUMBER_OF_NEUTRONS);
        printf("SCATTERING_COMPONENT: %f\n",SCATTERING_COMPONENT);
        printf("ABSORBING_COMPONENT: %f\n",ABSORBING_COMPONENT);
        printf("THICKNESS_OF_THE_PLATE: %d\n",THICKNESS_OF_THE_PLATE);
        printf("TOTAL NUMBER OF PROCESSES: %d\n",number_of_processes);
        printf("TOTAL NUMBER OF THREADS: %d\n",TOTAL_NUMBER_OF_THREADS);
        printf("*****************************************************************************************\n\n");
        printf("Total particles reflected,absorbed and transmitted respectively are: %d, %d, %d \n",global_count_of_reflected_absorbed_transmitted[0],global_count_of_reflected_absorbed_transmitted[1],global_count_of_reflected_absorbed_transmitted[2]);
            printf("Percentage of particles reflected,absorbed and transmitted respectively are: %lf, %lf, %lf\n", total_amount_reflected, total_amount_absorbed,   total_amount_transmitted);
        printf("Total time taken in sec %10.6f\n",elapsed_time1);
    }
    MPI_Finalize();
    return 0;
}
0
R.Anush 14 Сен 2016 в 04:37

Похожие вопросы

32 В чем разница между #include <filename> и #include "filename"?
23 Как определить размер моего массива в C?
19 Почему с массивами, почему [5] == 5 [a]?
29 Я использую результат malloc?
16 Каково влияние extern "C" в C ++?
29 В чем разница между параллелизмом и параллелизмом?
1 Как реализован ввод-вывод MPI?
21 В чем разница между const int *, const int * const и int const *?
9 Неопределенное, неопределенное и определяемое реализацией поведение
2 Что это ??!??! оператор делать в C?
1 Использование MPI_Scan для реализации простой суммы префикса
1 сложность с функцией MPI_Gather
1 Реализация алгоритма Cannons в MPI
5 Почему препроцессор C интерпретирует слово «linux» как константу «1»?
1 сложность понимания разброса и сборки MPI в C
💵 Получи $100 на хостинг на 60 дней.
Регистрируйся!

Новые вопросы

1 C Размер списка макросов разрешается, но не входит в цикл for
1 Как исправить десятичную ошибку после точки на платформе Beecrowd для расчета процентов?
2 Почему не происходит неявное преобразование типов из unsigned short int в signed char?
1 Поддерживает ли неявное приведение типов в C одинаковый ранг для char и коротких переменных?
1 В C printf вывод на стандартный вывод "\0", но не должен
1 Определение: struct termios tty; возвращает SIGSEGV в функции main()
1 Как рассчитать квадрат первых 20 чисел в двух дочерних процессах с использованием POSIX?
1 Как получить топологию конвейера gstreamer (диаграмма)
1 Исключает ли параметр ширины формата с плавающей запятой десятичную точку, когда это последний элемент?
2 Как объединить 3 растровых изображения одинакового размера в одно растровое изображение в C?
Все вопросы по теме c >

c

C - это язык программирования общего назначения, используемый для системного программирования (ОС и встраиваемых), библиотек, игр и кроссплатформенности. Этот тег следует использовать с общими вопросами, касающимися языка C, как это определено в стандарте ISO 9899 (последняя версия 9899: 2018, если не указано иное, а также для запросов, специфичных для версии, с c89, c99, c11 и т. Д.). C отличается от C ++ и не должен сочетаться с тэгом C ++ без разумной причины.

Подробнее про c...