ElementSubdomainModifierBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* 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 "ElementUserObject.h"
#include "NonlinearSystemBase.h"
#include "AuxiliarySystem.h"
#include "NodalPatchRecoveryVariable.h"
#include "KDTree.h"
 
enum class ReinitStrategy
{
  IC,
  POLYNOMIAL_NEIGHBOR,
  POLYNOMIAL_WHOLE,
  POLYNOMIAL_NEARBY,
  NONE
};
 
class ElementSubdomainModifierBase : public ElementUserObject
{
public:
  static InputParameters validParams();
 
  ElementSubdomainModifierBase(const InputParameters & parameters);
 
  void initialSetup() override;
  void meshChanged() override;
  void timestepSetup() override;
 
protected:
  virtual void
  modify(const std::unordered_map<dof_id_type, std::pair<SubdomainID, SubdomainID>> & moved_elems);
 
  bool subdomainIsReinitialized(SubdomainID id) const;
 
  DisplacedProblem * _displaced_problem;
 
  MooseMesh * _displaced_mesh;
 
  std::unordered_map<BoundaryID, BoundaryName> _moving_boundary_names;
 
  NonlinearSystemBase & _nl_sys;
 
  AuxiliarySystem & _aux_sys;
 
private:
  void createMovingBoundaries(MooseMesh & mesh);
 
  void applySubdomainChanges(
      const std::unordered_map<dof_id_type, std::pair<SubdomainID, SubdomainID>> & moved_elems,
      MooseMesh & mesh);
 
  void setAncestorsSubdomainIDs(Elem * elem, const SubdomainID subdomain_id);
 
  void gatherMovingBoundaryChanges(
      const std::unordered_map<dof_id_type, std::pair<SubdomainID, SubdomainID>> & moved_elems);
 
  void gatherMovingBoundaryChangesHelper(const Elem * elem,
                                         unsigned short side,
                                         const Elem * neigh,
                                         unsigned short neigh_side);
 
  void applyMovingBoundaryChanges(MooseMesh & mesh);
 
  void prepareVariableForReinitialization(const VariableName & var_name,
                                          ReinitStrategy reinit_strategy);
 
  void updateAMRMovingBoundary(MooseMesh & mesh);
 
  void findReinitializedElemsAndNodes(
      const std::unordered_map<dof_id_type, std::pair<SubdomainID, SubdomainID>> & moved_elems);
 
  void setOldAndOlderSolutions(SystemBase & sys,
                               ConstElemRange & elem_range,
                               ConstBndNodeRange & bnd_node_range);
 
  bool nodeIsNewlyReinitialized(dof_id_type node_id) const;
 
  void applyIC();
 
  void initElementStatefulProps();
 
  ConstElemRange & reinitializedElemRange();
 
  ConstNodeRange & reinitializedNodeRange();
 
  ConstBndNodeRange & reinitializedBndNodeRange();
 
  void gatherPatchElements(const VariableName & var_name, ReinitStrategy reinit_strategy);
 
  void extrapolatePolynomial(const VariableName & var_name);
 
  void storeOverriddenDofValues(const VariableName & var_name);
 
  void restoreOverriddenDofValues(const VariableName & var_name);
 
  std::unordered_map<dof_id_type, std::pair<SubdomainID, SubdomainID>> _moved_elems;
 
  int & _t_step_old;
 
  bool _restep;
 
  bool _skip_restore_subdomain_changes;
 
  std::vector<SubdomainID> _subdomain_ids_to_reinitialize;
 
  const bool _old_subdomain_reinitialized;
 
  typedef std::pair<SubdomainID, SubdomainID> SubdomainPair;
  std::unordered_map<SubdomainPair, BoundaryID> _moving_boundaries;
 
  std::unordered_map<dof_id_type, std::unordered_map<unsigned short, BoundaryID>>
      _add_element_sides;
 
  std::unordered_map<dof_id_type, std::unordered_map<unsigned short, BoundaryID>>
      _remove_element_sides;
 
  std::unordered_map<dof_id_type, std::unordered_map<unsigned short, BoundaryID>>
      _add_neighbor_sides;
 
  std::unordered_map<dof_id_type, std::unordered_map<unsigned short, BoundaryID>>
      _remove_neighbor_sides;
 
  std::unordered_set<dof_id_type> _reinitialized_elems;
  std::unique_ptr<ConstElemRange> _reinitialized_elem_range;
 
  std::unordered_set<dof_id_type> _semi_local_reinitialized_elems;
 
  std::unordered_set<dof_id_type> _reinitialized_nodes;
  std::unique_ptr<ConstNodeRange> _reinitialized_node_range;
  std::unique_ptr<ConstBndNodeRange> _reinitialized_bnd_node_range;
 
  std::map<VariableName, std::pair<std::vector<dof_id_type>, std::vector<Number>>>
      _overridden_values_on_reinit_elems;
 
  std::vector<ReinitStrategy> _reinit_strategy;
 
  const std::vector<UserObjectName> _pr_names;
 
  std::vector<NodalPatchRecoveryVariable *> _pr;
 
  std::vector<VariableName> _reinit_vars;
 
  std::map<VariableName, unsigned int> _var_name_to_pr_idx;
 
  std::map<unsigned int, std::pair<std::unordered_set<const Elem *>, std::vector<dof_id_type>>>
      _evaluable_elems;
 
  std::map<VariableName, std::vector<dof_id_type>> _patch_elem_ids;
 
  int _leaf_max_size = 10;
  std::vector<Point> _kd_tree_points;
  double _nearby_distance_threshold;
 
  std::vector<VariableName> _vars_to_restore_overridden_dofs;
};