GrainTracker.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 "FeatureFloodCount.h"
#include "GrainTrackerInterface.h"
 
#include "libmesh/bounding_box.h"
 
class GrainTracker;
class PolycrystalUserObjectBase;
struct GrainDistance;
 
template <>
InputParameters validParams<GrainTracker>();
 
class GrainTracker : public FeatureFloodCount, public GrainTrackerInterface
{
public:
  GrainTracker(const InputParameters & parameters);
  virtual ~GrainTracker();
 
  virtual void meshChanged() override;
  virtual void initialize() override;
  virtual void execute() override;
  virtual void finalize() override;
 
  virtual std::size_t getTotalFeatureCount() const override;
 
  // Struct used to transfer minimal data to all ranks
  struct PartialFeatureData
  {
    BoundaryIntersection boundary_intersection;
    unsigned int id;
    Point centroid;
    Status status;
  };
 
  struct CacheValues
  {
    Real current;
    Real old;
    Real older;
  };
 
  enum class RemapCacheMode
  {
    FILL,
    USE,
    BYPASS
  };
 
  // GrainTrackerInterface methods
  virtual Real getEntityValue(dof_id_type node_id,
                              FieldType field_type,
                              std::size_t var_index = 0) const override;
  virtual const std::vector<unsigned int> &
  getVarToFeatureVector(dof_id_type elem_id) const override;
  virtual unsigned int getFeatureVar(unsigned int feature_id) const override;
  virtual std::size_t getNumberActiveGrains() const override;
  virtual Point getGrainCentroid(unsigned int grain_id) const override;
  virtual bool doesFeatureIntersectBoundary(unsigned int feature_id) const override;
  virtual bool doesFeatureIntersectSpecifiedBoundary(unsigned int feature_id) const override;
  virtual bool isFeaturePercolated(unsigned int feature_id) const override;
  virtual std::vector<unsigned int> getNewGrainIDs() const override;
 
protected:
  virtual void updateFieldInfo() override;
  virtual Real getThreshold(std::size_t current_index) const override;
 
  void prepopulateState(const FeatureFloodCount & ffc_object);
 
  void communicateHaloMap();
 
  void assignGrains();
 
  void trackGrains();
 
  virtual void newGrainCreated(unsigned int new_grain_id);
 
  void remapGrains();
 
  void broadcastAndUpdateGrainData();
 
  void computeMinDistancesFromGrain(FeatureData & grain,
                                    std::vector<std::list<GrainDistance>> & min_distances);
 
  bool attemptGrainRenumber(FeatureData & grain, unsigned int depth, unsigned int max_depth);
 
  void swapSolutionValues(FeatureData & grain,
                          std::size_t new_var_index,
                          std::vector<std::map<Node *, CacheValues>> & cache,
                          RemapCacheMode cache_mode);
 
  void swapSolutionValuesHelper(Node * curr_node,
                                std::size_t curr_var_index,
                                std::size_t new_var_index,
                                std::vector<std::map<Node *, CacheValues>> & cache,
                                RemapCacheMode cache_mode);
 
  Real boundingRegionDistance(std::vector<BoundingBox> & bboxes1,
                              std::vector<BoundingBox> & bboxes2) const;
 
  Real centroidRegionDistance(std::vector<BoundingBox> & bboxes1,
                              std::vector<BoundingBox> & bboxes2) const;
 
  unsigned int getNextUniqueID();
 
  /*************************************************
   *************** Data Structures *****************
   ************************************************/
 
  const int _tracking_step;
 
  const unsigned short _halo_level;
 
  const unsigned short _max_remap_recursion_depth;
 
  const unsigned short _n_reserve_ops;
 
  const std::size_t _reserve_op_index;
 
  const Real _reserve_op_threshold;
 
  const bool _remap;
 
  const bool _tolerate_failure;
 
  NonlinearSystemBase & _nl;
 
  std::vector<FeatureData> _feature_sets_old;
 
  const PolycrystalUserObjectBase * _poly_ic_uo;
 
  const short _verbosity_level;
 
  bool & _first_time;
 
  const bool _error_on_grain_creation;
 
private:
  unsigned int _reserve_grain_first_index;
 
  unsigned int _old_max_grain_id;
 
  unsigned int & _max_curr_grain_id;
 
  const bool _is_transient;
 
  std::vector<std::pair<dof_id_type, dof_id_type>> _all_ranges;
 
  const PerfID _finalize_timer;
  const PerfID _remap_timer;
  const PerfID _track_grains;
  const PerfID _broadcast_update;
  const PerfID _update_field_info;
};
 
struct GrainDistance
{
  GrainDistance(Real distance, std::size_t var_index);
 
  GrainDistance(Real distance,
                std::size_t var_index,
                std::size_t grain_index,
                unsigned int grain_id);
 
  // Copy constructors
  GrainDistance(const GrainDistance & f) = default;
  GrainDistance & operator=(const GrainDistance & f) = default;
 
  // Move constructors
  GrainDistance(GrainDistance && f) = default;
  GrainDistance & operator=(GrainDistance && f) = default;
 
  bool operator<(const GrainDistance & rhs) const;
 
  Real _distance;
  std::size_t _var_index;
  std::size_t _grain_index;
  unsigned int _grain_id;
};
 
template <>
void dataStore(std::ostream & stream, GrainTracker::PartialFeatureData & feature, void * context);
template <>
void dataLoad(std::istream & stream, GrainTracker::PartialFeatureData & feature, void * context);