LocalTree.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_PABLO_LOCALTREE_HPP__
#define __BITPIT_PABLO_LOCALTREE_HPP__
 
// =================================================================================== //
// INCLUDES                                                                            //
// =================================================================================== //
#include "tree_constants.hpp"
#include "Octant.hpp"
#include "Intersection.hpp"
 
namespace bitpit {
 
// =================================================================================== //
// TYPEDEFS
// =================================================================================== //
 
typedef std::vector<Octant>             octvector;
typedef std::vector<Intersection>       intervector;
 
// =================================================================================== //
// CLASS DEFINITION                                                                    //
// =================================================================================== //
class LocalTree{
 
    // =================================================================================== //
    // FRIENDSHIPS
    // =================================================================================== //
 
    friend class ParaTree;
 
    // =================================================================================== //
    // TYPEDEFS
    // =================================================================================== //
public:
 
    typedef std::vector<Octant>                 octvector;
 
    typedef std::vector<Intersection>           intervector;
 
    typedef std::vector<bool>                   bvector;
 
    typedef std::vector<uint8_t>                u8vector;
 
    typedef std::vector<uint32_t>               u32vector;
 
    typedef std::vector<uint64_t>               u64vector;
 
    typedef std::vector<u32array3>              u32arr3vector;
 
    // =================================================================================== //
    // MEMBERS
    // =================================================================================== //
 
private:
    octvector               m_octants;              
    octvector               m_ghosts;               
    intervector             m_intersections;        
    u64vector               m_globalIdxGhosts;      
    uint64_t                m_firstDescMorton;      
    uint64_t                m_lastDescMorton;       
    int8_t                  m_localMaxDepth;        
    uint8_t                 m_balanceCodim;         
    u32vector               m_lastGhostBros;        
    u32vector               m_firstGhostBros;       
    u32vector2D             m_connectivity;         
    u32vector2D             m_ghostsConnectivity;   
    u32arr3vector           m_nodes;                
    uint8_t                 m_dim;                  
    const TreeConstants    *m_treeConstants;        
    bvector                 m_periodic;             
    // =================================================================================== //
    // CONSTRUCTORS
    // =================================================================================== //
    LocalTree();
    LocalTree(uint8_t dim);
 
    // =================================================================================== //
    // METHODS
    // =================================================================================== //
 
protected:
    std::array<int64_t, 3> computeFirstVirtualNeighOffset(uint8_t level, uint8_t iface, uint8_t neighLevel) const;
    std::array<int64_t, 3> computeLastVirtualNeighOffset(uint8_t level, uint8_t iface, uint8_t neighLevel) const;
    void computeVirtualNeighOffsets(uint8_t level, uint8_t iface, uint8_t neighLevel, std::vector<std::array<int64_t, 3>> *neighOffsets) const;
 
    std::array<int64_t, 3> computeFirstVirtualNodeNeighOffset(uint8_t level, uint8_t inode, uint8_t neighLevel) const;
    std::array<int64_t, 3> computeLastVirtualNodeNeighOffset(uint8_t level, uint8_t inode, uint8_t neighLevel) const;
    void computeVirtualNodeNeighOffsets(uint8_t level, uint8_t inode, uint8_t neighLevel, std::vector<std::array<int64_t, 3>> *neighOffsets) const;
 
    std::array<int64_t, 3> computeFirstVirtualEdgeNeighOffset(uint8_t level, uint8_t iedge, uint8_t neighLevel) const;
    std::array<int64_t, 3> computeLastVirtualEdgeNeighOffset(uint8_t level, uint8_t iedge, uint8_t neighLevel) const;
    void computeVirtualEdgeNeighOffsets(uint8_t level, uint8_t iedge, uint8_t neighLevel, std::vector<std::array<int64_t, 3>> *neighOffsets) const;
 
    std::array<int64_t, 3> getPeriodicOffset(const Octant &octant, uint8_t iface) const;
    std::array<int64_t, 3> getNodePeriodicOffset(const Octant &octant, uint8_t inode) const;
    std::array<int64_t, 3> getEdgePeriodicOffset(const Octant &octant, uint8_t iedge) const;
 
    uint8_t getMaxNeighLevel(const Octant &octant) const;
    uint8_t getMaxNodeNeighLevel(const Octant &octant) const;
    uint8_t getMaxEdgeNeighLevel(const Octant &octant) const;
 
    // =================================================================================== //
    // BASIC GET/SET METHODS
    // =================================================================================== //
private:
    uint64_t        getFirstDescMorton() const;
    uint64_t        getLastDescMorton() const;
    uint32_t        getNumGhosts() const;
    uint32_t        getNumOctants() const;
    int8_t          getLocalMaxDepth() const;
    int8_t          getMarker(int32_t idx) const;
    uint8_t         getLevel(int32_t idx) const;
    uint64_t        getMorton(int32_t idx) const;
    uint64_t        computeNodePersistentKey(int32_t idx, uint8_t inode) const;
    uint8_t         getGhostLevel(int32_t idx) const;
    uint64_t        computeGhostMorton(int32_t idx) const;
    uint64_t        computeGhostNodePersistentKey(int32_t idx, uint8_t inode) const;
    bool            getBalance(int32_t idx) const;
    uint8_t         getBalanceCodim() const;
    void            setMarker(int32_t idx, int8_t marker);
    void            setBalance(int32_t idx, bool balance);
    void            setBalanceCodim(uint8_t b21codim);
    void            setFirstDescMorton();
    void            setLastDescMorton();
    void            setPeriodic(bvector & periodic);
 
    // =================================================================================== //
    // OTHER GET/SET METHODS
    // =================================================================================== //
    bool        isPeriodic(const Octant* oct, uint8_t iface) const;
    bool        isEdgePeriodic(const Octant* oct, uint8_t iedge) const;
    bool        isNodePeriodic(const Octant* oct, uint8_t inode) const;
 
    // =================================================================================== //
    // OTHER METHODS
    // =================================================================================== //
 
    void    initialize();
    void    initialize(uint8_t dim);
    void    reset(bool createRoot);
 
    Octant&         extractOctant(uint32_t idx);
    const Octant&   extractOctant(uint32_t idx) const;
    Octant&         extractGhostOctant(uint32_t idx);
    const Octant&   extractGhostOctant(uint32_t idx) const;
 
 
    bool        refine(u32vector & mapidx);
    bool        coarse(u32vector & mapidx);
    bool        globalRefine(u32vector & mapidx);
    bool        globalCoarse(u32vector & mapidx);
    void        checkCoarse(uint64_t partLastDesc, u32vector & mapidx);
    void        updateLocalMaxDepth();
 
    void        findNeighbours(const Octant* oct, uint8_t iface, u32vector & neighbours, bvector & isghost, bool onlyinternal, bool append) const;
    void        findEdgeNeighbours(const Octant* oct, uint8_t iedge, u32vector & neighbours, bvector & isghost, bool onlyinternal, bool append) const;
    void        findNodeNeighbours(const Octant* oct, uint8_t inode, u32vector & neighbours, bvector & isghost, bool onlyinternal, bool append) const;
 
    void        computeNeighSearchBegin(uint64_t sameSizeVirtualNeighMorton, const octvector &octants, uint32_t *searchBeginIdx, uint64_t *searchBeginMorton) const;
 
    bool        localBalance(bool doNew, bool checkInterior, bool checkGhost);
 
    bool        fixBrokenFamiliesMarkers(std::vector<Octant *> *updatedOctants = nullptr, std::vector<bool> *updatedGhostFlags = nullptr);
 
    void        computeIntersections();
 
    uint32_t    findMorton(uint64_t targetMorton) const;
    uint32_t    findGhostMorton(uint64_t targetMorton) const;
    uint32_t    findMorton(uint64_t targetMorton, const octvector &octants) const;
    void        findMortonLowerBound(uint64_t targetMorton, const octvector &octants, uint32_t *lowerBoundIdx, uint64_t *lowerBoundMorton) const;
    void        findMortonUpperBound(uint64_t targetMorton, const octvector &octants, uint32_t *upperBoundIdx, uint64_t *upperBoundMorton) const;
 
    void        computeConnectivity();
    void        clearConnectivity(bool release = true);
    void        updateConnectivity();
 
    // =================================================================================== //
 
};
 
}
 
#endif /* __BITPIT_PABLO_LOCALTREE_HPP__ */