/************************************************************************* ************************************************************************** #cat: dft_power_stats - Derives statistics from a set of DFT power vectors. #cat: Statistics are computed for all but the lowest frequency #cat: wave form, including the Maximum power for each wave form, #cat: the direction at which the maximum power occured, and a #cat: normalized value for the maximum power. In addition, the #cat: statistics are ranked in descending order based on normalized #cat: squared maximum power. These statistics are fundamental #cat: to selecting a dominant direction flow for the current #cat: input image block. Input: powers - DFT power vectors (N Waves X M Directions) computed for the current image block from which the values in the statistics arrays are derived fw - the beginning of the range of wave form indices from which the statistcs are to derived tw - the ending of the range of wave form indices from which the statistcs are to derived (last index is tw-1) ndirs - number of orientations (directions) at which the DFT analysis was conducted Output: wis - list of ranked wave form indicies of the corresponding statistics based on normalized squared maximum power. These indices will be used as indirect addresses when processing the power statistics in descending order of "dominance" powmaxs - array holding the maximum DFT power for each wave form (other than the lowest frequecy) powmax_dirs - array to holding the direction corresponding to each maximum power value in powmaxs pownorms - array to holding the normalized maximum powers corresponding to each value in powmaxs Return Code: Zero - successful completion Negative - system error **************************************************************************/ int dft_power_stats(int *wis, double *powmaxs, int *powmax_dirs, double *pownorms, double **powers, const int fw, const int tw, const int ndirs) { int w, i; int ret; /* return code */ for(w = fw, i = 0; w < tw; w++, i++){ get_max_norm(&(powmaxs[i]), &(powmax_dirs[i]), &(pownorms[i]), powers[w], ndirs); } /* Get sorted order of applied DFT waves based on normalized power */ if((ret = sort_dft_waves(wis, powmaxs, pownorms, tw-fw))) return(ret); return(0); }
int main(int argc, char* argv[]) { if (MPI_Init(&argc, &argv) != MPI_SUCCESS) { std::cerr << "Couldn't initialize MPI." << std::endl; abort(); } MPI_Comm comm = MPI_COMM_WORLD; int rank = 0, comm_size = 0; if (MPI_Comm_rank(comm, &rank) != MPI_SUCCESS) { std::cerr << "Couldn't obtain MPI rank." << std::endl; abort(); } if (MPI_Comm_size(comm, &comm_size) != MPI_SUCCESS) { std::cerr << "Couldn't obtain size of MPI communicator." << std::endl; abort(); } // intialize Zoltan float zoltan_version; if (Zoltan_Initialize(argc, argv, &zoltan_version) != ZOLTAN_OK) { std::cerr << "Zoltan_Initialize failed." << std::endl; abort(); } const unsigned int neighborhood_size = 0; const int max_refinement_level = 1; std::array<double, 3> old_norm{{ std::numeric_limits<double>::max(), std::numeric_limits<double>::max(), std::numeric_limits<double>::max() }}; size_t old_nr_of_cells = 0; for (size_t nr_of_cells = 4; nr_of_cells <= 16; nr_of_cells *= 2) { dccrg::Dccrg<Cell, dccrg::Cartesian_Geometry> grid; const std::array<uint64_t, 3> grid_size{{ nr_of_cells + 2, nr_of_cells + 2, nr_of_cells + 2 }}; if ( not grid.initialize( grid_size, comm, "RANDOM", neighborhood_size, max_refinement_level, false, false, false ) ) { std::cerr << __FILE__ << ":" << __LINE__ << ": Couldn't initialize grid." << std::endl; abort(); } const std::array<double, 3> cell_length{{ double(5) / (grid_size[0] - 2), double(5) / (grid_size[1] - 2), double(1) / (grid_size[2] - 2), }}, grid_start{{1, 1, 0}}; dccrg::Cartesian_Geometry::Parameters geom_params; geom_params.start = grid_start; geom_params.level_0_cell_length = cell_length; if (not grid.set_geometry(geom_params)) { std::cerr << __FILE__ << ":" << __LINE__ << ": Couldn't set grid geometry." << std::endl; abort(); } grid.balance_load(); for (int i = 0; i < max_refinement_level; i++) { for (const auto& cell: grid.get_cells()) { const auto center = grid.geometry.get_center(cell); if ( center[0] > grid_start[0] + cell_length[0] + 5.0*2/4 and center[0] < grid_start[0] + cell_length[0] + 5.0*4/4 and center[1] > grid_start[1] + cell_length[1] + 5.0*1/4 and center[1] < grid_start[1] + cell_length[1] + 5.0*3/4 and center[2] > grid_start[2] + cell_length[2] + 2.0/4 and center[2] < grid_start[2] + cell_length[2] + 4.0/4 ) { grid.refine_completely(cell); } } grid.stop_refining(); } std::vector<uint64_t> solve_cells; for (const auto& cell: grid.get_cells()) { auto* const cell_data = grid[cell]; if (cell_data == nullptr) { std::cerr << __FILE__ << ":" << __LINE__ << std::endl; abort(); } const auto center = grid.geometry.get_center(cell); (*cell_data)[Scalar()] = function(center); if ( center[0] > grid_start[0] + cell_length[0] and center[0] < grid_start[0] + cell_length[0] + 5 and center[1] > grid_start[1] + cell_length[1] and center[1] < grid_start[1] + cell_length[1] + 5 and center[2] > grid_start[2] + cell_length[2] and center[2] < grid_start[2] + cell_length[2] + 1 ) { solve_cells.push_back(cell); } } grid.update_copies_of_remote_neighbors(); pamhd::divergence::get_gradient( solve_cells, grid, [](Cell& cell_data) -> Scalar::data_type& { return cell_data[Scalar()]; }, [](Cell& cell_data) -> Gradient::data_type& { return cell_data[Gradient()]; } ); const auto norm = get_max_norm(solve_cells, grid); for (size_t dim = 0; dim < 3; dim++) { if (norm[dim] > old_norm[dim]) { if (grid.get_rank() == 0) { std::cerr << __FILE__ << ":" << __LINE__ << " dim " << dim << ": Norm with " << solve_cells.size() << " cells " << norm[dim] << " is larger than with " << old_nr_of_cells << " cells " << old_norm[dim] << std::endl; } abort(); } if (old_nr_of_cells > 0) { const double order_of_accuracy = -log(norm[dim] / old_norm[dim]) / log(double(solve_cells.size()) / old_nr_of_cells); if (order_of_accuracy < 0.15) { if (grid.get_rank() == 0) { std::cerr << __FILE__ << ":" << __LINE__ << " dim " << dim << ": Order of accuracy from " << old_nr_of_cells << " to " << solve_cells.size() << " is too low: " << order_of_accuracy << std::endl; } abort(); } } } old_nr_of_cells = solve_cells.size(); old_norm = norm; } MPI_Finalize(); return EXIT_SUCCESS; }