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