adaption.cpp

/*---------------------------------------------------------------------------*\
 *
 *  bitpit
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of bitpit.
 *
 *  bitpit 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.
 *
 *  bitpit 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 bitpit. If not, see <http://www.gnu.org/licenses/>.
 *
\*---------------------------------------------------------------------------*/
 
#include <unordered_map>
#include <unordered_set>
 
#include "patch_kernel.hpp"
 
namespace bitpit {

namespace adaption
{






InfoCollection::InfoCollection()
{
    m_cachedTypes.insert(adaption::TYPE_RENUMBERING);
    m_cachedTypes.insert(adaption::TYPE_DELETION);
    m_cachedTypes.insert(adaption::TYPE_CREATION);
    m_cachedTypes.insert(adaption::TYPE_PARTITION_RECV);
    m_cachedTypes.insert(adaption::TYPE_PARTITION_SEND);
}
 

std::size_t InfoCollection::size() const
{
    return m_collection.size();
}

InfoCollection::iterator InfoCollection::begin() noexcept
{
    return iterator(m_collection.begin());
}

InfoCollection::iterator InfoCollection::end() noexcept
{
    return iterator(m_collection.end());
}

InfoCollection::const_iterator InfoCollection::begin() const noexcept
{
    return const_iterator(cbegin());
}

InfoCollection::const_iterator InfoCollection::end() const noexcept
{
    return const_iterator(cend());
}

InfoCollection::const_iterator InfoCollection::cbegin() const noexcept
{
    return const_iterator(m_collection.cbegin());
}

InfoCollection::const_iterator InfoCollection::cend() const noexcept
{
    return const_iterator(m_collection.cend());
}

const std::vector<Info> & InfoCollection::data() const noexcept
{
    return m_collection;
}

std::vector<Info> & InfoCollection::data() noexcept
{
    return m_collection;
}

std::size_t InfoCollection::insert()
{
    m_collection.emplace_back();
 
    return m_collection.size() - 1;
}

std::size_t InfoCollection::insert(Type type, Entity entity, int rank)
{
    infoData_t infoData = infoData_t(type, entity, rank);
    bool useCache = (m_cachedTypes.count(type) > 0);
 
    if (useCache) {
        if (m_cache.count(infoData) > 0) {
            return m_cache.at(infoData);
        }
    }
 
    m_collection.emplace_back(type, entity, rank);
 
    std::size_t id = m_collection.size() - 1;
    if (useCache) {
        m_cache.insert({{infoData, id}});
    }
    return id;
}

std::size_t InfoCollection::insert(const Info &other)
{
    return insert(Info(other));
}

std::size_t InfoCollection::insert(Info &&other)
{
    std::size_t id = insert(other.type, other.entity, other.rank);
    Info &info = m_collection[id];
 
    if (info.previous.empty()) {
        info.previous = std::move(other.previous);
    } else {
        appendIds(std::move(other.previous), true, &(info.previous));
    }
 
    if (info.current.empty()) {
        info.current = std::move(other.current);
    } else {
        appendIds(std::move(other.current), true, &(info.current));
    }
 
    return id;
}

bool InfoCollection::erase(std::size_t id)
{
    if (id >= size()) {
        return false;
    }
 
    const Info &info = m_collection[id];
    if (m_cachedTypes.count(info.type)) {
        infoData_t infoData = infoData_t(info.type, info.entity, info.rank);
        auto cacheItr = m_cache.find(infoData);
        if (cacheItr != m_cache.end()) {
            m_cache.erase(cacheItr);
        }
    }
 
    m_collection.erase(m_collection.begin() + id);
 
    return true;
}

std::size_t InfoCollection::erase(Type type)
{
    std::size_t nErasedInfo = 0;
 
    std::size_t id = 0;
    while (id < m_collection.size()) {
        const Info &info = at(id);
        if (info.type != type) {
            ++id;
            continue;
        }
 
        erase(id);
        ++nErasedInfo;
    }
 
    return nErasedInfo;
}

Info & InfoCollection::at(std::size_t id)
{
    if (id >= m_collection.size()) {
        throw std::out_of_range("Requested adaption info is not in the collection");
    }
 
    return (*this)[id];
}

const Info & InfoCollection::at(std::size_t id) const
{
    if (id >= m_collection.size()) {
        throw std::out_of_range("Requested adaption info is not in the collection");
    }
 
    return (*this)[id];
}

Info & InfoCollection::operator[](std::size_t id)
{
    return m_collection[id];
}

const Info & InfoCollection::operator[](std::size_t id) const
{
    return m_collection[id];
}

std::vector<Info> InfoCollection::dump()
{
    std::vector<Info> exportedCollection;
    exportedCollection.swap(m_collection);
 
    m_cache.clear();
 
    return exportedCollection;
}

void InfoCollection::appendIds(std::vector<long> src, bool unique, std::vector<long> *dst)
{
    // Early return if the source is empty
    if (src.empty()) {
        return;
    }
 
    // Early return if the destination is empty
    if (dst->empty()) {
        *dst = std::move(src);
        return;
    }
 
    // Append the ids
    if (unique) {
        std::unordered_set<long> dstSet(dst->begin(), dst->end());
        for (long id : src) {
            if (dstSet.count(id) == 0) {
                dst->push_back(id);
            }
        }
    } else {
        dst->insert(dst->end(), src.begin(), src.end());
    }
}

std::size_t InfoCollection::removeIds(std::unordered_set<long> src, std::vector<long> *dst)
{
    // Early return if the source is empty
    if (src.empty()) {
        return 0;
    }
 
    // Early return if the destination is empty
    if (dst->empty()) {
        return 0;
    }
 
    // Remove the ids
    std::size_t nDeletedIds = 0;
    for (auto itr = dst->begin(); itr != dst->end(); ++itr) {
        long vertexId = *itr;
        if (src.count(vertexId) > 0) {
            ++nDeletedIds;
        } else if (nDeletedIds > 0) {
            *(itr - nDeletedIds) = *itr;
        }
    }
 
    if (nDeletedIds > 0) {
        dst->resize(dst->size() - nDeletedIds);
        dst->shrink_to_fit();
    }
 
    return nDeletedIds;
}
 
}


FlatMapping::FlatMapping()
    : m_patch(nullptr)
{
}

FlatMapping::FlatMapping(PatchKernel *patch)
    : m_patch(patch)
{
}

const std::vector<long> & FlatMapping::getNumbering() const
{
    return m_numbering;
}

const std::vector<long> & FlatMapping::getMapping() const
{
    return m_mapping;
}


CellFlatMapping::CellFlatMapping()
    : FlatMapping()
{
}

CellFlatMapping::CellFlatMapping(PatchKernel *patch)
    : FlatMapping(patch)
{
    m_numbering.reserve(m_patch->getCellCount());
    m_mapping.reserve(m_patch->getCellCount());
 
    long flatId = -1;
    for (const auto &cell : m_patch->getCells()) {
        flatId++;
 
        m_numbering.emplace_back();
        long &cellId = m_numbering.back();
        cellId = cell.getId();
 
        m_mapping.emplace_back();
        long &cellMapping = m_mapping.back();
        cellMapping = flatId;
    }
}

void CellFlatMapping::update(const std::vector<adaption::Info> &adaptionData)
{
    // Previous number of cells
    long nPreviousCells = m_numbering.size();
 
    // Current number of cells
    long nCurrentCells = m_patch->getCellCount();
 
    // Find the first change
    long firstChangedFlatId = std::min(nCurrentCells, nPreviousCells);
    long firstChangedId     = m_patch->getCells().getSizeMarker(firstChangedFlatId, Element::NULL_ID);
    for (auto &adaptionInfo : adaptionData) {
        if (adaptionInfo.entity != adaption::ENTITY_CELL) {
            continue;
        }
 
        for (const auto &currentId : adaptionInfo.current) {
            long currentFlatId = m_patch->getCells().evalFlatIndex(currentId);
            if (currentFlatId < firstChangedFlatId) {
                firstChangedId     = currentId;
                firstChangedFlatId = currentFlatId;
            }
        }
    }
 
    // The mapping, until the flat id with the first change, is a no-op mapping
    m_mapping.resize(nCurrentCells);
    for (long flatId = 0; flatId < firstChangedFlatId; ++flatId) {
        m_mapping[flatId] = flatId;
    }
 
    // If there are no changes the mapping is already updated
    if (firstChangedId < 0) {
        return;
    }
 
    // List of cells that have been deleted
    std::unordered_set<long> removedIds;
    for (auto &adaptionInfo : adaptionData) {
        if (adaptionInfo.entity != adaption::ENTITY_CELL) {
            continue;
        }
 
        for (const auto &previousId : adaptionInfo.previous) {
            removedIds.insert(previousId);
        }
    }
    long nRemovedCells = removedIds.size();
 
    // Create a mapping between cell ids and previous flat ids
    std::unordered_map<long, long> previousFlatIds;
    std::unordered_map<long, long> removedFlatIds;
    previousFlatIds.reserve(nCurrentCells - firstChangedFlatId - nRemovedCells);
    removedFlatIds.reserve(nRemovedCells);
    for (long previousFlatId = firstChangedFlatId; previousFlatId < nPreviousCells; ++previousFlatId) {
        long previousId = m_numbering[previousFlatId];
        if (removedIds.count(previousId) > 0) {
            removedFlatIds.insert({{previousId, previousFlatId}});
        } else {
            previousFlatIds.insert({{previousId, previousFlatId}});
        }
    }
 
    // Add to the mapping the added cells
    for (auto &adaptionInfo : adaptionData) {
        if (adaptionInfo.entity != adaption::ENTITY_CELL) {
            continue;
        }
 
        // Ancestor flat index of the added cells
        long ancestorFlatId;
        if (adaptionInfo.previous.size() > 0) {
            ancestorFlatId = removedFlatIds.at(adaptionInfo.previous[0]);
        } else {
            ancestorFlatId = -1;
        }
 
        // Mapping of the added cells
        for (const auto &currentId : adaptionInfo.current) {
            previousFlatIds.insert({{currentId, ancestorFlatId}});
        }
    }
 
    std::unordered_map<long, long>().swap(removedFlatIds);
 
    // Update numbering and mapping past the flat id with the first change
    m_numbering.resize(nCurrentCells);
    auto cellIterator = m_patch->getCells().find(firstChangedId);
    for (long flatId = firstChangedFlatId; flatId < nCurrentCells; ++flatId) {
        long cellId = cellIterator->getId();
 
        m_numbering[flatId] = cellId;
        m_mapping[flatId]   = previousFlatIds[cellId];
 
        cellIterator++;
    }
}
 
}