wmbasisarrayset.h

Go to the documentation of this file.

#ifndef WMBASISARRAYSET_H
#define WMBASISARRAYSET_H
 
// Wm includes
#include "lib/wxexcept.h"
#include "warpxm/warpxm_config.h"
 
// std includes
#include <vector>
#include <string>
#include <functional>
 
class WmBasisArraySet
{
public:
    WmBasisArraySet();
 
    void loadBasis(const int primitiveID,
                   const std::string& basisArraySetName,
                   const std::string& vspace_basisName,
                   const size_t vspace_ndims);
    void loadFile(const std::string& filename);
 
    int getNumFacesPerElement() const
    {
        return _numFacesPerElement;
    }
    int getNumFaceNodes() const
    {
        return _numFaceNodes;
    }
    int getNumTotalFaceNodes() const
    {
        return _numTotalFaceNodes;
    }
    int getNumTotalFaceNodesDeduplicated() const
    {
        return _numTotalFaceNodesDeduplicated;
    }
    int getNumDims() const
    {
        return _numDims;
    }
    int getNumTotalNodes() const
    {
        return _numTotalNodes;
    }
    int getNumGaussQuadNodes() const
    {
        return _numGaussQuadNodes;
    }
    int getNumInternalNodes() const
    {
        return _numInternalNodes;
    }
    int getSpatialOrder() const
    {
        return _spatialOrder;
    }
 
    real getCFLLimit() const
    {
        return _cfl;
    }
 
    size_t getBasisArrayBlockSize_Source() const
    {
        return _numTotalNodes * _numTotalNodes;
    }
    size_t getBasisArrayBlockSize_NumericalFlux() const
    {
        return _basisArray_NumericalFlux_Size;
    }
    size_t getBasisArrayBlockSize_InternalFlux() const
    {
        return _basisArray_InternalFlux_Size;
    }
 
    size_t getBasisArrayBlockSize_DerivativeApproximation() const
    {
        return _basisArray_Derivative_Approximation_Size;
    }
 
    size_t getBasisArraySize_NumericalFlux() const
    {
        return _basisArray_NumericalFlux_Size;
    }
    size_t getBasisArraySize_NumericalFlux_altFace() const
    {
        return _basisArray_NumericalFlux_altFace_Size;
    }
    size_t getBasisArraySize_InternalFlux() const
    {
        return _basisArray_InternalFlux_Size;
    }
 
    size_t getBasisArraySize_DerivativeApproximation() const
    {
        return _basisArray_Derivative_Approximation_Size;
    }
 
    size_t getBasisArraySize_LinearAverage() const
    {
        return _basisArray_LinearAverage_Size;
    }
 
    size_t getBasisArraySize_LinearCenter() const
    {
        return _basisArray_LinearCenter_Size;
    }
 
    size_t getBasisArraySize_MonomialConversion() const
    {
        return _basisArray_MonomialConversion_Size;
    }
 
    int getNumSubElements() const
    {
        return _numSubElements;
    }
    int getNumNodesPerSubElement() const
    {
        return _numNodesPerSubElement;
    }
    const int* getSubElementConnectivity() const
    {
        return &(_subElementConnectivity[0]);
    }
 
    const std::vector<int>& getFaceNodesDeduplicated() const
    {
        return _faceNodesDeduplicated;
    }
 
    const std::vector<real>& getNodePositions() const
    {
        return _nodePositions;
    }
 
    const std::vector<real>& getNodePositionsGaussQuad() const
    {
        return _nodePositionsGaussQuad;
    }
 
    const std::vector<real>& getNodePositions_PositivityPreservingQuad() const
    {
        if (getNumDims() == 1)
        {
            return _nodePositions;
        }
        else
        {
            WxExcept wxe("WmBasisArraySet.h : ");
            wxe << "Positivity-preserving quadrature node positions only defined for "
                   "1-dimensional elements"
                << std::endl;
            throw wxe;
        }
    }
 
    size_t getNumPositivityPreservingQuadNodes()
    {
        if (getNumDims() == 1)
        {
            return _numTotalNodes;
        }
        else if (getNumDims() == 2)
        {
            return _numInteriorPositivityPreservingQuadNodes +
                   _numTotalFaceNodesDeduplicated;
        }
        else
        {
            WxExcept wxe("WmBasisArraySet.h : ");
            wxe << "Positivity-preserving quadrature node positions only defined for "
                   "1 and 2-dimensional elements"
                << std::endl;
            throw wxe;
        }
    }
 
    size_t getNumInteriorPositivityPreservingQuadNodes() const
    {
        if (getNumDims() == 1)
        {
            return 0;
        }
        else if (getNumDims() == 2)
        {
            return _numInteriorPositivityPreservingQuadNodes;
        }
        else
        {
            WxExcept wxe("WmBasisArraySet.h : ");
            wxe << "Positivity-preserving quadrature node positions only defined for "
                   "1 and 2-dimensional elements"
                << std::endl;
            throw wxe;
        }
    }
 
    const real* getBasisArray_LagrangeOnGQnodes() const
    {
        return &(_basisArray_LagrangeOnGQnodes[0]);
    }
 
    const real* getBasisArray_NumericalFlux() const
    {
        return &(_basisArray_NumericalFlux[0]);
    }
    const real* getBasisArray_NumericalFlux_altFace() const
    {
        return &(_basisArray_NumericalFlux_altFace[0]);
    }
    const real* getBasisArray_InternalFlux() const
    {
        return &(_basisArray_InternalFlux[0]);
    }
    const real* getBasisArray_GaussQuad() const
    {
        return &(_basisArray_GaussQuad[0]);
    }
 
    const std::vector<real>& getBasisArray_PositivityPreservingQuadWeights() const
    {
        if (getNumDims() == 1)
        {
            return _basisArray_LinearAverage;
        }
        else
        {
            WxExcept wxe("WmBasisArraySet.h : ");
            wxe << "Positivity-preserving quadrature weights only defined for "
                   "1-dimensional elements"
                << std::endl;
            throw wxe;
        }
    }
 
    const std::vector<real>&
    getBasisArray_evaluateAtInteriorPositivityPreservingQuadNodes() const
    {
        return _basisArray_evaluateAtInteriorPositivityPreservingQuadNodes;
    }
 
    const real* getBasisArray_DerivativeApproximation() const
    {
        return &(_basisArray_Derivative_Approximation[0]);
    }
 
    const std::vector<real>& getBasisArray_LinearAverage() const
    {
        return _basisArray_LinearAverage;
    }
    const real* getBasisArray_LinearCenter() const
    {
        return &(_basisArray_LinearCenter[0]);
    }
    const real* getBasisArray_MonomialConversion() const
    {
        return &(_basisArray_MonomialConversion[0]);
    }
    const real* getBasisArray_OrthogonalToCollocation() const
    {
        return &(_basisArray_OrthogonalToCollocation[0]);
    }
    const real* getBasisArray_CollocationToOrthogonal() const
    {
        return &(_basisArray_CollocationToOrthogonal[0]);
    }
 
    const real* getBasisArray_FaceQuadratureWeights() const
    {
        return &(_basisArray_faceQuadratureWeights[0]);
    }
 
    const std::vector<std::function<real(const std::array<real, 3>&)>>&
    get_monomial_functions() const
    {
        return _monomial_functions;
    }
 
    const int* getOrientations(const int index) const
    {
        return &(_orientations[index][0]);
    }
    const int* getFaceNodes(const int face_index) const
    {
        return &(_faceNodes[face_index][0]);
    }
 
    real getInverseElementVolume() const
    {
        return _vol_multiplier;
    }
 
    // stuff for element with different types of faces
    int getNumFaceTypes() const
    {
        return _num_face_types;
    }
 
    int getNumFaceNodes(int face_index) const
    {
        return _num_face_nodes_per_face[face_index];
    }
 
    int getNumOrientations() const
    {
        return _numOrientations;
    }
 
    int getNumFaceNodesForFaceType(int face_type) const
    {
        return _num_face_nodes_per_face_type[face_type];
    }
 
    const std::vector<int>& getNumFaceNodesVector() const
    {
        return _num_face_nodes_per_face;
    }
 
    // CSR Array Getters
    bool has_csr() const
    {
        return _has_csr;
    }
 
    // Internal Flux Matrix
    const std::vector<real>& getBasisArrayInternalFluxCSRVal(const int dim) const
    {
        return _ups2csr_val[dim];
    }
 
    const std::vector<int>& getBasisArrayInternalFluxCSRCol(const int dim) const
    {
        return _ups2csr_col[dim];
    }
 
    const std::vector<int>& getBasisArrayInternalFluxCSRRowPtr(const int dim) const
    {
        return _ups2csr_rowptr[dim];
    }
 
    // Derivative Matrix
    const std::vector<real>& getBasisArrayDerivativeMatrixCSRVal(const int dim) const
    {
        return _Drcsr_val[dim];
    }
 
    const std::vector<int>& getBasisArrayDerivativeMatrixCSRCol(const int dim) const
    {
        return _Drcsr_col[dim];
    }
 
    const std::vector<int>& getBasisArrayDerivativeCSRRowPtr(const int dim) const
    {
        return _Drcsr_rowptr[dim];
    }
 
    // Numerical Flux Matrix
    const std::vector<real>& getBasisArrayNumericalFluxCSRVal(const int face) const
    {
        return _ups1csr_val[face];
    }
 
    const std::vector<int>& getBasisArrayNumericalFluxCSRCol(const int face) const
    {
        return _ups1csr_col[face];
    }
 
    const std::vector<int>& getBasisArrayNumericalFluxCSRRowPtr(const int face) const
    {
        return _ups1csr_rowptr[face];
    }
 
protected:
    void clear();
 
    int _two_num_flux_arrays_flag;
 
    // Convention here is that unstructured (simplex) parts have original names
    // and the structured parts (squares, for velocity space) have "Squares" after name
    int _numFacesPerElement;
    int _numFacesPerElementSquares;
    int _numFaceNodes;
    int _numFaceNodesSquares;
    int _numTotalFaceNodes;
    int _numTotalFaceNodesDeduplicated;
    int _numInternalNodes;
    int _numTotalNodes;
    int _numGaussQuadNodes;
    int _numDims;         // Actual dimensionality of elements
    int _numDimsUnstruct; // Number of unstructured dimensions (only specified in mixed
                          // case)
    int _numOrientations;
    int _spatialOrder;
    int _numInteriorPositivityPreservingQuadNodes;
 
    real _vol_multiplier;
 
    // Sub element deconstruction of basis
    int _numSubElements;
    int _numNodesPerSubElement;
    std::vector<int> _subElementConnectivity;
 
    int _basisArray_NumericalFlux_Size;
    int _basisArray_NumericalFlux_altFace_Size;
    int _basisArray_InternalFlux_Size;
    int _basisArray_LinearAverage_Size;
    int _basisArray_LinearCenter_Size;
    int _basisArray_MonomialConversion_Size;
    int _basisArray_Derivative_Approximation_Size;
 
    real _cfl;
 
    // Used of faces can be different i.e. phase space element where not all the faces are
    // the same
    int _num_face_types;
    // sets the number of faces for each face type
    std::vector<int> _num_faces_per_face_type;
    std::vector<int> _num_face_nodes_per_face_type;
    std::vector<int> _num_face_nodes_per_face;
    std::vector<int> _faceNodesDeduplicated;
 
    std::vector<real> _nodePositionsGaussQuad;
    std::vector<real> _basisArray_GaussQuad;
    std::vector<real> _basisArray_LagrangeOnGQnodes;
 
    std::vector<real> _nodePositions;
    std::vector<real> _basisArray_NumericalFlux;
    std::vector<real> _basisArray_NumericalFlux_altFace; // Alternate num. flux for
                                                         // structured velocity space
    std::vector<real> _basisArray_InternalFlux;
    std::vector<real> _basisArray_LinearAverage;
    std::vector<real> _basisArray_LinearCenter;
    std::vector<real> _basisArray_MonomialConversion;
    std::vector<real> _basisArray_OrthogonalToCollocation;
    std::vector<real> _basisArray_CollocationToOrthogonal;
    std::vector<std::function<real(const std::array<real, 3>&)>> _monomial_functions;
    std::vector<real> _basisArray_Derivative_Approximation;
    // Vector of quadrature weights for integrating a function along
    // the face. The node ordering coincides with the ordering used
    // in _faceNodes.
    std::vector<real> _basisArray_faceQuadratureWeights;
 
    std::vector<real> _basisArray_evaluateAtInteriorPositivityPreservingQuadNodes;
 
    std::vector<std::vector<int>> _orientations;
    std::vector<std::vector<int>> _faceNodes;
 
    // csr data
    bool _has_csr;
    // ups2
    std::vector<int> _ups2csr_val_lengths;
    std::vector<std::vector<real>> _ups2csr_val;
    std::vector<std::vector<int>> _ups2csr_col;
    std::vector<std::vector<int>> _ups2csr_rowptr;
    // Dr
    std::vector<int> _Drcsr_val_lengths;
    std::vector<std::vector<real>> _Drcsr_val;
    std::vector<std::vector<int>> _Drcsr_col;
    std::vector<std::vector<int>> _Drcsr_rowptr;
    // ups1
    std::vector<int> _ups1csr_val_lengths;
    std::vector<std::vector<real>> _ups1csr_val;
    std::vector<std::vector<int>> _ups1csr_col;
    std::vector<std::vector<int>> _ups1csr_rowptr;
 
private:
};
 
#endif // WMBASISARRAYSET_H