SurfaceMeshGeneratorBase.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 "MeshGenerator.h"

/*
 * Base class for mesh generators that loop over elements in subdomains on a mesh
 * - defines some common parameters
 * - defines a useful flooding/painting algorithm to apply an operation on elements
 */
class SurfaceMeshGeneratorBase : public MeshGenerator
{
public:
  static InputParameters validParams();

  SurfaceMeshGeneratorBase(const InputParameters & parameters);

protected:
  void setup(MeshBase & mesh);

  void flood(Elem * const elem,
             const Point & normal,
             const Elem & starting_elem,
             const subdomain_id_type & sub_id,
             MeshBase & mesh);

  virtual void actOnElem(Elem * const elem,
                         const Point & normal,
                         const subdomain_id_type & sub_id,
                         MeshBase & mesh) = 0;

  bool elementSatisfiesRequirements(const Elem * const elem,
                                    const Point & desired_normal,
                                    const Elem & base_elem,
                                    const Point & face_normal) const;

  Point get2DElemNormal(const Elem * const elem) const;

  std::unique_ptr<MeshBase> & _input;

  std::vector<SubdomainName> _subdomain_names;

  const bool _check_subdomains;

  std::vector<subdomain_id_type> _included_subdomain_ids;

  bool _using_normal;

  Point _normal;
  const Real _normal_tol;
  const Real _flipped_normal_tol;
  const bool _fixed_flooding_normal;
  const bool _consider_flipped_normals;
  const bool _flip_inverted_normals;
  const bool _has_max_distance_criterion;
  std::unordered_map<subdomain_id_type, Real> _max_elem_distance;

  std::unordered_map<subdomain_id_type, std::unordered_set<Elem *>> _visited;
  bool _flood_only_once;
  std::unordered_set<Elem *> _acted_upon_once;
  const unsigned int _flood_max_recursion;
  unsigned int _flood_recursion_count = 0;
  const bool _check_painted_neighor_normals;
};