void NodalFloodCount::calculateBubbleVolumes() { Moose::perf_log.push("calculateBubbleVolume()", "NodalFloodCount"); // Size our temporary data structure std::vector<std::vector<Real> > bubble_volumes(_maps_size); for (unsigned int map_num = 0; map_num < _maps_size; ++map_num) { bubble_volumes[map_num].resize(_bubble_sets[map_num].size()); } std::vector<unsigned int> flood_nodes(_maps_size); const MeshBase::const_element_iterator el_end = _mesh.getMesh().active_local_elements_end(); for (MeshBase::const_element_iterator el = _mesh.getMesh().active_local_elements_begin(); el != el_end; ++el) { Elem *elem = *el; unsigned int elem_n_nodes = elem->n_nodes(); Real curr_volume = elem->volume(); for (unsigned int map_num = 0; map_num < _maps_size; ++map_num) { unsigned int bubble_counter = 0; std::list<BubbleData>::const_iterator end = _bubble_sets[map_num].end(); for (std::list<BubbleData>::const_iterator bubble_it1 = _bubble_sets[map_num].begin(); bubble_it1 != end; ++bubble_it1) { unsigned int flooded_nodes = 0; for (unsigned int node = 0; node < elem_n_nodes; ++node) { unsigned int node_id = elem->node(node); if (bubble_it1->_nodes.find(node_id) != bubble_it1->_nodes.end()) ++flooded_nodes; } // Are a majority of the nodes flooded for this element? if (flooded_nodes >= elem_n_nodes / 2) bubble_volumes[map_num][bubble_counter] += curr_volume; ++bubble_counter; } } } // Stick all the partial bubble volumes in one long single vector to be gathered on the root processor for (unsigned int map_num = 0; map_num < _maps_size; ++map_num) _all_bubble_volumes.insert(_all_bubble_volumes.end(), bubble_volumes[map_num].begin(), bubble_volumes[map_num].end()); _communicator.sum(_all_bubble_volumes); //do all the sums! std::sort(_all_bubble_volumes.begin(), _all_bubble_volumes.end(), std::greater<Real>()); Moose::perf_log.pop("calculateBubbleVolume()", "NodalFloodCount"); }
void FeatureFloodCount::calculateBubbleVolumes() { Moose::perf_log.push("calculateBubbleVolume()", "FeatureFloodCount"); // Figure out which bubbles intersect the boundary if the user has enabled that capability. if (_compute_boundary_intersecting_volume) { // Create a std::set of node IDs which are on the boundary called all_boundary_node_ids. std::set<dof_id_type> all_boundary_node_ids; // Iterate over the boundary nodes, putting them into the std::set data structure MooseMesh::bnd_node_iterator boundary_nodes_it = _mesh.bndNodesBegin(), boundary_nodes_end = _mesh.bndNodesEnd(); for (; boundary_nodes_it != boundary_nodes_end; ++boundary_nodes_it) { BndNode * boundary_node = *boundary_nodes_it; all_boundary_node_ids.insert(boundary_node->_node->id()); } // For each of the _maps_size BubbleData lists, determine if the set // of nodes includes any boundary nodes. for (unsigned int map_num = 0; map_num < _maps_size; ++map_num) { std::list<BubbleData>::iterator bubble_it = _bubble_sets[map_num].begin(), bubble_end = _bubble_sets[map_num].end(); // Determine boundary intersection for each BubbleData object for (; bubble_it != bubble_end; ++bubble_it) bubble_it->_intersects_boundary = setsIntersect(all_boundary_node_ids.begin(), all_boundary_node_ids.end(), bubble_it->_entity_ids.begin(), bubble_it->_entity_ids.end()); } } // Size our temporary data structure std::vector<std::vector<Real> > bubble_volumes(_maps_size); for (unsigned int map_num = 0; map_num < _maps_size; ++map_num) bubble_volumes[map_num].resize(_bubble_sets[map_num].size()); // Clear pre-existing values and allocate space to store the volume // of the boundary-intersecting grains for each variable. _total_volume_intersecting_boundary.clear(); _total_volume_intersecting_boundary.resize(_maps_size); // Loop over the active local elements. For each variable, and for // each BubbleData object, check whether a majority of the element's // nodes belong to that Bubble, and if so assign the element's full // volume to that bubble. const MeshBase::const_element_iterator el_end = _mesh.getMesh().active_local_elements_end(); for (MeshBase::const_element_iterator el = _mesh.getMesh().active_local_elements_begin(); el != el_end; ++el) { Elem * elem = *el; unsigned int elem_n_nodes = elem->n_nodes(); Real curr_volume = elem->volume(); for (unsigned int map_num = 0; map_num < _maps_size; ++map_num) { std::list<BubbleData>::const_iterator bubble_it = _bubble_sets[map_num].begin(), bubble_end = _bubble_sets[map_num].end(); for (unsigned int bubble_counter = 0; bubble_it != bubble_end; ++bubble_it, ++bubble_counter) { // Count the number of nodes on this element which are flooded. unsigned int flooded_nodes = 0; for (unsigned int node = 0; node < elem_n_nodes; ++node) { dof_id_type node_id = elem->node(node); if (bubble_it->_entity_ids.find(node_id) != bubble_it->_entity_ids.end()) ++flooded_nodes; } // If a majority of the nodes for this element are flooded, // assign its volume to the current bubble_counter entry. if (flooded_nodes >= elem_n_nodes / 2) { bubble_volumes[map_num][bubble_counter] += curr_volume; // If the current bubble also intersects the boundary, also // accumlate the volume into the total volume of bubbles // which intersect the boundary. if (bubble_it->_intersects_boundary) _total_volume_intersecting_boundary[map_num] += curr_volume; } } } } // If we're calculating boundary-intersecting volumes, we have to normalize it by the // volume of the entire domain. if (_compute_boundary_intersecting_volume) { // Compute the total area using a bounding box. FIXME: this // assumes the domain is rectangular and 2D, and is probably a // little expensive so we should only do it once if possible. MeshTools::BoundingBox bbox = MeshTools::bounding_box(_mesh); Real total_volume = (bbox.max()(0)-bbox.min()(0))*(bbox.max()(1)-bbox.min()(1)); // Sum up the partial boundary grain volume contributions from all processors _communicator.sum(_total_volume_intersecting_boundary); // Scale the boundary intersecting grain volumes by the total domain volume for (unsigned int i = 0; i<_total_volume_intersecting_boundary.size(); ++i) _total_volume_intersecting_boundary[i] /= total_volume; } // Stick all the partial bubble volumes in one long single vector to be gathered on the root processor for (unsigned int map_num = 0; map_num < _maps_size; ++map_num) _all_bubble_volumes.insert(_all_bubble_volumes.end(), bubble_volumes[map_num].begin(), bubble_volumes[map_num].end()); // do all the sums! _communicator.sum(_all_bubble_volumes); std::sort(_all_bubble_volumes.begin(), _all_bubble_volumes.end(), std::greater<Real>()); Moose::perf_log.pop("calculateBubbleVolume()", "FeatureFloodCount"); }