wmquadraturesystem.h

Go to the documentation of this file.

 
#ifndef WMQUADRATURESYSTEM_H_
#define WMQUADRATURESYSTEM_H_
 
// STD includes
#include <iostream>
#include <iomanip>
#include <vector>
#include <numeric>
 
// WarpX includes
#include "lib/wxlogger.h"
#include "lib/wxlogstream.h"
 
template<typename T> class WmQuadratureSystem
{
public:
    WmQuadratureSystem(); // const unsigned numQuadPoints);
 
    ~WmQuadratureSystem();
 
    //  void generateQuadraturePoints();
    static void generateQuadraturePoints(int numPoints, T* weights, T* points);
 
    //  // returns the weight (includes Jacobian determinant) - works for 1D, 2D, and 3D
    //  T getQuadraturePosition(const std::vector<std::vector<T> > & nodePositions, const
    //T * centroid, const int * indices, const unsigned integralType, T * quadPosition);
    //  void getQuadratureComponents(const std::vector<std::vector<T> > & nodePositions,
    //const T * A, const unsigned integralType, std::vector<std::vector<T> > &
    //quadPositions, std::vector<T> & quadModifiers);
 
    //    static void generateQuadratureSystem(int primitiveID, const
    //    std::vector<std::vector<T> > & nodePositions, std::vector<std::vector<T> > &
    //    quadratureSystem); static void generateQuadratureJacobian(int primitiveID, const
    //    std::vector<std::vector<T> > & quadratureSystem, std::vector<T> &
    //    quadratureJacobian);
 
    // This is a modification I'm going to try out for triangles and tetrahedra
    // nodePositions[3*_numNodesPerElement]
    // weights[_numQuadPoints]
    // positions[3*_numQuadPoints]
    static int getNumQuadraturePoints(const int primitiveID, const int polynomialOrder);
    static void generateQuadratureSystem(const int primitiveID,
                                         const int polynomialOrder,
                                         const T* nodePositions,
                                         T* weights,
                                         T* positions);
    static void generateNormalizedQuadratureSystem(const int primitiveID,
                                                   const int polynomialOrder,
                                                   T* weights,
                                                   T* positions);
 
    //  unsigned getNumQuadraturePoints(){return _numQuadPoints;}
 
    //  std::string getQuadratureString();
 
    //    T getQuadraturePoint(unsigned i) const;
    //    T getQuadratureWeight(unsigned i) const;
 
protected:
    //  std::vector<T> _quadPoints;
    //  std::vector<T> _quadWeights;
 
    //  unsigned _numQuadPoints;
 
    // Triangles and Tetrahedra are a bit more complicated
    // We will use a symmetric simplex quadrature system for that
 
private:
};
 
extern template class WmQuadratureSystem<real>;
 
#endif // WMQUADRATURESYSTEM_H_