void RCGStrategy::on_parameters_changed_event(common::SignalArgs& args) { common::XML::SignalOptions options(args); const common::URI parameters_uri = options.value<common::URI>("parameters_uri"); if(boost::starts_with(parameters_uri.path(), uri().path())) { CFdebug << "Acting on trilinos_parameters_changed event from paramater list " << parameters_uri.string() << CFendl; m_implementation->reset_solver(); } else { CFdebug << "Ignoring trilinos_parameters_changed event from paramater list " << parameters_uri.string() << CFendl; } }
void TrilinosVector::read_native(const common::URI& filename, const string type) { if(type == "rhs") { EpetraExt::readEpetraLinearSystem(filename.path(), m_comm, nullptr, &m_map, nullptr, &m_vec); } else if(type == "solution") { EpetraExt::readEpetraLinearSystem(filename.path(), m_comm, nullptr, &m_map, &m_vec); } else { throw common::SetupError(FromHere(), "Unknown type " + type + " for vector type when reading"); } m_is_created = true; }
void ReadRestartFile::execute() { Handle<mesh::Mesh> mesh = options().value< Handle<mesh::Mesh> >("mesh"); if(is_null(mesh)) throw common::SetupError(FromHere(), "Option mesh is not configured"); Handle<Time> time = options().value< Handle<Time> >(solver::Tags::time()); if(is_null(time)) throw common::SetupError(FromHere(), "Time component not configured"); const common::URI filepath = options().value<common::URI>("file"); boost::shared_ptr<common::XML::XmlNode> input_file = common::XML::parse_file(filepath); common::XML::XmlNode restart_node(input_file->content->first_node("restart")); if(!restart_node.is_valid()) throw common::FileFormatError(FromHere(), "File " + filepath.path() + " has no restart node"); if(options().value<bool>("read_time_step")) { time->options().set("time_step", common::from_str<Real>(restart_node.attribute_value("time_step"))); time->options().set("current_time", common::from_str<Real>(restart_node.attribute_value("current_time"))); time->options().set("iteration", common::from_str<Uint>(restart_node.attribute_value("iteration"))); } if(common::from_str<Uint>(restart_node.attribute_value("version")) != 1) throw common::FileFormatError(FromHere(), "File " + filepath.path() + " has unsupported version"); common::PE::Comm& comm = common::PE::Comm::instance(); if(common::from_str<Uint>(restart_node.attribute_value("nb_procs")) != comm.size()) throw common::SetupError(FromHere(), "File " + filepath.path() + " was made for " + restart_node.attribute_value("nb_procs") + " CPUs, but we are loading on " + common::to_str(comm.size()) + " CPUs"); boost::shared_ptr<common::BinaryDataReader> data_reader = common::allocate_component<common::BinaryDataReader>("DataReader"); data_reader->options().set("file", common::URI(restart_node.attribute_value("binary_file"))); common::XML::XmlNode field_node = restart_node.content->first_node("field"); for(; field_node.is_valid(); field_node.content = field_node.content->next_sibling("field")) { Handle<mesh::Field> field(mesh->access_component(common::URI(field_node.attribute_value("path"), common::URI::Scheme::CPATH))); if(is_null(field)) throw common::SetupError(FromHere(), "Field " + field_node.attribute_value("path") + " was not found in mesh " + mesh->uri().path()); data_reader->read_table(*field, common::from_str<Uint>(field_node.attribute_value("index"))); } }
void History::open_file(boost::filesystem::fstream& file, const common::URI& file_uri) { boost::filesystem::path path (file_uri.path()); file.open(path,std::ios_base::out); if (!file) // didn't open so throw exception { throw boost::filesystem::filesystem_error( path.string() + " failed to open", boost::system::error_code() ); } file.precision(10); }
void Reader::do_read_mesh_into(const common::URI& path, Mesh& mesh) { boost::shared_ptr<common::XML::XmlDoc> doc = common::XML::parse_file(path); common::XML::XmlNode mesh_node(doc->content->first_node("mesh")); common::PE::Comm& comm = common::PE::Comm::instance(); if(!mesh_node.is_valid()) throw common::FileFormatError(FromHere(), "File " + path.path() + " has no mesh node"); if(mesh_node.attribute_value("version") != "1") throw common::FileFormatError(FromHere(), "File " + path.path() + " has incorrect version " + mesh_node.attribute_value("version") + "(expected 1)"); if(common::from_str<Uint>(mesh_node.attribute_value("nb_procs")) != comm.size()) throw common::FileFormatError(FromHere(), "File " + path.path() + " has was created for " + mesh_node.attribute_value("nb_procs") + " processes and can't load on " + common::to_str(comm.size()) + " processors"); boost::shared_ptr<common::BinaryDataReader> data_reader = common::allocate_component<common::BinaryDataReader>("DataReader"); data_reader->options().set("file", common::URI(mesh_node.attribute_value("binary_file"))); common::XML::XmlNode topology_node = mesh_node.content->first_node("topology"); if(!topology_node.is_valid()) throw common::FileFormatError(FromHere(), "File " + path.path() + " does has no topology node"); common::XML::XmlNode region_node(topology_node.content->first_node("region")); typedef std::map<Handle< common::List<Uint> >, std::string> PeriodicMapT; PeriodicMapT periodic_links_map; // Collect a map of the periodic links to create, if any for(; region_node.is_valid(); region_node.content = region_node.content->next_sibling("region")) { Region& region = mesh.topology().create_region(region_node.attribute_value("name")); common::XML::XmlNode elements_node(region_node.content->first_node("elements")); for(; elements_node.is_valid(); elements_node.content = elements_node.content->next_sibling("elements")) { Elements& elems = region.create_elements(elements_node.attribute_value("element_type"), mesh.geometry_fields()); data_reader->read_list(elems.glb_idx(), common::from_str<Uint>(elements_node.attribute_value("global_indices"))); data_reader->read_list(elems.rank(), common::from_str<Uint>(elements_node.attribute_value("ranks"))); common::XML::XmlNode periodic_node(elements_node.content->first_node("periodic_links_elements")); if(periodic_node.is_valid()) { Handle< common::List<Uint> > periodic_links_elements = elems.create_component< common::List<Uint> >("periodic_links_elements"); data_reader->read_list(*periodic_links_elements, common::from_str<Uint>(periodic_node.attribute_value("index"))); periodic_links_map.insert(std::make_pair(periodic_links_elements, periodic_node.attribute_value("periodic_link"))); } } } // Link the periodic elements, now all elements have been created for(PeriodicMapT::const_iterator it = periodic_links_map.begin(); it != periodic_links_map.end(); ++it) { Handle<common::Link> link = it->first->create_component<common::Link>("periodic_link"); Handle<Elements> elements_to_link(mesh.access_component(common::URI(it->second, common::URI::Scheme::CPATH))); if(is_null(elements_to_link)) throw common::FileFormatError(FromHere(), "Invalid periodic link: " + it->second); link->link_to(*elements_to_link); } common::XML::XmlNode dictionaries_node(mesh_node.content->first_node("dictionaries")); if(!dictionaries_node.is_valid()) throw common::FileFormatError(FromHere(), "File " + path.path() + " does has no dictionaries node"); common::XML::XmlNode dictionary_node(dictionaries_node.content->first_node("dictionary")); for(; dictionary_node.is_valid(); dictionary_node.content = dictionary_node.content->next_sibling("dictionary")) { const std::string dict_name = dictionary_node.attribute_value("name"); // Add the coordinates first if(dict_name == "geometry") { common::XML::XmlNode field_node(dictionary_node.content->first_node("field")); for(; field_node.is_valid(); field_node.content = field_node.content->next_sibling("field")) { if(field_node.attribute_value("name") == "coordinates") { const Uint table_idx = common::from_str<Uint>(field_node.attribute_value("table_idx")); mesh.initialize_nodes(data_reader->block_rows(table_idx), data_reader->block_cols(table_idx)); data_reader->read_table(mesh.geometry_fields().coordinates(), table_idx); } } // Periodic links if(is_not_null(dictionary_node.content->first_attribute("periodic_links_nodes")) && is_not_null(dictionary_node.content->first_attribute("periodic_links_active"))) { cf3_assert(is_null(mesh.geometry_fields().get_child("periodic_links_nodes"))); cf3_assert(is_null(mesh.geometry_fields().get_child("periodic_links_active"))); Handle< common::List<Uint> > periodic_links_nodes = mesh.geometry_fields().create_component< common::List<Uint> >("periodic_links_nodes"); Handle< common::List<bool> > periodic_links_active = mesh.geometry_fields().create_component< common::List<bool> >("periodic_links_active"); data_reader->read_list(*periodic_links_nodes, common::from_str<Uint>(dictionary_node.attribute_value("periodic_links_nodes"))); data_reader->read_list(*periodic_links_active, common::from_str<Uint>(dictionary_node.attribute_value("periodic_links_active"))); } } } dictionary_node.content = dictionaries_node.content->first_node("dictionary"); for(; dictionary_node.is_valid(); dictionary_node.content = dictionary_node.content->next_sibling("dictionary")) { const std::string dict_name = dictionary_node.attribute_value("name"); const std::string space_lib_name = dictionary_node.attribute_value("space_lib_name"); const bool continuous = common::from_str<bool>(dictionary_node.attribute_value("continuous")); // The entities used by this dictionary std::vector< Handle<Entities> > entities_list; std::vector<Uint> entities_binary_file_indices; common::XML::XmlNode entities_node = dictionary_node.content->first_node("entities"); for(; entities_node.is_valid(); entities_node.content = entities_node.content->next_sibling("entities")) { Handle<Entities> entities(mesh.access_component(common::URI(entities_node.attribute_value("path"), common::URI::Scheme::CPATH))); if(is_null(entities)) throw common::FileFormatError(FromHere(), "Referred entities " + entities_node.attribute_value("path") + " doesn't exist in mesh"); entities_list.push_back(entities); entities_binary_file_indices.push_back(common::from_str<Uint>(entities_node.attribute_value("table_idx"))); } Dictionary& dictionary = dict_name == "geometry" ? mesh.geometry_fields() : (continuous ? mesh.create_continuous_space(dict_name, space_lib_name, entities_list) : mesh.create_discontinuous_space(dict_name, space_lib_name, entities_list)); // Read the global indices data_reader->read_list(dictionary.glb_idx(), common::from_str<Uint>(dictionary_node.attribute_value("global_indices"))); data_reader->read_list(dictionary.rank(), common::from_str<Uint>(dictionary_node.attribute_value("ranks"))); // Read the fields common::XML::XmlNode field_node(dictionary_node.content->first_node("field")); for(; field_node.is_valid(); field_node.content = field_node.content->next_sibling("field")) { if(field_node.attribute_value("name") == "coordinates") continue; const Uint table_idx = common::from_str<Uint>(field_node.attribute_value("table_idx")); Field& field = dictionary.create_field(field_node.attribute_value("name"), field_node.attribute_value("description")); common::XML::XmlNode tag_node = field_node.content->first_node("tag"); for(; tag_node.is_valid(); tag_node.content = tag_node.content->next_sibling("tag")) field.add_tag(tag_node.attribute_value("name")); data_reader->read_table(field, table_idx); } // Read in the connectivity tables for(Uint i = 0; i != entities_list.size(); ++i) { data_reader->read_table(entities_list[i]->space(dictionary).connectivity(), entities_binary_file_indices[i]); } } }
void TurbulenceStatistics::setup() { if(!m_options_changed) return; m_options_changed = false; m_used_nodes.reset(); Handle<mesh::Region> region = options().value< Handle<mesh::Region> >("region"); if(is_null(region)) { return; } const std::string velocity_var_name = options().value<std::string>("velocity_variable_name"); const std::string pressure_var_name = options().value<std::string>("pressure_variable_name"); m_velocity_field.reset(); m_pressure_field.reset(); const mesh::Mesh& mesh = common::find_parent_component<mesh::Mesh>(*region); Handle<mesh::Dictionary> dictionary; BOOST_FOREACH(const Handle<mesh::Dictionary>& dict, mesh.dictionaries()) { BOOST_FOREACH(const Handle<mesh::Field>& field, dict->fields()) { if(field->has_variable( velocity_var_name )) { if(is_not_null(m_velocity_field)) throw common::SetupError(FromHere(), "There are two fields that contain the variable " + velocity_var_name ); m_velocity_field = field; dictionary = dict; } } } if(is_null(m_velocity_field)) throw common::SetupError(FromHere(), "There is no field with the variable " + velocity_var_name ); m_dim = mesh.dimension(); if(m_dim == 1) { throw common::SetupError(FromHere(), "TurbulenceStatistics are not supported in 1D"); } cf3_assert(m_velocity_field->var_length(velocity_var_name) == m_dim); m_velocity_field_offset = m_velocity_field->var_offset( velocity_var_name ); BOOST_FOREACH(const Handle<mesh::Field>& field, dictionary->fields()) { if(field->has_variable( pressure_var_name )) { m_pressure_field = field; } } if(is_null(m_pressure_field)) throw common::SetupError(FromHere(), "There is no field with the variable " + pressure_var_name ); m_pressure_field_offset = m_pressure_field->var_offset( pressure_var_name ); const mesh::Field& coords = dictionary->coordinates(); common::PE::Comm& comm = common::PE::Comm::instance(); m_used_nodes = mesh::build_used_nodes_list(*region, *dictionary, true, false); const int nb_probes = m_probe_locations.size(); std::vector<int> my_probes_found(nb_probes, 0); m_probe_nodes.clear(); m_probe_indices.clear(); const common::List<Uint>::ListT& used_nodes_list = m_used_nodes->array(); BOOST_FOREACH(const Uint node_idx, used_nodes_list) { if(dictionary->is_ghost(node_idx)) continue; for(int probe_idx = 0; probe_idx != nb_probes; ++probe_idx) { if(m_probe_locations[probe_idx].size() != m_dim) { throw common::SetupError(FromHere(), "Probe coordinates of dimension " + common::to_str(m_probe_locations[probe_idx].size()) + " do not match dimension " + common::to_str(m_dim)); } if(((RealVector::Map(&coords[node_idx][0], m_dim) - m_probe_locations[probe_idx]).array().abs() < 1e-10).all()) { m_probe_nodes.push_back(node_idx); m_probe_indices.push_back(probe_idx); my_probes_found[probe_idx] = 1; } } } std::vector<int> global_probes_found(nb_probes); if(comm.is_active() && nb_probes > 0) { comm.all_reduce(common::PE::plus(), my_probes_found, global_probes_found); } else { global_probes_found = my_probes_found; } for(int probe_idx = 0; probe_idx != nb_probes; ++probe_idx) { if(global_probes_found[probe_idx] == 0) throw common::SetupError(FromHere(), "Probe " + common::to_str(probe_idx) + " has no matching node"); if(global_probes_found[probe_idx] > 1) throw common::SetupError(FromHere(), "Probe " + common::to_str(probe_idx) + " was found on " + common::to_str(global_probes_found[probe_idx]) + " CPUs"); } const common::URI original_uri = options().value<common::URI>("file"); // Init probe files m_probe_files.clear(); const Uint nb_my_probes = m_probe_nodes.size(); for(Uint my_idx = 0; my_idx != nb_my_probes; ++my_idx) { const Uint probe_idx = m_probe_indices[my_idx]; std::string probe_path = (original_uri.base_path() / (original_uri.base_name() + "-probe-" + common::to_str(probe_idx) + original_uri.extension())).path(); m_probe_files.push_back(boost::make_shared<boost::filesystem::fstream>(probe_path, std::ios_base::out)); boost::filesystem::fstream& file = *m_probe_files.back(); if(!file) throw common::FileSystemError(FromHere(), "Failed to open file " + probe_path); file << "# Probe data for probe " << probe_idx << " at point " << m_probe_locations[probe_idx].transpose() << "\n"; if(m_dim == 2) { file << "# U, V, uu, vv, uv, U_rolling, V_rolling, uu_rolling, vv_rolling, uv_rolling\n"; } else if(m_dim == 3) { file << "# U, V, W, uu, vv, ww, uv, uw, vw, U_rolling, V_rolling, W_rolling, uu_rolling, vv_rolling, ww_rolling, uv_rolling, uw_rolling, vw_rolling\n"; } } // Create a field for the statistics data m_statistics_field = Handle<mesh::Field>(dictionary->get_child("turbulence_statistics")); if(is_null(m_statistics_field)) { if(m_dim == 2) { m_statistics_field = dictionary->create_field("turbulence_statistics", "V[vector],uu,vv,uv,p").handle<mesh::Field>(); } else if(m_dim == 3) { m_statistics_field = dictionary->create_field("turbulence_statistics", "V[vector],uu,vv,ww,uv,uw,vw,p").handle<mesh::Field>(); } m_statistics_field->add_tag("turbulence_statistics"); } // Reset statistics without changing m_count const Uint nb_accs = (2.*m_dim + m_dim-1 + m_dim-2)*m_probe_nodes.size(); m_means.assign(nb_accs, MeanAccT()); m_rolling_means.assign(nb_accs, RollingAccT(boost::accumulators::tag::rolling_window::window_size = options().value<Uint>("rolling_window"))); }