wmunstructuredarray.h

Go to the documentation of this file.

/*
 * wmunstructuredarray.h
 *
 *  Created on: Feb 23, 2012
 *      Author: smiller
 */
 
#ifndef WMUNSTRUCTUREDARRAY_H_
#define WMUNSTRUCTUREDARRAY_H_
 
// STD includes
#include <iostream>
#include <map>
#include <vector>
#include <typeinfo>
#include <limits>
 
// Wx includes
#include "lib/wxlogger.h"
#include "lib/wxlogstream.h"
#include "lib/wxany.h"
 
// Wm includes
#include "solver/wmsolver.h"
#include "variables/wmvariable.h"
#include "variables/wmunstructuredsubdomainarray.h"
#include "variables/wmunstructuredpatcharray.h"
 
class WxIoBase;
// class WxIoNodeType;
class WmUnstructuredSubdomainArrayBase;
class localTransfer_t;
class sendRemoteTransfer_t;
class recvRemoteTransfer_t;
 
class WmUnstructuredArray :
    // public WmVariable,
    public WmDistributedVariable
{
 
public:
    WmUnstructuredArray(const WmConstOpaquePtr& parentPointer);
 
    ~WmUnstructuredArray();
 
    virtual void setup(const WxCryptSet& wxc);
 
    virtual WmTypeOpaqueArray<_WX_ROW_MAJOR_ORDER>&
    accessLocalArray(const unsigned int component, const std::string& subdomainName);
 
    virtual const WmTypeOpaqueArray<_WX_ROW_MAJOR_ORDER>&
    accessLocalArrayReadOnly(const unsigned int component,
                             const std::string& subdomainName) const;
 
    virtual WmTypeOpaqueArray<_WX_ROW_MAJOR_ORDER>&
    accessPatchArray(const unsigned int component, int patchIndex);
 
    virtual const WmTypeOpaqueArray<_WX_ROW_MAJOR_ORDER>&
    accessPatchArrayReadOnly(const unsigned int component, int patchIndex) const;
 
    unsigned getNumGhostCells()
    {
        return 0;
    }
 
    virtual void updateGhosts_register(const int key);
 
    virtual void updateGhosts_nb(const int key);
 
    virtual void updateGhosts_wait(const int key);
 
    virtual void updatePatchGhosts(const int patchIndex);
 
    virtual void updateGhosts();
 
    virtual void
        updateGhostsComponents(/* TODO: std::vector<some new type> componentList */)
    {
        throw WxExcept("WmUnstructuredArray::updateGhostsComponents: Not implemented for "
                       "unstructured arrays");
    }
 
    virtual void fill(const std::vector<WxAny>& fillVector);
    virtual void fill(const std::map<std::string, WxAny>& fillMap);
 
    bool is_alloc() const;
 
    // virtual const std::type_info & getElementTypeForComponent(const std::string &
    // componentName) const;
 
    virtual const std::type_info&
    getElementTypeForComponent(unsigned int componentIndex) const;
 
    virtual void dump(WxIoBase& io, WxIoNodeType& grpNode) const;
 
    virtual void load(WxIoBase& io, const WxIoNodeType& grpNode);
 
    const WxAny min(const int componentIndex) const;
 
    const WxAny absoluteMin(const int componentIndex) const;
 
    void uploadInternalElementsToBuffers();
 
    void downloadInternalElementsFromBuffers();
 
    const std::vector<std::string>& getSubdomainNames() const
    {
        return _onSubdomains;
    }
 
    bool onSubdomain(const std::string& subdomainName) const;
 
    template<typename T>
    const WmUnstructuredPatchArray<T>& getPatchArray(const int componentIndex,
                                                     const int patchIndex) const
    {
        // The WmUnstructuredSubdomainArray class makes this a pain...
 
        const subdomainArrayMap_t& sam = (*_componentArrays)[componentIndex];
        for (subdomainArrayMap_t::const_iterator itr0 = sam.begin(); itr0 != sam.end();
             itr0++)
        {
            const WmUnstructuredSubdomainArray<T>& usa =
                dynamic_cast<const WmUnstructuredSubdomainArray<T>&>(*(itr0->second));
            if (usa.hasPatch(patchIndex))
            {
                return usa.getPatchArray(patchIndex);
            }
        }
        throw WxExcept(
            "WmUnstructuredArray::getPatchArray : Patch does not exist for component.\n");
    }
 
protected:
    //    void gather();
 
    std::vector<std::string> _onSubdomains; // list of subdomains on which variable exists
                                            // unsigned _numGhostLevels;
 
    typedef std::vector<localTransfer_t*> localTransferList_t;
    typedef std::map<int, sendRemoteTransfer_t*> sendMap_t;
    typedef std::map<int, recvRemoteTransfer_t*> recvMap_t;
 
    localTransferList_t _localTransfers;
    sendMap_t _sendTransfers;
    recvMap_t _recvTransfers;
 
    int _numPatchesSignedIn;
    std::vector<int> _localPatchIndexes;
 
    struct syncRegistry_t
    {
 
        syncRegistry_t() : _key(-1), _numRegistered(0), _numCalledIn(0)
        {
        }
 
        syncRegistry_t(const syncRegistry_t& other)
        {
            _key = other._key;
            _numCalledIn = other._numCalledIn;
            _numRegistered = other._numRegistered;
        }
 
        int _key;
        int _numRegistered;
        int _numCalledIn;
    };
 
    typedef std::map<int, syncRegistry_t> rsyncMap_t;
    rsyncMap_t _rsync;
 
    struct SwapImpl : WmVariable::SwapImpl
    {
        virtual void swap_impl(WmVariable& varA, WmVariable& varB) const;
 
        virtual bool checkCompatible_impl(const WmVariable& varA,
                                          const WmVariable& varB) const;
    };
 
    void synchronizeArrays();
 
private:
    WmUnstructuredArray& operator=(const WmUnstructuredArray& arr);
    WmUnstructuredArray(const WmUnstructuredArray& arr);
 
    typedef WmUnstructuredSubdomainArrayBase*
        globalArray_t; // Component Arrays are global Arrays
    typedef std::pair<std::string, globalArray_t> subdomainArrayPair_t;
    typedef std::map<std::string, globalArray_t> subdomainArrayMap_t;
    typedef std::vector<subdomainArrayMap_t>
        componentVector_t; // Each Variable has a set of components
    componentVector_t* _componentArrays;
};
 
#endif /* WMUNSTRUCTUREDARRAY_H_ */