sparseBlockStructure2D.h

Go to the documentation of this file.

/* This file is part of the Palabos library.
 *
 * Copyright (C) 2011 FlowKit Sarl
 * Avenue de Chailly 23
 * 1012 Lausanne, Switzerland
 * E-mail contact: contact@flowkit.com
 *
 * The most recent release of Palabos can be downloaded at 
 * <http://www.palabos.org/>
 *
 * The library Palabos is free software: you can redistribute it and/or
 * modify it under the terms of the GNU Affero General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * The library 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 Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

#ifndef SPARSE_BLOCK_STRUCTURE_2D_H
#define SPARSE_BLOCK_STRUCTURE_2D_H

#include "core/globalDefs.h"
#include "core/geometry2D.h"
#include "multiBlock/threadAttribution.h"
#include <vector>
#include <map>


namespace plb {

class SparseBlockStructure2D {
public:
    typedef std::map<Dot2D, std::vector<plint> > GridT;
public:
    SparseBlockStructure2D(plint nx, plint ny);
    SparseBlockStructure2D(Box2D boundingBox_);
    SparseBlockStructure2D(Box2D boundingBox_,
                           plint gridNx_, plint gridNy_);
    SparseBlockStructure2D(SparseBlockStructure2D const& rhs, Box2D boundingBox_);
    void addBlock(Box2D const& bulk, Box2D const& uniqueBulk, plint blockId);
    void addBlock(Box2D const& bulk, plint blockId);
    void removeBlock(plint blockId);
    bool exists(plint blockId);
    plint nextIncrementalId() const;
    Box2D getBoundingBox() const;
    bool getBulk(plint blockId, Box2D& bulk) const;
    bool getUniqueBulk(plint blockId, Box2D& uniqueBulk) const;
    plint getNumBlocks() const;
    plint getNumBulkCells() const;
    std::map<plint,Box2D> const& getBulks() const;
    std::vector<plint> getLocalBlocks(ThreadAttribution const& attribution) const;
    plint locate(plint iX, plint iY) const;
    void intersect( Box2D const& bulk, std::vector<plint>& ids,
                    std::vector<Box2D>& intersections ) const;
    void computeOverlaps( Box2D const& bulk, plint dx, plint dy,
                          std::vector<plint>& ids,
                          std::vector<Box2D>& overlapsOnBulk,
                          std::vector<Box2D>& overlapsOnNeighbors ) const;
    void computeOverlaps( plint blockId, plint envelopeWidth,
                          std::vector<plint>& ids,
                          std::vector<Box2D>& overlapsOnBulk,
                          std::vector<Box2D>& overlapsOnNeighbors ) const;
    void findNeighbors( Box2D const& block, plint neighborhoodWidth,
                        std::vector<plint>& neighbors,
                        plint excludeId=-1 ) const;
    void findNeighbors( plint blockId, plint neighborhoodWidth,
                        std::vector<plint>& neighbors ) const;
    void swap(SparseBlockStructure2D& rhs);
private:
    void defaultGridN();
    void iniGridParameters();
    plint gridPosX(plint realX) const;
    plint gridPosY(plint realY) const;
    Box2D getGridBox(Box2D const& realBlock) const;
    void computeEnvelopeTerm (
        plint block0, plint block1,
        plint& env0, plint& env1, plint delta ) const;
    void integrateBlock(plint blockId, Box2D bulk);
    void extractBlock(plint blockId);
private:
    Box2D boundingBox;
    plint gridLx, gridLy;
    plint gridNx, gridNy;
    GridT grid;
    // Attention: If replacing the map by a hashed_map, remember that
    // nextIncrementalId() uses the fact that elements are ordered inside
    // the map. Therefore, nextIncrementalId() must then be rewritten.
    std::map<plint,Box2D> bulks;
    std::map<plint,Box2D> uniqueBulks;
};

SparseBlockStructure2D intersect( SparseBlockStructure2D const& sparseBlock,
                                  Box2D domain, bool crop );

SparseBlockStructure2D intersect( SparseBlockStructure2D const& sparseBlock,
                                  Box2D domain, Box2D newBoundingBox );

SparseBlockStructure2D intersect( SparseBlockStructure2D const& sparseBlock1,
                                  SparseBlockStructure2D const& sparseBlock2, bool crop );

SparseBlockStructure2D block_union( SparseBlockStructure2D const& sparseBlock1,
                                    SparseBlockStructure2D const& sparseBlock2,
                                    std::map<plint,std::vector<plint> >& remappedIds);

SparseBlockStructure2D extend( SparseBlockStructure2D const& sparseBlock,
                               Box2D addedBulk, Box2D addedUniqueBulk,
                               std::vector<plint>& newIds );

SparseBlockStructure2D except( SparseBlockStructure2D const& sparseBlock,
                               Box2D exceptedBlock,
                               std::map<plint,std::vector<plint> >& remappedIds );

SparseBlockStructure2D alignDistribution2D (
                           SparseBlockStructure2D const& originalStructure,
                           SparseBlockStructure2D const& partnerStructure,
                           std::vector<plint>& newIds,
                           std::map<plint,std::vector<plint> >& remappedFromPartner );



class EuclideanIterator2D {
public:
    EuclideanIterator2D(SparseBlockStructure2D const& sparseBlock_);
    bool getNextChunkX(plint iX, plint iY,
                       plint& blockId, plint& chunkSize) const;
    bool getNextChunkY(plint iX, plint iY,
                       plint& blockId, plint& chunkSize) const;
private:
    SparseBlockStructure2D const& sparseBlock;
};

}  // namespace plb

#endif  // SPARSE_BLOCK_STRUCTURE_2D_H