LayeredBase.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
 
// MOOSE includes
#include "Moose.h"
#include "MooseEnum.h"
#include "MooseTypes.h"
#include "Restartable.h"
 
// Forward Declarations
class InputParameters;
class SubProblem;
class UserObject;
 
namespace libMesh
{
class Point;
}
 
template <typename T>
InputParameters validParams();
 
class LayeredBase : private Restartable
{
public:
  static InputParameters validParams();
 
  LayeredBase(const InputParameters & parameters);
 
  virtual Real integralValue(const Point & p) const;
 
  virtual Real getLayerValue(unsigned int layer) const;
 
  virtual unsigned int getLayer(const Point & p) const;
 
  const std::vector<Real> & getLayerCenters() const { return _layer_centers; }
 
  unsigned int direction() const { return _direction; }
 
  virtual void initialize();
  virtual void finalize();
  virtual void threadJoin(const UserObject & y);
 
protected:
  void setLayerValue(unsigned int layer, Real value);
 
  bool layerHasValue(unsigned int layer) const { return _layer_has_value[layer]; }
 
  void getBounds();
 
  void computeLayerCenters();
 
  std::string _layered_base_name;
 
  const InputParameters & _layered_base_params;
 
  MooseEnum _direction_enum;
 
  unsigned int _direction;
 
  bool _interval_based;
 
  unsigned int _num_layers;
 
  std::vector<Real> _layer_bounds;
 
  unsigned int _sample_type;
 
  unsigned int _average_radius;
 
  bool _using_displaced_mesh;
 
  std::vector<Real> _layer_centers;
 
  Real _direction_min;
  Real _direction_max;
 
  std::vector<Real> & _layer_values;
 
  std::vector<int> & _layer_has_value;
 
  bool _cumulative;
 
  const bool _positive_cumulative_direction;
 
private:
  SubProblem & _layered_base_subproblem;
 
  std::vector<SubdomainID> _layer_bounding_blocks;
 
  bool _has_direction_max_min;
};