voloctree_mapper.hpp

/*---------------------------------------------------------------------------*\
 *
 *  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/>.
 *
\*---------------------------------------------------------------------------*/
 
#ifndef __BITPIT_VOLOCTREE_MAPPER_HPP__
#define __BITPIT_VOLOCTREE_MAPPER_HPP__
 
#if BITPIT_ENABLE_MPI
#    include <mpi.h>
#endif
#include <string>
#include <vector>
#include <unordered_map>
 
#include "volume_mapper.hpp"
#include "voloctree.hpp"
#include "voloctree_mapper.hpp"
 
namespace bitpit {
 
class VolOctreeMapper: public VolumeMapper {
 
public:
#if BITPIT_ENABLE_MPI
    VolOctreeMapper(const VolOctree *referencePatch, const VolOctree *mappedPatch, MPI_Comm communicator);
#else
    VolOctreeMapper(const VolOctree *referencePatch, const VolOctree *mappedPatch);
#endif
 
    void adaptionPrepare(const std::vector<adaption::Info> &adaptionInfo, bool reference = true) override;
    void adaptionAlter(const std::vector<adaption::Info> &adaptionInfo, bool reference = true, bool inverseFilled = false) override;
    void adaptionCleanup() override;
 
#if BITPIT_ENABLE_MPI
    bool checkPartition() override;
    void clearPartitionMapping();
    std::unordered_map<int, std::vector<long>> getReceivedMappedIds() const override;
    std::unordered_map<int, std::vector<long>> getSentMappedIds() const override;
    std::unordered_map<int, std::vector<long>> getReceivedReferenceIds() const override;
    std::unordered_map<int, std::vector<long>> getSentReferenceIds() const override;
#endif
 
private:
    struct OctantIR {
        Octant octant;  
        long id;        
        long globalId;  
        int rank;       
        OctantIR()
        {
        };
 
        OctantIR(const Octant &_octant, long _id, long _globalId = -1, int _rank = -1)
        {
            octant = _octant;
            id = _id;
            globalId = _globalId;
            rank = _rank;
        };
    };
 
#if BITPIT_ENABLE_MPI
    struct PartitionMapper {
        std::vector<OctantIR> list_rec_octantIR_before; 
        std::vector<OctantIR> list_rec_octantIR_after;  
        std::unordered_map<int, std::unordered_map<long, OctantIR *>> map_rank_rec_octantIR;       
        std::unordered_map<int, std::unordered_map<long, mapping::Info>> map_rank_inverseMapping;  
        std::unordered_map<int, std::unordered_map<long, mapping::Info>> map_rank_previousMapping; 
        std::vector<OctantIR> list_sent_octantIR;   
        std::vector<uint64_t> partitionFDReference;  
        std::vector<uint64_t> partitionLDReference;  
        std::vector<uint64_t> partitionFDMapped;     
        std::vector<uint64_t> partitionLDMapped;     
        PartitionMapper(){};
 
        void clear(){
            list_rec_octantIR_before.clear();
            list_rec_octantIR_after.clear();
            list_sent_octantIR.clear();
            map_rank_rec_octantIR.clear();
            map_rank_inverseMapping.clear();
            map_rank_previousMapping.clear();
            partitionFDReference.clear();
            partitionLDReference.clear();
            partitionFDMapped.clear();
            partitionLDMapped.clear();
        }
 
        void clearLists(){
            list_rec_octantIR_before.clear();
            list_rec_octantIR_after.clear();
            list_sent_octantIR.clear();
        }
    };
#endif
 
#if BITPIT_ENABLE_MPI
    PartitionMapper m_partitionIR;  
#endif
 
    void _mapMeshes(bool fillInverse) override;
    void _mapMeshesSamePartition(const std::vector<OctantIR> * octantsReference, const std::vector<OctantIR> * octantsMapped,
                                 bool fillInverse, long *indRef);
 
    void _mappingAdaptionReferenceUpdate(const std::vector<adaption::Info> &adaptionInfo, bool fillInverse = false);
    void _mappingAdaptionMappedUpdate(const std::vector<adaption::Info> &adaptionInfo);
 
#if BITPIT_ENABLE_MPI
    void clearPartitionMappingLists();
 
    void _mapMeshPartitioned(bool fillInverse);
 
    bool _recoverPartition();
 
    void _communicateInverseMapper(const std::vector<OctantIR> *octantsIRMapped,
                                   const std::unordered_map<long, mapping::Info> &inverseGlobalMapping,
                                   std::unordered_map<long, mapping::Info> *inverseLocalMapping);
 
    void _communicateInverseMapperBack();
 
    void _communicateMappedAdaptionInfo(const std::vector<adaption::Info> &adaptionInfoMap, std::vector<adaption::Info> *adaptionInfoRef);
#endif
 
};
 
}
 
#endif