示例#1
0
void finalization(char* file_in, char* out_prefix, int total_iters, double residual_ratio,
                  int nintci, int nintcf, int points_count, int** points, int* elems, double* var,
                  double* cgup, double* su,  int* local_global_index,int num_elems_local) {
    char file_out[100];
    sprintf(file_out, "%s_summary.out", out_prefix);
        int my_rank, num_procs;
    MPI_Comm_rank(MPI_COMM_WORLD, &my_rank);    /// Get current process id
    MPI_Comm_size(MPI_COMM_WORLD, &num_procs);    /// get number of processe
     int num_elems = nintcf-nintci+1;
      int nc_global= 0;
     int i;
    double *su_global = (double*) calloc(sizeof(double), (num_elems));
    double *var_global = (double*) calloc(sizeof(double), (num_elems));
    double *cgup_global = (double*) calloc(sizeof(double), (num_elems));
    
    for (i = 0; i < num_elems_local; i++){
      nc_global = local_global_index[i];
      var_global[nc_global] = var[i];
      su_global[nc_global] = su[i];
      cgup_global[nc_global] = cgup[i];
    }
    double *su_global_sum = (double*) calloc(sizeof(double), (num_elems));
    double *var_global_sum = (double*) calloc(sizeof(double), (num_elems));
    double *cgup_global_sum = (double*) calloc(sizeof(double), (num_elems));
    MPI_Reduce(&var_global[0], &var_global_sum[0], num_elems, MPI_DOUBLE, MPI_SUM,0, MPI_COMM_WORLD);
    MPI_Reduce(&su_global[0], &su_global_sum[0], num_elems, MPI_DOUBLE, MPI_SUM,0, MPI_COMM_WORLD);
    MPI_Reduce(&cgup_global[0], &cgup_global_sum[0], num_elems, MPI_DOUBLE, MPI_SUM,0, MPI_COMM_WORLD);
     if (my_rank == 0){
   int status = store_simulation_stats(file_in, file_out, nintci, nintcf, var_global, total_iters,
                                        residual_ratio);

    sprintf(file_out, "%s_data.vtk", out_prefix);
    
    

    vtk_write_unstr_grid_header(file_in, file_out, nintci, nintcf, points_count, points, elems);
    vtk_append_double(file_out, "CGUP", nintci, nintcf, cgup_global_sum);
    }
    free(su_global);
    free(var_global);
    free(cgup_global);
    free(su_global_sum);
    free(var_global_sum);
    free(cgup_global_sum);
    
   // if ( status != 0 ) fprintf(stderr, "Error when trying to write to file %s\n", file_out);
}
void finalization(char* file_in, int nprocs, int myrank, int total_iters, double residual_ratio,
                  int nintci, int nintcf, double* var, int* local_global_index, int* global_local_index)
{
    // int global_nintci, global_nintcf;
    int i, j, status, global_int_count, local_int_count;
    double *unordered_global_vars, *ordered_global_vars;
    int *int_counts, *int_disps, *local_global_index_all;
    char file_out[100];

    sprintf(file_out, "%s.summary.out", file_in);

    // Perfrom inter-process communication if necessary
    if(nprocs > 1)
    {
        local_int_count = nintcf - nintci + 1;
        int_counts = (int *)malloc(nprocs * sizeof(int));
        int_disps = (int *)malloc(nprocs * sizeof(int));

        // Communicate neighboring procs' internal cell counts
        MPI_Gather(&local_int_count, 1, MPI_INT, int_counts, 1, MPI_INT, 0, MPI_COMM_WORLD);

        if(myrank == 0)
        {
            global_int_count = 0;
            for(i = 0; i < nprocs; i++)
            {
                int_disps[i] = global_int_count;
                global_int_count += int_counts[i];
            }

            local_global_index_all = (int *)malloc(global_int_count * sizeof(int));
            unordered_global_vars = (double *)malloc(global_int_count * sizeof(double));
        }

        // Communicate neighboring procs' local-to-global index mappings
        MPI_Gatherv(local_global_index, (nintcf + 1), MPI_INT, local_global_index_all, int_counts, int_disps, MPI_INT, 0, MPI_COMM_WORLD);

        // Communicate neighboring procs' var elements
        MPI_Gatherv(var, (nintcf + 1), MPI_DOUBLE, unordered_global_vars, int_counts, int_disps, MPI_DOUBLE, 0, MPI_COMM_WORLD);

        if(myrank == 0)
        {
            ordered_global_vars = (double *)malloc(global_int_count * sizeof(double));

            // Input vars from master rank
            for(j = 0; j < int_counts[0]; j++)
            {
                ordered_global_vars[local_global_index_all[j]] = unordered_global_vars[j];
            }

            // Input vars from neighbor ranks
            for(i = 1; i < nprocs; i++)
            {
                for(j = 0; j < int_counts[i]; j++)
                {
                    //ordered_global_vars[local_global_index_all[j + int_counts[i - 1]]] = unordered_global_vars[j + int_counts[i - 1]];
                    ordered_global_vars[local_global_index_all[j + int_disps[i]]] = unordered_global_vars[j + int_disps[i]];
                }
            }

            status = store_simulation_stats(file_in, file_out, 0, (global_int_count - 1), ordered_global_vars, total_iters, residual_ratio);

            if ( status != 0 ) fprintf(stderr, "Error when trying to write to file %s\n", file_out);

            // Deallocate memory
            free(ordered_global_vars);
            free(unordered_global_vars);
            free(local_global_index_all);
        }

        // Deallocate memory
        free(int_counts);
        free(int_disps);
    }
    else
    {
        status = store_simulation_stats(file_in, file_out, nintci, nintcf, var, total_iters, residual_ratio);

        if ( status != 0 ) fprintf(stderr, "Error when trying to write to file %s\n", file_out);
    }
}