LayeredBase.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://www.mooseframework.org
//*
//* 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(Point p) const;

  virtual Real getLayerValue(unsigned int layer) const;

  virtual unsigned int getLayer(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;
};