SingleSeriesBasisInterface.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
 
#include "FunctionalBasisInterface.h"
#include <functional>
 
class SingleSeriesBasisInterface : public FunctionalBasisInterface
{
public:
  SingleSeriesBasisInterface();
  SingleSeriesBasisInterface(const std::vector<MooseEnum> & domains,
                             const std::vector<std::size_t> & orders,
                             const unsigned int number_of_terms);
  virtual ~SingleSeriesBasisInterface();
 
  // Disable move and copy operations
  SingleSeriesBasisInterface(const SingleSeriesBasisInterface &) = delete;
  SingleSeriesBasisInterface(SingleSeriesBasisInterface &&) = delete;
  void operator=(const SingleSeriesBasisInterface &) = delete;
  SingleSeriesBasisInterface & operator=(SingleSeriesBasisInterface &&) = delete;
 
  // Overrides from FunctionalBasisInterface
  virtual bool isCacheInvalid() const final;
  virtual void setLocation(const Point & point) final;
  virtual void setOrder(const std::vector<std::size_t> & orders) final;
  virtual void setPhysicalBounds(const std::vector<Real> & bounds) final;
 
  virtual std::size_t
  calculatedNumberOfTermsBasedOnOrder(const std::vector<std::size_t> & order) const = 0;
 
  virtual std::vector<Real> getStandardizedLocation(const std::vector<Real> & location) const = 0;
 
  std::size_t getOrder(std::size_t domain) const;
 
  const std::vector<MooseEnum> _domains;
 
protected:
  // Overrides from FunctionalBasisInterface
  virtual void evaluateGeneration() override;
  virtual void evaluateExpansion() override;
 
  virtual void checkPhysicalBounds(const std::vector<Real> & bounds) const = 0;
 
  std::vector<Real> extractLocationFromPoint(const Point & point) const;
 
  std::vector<std::size_t> _orders;
 
  std::vector<Real> _physical_bounds;
 
  std::vector<Real> _standardized_location;
 
  std::function<void()> _evaluateExpansionWrapper;
 
  std::function<void()> _evaluateGenerationWrapper;
 
private:
  bool _are_physical_bounds_specified;
 
  std::vector<Real> _location;
 
  // Hide from subclasses to prevent BAD things from happening
  using FunctionalBasisInterface::_is_cache_invalid;
  using FunctionalBasisInterface::clearBasisEvaluation;
};