sparseBlockStructure3D.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_3D_H
#define SPARSE_BLOCK_STRUCTURE_3D_H

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


namespace plb {

class SparseBlockStructure3D {
public:
    typedef std::map<Dot3D, std::vector<plint> > GridT;
public:
    SparseBlockStructure3D(plint nx, plint ny, plint nz);
    SparseBlockStructure3D(Box3D boundingBox_);
    SparseBlockStructure3D(Box3D boundingBox_,
                           plint gridNx_, plint gridNy_, plint gridNz_);
    SparseBlockStructure3D(SparseBlockStructure3D const& rhs, Box3D boundingBox_);
    void addBlock(Box3D const& bulk, Box3D const& uniqueBulk, plint blockId);
    void addBlock(Box3D const& bulk, plint blockId);
    void removeBlock(plint blockId);
    bool exists(plint blockId);
    plint nextIncrementalId() const;
    Box3D getBoundingBox() const;
    bool getBulk(plint blockId, Box3D& bulk) const;
    bool getUniqueBulk(plint blockId, Box3D& uniqueBulk) const;
    plint getNumBlocks() const;
    plint getNumBulkCells() const;
    std::map<plint,Box3D> const& getBulks() const;
    std::vector<plint> getLocalBlocks(ThreadAttribution const& attribution) const;
    plint locate(plint iX, plint iY, plint iZ) const;
    void intersect( Box3D const& bulk, std::vector<plint>& ids,
                    std::vector<Box3D>& intersections ) const;
    void computeOverlaps( Box3D const& bulk, plint dx, plint dy, plint dz,
                          std::vector<plint>& ids,
                          std::vector<Box3D>& overlapsOnBulk,
                          std::vector<Box3D>& overlapsOnNeighbors ) const;
    void computeOverlaps( plint blockId, plint envelopeWidth,
                          std::vector<plint>& ids,
                          std::vector<Box3D>& overlapsOnBulk,
                          std::vector<Box3D>& overlapsOnNeighbors ) const;
    void findNeighbors( Box3D 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(SparseBlockStructure3D& rhs);
private:
    void defaultGridN();
    void iniGridParameters();
    plint gridPosX(plint realX) const;
    plint gridPosY(plint realY) const;
    plint gridPosZ(plint realZ) const;
    Box3D getGridBox(Box3D const& realBlock) const;
    void computeEnvelopeTerm (
        plint block0, plint block1,
        plint& env0, plint& env1, plint delta ) const;
    void integrateBlock(plint blockId, Box3D bulk);
    void extractBlock(plint blockId);
private:
    Box3D boundingBox;
    plint gridLx, gridLy, gridLz;
    plint gridNx, gridNy, gridNz;
    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,Box3D> bulks;
    std::map<plint,Box3D> uniqueBulks;
};

SparseBlockStructure3D scale(SparseBlockStructure3D const& sparseBlock, plint relativeLevel);

SparseBlockStructure3D intersect( SparseBlockStructure3D const& sparseBlock,
                                  Box3D domain, bool crop );

SparseBlockStructure3D intersect( SparseBlockStructure3D const& sparseBlock,
                                  Box3D domain, Box3D newBoundingBox );

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

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

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

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

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


class EuclideanIterator3D {
public:
    EuclideanIterator3D(SparseBlockStructure3D const& sparseBlock_);
    bool getNextChunkX(plint iX, plint iY, plint iZ,
                       plint& blockId, plint& chunkSize) const;
    bool getNextChunkY(plint iX, plint iY, plint iZ,
                       plint& blockId, plint& chunkSize) const;
    bool getNextChunkZ(plint iX, plint iY, plint iZ,
                       plint& blockId, plint& chunkSize) const;
private:
    SparseBlockStructure3D const& sparseBlock;
};

}  // namespace plb

#endif  // SPARSE_BLOCK_STRUCTURE_3D_H