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