/home/brandes/workspace/LAMA/src/lama/distribution/Halo.hpp

Go to the documentation of this file.

#ifndef LAMA_HALO_HPP_
#define LAMA_HALO_HPP_

// for dll_import
#include <lama/config.hpp>

// base classes
#include <lama/Printable.hpp>

// others
#include <lama/LAMAArray.hpp>
#include <lama/CommunicationPlan.hpp>

#include <lama/exception/LAMAAssert.hpp>

#include <map>

namespace lama
{

class LAMA_DLL_IMPORTEXPORT Halo : public Printable
{
    friend class HaloBuilder;

public:

    Halo();

    Halo( const Halo& halo );

    virtual ~Halo();

    void clear();

    Halo& operator=( const Halo& other );

    inline const CommunicationPlan& getRequiredPlan() const;

    inline const CommunicationPlan& getProvidesPlan() const;

    inline IndexType global2halo(const IndexType globalIndex) const;

    inline const LAMAArray<IndexType>& getProvidesIndexes() const;

    inline const LAMAArray<IndexType>& getRequiredIndexes() const;

    inline IndexType getHaloSize() const;

    inline bool isEmpty() const;

    inline const std::map<IndexType, IndexType>& getMap() const { return mGlobal2Halo; }

    virtual void writeAt( std::ostream& stream ) const;

protected:

    inline void setGlobal2Halo(IndexType globalIndex, IndexType haloIndex);

private:

    CommunicationPlan mRequiredPlan;
    CommunicationPlan mProvidesPlan;

    // Indexes for required values and values to provide are stored in LAMAArrays
    // so they might be used in different contexts, especially also on GPU 

    LAMAArray<IndexType> mRequiredIndexes;
    LAMAArray<IndexType> mProvidesIndexes;

    std::map<IndexType, IndexType> mGlobal2Halo;

    LAMA_LOG_DECL_STATIC_LOGGER(logger);
};

const CommunicationPlan& Halo::getRequiredPlan() const
{
    return mRequiredPlan;
}

const CommunicationPlan& Halo::getProvidesPlan() const
{
    return mProvidesPlan;
}

const LAMAArray<IndexType>& Halo::getProvidesIndexes() const
{
    return mProvidesIndexes;
}

const LAMAArray<IndexType>& Halo::getRequiredIndexes() const
{
    return mRequiredIndexes;
}

void Halo::setGlobal2Halo(IndexType globalIndex, IndexType haloIndex)
{
    LAMA_ASSERT_DEBUG( 0 <= haloIndex && haloIndex < getHaloSize(),
           "illegal halo index " << haloIndex << ", halo size = " << getHaloSize());
    mGlobal2Halo[globalIndex] = haloIndex;
}

IndexType Halo::global2halo(const IndexType globalIndex) const
{
    const std::map<IndexType, IndexType>::const_iterator elem = mGlobal2Halo.find(globalIndex);

    if (elem == mGlobal2Halo.end())
    {
        return nIndex;
    }

    return elem->second;
}

IndexType Halo::getHaloSize() const
{
    return mRequiredPlan.totalQuantity();
}

bool Halo::isEmpty() const
{
    return ( mRequiredPlan.totalQuantity() == 0 ) && ( mProvidesPlan.totalQuantity() == 0 );
}

}

#endif // LAMA_HALO_HPP_