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;
};