wmunstructuredsubdomainarray.h

Go to the documentation of this file.

#ifndef __WmUnstructuredSubdomainArray__h__
#define __WmUnstructuredSubdomainArray__h__
 
#include <limits>
//#include <ga.h>
//#include <macdecls.h>
#include <mpi.h>
#include <algorithm>
 
// WarpM includes
#include "lib/wmdomain.h"
#include "lib/wxany.h"
#include "lib/wxmsgbase.h"
#include "variables/wmvariable.h"
#include "lib/wxrange.h"
#include "basis/wmbasisarrayset.h"
 
// forward declarations
template<typename T> class WmUnstructuredPatchArray;
class WmSolverBase;
 
class WmUnstructuredSubdomainArrayBase
{
public:
    virtual ~WmUnstructuredSubdomainArrayBase()
    {
    }
 
    // Shared for structured and unstructured
 
    virtual const WxAny min() const = 0;
 
    virtual const WxAny absoluteMin() const = 0;
 
    virtual void fill(const WxAny& fillValue) = 0;
 
    virtual void fill(const std::vector<WxAny>& fillValuesVector) = 0;
 
    virtual void
    dump(WxIoBase& io, WxIoNodeType& grpNode, bool writeGhostCellsToo = false) const = 0;
 
    virtual void
    load(WxIoBase& io, const WxIoNodeType& grpNode, bool loadGhostCellsToo) = 0;
 
    virtual bool checkCompatible(const WmUnstructuredSubdomainArrayBase& other) const = 0;
 
    virtual const std::type_info& getElementType() const = 0;
 
    virtual void uploadInternalElementsToBuffers() = 0;
    virtual void downloadInternalElementsFromBuffers() const = 0;
    virtual void downloadImportExportElementsFromBuffers() const = 0;
    virtual void uploadImportElementsToBuffers() = 0;
 
    virtual WmTypeOpaqueArray<_WX_ROW_MAJOR_ORDER>* getPatchArrayData(int patchIndex)
    {
        return NULL;
    }
    virtual const WmTypeOpaqueArray<_WX_ROW_MAJOR_ORDER>*
    getPatchArrayData(int patchIndex) const
    {
        return NULL;
    }
 
    virtual void print() const = 0;
 
protected:
private:
};
 
template<typename T>
class WmUnstructuredSubdomainArray : public WmUnstructuredSubdomainArrayBase
{
 
public:
    typedef typename std::map<int, WmUnstructuredPatchArray<T>*> patchArrays_t;
 
    WmUnstructuredSubdomainArray(const std::string& arrayName,
                                 std::string& variableName,
                                 int componentIndex,
                                 int numSubComponents,
                                 std::string& subdomainName,
                                 const WmDomain& domain,
                                 const std::string& basisArraySetName = "");
 
    ~WmUnstructuredSubdomainArray();
 
    bool hasPatch(const int patchIndex) const;
 
    void fill(const WxAny& fillValue);
 
    void fill(const std::vector<WxAny>& fillValuesVector);
 
    virtual bool checkCompatible(const WmUnstructuredSubdomainArrayBase& other) const;
 
    virtual const std::type_info& getElementType() const;
 
    virtual void
    dump(WxIoBase& io, WxIoNodeType& grpNode, bool writeGhostCellsToo = false) const;
 
    virtual void load(WxIoBase& io, const WxIoNodeType& grpNode, bool includeGhosts);
 
    virtual WmUnstructuredPatchArray<T>& getPatchArray(int patchIndex);
 
    virtual const WmUnstructuredPatchArray<T>& getPatchArray(int patchIndex) const;
 
    virtual WmTypeOpaqueArray<_WX_ROW_MAJOR_ORDER>* getPatchArrayData(int patchIndex);
 
    virtual const WmTypeOpaqueArray<_WX_ROW_MAJOR_ORDER>*
    getPatchArrayData(int patchIndex) const;
 
    const WxAny min() const;
 
    const WxAny absoluteMin() const;
 
    void print() const;
 
protected:
    // Protected variables
 
    bool _gatherListSet;
 
    // Ranges of dataset
    unsigned _ndims;
    WxRange _globalRange;
 
    // Parents
    const WmSolverBase* _parentSolver;
 
    // Global array identities
    std::string _arrayName;
    std::string _variableName;
    int _componentIndex;
    std::string _subdomainName;
 
    // Number of subcomponents per element
    WmBasisArraySet _basisSet;
    int _numSubComponents;
 
    // Is there a local portion to this global array
    bool _existsOnProcess;
 
    // Patch array allocations
    patchArrays_t _patchArrays;
 
    // Mesh id
    int _meshID;
 
private:
    // Default constructor blocked.
    WmUnstructuredSubdomainArray();
 
    // Default copy constructor blocked.
    WmUnstructuredSubdomainArray(const WmUnstructuredSubdomainArray<T>& f);
 
    // Default equate blocked.
    WmUnstructuredSubdomainArray<T>& operator=(const WmUnstructuredSubdomainArray<T>& f);
};
 
#endif //  __WmUnstructuredSubdomainArray__h__