BasisExpansion.h

Go to the documentation of this file.

#ifndef BASISEXPANSION_H
#define BASISEXPANSION_H
 
#include "MUQ/Modeling/ModPiece.h"
 
#include "MUQ/Approximation/Polynomials/IndexedScalarBasis.h"
 
#include "MUQ/Utilities/MultiIndices/MultiIndexSet.h"
#include "MUQ/Utilities/VariadicMacros.h"
 
namespace muq{
  namespace Approximation{
 
    class MonotoneExpansion;
 
    class BasisExpansion : public muq::Modeling::ModPiece{
 
      friend class MonotoneExpansion;
 
    public:
 
      BasisExpansion(std::vector<std::shared_ptr<IndexedScalarBasis>> const& basisCompsIn,
                     bool                                                    coeffInput=false);
 
      BasisExpansion(std::vector<std::shared_ptr<IndexedScalarBasis>> const& basisCompsIn,
                     std::shared_ptr<muq::Utilities::MultiIndexSet>          multisIn,
                     bool                                                    coeffInput=false);
 
      BasisExpansion(std::vector<std::shared_ptr<IndexedScalarBasis>> const& basisCompsIn,
                     std::shared_ptr<muq::Utilities::MultiIndexSet>          multisIn,
                     Eigen::MatrixXd                                  const& coeffsIn,
                     bool                                                    coeffInput=false);
 
      virtual ~BasisExpansion() = default;
 
 
      virtual unsigned NumTerms() const{return multis->Size();};
 
 
      Eigen::MatrixXd BuildVandermonde(Eigen::MatrixXd const& evalPts) const;
 
      Eigen::MatrixXd BuildDerivMatrix(Eigen::MatrixXd const& evalPts, int wrtDim) const;
 
      Eigen::MatrixXd SecondDerivative(unsigned                                     outputDim,
                                       unsigned                                     wrtDim1,
                                       unsigned                                     wrtDim2,
                                       Eigen::VectorXd                       const& evalPt,
                                       Eigen::MatrixXd                       const& coeffs);
 
      Eigen::MatrixXd SecondDerivative(unsigned                                     outputDim,
                                       unsigned                                     wrtDim1,
                                       unsigned                                     wrtDim2,
                                       Eigen::VectorXd                       const& evalPt);
 
      Eigen::MatrixXd GetCoeffs() const;
 
      void SetCoeffs(Eigen::MatrixXd const& allCoeffs);
 
      const std::shared_ptr<muq::Utilities::MultiIndexSet> Multis() const{return multis;};
 
 
      virtual void ToHDF5(std::string filename, std::string groupName="/") const;
 
      virtual void ToHDF5(muq::Utilities::H5Object &group) const;
 
      static std::shared_ptr<BasisExpansion> FromHDF5(std::string filename, std::string groupName="/");
 
      static std::shared_ptr<BasisExpansion> FromHDF5(muq::Utilities::H5Object &group);
 
 
    protected:
 
      static Eigen::VectorXi GetInputSizes(std::shared_ptr<muq::Utilities::MultiIndexSet> multisIn,
                                           Eigen::MatrixXd                         const& coeffsIn,
                                           bool                                           coeffInput);
 
      static Eigen::VectorXi GetOutputSizes(std::shared_ptr<muq::Utilities::MultiIndexSet> multisIn,
                                            Eigen::MatrixXd                         const& coeffsIn);
 
      virtual void EvaluateImpl(muq::Modeling::ref_vector<Eigen::VectorXd> const& inputs) override;
 
      virtual void JacobianImpl(unsigned int const                           wrtIn,
                                unsigned int const                           wrtOut,
                                muq::Modeling::ref_vector<Eigen::VectorXd> const& inputs) override;
 
      void ProcessCoeffs(Eigen::VectorXd const& newCoeffs);
 
      Eigen::VectorXd GetAllTerms(Eigen::VectorXd const& x) const;
 
      Eigen::MatrixXd GetAllDerivs(Eigen::VectorXd const& x) const;
 
      std::vector<Eigen::MatrixXd> GetHessians(Eigen::VectorXd const& x) const;
 
      //Eigen::VectorXd GetAllDerivs(Eigen::VectorXd const& x,
      //                             unsigned               derivOrder) const;
 
      // Components of the basis functions
      std::vector<std::shared_ptr<IndexedScalarBasis>> basisComps;
 
      // MultiIndexSet defining each term in the expansion
      std::shared_ptr<muq::Utilities::MultiIndexSet> multis;
 
      // Coefficients for the output
      Eigen::MatrixXd coeffs;
 
    };
 
  }
}
 
#endif