MimmoPiercedVector.tpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  mimmo is distributed in the hope that it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
template< typename T>
mimmo::IBinaryStream& operator>>(mimmo::IBinaryStream &buffer, mimmo::MimmoPiercedVector<T>& element){
 
    element.clear();
    mimmo::MimmoSharedPointer<mimmo::MimmoObject> geo;
    buffer >> geo;
    element.setGeometry(geo);
    std::string name;
    buffer>>name;
    element.setName(name);
 
    int loc_;
    buffer >> loc_;
    element.setDataLocation(static_cast<mimmo::MPVLocation>(loc_));
 
    std::size_t nP;
    buffer >> nP;
 
    T val;
    long int id;
    for (std::size_t i = 0; i < nP; ++i) {
        buffer >> id;
        buffer >> val;
        element.insert(id, val);
    }
    return buffer;
};
 
template<typename T>
mimmo::OBinaryStream& operator<<(mimmo::OBinaryStream &buffer, const mimmo::MimmoPiercedVector<T>& element){
 
    buffer << element.getGeometry();
 
    std::string name = element.getName();
    buffer << name;
    buffer << static_cast<int>(element.getConstDataLocation());
    buffer << (std::size_t)element.size();
    auto itE = element.cend();
    for (auto it=element.cbegin(); it!=itE; it++){
        buffer << it.getId();
        buffer << *it;
    }
    return buffer;
};
 
 
namespace mimmo{
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t>::MimmoPiercedVector(MimmoSharedPointer<MimmoObject> geo, MPVLocation loc):bitpit::PiercedVector<mpv_t,long int>(){
    m_geometry = geo;
    m_loc = loc;
    m_log = &bitpit::log::cout(MIMMO_LOG_FILE);
    m_name = "data";
}
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t>::~MimmoPiercedVector(){}
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t>::MimmoPiercedVector(const MimmoPiercedVector<mpv_t> & other):bitpit::PiercedVector<mpv_t,long int>(other){
    this->m_geometry = other.m_geometry;
    this->m_loc = other.m_loc;
    this->m_name = other.m_name;
    m_log = &bitpit::log::cout(MIMMO_LOG_FILE);
};
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t> & MimmoPiercedVector<mpv_t>::operator =(MimmoPiercedVector<mpv_t> other){
    this->swap(other);
    return *this;
};
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t> & MimmoPiercedVector<mpv_t>::operator =(bitpit::PiercedVector<mpv_t, long int> other){
 
    this->bitpit::PiercedVector<mpv_t, long int>::swap(other);
    return *this;
};
 
template<typename mpv_t>
void MimmoPiercedVector<mpv_t>::swap(MimmoPiercedVector<mpv_t> & x) noexcept
{
    std::swap(this->m_geometry, x.m_geometry);
    std::swap(this->m_loc, x.m_loc);
    this->m_name.swap(x.m_name);
    this->bitpit::PiercedVector<mpv_t, long int>::swap(x);
}
 
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::clear(){
    m_geometry = nullptr;
    m_name = "data";
    m_loc = MPVLocation::UNDEFINED;
    bitpit::PiercedVector<mpv_t, long int>::clear();
}
 
template<typename mpv_t>
MimmoSharedPointer<MimmoObject>
MimmoPiercedVector<mpv_t>::getGeometry() const{
    return m_geometry;
}
 
template<typename mpv_t>
MPVLocation
MimmoPiercedVector<mpv_t>::getConstDataLocation() const{
    return m_loc;
}
 
template<typename mpv_t>
MPVLocation
MimmoPiercedVector<mpv_t>::getDataLocation(){
    return m_loc;
}
 
template<typename mpv_t>
std::string
MimmoPiercedVector<mpv_t>::getName() const{
    return m_name;
}
 
template<typename mpv_t>
std::vector<mpv_t>
MimmoPiercedVector<mpv_t>::getDataAsVector(bool ordered){
    if(getGeometry() == nullptr) return std::vector<mpv_t>();
    livector1D ids = getGeometryIds(ordered);
    std::vector<mpv_t> result;
    result.reserve(this->size());
    for(long id : ids){
        if(this->exists(id)){
            result.push_back(this->at(id));
        }
    }
    result.shrink_to_fit();
    return result;
}
 
template<typename mpv_t>
std::vector<mpv_t>
MimmoPiercedVector<mpv_t>::getInternalDataAsVector(bool ordered, bool squeeze){
    if(getGeometry() == nullptr) return std::vector<mpv_t>(0);
    std::vector<mpv_t> result;
    livector1D ids;
    std::unordered_set<long> ids_;
    switch (getDataLocation())
    {
    case MPVLocation::CELL:
        result.reserve(getGeometry()->getPatch()->getInternalCellCount());
        ids = getGeometryIds(ordered);
        for(const auto val: ids){
            if(this->exists(val) && getGeometry()->getPatch()->getCell(val).isInterior()){
                result.push_back((*this)[val]);
            }
        }
        break;
    case MPVLocation::POINT:
        result.reserve(getGeometry()->getPatch()->getVertexCount());
        for (auto & cell : getGeometry()->getCells()){
            if (cell.isInterior()){
                for (long id : cell.getVertexIds())
                    ids_.insert(id);
            }
        }
        ids = getGeometryIds(ordered);
        for(const auto val: ids){
            if(this->exists(val) && ids_.count(val)){
                result.push_back((*this)[val]);
            }
        }
        break;
    case MPVLocation::INTERFACE:
        result.reserve(getGeometry()->getPatch()->getInterfaceCount());
        //Interfaces ghost/ghost are not stored in bitpit::PathcKernel, so use all the interfaces in the geometry
        ids = getGeometryIds(ordered);
        for(const auto val: ids){
            if(this->exists(val)){
                result.push_back((*this)[val]);
            }
        }
        break;
    default:
        break;
    }
    if (squeeze)
        result.shrink_to_fit();
    return result;
}
 
template<typename mpv_t>
std::vector<mpv_t>
MimmoPiercedVector<mpv_t>::getRawDataAsVector(bool ordered){
    livector1D ids = this->getIds(ordered);
    std::vector<mpv_t> result(this->size());
    int counter= 0;
    for(const auto val: ids){
        result[counter] = (*this)[val];
        ++counter;
    }
    return result;
}
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::setGeometry(MimmoSharedPointer<MimmoObject> geo){
    m_geometry = geo;
}
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::setDataLocation(MPVLocation loc){
    m_loc = loc;
}
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::setDataLocation(int loc){
    loc = std::max(0, loc);
    if (loc > 3) loc =0;
    setDataLocation(static_cast<MPVLocation>(loc));
}
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::setData(std::vector<mpv_t>& data){
    bitpit::PiercedVector<mpv_t, long int>::clear();
    long int  id = 0;
    this->reserve(data.size());
    for(const auto val: data){
        this->insert(id, val);
        id++;
    }
}
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::setName(std::string name){
    m_name = name;
}
 
template<typename mpv_t>
bool
MimmoPiercedVector<mpv_t>::checkDataSizeCoherence(){
    if(getGeometry()==nullptr) return false;
    bool check = false;
    switch(m_loc){
    case MPVLocation::CELL:
        check = (this->size()==m_geometry->getPatch()->getCells().size());
        break;
    case MPVLocation::INTERFACE:
    {
        size_t sizeInterfaces = m_geometry->getPatch()->getInterfaces().size();
        check = (this->size()==sizeInterfaces);
    }
    break;
    case MPVLocation::POINT:
        check = (this->size()==m_geometry->getPatch()->getVertices().size());
        break;
    default:
        check=false;
        (*m_log)<<"NO suitable location data found to perform data size coherence check"<<std::endl;
        break;
    }
    return check;
}
 
template<typename mpv_t>
bool
MimmoPiercedVector<mpv_t>::checkDataIdsCoherence(){
    if(getGeometry()==nullptr) return false;
    if (this->isEmpty()) return true;
    auto ids = this->getIds();
    bool check = true;
    switch(m_loc){
    case MPVLocation::CELL:
    {
        auto vcell = m_geometry->getPatch()->getCells();
        for(auto el : ids){
            check =check && vcell.exists(el);
        }
    }
    break;
    case MPVLocation::INTERFACE:
    {
        auto vint = m_geometry->getPatch()->getInterfaces();
        for(auto el : ids){
            check =check && vint.exists(el);
        }
    }
    break;
    case MPVLocation::POINT:
    {
        auto vvert = m_geometry->getPatch()->getVertices();
        for(auto el = this->begin(); el != this->end(); el++ ){
            check =check && vvert.exists(el.getId());
        }
    }
    break;
    default:
        check = false;
        (*m_log)<<"NO suitable location data found to perform ids coherence check"<<std::endl;
        break;
    }
    return check;
}
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t>
MimmoPiercedVector<mpv_t>::resizeToCoherentDataIds(){
 
    MimmoPiercedVector<mpv_t> result(this->getGeometry(), m_loc);
    if(!this->getGeometry()) return result;
 
    switch(m_loc){
 
    case MPVLocation::CELL:
    {
        bitpit::PiercedVector<bitpit::Cell> & cells = m_geometry->getCells();
        result.reserve(cells.size());
        long id;
        for(auto it=this->begin(); it!=this->end(); ++it){
            id = it.getId();
            if(cells.exists(id)){
                result.insert(id, *it);
            }
        }
    }
    break;
    case MPVLocation::INTERFACE:
    {
        bitpit::PiercedVector<bitpit::Interface> & interfaces = m_geometry->getInterfaces();
        result.reserve(interfaces.size());
        long id;
        for(auto it=this->begin(); it!=this->end(); ++it){
            id = it.getId();
            if(interfaces.exists(id)){
                result.insert(id, *it);
            }
        }
    }
    break;
    case MPVLocation::POINT:
    {
        bitpit::PiercedVector<bitpit::Vertex> & verts = m_geometry->getVertices();
        result.reserve(verts.size());
        long id;
        for(auto it=this->begin(); it!=this->end(); ++it){
            id = it.getId();
            if(verts.exists(id)){
                result.insert(id, *it);
            }
        }
    }
    break;
    default:
        (*m_log)<<"NO suitable location data found to perform ids coherent resizing "<<std::endl;
        break;
    }
    return result;
}
 
 
template<typename mpv_t>
bool
MimmoPiercedVector<mpv_t>::intIsValidLocation(int &value){
    return !(value<0 && value>3) ;
}
 
template<typename mpv_t>
livector1D
MimmoPiercedVector<mpv_t>::getGeometryIds(bool ordered){
    if(getGeometry()==nullptr) return livector1D(0);
    switch(m_loc){
        case MPVLocation::POINT:
            return getGeometry()->getVertices().getIds(ordered);
            break;
        case MPVLocation::CELL:
            return getGeometry()->getCells().getIds(ordered);
            break;
        case MPVLocation::INTERFACE:
            return getGeometry()->getInterfaces().getIds(ordered);
            break;
        default:
            return livector1D(0);
            break;
    }
}
 
template<typename mpv_t>
bool
MimmoPiercedVector<mpv_t>::isEmpty(){
    return this->size() == size_t(0);
}
 
template<typename mpv_t>
bool
MimmoPiercedVector<mpv_t>::completeMissingData(const mpv_t & defValue){
 
    if(!this->checkDataIdsCoherence()) return false;
    if(!this->checkDataSizeCoherence()){
 
        livector1D ids = this->getGeometryIds();
        this->reserve(ids.size());
        for(auto id: ids){
            if(!this->exists(id)) this->insert(id, defValue);
        }
    }
    return true;
}
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::initialize(MimmoSharedPointer<MimmoObject> geo, MPVLocation loc, const mpv_t & data){
 
    switch(loc){
    case MPVLocation::POINT :
        {
            this->clear();
            this->reserve(geo->getNVertices());
            m_geometry = geo;
            m_loc = loc;
            for(const auto & vertex: geo->getVertices()){
                this->insert(vertex.getId(), data);
            }
        }
        break;
    case MPVLocation::CELL :
        {
            this->clear();
            this->reserve(geo->getNCells());
            m_geometry = geo;
            m_loc = loc;
            for(const auto & cell: geo->getCells()){
                this->insert(cell.getId(), data);
            }
        }
        break;
    case MPVLocation::INTERFACE :
        if(geo->getInterfacesSyncStatus() != SyncStatus::SYNC){
            (*m_log)<<"MimmoPiercedVector warning: geometry interfaces are not built"<<std::endl;
        }
        {
            this->clear();
            this->reserve(geo->getPatch()->getInterfaceCount());
            m_geometry = geo;
            m_loc = loc;
            for(const auto & interf: geo->getInterfaces()){
                this->insert(interf.getId(), data);
            }
        }
        break;
    default:
        //do nothing
        break;
    }
}
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t> MimmoPiercedVector<mpv_t>::pointDataToCellData(double p){
    MimmoSharedPointer<MimmoObject> geo = this->getGeometry();
    MimmoPiercedVector<mpv_t> cellData(geo, MPVLocation::CELL);
    MimmoPiercedVector<double> sumWeights(geo, MPVLocation::POINT);
    for (bitpit::Cell & cell : geo->getCells()){
        long idcell = cell.getId();
        std::array<double,3> center = geo->getPatch()->evalCellCentroid(idcell);
        mpv_t data{};
        bool init = false;
        for (long idvertex : cell.getVertexIds()){
            std::array<double,3> point = geo->getPatch()->getVertexCoords(idvertex);
            double weight = 1. / std::pow(norm2(center-point),p);
            if (!init){
                data = this->at(idvertex)*weight;
                sumWeights.insert(idcell, weight);
                init = true;
            }
            else{
                data = data + this->at(idvertex)*weight;
                sumWeights[idcell] = sumWeights[idcell] + weight;
            }
        }
        data = data / sumWeights[idcell];
        cellData.insert(idcell, data);
    }
    return cellData;
};
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t> MimmoPiercedVector<mpv_t>::cellDataToPointData(double p){
    MimmoSharedPointer<MimmoObject> geo = this->getGeometry();
    MimmoPiercedVector<mpv_t> pointData(geo, MPVLocation::POINT);
    MimmoPiercedVector<int> countCells(geo, MPVLocation::POINT);
    MimmoPiercedVector<double> sumWeights(geo, MPVLocation::POINT);
    for (bitpit::Cell & cell : geo->getCells()){
        long idcell = cell.getId();
        if (this->exists(idcell)){
            std::array<double,3> center = geo->getPatch()->evalCellCentroid(idcell);
            for (long idvertex : cell.getVertexIds()){
                std::array<double,3> point = geo->getPatch()->getVertexCoords(idvertex);
                double weight = 1. / std::pow(norm2(center-point),p);
                if (!pointData.exists(idvertex)){
                    pointData.insert(idvertex, this->at(idcell)*weight);
                    sumWeights.insert(idvertex, weight);
                }
                else{
                    pointData[idvertex] = pointData[idvertex] + this->at(idcell)*weight;
                    sumWeights[idvertex] = sumWeights[idvertex] + weight;
                }
            }
        }
    }
    for (bitpit::Vertex & vertex : geo->getVertices()){
        long idvertex = vertex.getId();
        if (pointData.exists(idvertex)){
            pointData[idvertex] = pointData[idvertex] / sumWeights[idvertex];
        }
    }
    return pointData;
};
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t> MimmoPiercedVector<mpv_t>::cellDataToPointData(const MimmoPiercedVector<mpv_t> & cellGradientsX, const MimmoPiercedVector<mpv_t> & cellGradientsY, const MimmoPiercedVector<mpv_t> & cellGradientsZ, bool maximum){
    double p = 3.;
    if (maximum){
        p = 0.;
    }
    MimmoSharedPointer<MimmoObject> geo = this->getGeometry();
    MimmoPiercedVector<mpv_t> pointData(geo, MPVLocation::POINT);
    MimmoPiercedVector<double> sumWeights(geo, MPVLocation::POINT);
    for (bitpit::Cell & cell : geo->getCells()){
        long idcell = cell.getId();
        if (this->exists(idcell)){
            double volume = geo->evalCellVolume(idcell);
            double weight = 1. / std::pow(volume,p);
            std::array<double,3> center = geo->getPatch()->evalCellCentroid(idcell);
            for (long idvertex : cell.getVertexIds()){
                std::array<double,3> point = geo->getPatch()->getVertexCoords(idvertex);
                std::array<mpv_t,3> grad({cellGradientsX.at(idcell), cellGradientsY.at(idcell), cellGradientsZ.at(idcell)});
                mpv_t value;
                value = this->at(idcell) + this->at(idcell)*(grad[0]*(point-center)[0]);
                value = value + this->at(idcell)*(grad[1]*(point-center)[1]);
                value = value + this->at(idcell)*(grad[2]*(point-center)[2]);
                value = value * weight;
                if (!pointData.exists(idvertex)){
                    pointData.insert(idvertex, value);
                    sumWeights.insert(idvertex, weight);
                }
                else{
                    if (maximum){
                        if (norm2(value) > norm2(pointData[idvertex]))
                            pointData[idvertex] = value;
                    }
                    else{
                        pointData[idvertex] = pointData[idvertex] + value;
                        sumWeights[idvertex] = sumWeights[idvertex] + weight;
                    }
                }
            }
        }
    }
    if (!maximum){
        for (bitpit::Vertex & vertex : geo->getVertices()){
            long idvertex = vertex.getId();
            if (pointData.exists(idvertex)){
                pointData[idvertex] = pointData[idvertex] / sumWeights[idvertex];
            }
        }
    }
    return pointData;
};
 
template<typename mpv_t>
MimmoPiercedVector<mpv_t> MimmoPiercedVector<mpv_t>::pointDataToBoundaryInterfaceData(double p){
    MimmoSharedPointer<MimmoObject> geo = this->getGeometry();
    MimmoPiercedVector<mpv_t> interfaceData(geo, MPVLocation::INTERFACE);
    MimmoPiercedVector<double> sumWeights(geo, MPVLocation::POINT);
    for (bitpit::Interface & interface : geo->getInterfaces()){
        //Check if interface is border
        if (interface.isBorder()){
            long idinterface = interface.getId();
            //Check if interface has at least one node presents in mimmo pierced vector point data
            std::size_t found = 0;
            for (long idvertex : interface.getVertexIds()){
                if (this->exists(idvertex))
                    found++;
            }
            if (found == std::size_t(interface.getVertexCount())){
                //Interpolate value
                std::array<double,3> center = geo->getPatch()->evalInterfaceCentroid(idinterface);
                mpv_t data{};
                bool init = false;
                for (long idvertex : interface.getVertexIds()){
                    std::array<double,3> point = geo->getPatch()->getVertexCoords(idvertex);
                    double weight = 1. / std::pow(norm2(center-point),p);
                    if (!init){
                        if (this->exists(idvertex)){
                            data = this->at(idvertex)*weight;
                        }
                        sumWeights.insert(idinterface, weight);
                        init = true;
                    }
                    else{
                        if (this->exists(idvertex)){
                            data = data + this->at(idvertex)*weight;
                        }
                        sumWeights[idinterface] = sumWeights[idinterface] + weight;
                    }
                }
                data = data / sumWeights[idinterface];
                interfaceData.insert(idinterface, data);
            }
        }
    }
    return interfaceData;
};
 
template<typename mpv_t>
std::size_t
MimmoPiercedVector<mpv_t>::getDataFrom(const MimmoPiercedVector<mpv_t> & other, bool strict){
    long id;
    std::size_t counter(0);
    for(auto it= other.begin(); it != other.end(); ++it){
        id = it.getId();
        if(this->exists(id)){
            this->at(id) = *it;
            counter++;
        }else if(!strict){
            this->insert(id, *it);
            counter++;
        }
    }
    return counter;
}
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::squeezeOutExcept(const std::vector<long int> & list, bool keepOrder){
 
    if(keepOrder){
        // erase elements in the list then squeeze the piercedvector.
        std::unordered_set<long> maplist(list.begin(), list.end());
        MimmoPiercedVector<mpv_t> result (m_geometry, m_loc);
        result.setName(m_name);
        result.reserve(maplist.size());
        for(auto it = this->begin(); it != this->end(); ++it){
            if(maplist.count(it.getId()) > 0){
                result.insert(it.getId(), *it);
            }
        }
        this->swap(result);
    }else{
        // if the order does not matter, create a new mpv and swap with the current
        MimmoPiercedVector<mpv_t> result (m_geometry, m_loc);
        result.setName(m_name);
        for(long id: list){
            if(this->exists(id)){
                result.insert(id, this->at(id));
            }
        }
        this->swap(result);
    }
}
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::squeezeOutExcept(const std::unordered_set<long int> & list, bool keepOrder){
 
    if(keepOrder){
        // erase elements in the list then squeeze the piercedvector.
        MimmoPiercedVector<mpv_t> result (m_geometry, m_loc);
        result.setName(m_name);
        result.reserve(list.size());
        for(auto it = this->begin(); it != this->end(); ++it){
            if(list.count(it.getId()) > 0){
                result.insert(it.getId(), *it);
            }
        }
        this->swap(result);
    }else{
        // if the order does not matter, create a new mpv and swap with the current
        MimmoPiercedVector<mpv_t> result (m_geometry, m_loc);
        result.setName(m_name);
        for(long id: list){
            if(this->exists(id)){
                result.insert(id, this->at(id));
            }
        }
        this->swap(result);
    }
}
 
#if MIMMO_ENABLE_MPI
 
template<typename mpv_t>
void
MimmoPiercedVector<mpv_t>::communicateData(){
 
    // If geometry not linked return
    if (getGeometry() == nullptr){
        return;
    }
 
    // Recover geometry
    MimmoSharedPointer<MimmoObject> geometry = getGeometry();
 
    // If geometry not distributed return
    if (!geometry->isDistributed()){
        return;
    }
 
    // The linked geometry has to be updated before to call the communication method
 
    // Instantiate data communicator
    std::unique_ptr<bitpit::DataCommunicator> dataCommunicator(new bitpit::DataCommunicator(geometry->getCommunicator()));
 
    // Set sources and targets lists
    MPVLocation location = getDataLocation();
    std::unordered_map<int, std::vector<long>> sources, targets;
    switch (location){
    case MPVLocation::POINT :
        sources = getGeometry()->getPatch()->getGhostVertexExchangeSources();
        targets = getGeometry()->getPatch()->getGhostVertexExchangeTargets();
        break;
    case MPVLocation::CELL :
        sources = getGeometry()->getPatch()->getGhostCellExchangeSources();
        targets = getGeometry()->getPatch()->getGhostCellExchangeTargets();
        break;
    default :
        break;
    }
 
    // Recover data size
    size_t exchangeDataSize = sizeof(mpv_t);
 
    // Set and start the sends
    for (const auto entry : sources) {
        const int rank = entry.first;
        auto &list = entry.second;
        dataCommunicator->setSend(rank, list.size() * exchangeDataSize);
        bitpit::SendBuffer &buffer = dataCommunicator->getSendBuffer(rank);
        for (long id : list) {
            if (this->count(id)){
                buffer << this->at(id);
            }else{
                // If data id doesn't exist use default constructor value
                buffer << mpv_t();
            }
        }
        dataCommunicator->startSend(rank);
    }
 
    // Discover & start all the receives
    dataCommunicator->discoverRecvs();
    dataCommunicator->startAllRecvs();
 
    // Receive the data of the ghosts
    mpv_t value;
    int nCompletedRecvs = 0;
    while (nCompletedRecvs < dataCommunicator->getRecvCount()) {
        int rank = dataCommunicator->waitAnyRecv();
        const auto &list = targets.at(rank);
        bitpit::RecvBuffer &buffer = dataCommunicator->getRecvBuffer(rank);
        for (long id : list) {
            buffer >> value;
            if (this->count(id)){
                this->at(id) = value;
            }
            else{
                // If element id doesn't exist create it
                this->insert(id, value);
            }
        }
        ++nCompletedRecvs;
    }
 
    // Wait for the sends to finish
    dataCommunicator->waitAllSends();
    dataCommunicator->finalize();
}
#endif
 
}