wmunstructuredgeometry.h

Go to the documentation of this file.

 
#ifndef WMUNSTRUCTUREDGEOMETRY_H_
#define WMUNSTRUCTUREDGEOMETRY_H_
 
// STD includes
#include <iostream>
#include <map>
#include <vector>
#include <typeinfo>
 
#include <cmath> // a lot of stuff inherited needs this?
 
// Wm includes
#include "lib/wmunstructuredpatch.h"
#include "warpxm/warpxm_config.h"
 
enum
{
    WMPRIMITIVE_LINE = 9, // this line goes from (-1,1) in isoparametric space => should
                          // not be used anymore
    WMPRIMITIVE_01_LINE = 0, // this line goes from (0,1) in isoparametric space
    WMPRIMITIVE_TRIANGLE = 1,
    WMPRIMITIVE_QUADRILATERAL = 2,
    WMPRIMITIVE_TETRAHEDRON = 3,
    WMPRIMITIVE_HEXAHEDRON = 4,
    WMPRIMITIVE_POINT = 5,
    // Mixed structured/unstructured types
    WMPRIMITIVE_KINETIC_SQUARE = 6,
    WMPRIMITIVE_3DPRISM = 7,
    WMPRIMITIVE_4DPRISM = 8,
    WMPRIMITIVE_NONE = -1
};
 
class WmUnstructuredGeometry
{
public:
    typedef std::pair<std::string, std::vector<int>> nodeGroupPair_t;
    typedef std::map<std::string, std::vector<int>> nodeGroupMap_t;
 
    WmUnstructuredGeometry(const WmUnstructuredPatch& patch);
 
    ~WmUnstructuredGeometry();
 
    void generateGeometry(real* coordinates,
                          int* connectivity,
                          int* neighborhood,
                          int* orientations);
 
    void addNodeGroup(const std::string name, const std::vector<int>& nodeIndexes);
 
    const real* getCoordinates() const
    {
        return _coordinates;
    }
 
    const int* getConnectivity() const
    {
        return _connectivity;
    }
 
    const int* getNeighborhood() const
    {
        return _neighborhood;
    }
 
    const int* getOrientations() const
    {
        return _orientations;
    }
 
    std::string getNodeGroupOfNodes(const std::vector<int>& nodes) const;
 
    int getFaceOrientation(const int elementIndex, const int faceIndex) const
    {
        return _orientations[elementIndex * _numFacesPerElement + faceIndex];
    }
 
    real getVolume(const int elementIndex) const
    {
        return _volumes[elementIndex];
    }
 
    real getArea(const int elementIndex, const int faceIndex) const
    {
        return _areas[elementIndex * _numFacesPerElement + faceIndex];
    }
 
    real getElementWidth(const int elementIndex) const;
 
    const int* getLocalNeighborhood(const int elementIndex) const
    {
        return _neighborhood + elementIndex * _numFacesPerElement;
    }
 
    const std::type_info& getType() const
    {
        return typeid(real);
    }
 
    int getPrimitiveID() const
    {
        return _primitiveID;
    }
 
    int getFacePrimitiveID() const;
 
    const real* getCentroid(const int elementIndex) const
    {
        return _centroids + 3 * elementIndex;
    }
 
    const real*
    getNorm(const int elementIndex, const int faceIndex, const int normType) const
    {
        return _norms +
               ((elementIndex * _numFacesPerElement + faceIndex) * 3 + normType) * 3;
    }
 
    int getNumElements() const
    {
        return _numElements;
    }
 
    int getNumNodes() const
    {
        return _numNodes;
    }
 
    int getNumDimsPerNode() const
    {
        return _numDimsPerNode;
    }
 
    int getNumDimsPerPrimitive() const
    {
        return _numDimsPerPrimitive;
    }
 
    int getNumNodesPerFace() const
    {
        return _numNodesPerFace;
    }
 
    int getNumNodesPerElement() const
    {
        return _numNodesPerElement;
    }
 
    int getNumFacesPerElement() const
    {
        return _numFacesPerElement;
    }
 
    void getFaceNodes(const int elementIndex, const int faceIndex, int* faceNodes) const;
 
    void getNodePositions(const int elementIndex, real* nodePositions) const;
 
    int getNumTransformCoordinates() const
    {
        return _numTransformCoordinates;
    }
 
    void getTransformCoordinates(const int elementIndex, real tC[][3]) const;
 
    static int getNumTransformCoordinates(const int primitiveID);
 
    static void getTransformCoordinates(const int primitiveID,
                                        const real* nodePositions,
                                        real tC[]);
 
    void getPositionInElement(const int elementIndex,
                              const real normalizedPosition[3],
                              real position[3]) const;
 
    int getJumpedElementIndex(const int elementIndex,
                              const int neighborElementIndex,
                              const int numJumps) const;
 
    int getOppositeFace(const int faceIndex) const;
 
    int getFaceIndex(const int elementIndex, const int neighborElementIndex) const;
 
    real generateVolumeJacobian(const int elementIndex,
                                const real normalizedPosition[3]) const;
 
    void generateInverseJacobian(const int elementIndex,
                                 const real* normalizedPosition,
                                 real* inverseJacobian) const;
 
    void getCentralPositionInElement(const int elementIndex,
                                     const real normalizedPosition[3],
                                     real position[3]) const;
 
    void getFaceDistanceBetweenNeighborCentroids(const int fromElementIndex,
                                                 const int toElementIndex,
                                                 real dx[3]) const;
 
    void
    get_face_centroid(const int element_index, const int face_index, real x[3]) const;
 
    bool isEnclosedByElement(const int elementIndex, const real* x) const;
 
    int getEnclosingElementIndex(const real* x) const;
 
    void printElement(const int elementIndex) const;
 
    int num_boundary_faces() const
    {
        return _num_boundary_faces;
    }
 
    void reflect_centroid(const int element_index,
                          const int face_index,
                          real reflected_centroid[3]) const;
 
protected:
    const WmUnstructuredPatch& _patch;
 
    std::string _primitive;
 
    int _primitiveID;
 
    int _numElements;
 
    int _numNodes;
 
    int* _connectivity;
 
    int* _neighborhood;
 
    int* _orientations;
 
    real* _coordinates;
 
    real* _transformCoordinates;
 
    real* _centroids;
 
    real* _norms;
 
    real* _volumes;
 
    real* _areas;
 
    nodeGroupMap_t _nodeGroups;
 
    int _num_boundary_faces;
 
    int _numDimsPerNode;
 
    int _numDimsPerPrimitive;
 
    int _numTransformCoordinates;
 
    int _numNodesPerElement;
 
    int _numFacesPerElement;
 
    int _numNodesPerFace;
 
private:
};
 
#endif /* WMUNSTRUCTUREDGEOMETRY_H_ */