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"

class ElementSubdomainModifierBase : public ElementUserObject
{
public:
  static InputParameters validParams();

  ElementSubdomainModifierBase(const InputParameters & parameters);

  virtual void initialSetup() override;
  virtual void meshChanged() 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;

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 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(bool displaced);

  void initElementStatefulProps(bool displaced);

  ConstElemRange & reinitializedElemRange(bool displaced = false);

  ConstBndNodeRange & reinitializedBndNodeRange(bool displaced = false);

  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::unique_ptr<ConstElemRange> _reinitialized_displaced_elem_range;

  std::unordered_set<dof_id_type> _reinitialized_nodes;
  std::unique_ptr<ConstBndNodeRange> _reinitialized_bnd_node_range;
  std::unique_ptr<ConstBndNodeRange> _reinitialized_displaced_bnd_node_range;
};