LinearFVGradientInterface.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 "MooseTypes.h"
#include "GradientLimiterType.h"

#include "libmesh/utility.h"

#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>

class SystemBase;

namespace libMesh
{
template <typename T>
class NumericVector;
}

class LinearFVGradientInterface
{
public:
  LinearFVGradientInterface(SystemBase & sys) : _sys(sys) {}

  const std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>> &
  linearFVGradientContainer() const
  {
    return _raw_grad_container;
  }

  void requestLinearFVLimitedGradients(const Moose::FV::GradientLimiterType limiter_type,
                                       unsigned int variable_number);

  const std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>> &
  linearFVLimitedGradientContainer(const Moose::FV::GradientLimiterType limiter_type) const;

  const std::unordered_set<Moose::FV::GradientLimiterType> &
  requestedLinearFVLimitedGradientTypes() const
  {
    return _requested_limited_gradient_types;
  }

protected:
  void computeGradients();

  void rebuildLinearFVGradientStorage();

  std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>> &
  temporaryLinearFVGradientContainer()
  {
    return _temporary_gradient;
  }

  std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>> &
  temporaryLinearFVLimitedGradientContainer(const Moose::FV::GradientLimiterType limiter_type)
  {
    return _temporary_limited_gradient[limiter_type];
  }

  std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>> &
  rawLinearFVLimitedGradientContainer(const Moose::FV::GradientLimiterType limiter_type)
  {
    return _raw_limited_grad_containers[limiter_type];
  }

  const std::unordered_set<unsigned int> &
  requestedLinearFVLimitedGradientVariables(const Moose::FV::GradientLimiterType limiter_type) const
  {
    return libmesh_map_find(_requested_limited_gradient_variables, limiter_type);
  }

  bool needsLinearFVGradientStorage() const;

  void initializeContainer(
      std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>> & container) const;

  SystemBase & _sys;

  std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>> _temporary_gradient;

  std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>> _raw_grad_container;

  std::unordered_set<Moose::FV::GradientLimiterType> _requested_limited_gradient_types;

  std::unordered_map<Moose::FV::GradientLimiterType, std::unordered_set<unsigned int>>
      _requested_limited_gradient_variables;

  std::unordered_map<Moose::FV::GradientLimiterType,
                     std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>>>
      _raw_limited_grad_containers;

  std::unordered_map<Moose::FV::GradientLimiterType,
                     std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>>>
      _temporary_limited_gradient;
};