std::string PETScConfigurable::p_generatePrefix(const parallel::Communicator& comm) { std::string result; if (comm.rank() == 0) { result = p_generatePrefix(); } boost::mpi::broadcast(comm, result, 0); return result; }
Sort<KeyType,IdxType>::Sort(const Parallel::Communicator &comm_in, std::vector<KeyType>& d) : ParallelObject(comm_in), _n_procs(comm_in.size()), _proc_id(comm_in.rank()), _bin_is_sorted(false), _data(d) { std::sort(_data.begin(), _data.end()); // Allocate storage _local_bin_sizes.resize(_n_procs); }
void parallelBarrierNotify(const Parallel::Communicator & comm) { processor_id_type slave_processor_id; if (comm.rank() == 0) { // The master process is already through, so report it Moose::out << "Jobs complete: 1/" << comm.size() << (1 == comm.size() ? "\n" : "\r") << std::flush; for (unsigned int i=2; i<=comm.size(); ++i) { comm.receive(MPI_ANY_SOURCE, slave_processor_id); Moose::out << "Jobs complete: " << i << "/" << comm.size() << (i == comm.size() ? "\n" : "\r") << std::flush; } } else { slave_processor_id = comm.rank(); comm.send(0, slave_processor_id); } comm.barrier(); }
void RBConstructionBase<Base>::generate_training_parameters_deterministic(const Parallel::Communicator &communicator, std::map<std::string, bool> log_param_scale, std::map< std::string, NumericVector<Number>* >& training_parameters_in, unsigned int n_training_samples_in, const RBParameters& min_parameters, const RBParameters& max_parameters, bool serial_training_set) { libmesh_assert_equal_to ( min_parameters.n_parameters(), max_parameters.n_parameters() ); const unsigned int num_params = min_parameters.n_parameters(); if (num_params == 0) return; if(num_params > 2) { libMesh::out << "ERROR: Deterministic training sample generation " << " not implemented for more than two parameters." << std::endl; libmesh_not_implemented(); } // Clear training_parameters_in { std::map< std::string, NumericVector<Number>* >::iterator it = training_parameters_in.begin(); std::map< std::string, NumericVector<Number>* >::const_iterator it_end = training_parameters_in.end(); for ( ; it != it_end; ++it) { NumericVector<Number>* training_vector = it->second; delete training_vector; training_vector = NULL; } } // Initialize training_parameters_in { RBParameters::const_iterator it = min_parameters.begin(); RBParameters::const_iterator it_end = min_parameters.end(); for( ; it != it_end; ++it) { std::string param_name = it->first; training_parameters_in[param_name] = NumericVector<Number>::build(communicator).release(); if(!serial_training_set) { // Calculate the number of training parameters local to this processor unsigned int n_local_training_samples; unsigned int quotient = n_training_samples_in/communicator.size(); unsigned int remainder = n_training_samples_in%communicator.size(); if(communicator.rank() < remainder) n_local_training_samples = (quotient + 1); else n_local_training_samples = quotient; training_parameters_in[param_name]->init(n_training_samples_in, n_local_training_samples, false, PARALLEL); } else { training_parameters_in[param_name]->init(n_training_samples_in, false, SERIAL); } } } if(num_params == 1) { NumericVector<Number>* training_vector = training_parameters_in.begin()->second; bool use_log_scaling = log_param_scale.begin()->second; Real min_param = min_parameters.begin()->second; Real max_param = max_parameters.begin()->second; numeric_index_type first_index = training_vector->first_local_index(); for(numeric_index_type i=0; i<training_vector->local_size(); i++) { numeric_index_type index = first_index+i; if(use_log_scaling) { Real epsilon = 1.e-6; // Prevent rounding errors triggering asserts Real log_min = log10(min_param + epsilon); Real log_range = log10( (max_param-epsilon) / (min_param+epsilon) ); Real step_size = log_range / std::max((unsigned int)1,(n_training_samples_in-1)); if(index<(n_training_samples_in-1)) { training_vector->set(index, pow(10., log_min + index*step_size )); } else { // due to rounding error, the last parameter can be slightly // bigger than max_parameters, hence snap back to the max training_vector->set(index, max_param); } } else { // Generate linearly scaled training parameters Real step_size = (max_param - min_param) / std::max((unsigned int)1,(n_training_samples_in-1)); training_vector->set(index, index*step_size + min_param); } } } // This is for two parameters if(num_params == 2) { // First make sure n_training_samples_in is a square number unsigned int n_training_parameters_per_var = static_cast<unsigned int>( std::sqrt(static_cast<Real>(n_training_samples_in)) ); if( (n_training_parameters_per_var*n_training_parameters_per_var) != n_training_samples_in) libmesh_error_msg("Error: Number of training parameters = " \ << n_training_samples_in \ << ".\n" \ << "Deterministic training set generation with two parameters requires\n " \ << "the number of training parameters to be a perfect square."); // make a matrix to store all the parameters, put them in vector form afterwards std::vector< std::vector<Real> > training_parameters_matrix(num_params); RBParameters::const_iterator it = min_parameters.begin(); RBParameters::const_iterator it_end = min_parameters.end(); unsigned int i = 0; for( ; it != it_end; ++it) { std::string param_name = it->first; Real min_param = it->second; bool use_log_scaling = log_param_scale[param_name]; Real max_param = max_parameters.get_value(param_name); training_parameters_matrix[i].resize(n_training_parameters_per_var); for(unsigned int j=0; j<n_training_parameters_per_var; j++) { // Generate log10 scaled training parameters if(use_log_scaling) { Real epsilon = 1.e-6; // Prevent rounding errors triggering asserts Real log_min = log10(min_param + epsilon); Real log_range = log10( (max_param-epsilon) / (min_param+epsilon) ); Real step_size = log_range / std::max((unsigned int)1,(n_training_parameters_per_var-1)); if(j<(n_training_parameters_per_var-1)) { training_parameters_matrix[i][j] = pow(10., log_min + j*step_size ); } else { // due to rounding error, the last parameter can be slightly // bigger than max_parameters, hence snap back to the max training_parameters_matrix[i][j] = max_param; } } else { // Generate linearly scaled training parameters Real step_size = (max_param - min_param) / std::max((unsigned int)1,(n_training_parameters_per_var-1)); training_parameters_matrix[i][j] = j*step_size + min_param; } } i++; } // now load into training_samples_in: std::map<std::string, NumericVector<Number>*>::iterator new_it = training_parameters_in.begin(); NumericVector<Number>* training_vector_0 = new_it->second; ++new_it; NumericVector<Number>* training_vector_1 = new_it->second; for(unsigned int index1=0; index1<n_training_parameters_per_var; index1++) { for(unsigned int index2=0; index2<n_training_parameters_per_var; index2++) { unsigned int index = index1*n_training_parameters_per_var + index2; if( (training_vector_0->first_local_index() <= index) && (index < training_vector_0->last_local_index()) ) { training_vector_0->set(index, training_parameters_matrix[0][index1]); training_vector_1->set(index, training_parameters_matrix[1][index2]); } } } // libMesh::out << "n_training_samples = " << n_training_samples_in << std::endl; // for(unsigned int index=0; index<n_training_samples_in; index++) // { // libMesh::out << "training parameters for index="<<index<<":"<<std::endl; // for(unsigned int param=0; param<num_params; param++) // { // libMesh::out << " " << (*training_parameters_in[param])(index); // } // libMesh::out << std::endl << std::endl; // } } }
void RBConstructionBase<Base>::generate_training_parameters_random(const Parallel::Communicator &communicator, std::map<std::string, bool> log_param_scale, std::map< std::string, NumericVector<Number>* >& training_parameters_in, unsigned int n_training_samples_in, const RBParameters& min_parameters, const RBParameters& max_parameters, int training_parameters_random_seed, bool serial_training_set) { libmesh_assert_equal_to ( min_parameters.n_parameters(), max_parameters.n_parameters() ); const unsigned int num_params = min_parameters.n_parameters(); // Clear training_parameters_in { std::map< std::string, NumericVector<Number>* >::iterator it = training_parameters_in.begin(); std::map< std::string, NumericVector<Number>* >::const_iterator it_end = training_parameters_in.end(); for ( ; it != it_end; ++it) { NumericVector<Number>* training_vector = it->second; delete training_vector; training_vector = NULL; } training_parameters_in.clear(); } if (num_params == 0) return; if (training_parameters_random_seed < 0) { if(!serial_training_set) { // seed the random number generator with the system time // and the processor ID so that the seed is different // on different processors std::srand( static_cast<unsigned>( std::time(0)*(1+communicator.rank()) )); } else { // seed the random number generator with the system time // only so that the seed is the same on all processors std::srand( static_cast<unsigned>( std::time(0) )); } } else { if(!serial_training_set) { // seed the random number generator with the provided value // and the processor ID so that the seed is different // on different processors std::srand( static_cast<unsigned>( training_parameters_random_seed*(1+communicator.rank()) )); } else { // seed the random number generator with the provided value // so that the seed is the same on all processors std::srand( static_cast<unsigned>( training_parameters_random_seed )); } } // initialize training_parameters_in { RBParameters::const_iterator it = min_parameters.begin(); RBParameters::const_iterator it_end = min_parameters.end(); for( ; it != it_end; ++it) { std::string param_name = it->first; training_parameters_in[param_name] = NumericVector<Number>::build(communicator).release(); if(!serial_training_set) { // Calculate the number of training parameters local to this processor unsigned int n_local_training_samples; unsigned int quotient = n_training_samples_in/communicator.size(); unsigned int remainder = n_training_samples_in%communicator.size(); if(communicator.rank() < remainder) n_local_training_samples = (quotient + 1); else n_local_training_samples = quotient; training_parameters_in[param_name]->init(n_training_samples_in, n_local_training_samples, false, PARALLEL); } else { training_parameters_in[param_name]->init(n_training_samples_in, false, SERIAL); } } } // finally, set the values { std::map< std::string, NumericVector<Number>* >::iterator it = training_parameters_in.begin(); std::map< std::string, NumericVector<Number>* >::const_iterator it_end = training_parameters_in.end(); for( ; it != it_end; ++it) { std::string param_name = it->first; NumericVector<Number>* training_vector = it->second; numeric_index_type first_index = training_vector->first_local_index(); for(numeric_index_type i=0; i<training_vector->local_size(); i++) { numeric_index_type index = first_index + i; Real random_number = ((double)std::rand())/RAND_MAX; // in range [0,1] // Generate log10 scaled training parameters if(log_param_scale[param_name]) { Real log_min = log10(min_parameters.get_value(param_name)); Real log_range = log10(max_parameters.get_value(param_name) / min_parameters.get_value(param_name)); training_vector->set(index, pow(10., log_min + random_number*log_range ) ); } // Generate linearly scaled training parameters else { training_vector->set(index, random_number*(max_parameters.get_value(param_name) - min_parameters.get_value(param_name)) + min_parameters.get_value(param_name)); } } } } }