LinearFVGradientManager.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 "LinearFVGradientReader.h"
 
#include "libmesh/utility.h"
 
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
class SystemBase;
class ElemInfo;
class FaceInfo;
class FVGradientMethod;
 
namespace libMesh
{
template <typename T>
class NumericVector;
}
 
class LinearFVGradientManager
{
public:
  LinearFVGradientManager(SystemBase & sys) : _sys(sys) {}
 
  const FVGradientMethod & resolveFVGradientMethod(const GradientMethodName & method_name);
 
  LinearFVGradientReader registerFVGradient(unsigned int variable_number,
                                            const FVGradientMethod & method,
                                            unsigned int oldest_state = 0);
 
protected:
  using GradientContainer = LinearFVGradientReader::GradientContainer;
 
  using GradientStateContainer = LinearFVGradientReader::GradientStateContainer;
 
  using OwnedGradientContainer =
      std::vector<std::unique_ptr<libMesh::NumericVector<libMesh::Number>>>;
 
  void computeGradients();
 
  void updateFVGradient(const LinearFVGradientReader & reader);
 
  void initializeLinearFVGradientStorage();
 
  void initializeLinearFVGradientHistoryStorage();
 
  void rebuildLinearFVGradientStorage();
 
  void copyPreviousGradientStates(Moose::SolutionIterationType iteration_type,
                                  bool skip_current_to_old);
 
  void restoreGradientStates();
 
  bool hasLinearFVGradients() const;
 
  void initializeContainer(OwnedGradientContainer & container) const;
 
  struct LinearFVGradientContainer
  {
    std::unordered_set<unsigned int> variable_numbers;
 
    OwnedGradientContainer current_values;
 
    GradientStateContainer state_values;
 
    OwnedGradientContainer next_values;
 
    bool has_computed_gradient = false;
 
    bool has_initialized_history = false;
 
    bool has_checked_restart_history = false;
  };
 
  void resizeGradientStateStorage(LinearFVGradientContainer & container, unsigned int oldest_state);
 
  void setCurrentGradientState(LinearFVGradientContainer & container) const;
 
  void checkRestartedGradientHistory(const FVGradientMethod & method,
                                     LinearFVGradientContainer & container);
 
  static std::string gradientStateVectorName(const FVGradientMethod & method,
                                             unsigned int state,
                                             unsigned int component);
 
  void initializeGradientStatesForTimeAdvance();
 
  LinearFVGradientContainer & computeLinearFVGradientContainer(const FVGradientMethod & method);
 
  void finalizeLinearFVGradientContainer(LinearFVGradientContainer & container);
 
  SystemBase & _sys;
 
  std::unordered_map<const FVGradientMethod *, LinearFVGradientContainer>
      _linear_fv_gradient_container_by_method;
};