wmunstructuredpatch.h

Go to the documentation of this file.

#ifndef WMUNSTRUCTURED_PATCH_H
#define WMUNSTRUCTURED_PATCH_H
 
// WarpX includes
#include "wxrange.h"
 
// STD includes
#include <iostream>
#include <map>
#include <typeinfo>
#include <vector>
 
// List of classes found in this library
 
class WmDomain;
class WmUnstructuredPatch;
class WmUnstructuredGeometry;
class WmUnstructuredReconstruction;
class WmUnstructuredPatchLink;
 
class WmUnstructuredPatch
{
public:
    typedef std::pair<int, WmUnstructuredPatchLink*> patchLinkPair_t;
    typedef std::map<int, WmUnstructuredPatchLink*> patchLinkMap_t;
 
    typedef std::pair<int, int> reconstructionID_t;
 
    WmUnstructuredPatch(int patchIndex,
                        const std::string& patchName,
                        int primitiveID,
                        int numLayers,
                        const std::vector<int>& numElementsPerLayer,
                        const std::vector<int>& numNodesPerLayer,
                        const std::string& subdomainName,
                        WmDomain* pDomain);
 
    ~WmUnstructuredPatch();
 
    void setProcID(int num);
    void setGeometry(WmUnstructuredGeometry* pUG)
    {
        _pUG = pUG;
    }
 
    const WmDomain& domain() const
    {
        return *_domain;
    }
 
    void setMeshTranslation(int* mT);
    void setMeshIDs(int previousMeshID, int meshID);
 
    int getPatchIndex() const
    {
        return _patchIndex;
    }
    int getPrimitiveID() const
    {
        return _primitiveID;
    }
    const std::string& getName() const
    {
        return _name;
    }
    int getProcID() const
    {
        return _procID;
    }
    int getNumTotalElements() const
    {
        return _numTotalElements;
    }
    int getNumTotalNodes() const
    {
        return _numTotalNodes;
    }
    int getNumElementsInLayer(int ghostLayer) const;
    int getNumNodesInLayer(int ghostLayer) const;
    int getNumLayers() const
    {
        return _numLayers;
    }
    bool isLocal() const
    {
        return _local;
    }
    const std::string& getSubdomainName() const
    {
        return _subdomainName;
    }
    WmDomain* getDomain() const
    {
        return _domain;
    }
    WmUnstructuredGeometry* getUnstructuredGeometry() const
    {
        return _pUG;
    }
 
    std::map<int, int> getPatchConnectivity() const;
 
    int getMeshID() const
    {
        return _meshID;
    }
    int getPMeshID() const
    {
        return _pMeshID;
    }
 
    void addLink(const std::string& linkedPatchName,
                 int linkedPatchIndex,
                 const std::vector<int>& numElementsPerLayer);
    void
    setLinkedPatch(int linkedPatchIndex, const int* fromIndexes, const int* toIndexes);
    const patchLinkMap_t& getPatchLinks() const
    {
        return _linkedPatches;
    }
    const WmUnstructuredPatchLink& getPatchLink(const WmUnstructuredPatch& patch) const;
 
    int getNumElementsBelowLayer(int layer) const;
 
    int getLayerOfElement(int elementIndex) const;
 
    void setSubdomainRange(const WxRange& range)
    {
        _subdomainRange = range;
    }
    const WxRange& getSubdomainRange() const
    {
        return _subdomainRange;
    }
 
    void setPatchRange(const WxRange& range)
    {
        _patchRange = range;
    }
    const WxRange& getPatchRange() const
    {
        return _patchRange;
    }
 
    const int* getMeshTranslation() const
    {
        return _meshTranslation;
    }
 
protected:
    // General Patch Information
    std::string _name;          // Name of Patch
    int _patchIndex;            // Global index of Patch
    std::string _subdomainName; // Name of Parent Subdomain
    int _primitiveID;  // Primitive ID number of Element (see unstructured geometry)
    WmDomain* _domain; // Parent domain of patch
    bool _local;       // Locality test
    int _procID;       // Processor ID
    int _numLayers;    // Number of layers of elements and nodes
 
    // Patch Parameters
    int* _numElementsPerLayer; // Total Elements of patch specified in layers
    int _numTotalElements;     // This will be called a lot
 
    int _meshID;
    int _pMeshID;
    int* _meshTranslation;
 
    // Node Properties
    int* _numNodesPerLayer; // Total Nodes of patch specified in layers
    int _numTotalNodes;     // This will be called a lot
 
    // Holds geometry
    WmUnstructuredGeometry* _pUG;
 
    // Linked patches
    patchLinkMap_t _linkedPatches;
 
    // Range of patch within subdomain
    WxRange _patchRange;
 
    // Range of subdomain
    WxRange _subdomainRange;
};
 
class WmUnstructuredPatchLink
{
public:
    WmUnstructuredPatchLink(const WmUnstructuredPatch& to_patch,
                            int from_patch_index,
                            const std::string& from_patch_name,
                            const std::vector<int>& num_linked_elements_per_layer);
 
    ~WmUnstructuredPatchLink();
 
    void setLinkedIndexes(const int* fromIndexes, const int* toIndexes);
 
    bool isShared() const
    {
        return _sharedBoundary;
    }
 
    const WmUnstructuredPatch& from_patch() const
    {
        return *_from_patch;
    }
 
    const WmUnstructuredPatch& to_patch() const
    {
        return _to_patch;
    }
 
    const std::vector<int>& from_indexes() const
    {
        return _from_indexes;
    }
 
    const std::vector<int>& to_indexes() const
    {
        return _to_indexes;
    }
 
    const WmUnstructuredPatchLink& inverse() const;
 
    // Old commands - need to remove these
    const std::string& getLinkedSubdomainName() const;
 
    int getNumElements() const
    {
        return _numElements;
    }
    const std::vector<int>& getNumElementsPerLayer() const
    {
        return _numElementsPerLayer;
    }
    const int* getLinkedIndexes() const
    {
        return _from_indexes.data();
    }
    const int* getIndexes() const
    {
        return _to_indexes.data();
    }
 
    const WmUnstructuredPatch* getHostPatch() const
    {
        return &_to_patch;
    }
    const WmUnstructuredPatch* getLinkedPatch() const
    {
        return _from_patch;
    }
 
    int numBoundaryFaces() const
    {
        return _numElementsPerLayer[_from_patch->getNumLayers()];
    }
 
protected:
    const WmUnstructuredPatch& _to_patch;
 
    const WmUnstructuredPatch* _from_patch;
 
    bool _sharedBoundary;
 
    std::string _from_patch_name;
 
    int _from_patch_index;
 
    std::vector<int> _numElementsPerLayer;
 
    int _numElements;
 
    std::vector<int> _from_indexes;
 
    std::vector<int> _to_indexes;
 
private:
    WmUnstructuredPatchLink();
};
 
#endif