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 PolycrystalUserObjectBase;
struct GrainDistance;

class GrainTracker : public FeatureFloodCount, public GrainTrackerInterface
{
public:
  static InputParameters validParams();

  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 Real _bound_value;

  const bool _remap;

  const bool _tolerate_failure;

  NonlinearSystemBase & _nl;

  std::vector<FeatureData> _feature_sets_old;

  const PolycrystalUserObjectBase * const _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;
};

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);