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_DELETION);
    m_cachedTypes.insert(adaption::TYPE_CREATION);
    m_cachedTypes.insert(adaption::TYPE_PARTITION_RECV);
    m_cachedTypes.insert(adaption::TYPE_PARTITION_SEND);
}
 
const std::vector<Info> & InfoCollection::data() const noexcept
{
    return m_collection;
}
 
std::vector<Info> & InfoCollection::data() noexcept
{
    return m_collection;
}
 
std::size_t InfoCollection::create()
{
    m_collection.emplace_back();
 
    return m_collection.size() - 1;
}
 
std::size_t InfoCollection::create(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;
}
 
Info & InfoCollection::at(std::size_t n)
{
    if (n >= m_collection.size()) {
        throw std::out_of_range("Requested adaption info is not in the collection");
    }
 
    return (*this)[n];
}
 
const Info & InfoCollection::at(std::size_t n) const
{
    if (n >= m_collection.size()) {
        throw std::out_of_range("Requested adaption info is not in the collection");
    }
 
    return (*this)[n];
}
 
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;
}
 
}
 
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++;
    }
}
 
}