FeatureFloodCount.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html
 
#pragma once
 
#include "Coupleable.h"
#include "GeneralPostprocessor.h"
#include "InfixIterator.h"
#include "MooseVariableDependencyInterface.h"
#include "BoundaryRestrictable.h"
 
#include <iterator>
#include <list>
#include <set>
#include <vector>
 
#include "libmesh/bounding_box.h"
#include "libmesh/periodic_boundaries.h"
 
// External includes
#include "bitmask_operators.h"
 
// Forward Declarations
class FeatureFloodCount;
class MooseMesh;
 
template <>
InputParameters validParams<FeatureFloodCount>();
 
class FeatureFloodCount : public GeneralPostprocessor,
                          public Coupleable,
                          public MooseVariableDependencyInterface,
                          public BoundaryRestrictable
{
public:
  FeatureFloodCount(const InputParameters & parameters);
 
  virtual void initialSetup() override;
  virtual void meshChanged() override;
  virtual void initialize() override;
  virtual void execute() override;
  virtual void finalize() override;
  virtual Real getValue() override;
 
  std::size_t getNumberActiveFeatures() const;
 
  virtual std::size_t getTotalFeatureCount() const;
 
  virtual bool doesFeatureIntersectBoundary(unsigned int feature_id) const;
 
  virtual bool doesFeatureIntersectSpecifiedBoundary(unsigned int feature_id) const;
 
  virtual bool isFeaturePercolated(unsigned int feature_id) const;
 
  virtual Point featureCentroid(unsigned int feature_id) const;
 
  virtual const std::vector<unsigned int> & getVarToFeatureVector(dof_id_type elem_id) const;
 
  virtual unsigned int getFeatureVar(unsigned int feature_id) const;
 
  std::size_t numCoupledVars() const { return _n_vars; }
 
  static const std::size_t invalid_size_t;
  static const unsigned int invalid_id;
 
  const std::vector<MooseVariable *> & getCoupledVars() const { return _vars; }
 
  const std::vector<MooseVariableFEBase *> & getFECoupledVars() const { return _fe_vars; }
 
  enum class FieldType
  {
    UNIQUE_REGION,
    VARIABLE_COLORING,
    GHOSTED_ENTITIES,
    HALOS,
    CENTROID,
    ACTIVE_BOUNDS,
  };
 
  // Retrieve field information
  virtual Real
  getEntityValue(dof_id_type entity_id, FieldType field_type, std::size_t var_index = 0) const;
 
  inline bool isElemental() const { return _is_elemental; }
 
  enum class Status : unsigned char
  {
    CLEAR = 0x0,
    MARKED = 0x1,
    DIRTY = 0x2,
    INACTIVE = 0x4
  };
 
  enum class BoundaryIntersection : unsigned char
  {
    NONE = 0x0,
    ANY_BOUNDARY = 0x1,
    PRIMARY_PERCOLATION_BOUNDARY = 0x2,
    SECONDARY_PERCOLATION_BOUNDARY = 0x4,
    SPECIFIED_BOUNDARY = 0x8
  };
 
  class FeatureData
  {
  public:
    using container_type = std::set<dof_id_type>;
 
    FeatureData() : FeatureData(std::numeric_limits<std::size_t>::max(), Status::INACTIVE) {}
 
    FeatureData(std::size_t var_index,
                unsigned int local_index,
                processor_id_type rank,
                Status status)
      : FeatureData(var_index, status)
    {
      _orig_ids = {std::make_pair(rank, local_index)};
    }
 
    FeatureData(std::size_t var_index,
                Status status,
                unsigned int id = invalid_id,
                std::vector<BoundingBox> bboxes = {BoundingBox()})
      : _var_index(var_index),
        _id(id),
        _bboxes(bboxes), // Assume at least one bounding box
        _min_entity_id(DofObject::invalid_id),
        _vol_count(0),
        _status(status),
        _boundary_intersection(BoundaryIntersection::NONE)
    {
    }
 
    // Default Move constructors
    FeatureData(FeatureData && /* f */) = default;
    FeatureData & operator=(FeatureData && /* f */) = default;
 
 
    void updateBBoxExtremes(MeshBase & mesh);
    void updateBBoxExtremes(BoundingBox & bbox, const BoundingBox & rhs_bbox);
 
    bool boundingBoxesIntersect(const FeatureData & rhs) const;
 
    bool mergeable(const FeatureData & rhs) const;
 
    bool canConsolidate(const FeatureData & rhs) const;
 
 
    bool halosIntersect(const FeatureData & rhs) const;
    bool periodicBoundariesIntersect(const FeatureData & rhs) const;
    bool ghostedIntersect(const FeatureData & rhs) const;
 
    void expandBBox(const FeatureData & rhs);
 
    void merge(FeatureData && rhs);
 
    void consolidate(FeatureData && rhs);
 
    // TODO: Doco
    void clear();
 
    bool operator<(const FeatureData & rhs) const
    {
      if (_id != invalid_id)
      {
        mooseAssert(rhs._id != invalid_id, "Asymmetric setting of ids detected during sort");
 
        // Sort based on ids
        return _id < rhs._id;
      }
      else
        // Sort based on processor independent information (mesh and variable info)
        return _var_index < rhs._var_index ||
               (_var_index == rhs._var_index && _min_entity_id < rhs._min_entity_id);
    }
 
    friend std::ostream & operator<<(std::ostream & out, const FeatureData & feature);
 
    container_type _ghosted_ids;
 
    container_type _local_ids;
 
    container_type _halo_ids;
 
    container_type _disjoint_halo_ids;
 
    container_type _periodic_nodes;
 
    std::size_t _var_index;
 
    unsigned int _id;
 
    std::vector<BoundingBox> _bboxes;
 
    std::list<std::pair<processor_id_type, unsigned int>> _orig_ids;
 
    dof_id_type _min_entity_id;
 
    std::size_t _vol_count;
 
    Point _centroid;
 
    Status _status;
 
    BoundaryIntersection _boundary_intersection;
 
    FeatureData duplicate() const { return FeatureData(*this); }
 
#ifndef __INTEL_COMPILER
 
  private:
#endif
 
    FeatureData(const FeatureData & /* f */) = default;
    FeatureData & operator=(const FeatureData & /* f */) = default;
  };
 
  const std::vector<FeatureData> & getFeatures() const { return _feature_sets; }
 
protected:
  template <typename T>
  bool isBoundaryEntity(const T * entity) const;
 
  virtual void updateFieldInfo();
 
  bool flood(const DofObject * dof_object, std::size_t current_index);
 
  virtual Real getThreshold(std::size_t current_index) const;
 
  virtual Real getConnectingThreshold(std::size_t current_index) const;
 
  bool compareValueWithThreshold(Real entity_value, Real threshold) const;
 
  virtual bool isNewFeatureOrConnectedRegion(const DofObject * dof_object,
                                             std::size_t & current_index,
                                             FeatureData *& feature,
                                             Status & status,
                                             unsigned int & new_id);
 
  void expandPointHalos();
 
  void expandEdgeHalos(unsigned int num_layers_to_expand);
 
 
  void visitNodalNeighbors(const Node * node, FeatureData * feature, bool expand_halos_only);
  void visitElementalNeighbors(const Elem * elem,
                               FeatureData * feature,
                               bool expand_halos_only,
                               bool disjoint_only);
 
  template <typename T>
  void visitNeighborsHelper(const T * curr_entity,
                            std::vector<const T *> neighbor_entities,
                            FeatureData * feature,
                            bool expand_halos_only,
                            bool topological_neighbor,
                            bool disjoint_only);
 
  void prepareDataForTransfer();
 
  void serialize(std::string & serialized_buffer, unsigned int var_num = invalid_id);
 
  void deserialize(std::vector<std::string> & serialized_buffers,
                   unsigned int var_num = invalid_id);
 
  virtual void mergeSets();
 
  virtual bool areFeaturesMergeable(const FeatureData & f1, const FeatureData & f2) const;
 
  void communicateAndMerge();
 
  void sortAndLabel();
 
  void scatterAndUpdateRanks();
 
  virtual void buildLocalToGlobalIndices(std::vector<std::size_t> & local_to_global_all,
                                         std::vector<int> & counts) const;
 
  void buildFeatureIdToLocalIndices(unsigned int max_id);
 
  virtual void clearDataStructures();
 
  void updateBoundaryIntersections(FeatureData & feature) const;
 
  void appendPeriodicNeighborNodes(FeatureData & feature) const;
 
  void updateRegionOffsets();
 
  template <class InputIterator>
  static bool setsIntersect(InputIterator first1,
                            InputIterator last1,
                            InputIterator first2,
                            InputIterator last2)
  {
    while (first1 != last1 && first2 != last2)
    {
      if (*first1 == *first2)
        return true;
 
      if (*first1 < *first2)
        ++first1;
      else if (*first1 > *first2)
        ++first2;
    }
    return false;
  }
 
  /*************************************************
   *************** Data Structures *****************
   ************************************************/
  std::vector<MooseVariableFEBase *> _fe_vars;
  std::vector<MooseVariable *> _vars;
 
  const DofMap & _dof_map;
 
  const Real _threshold;
  Real _step_threshold;
 
  const Real _connecting_threshold;
  Real _step_connecting_threshold;
 
  MooseMesh & _mesh;
 
  unsigned long _var_number;
 
  const bool _single_map_mode;
 
  const bool _condense_map_info;
 
  const bool _global_numbering;
 
  const bool _var_index_mode;
 
  const bool _compute_halo_maps;
 
  const bool _compute_var_to_feature_map;
 
  const bool _use_less_than_threshold_comparison;
 
  // Convenience variable holding the number of variables coupled into this object
  const std::size_t _n_vars;
 
  const std::size_t _maps_size;
 
  const processor_id_type _n_procs;
 
  std::vector<std::set<dof_id_type>> _entities_visited;
 
  std::vector<std::map<dof_id_type, int>> _var_index_maps;
 
  std::vector<std::vector<const Elem *>> _nodes_to_elem_map;
 
  std::vector<unsigned int> _feature_counts_per_map;
 
  unsigned int _feature_count;
 
  std::vector<std::list<FeatureData>> _partial_feature_sets;
 
  std::vector<FeatureData> & _feature_sets;
 
  std::vector<FeatureData> _volatile_feature_sets;
 
  std::vector<std::map<dof_id_type, int>> _feature_maps;
 
  std::vector<std::size_t> _local_to_global_feature_map;
 
  std::vector<std::size_t> _feature_id_to_local_index;
 
  PeriodicBoundaries * _pbs;
 
  std::unique_ptr<PointLocatorBase> _point_locator;
 
  const PostprocessorValue & _element_average_value;
 
  std::map<dof_id_type, int> _ghosted_entity_ids;
 
  std::vector<std::map<dof_id_type, int>> _halo_ids;
 
  std::multimap<dof_id_type, dof_id_type> _periodic_node_map;
 
  std::unordered_set<dof_id_type> _all_boundary_entity_ids;
 
  std::map<dof_id_type, std::vector<unsigned int>> _entity_var_to_features;
 
  std::vector<unsigned int> _empty_var_to_features;
 
  std::vector<BoundaryID> _primary_perc_bnds;
  std::vector<BoundaryID> _secondary_perc_bnds;
 
  std::vector<BoundaryID> _specified_bnds;
 
  const bool _is_elemental;
 
  bool _is_boundary_restricted;
 
  ConstBndElemRange * _bnd_elem_range;
 
  const bool _is_master;
 
private:
  template <class T>
  static inline void sort(std::set<T> & /*container*/)
  {
    // Sets are already sorted, do nothing
  }
 
  template <class T>
  static inline void sort(std::vector<T> & container)
  {
    std::sort(container.begin(), container.end());
  }
 
  template <class T>
  static inline void reserve(std::set<T> & /*container*/, std::size_t /*size*/)
  {
    // Sets are trees, no reservations necessary
  }
 
  template <class T>
  static inline void reserve(std::vector<T> & container, std::size_t size)
  {
    container.reserve(size);
  }
 
  void consolidateMergedFeatures(std::vector<std::list<FeatureData>> * saved_data = nullptr);
 
  std::deque<const DofObject *> _entity_queue;
 
  const bool _distribute_merge_work;
 
  const PerfID _execute_timer;
  const PerfID _merge_timer;
  const PerfID _finalize_timer;
  const PerfID _comm_and_merge;
  const PerfID _expand_halos;
  const PerfID _update_field_info;
  const PerfID _prepare_for_transfer;
  const PerfID _consolidate_merged_features;
};
 
template <>
void dataStore(std::ostream & stream, FeatureFloodCount::FeatureData & feature, void * context);
template <>
void dataStore(std::ostream & stream, BoundingBox & bbox, void * context);
 
template <>
void dataLoad(std::istream & stream, FeatureFloodCount::FeatureData & feature, void * context);
template <>
void dataLoad(std::istream & stream, BoundingBox & bbox, void * context);
 
template <>
struct enable_bitmask_operators<FeatureFloodCount::Status>
{
  static const bool enable = true;
};
 
template <>
struct enable_bitmask_operators<FeatureFloodCount::BoundaryIntersection>
{
  static const bool enable = true;
};