LayeredIntegralBase.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 "SpatialUserObjectFunctor.h"
#include "LayeredBase.h"
#include "InputParameters.h"

template <typename UserObjectType>
class LayeredIntegralBase : public SpatialUserObjectFunctor<UserObjectType>, public LayeredBase
{
public:
  static InputParameters validParams();

  LayeredIntegralBase(const InputParameters & parameters);

  virtual Real spatialValue(const Point & p) const override { return integralValue(p); }

  virtual const std::vector<Point> spatialPoints() const override;

  virtual void initialize() override;
  virtual void execute() override;
  virtual void finalize() override;
  virtual void threadJoin(const UserObject & y) override;

protected:
  using UserObjectType::_current_elem;
  using UserObjectType::computeIntegral;
};

template <typename UserObjectType>
InputParameters
LayeredIntegralBase<UserObjectType>::validParams()
{
  InputParameters params = SpatialUserObjectFunctor<UserObjectType>::validParams();
  params += LayeredBase::validParams();
  return params;
}

template <typename UserObjectType>
LayeredIntegralBase<UserObjectType>::LayeredIntegralBase(const InputParameters & parameters)
  : SpatialUserObjectFunctor<UserObjectType>(parameters), LayeredBase(parameters)
{
  if (parameters.isParamValid("block") && parameters.isParamValid("boundary"))
    mooseError("Both block and boundary cannot be specified for a layered integral user object. If "
               "you want to define the geometric bounds of the layers from a specified block set "
               "layer_bounding_block instead.");
}

template <typename UserObjectType>
void
LayeredIntegralBase<UserObjectType>::initialize()
{
  UserObjectType::initialize();
  LayeredBase::initialize();
}

template <typename UserObjectType>
void
LayeredIntegralBase<UserObjectType>::execute()
{
  const auto integral_value = computeIntegral();

  const auto layer = getLayer(_current_elem->vertex_average());

  setLayerValue(layer, getLayerValue(layer) + integral_value);
}

template <typename UserObjectType>
void
LayeredIntegralBase<UserObjectType>::finalize()
{
  LayeredBase::finalize();
}

template <typename UserObjectType>
void
LayeredIntegralBase<UserObjectType>::threadJoin(const UserObject & y)
{
  UserObjectType::threadJoin(y);
  LayeredBase::threadJoin(y);
}

template <typename UserObjectType>
const std::vector<Point>
LayeredIntegralBase<UserObjectType>::spatialPoints() const
{
  std::vector<Point> points;

  for (const auto & l : _layer_centers)
  {
    Point pt(0.0, 0.0, 0.0);
    pt(_direction) = l;
    points.push_back(pt);
  }

  return points;
}