localMultiBlockInfo3D.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 LOCAL_MULTI_BLOCK_INFO_3D_H
#define LOCAL_MULTI_BLOCK_INFO_3D_H

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


namespace plb {

class Overlap3D {
public:
    Overlap3D(plint originalId_, plint overlapId_, Box3D const& intersection_)
        : originalId(originalId_), overlapId(overlapId_),
          originalRegion(intersection_),
          overlapRegion(intersection_)
    { }
    Overlap3D(plint originalId_, plint overlapId_,
              Box3D const& originalRegion_,
              plint shiftX, plint shiftY, plint shiftZ)
        : originalId(originalId_), overlapId(overlapId_),
          originalRegion(originalRegion_),
          overlapRegion(originalRegion.shift(-shiftX, -shiftY, -shiftZ))
    { }
    plint getOriginalId() const { return originalId; }
    plint getOverlapId()  const { return overlapId; }
    Box3D const& getOriginalCoordinates() const { return originalRegion; }

    Box3D const& getOverlapCoordinates() const  { return overlapRegion; }
    plint getShiftX() const { return originalRegion.x0 - overlapRegion.x0; }
    plint getShiftY() const { return originalRegion.y0 - overlapRegion.y0; }
    plint getShiftZ() const { return originalRegion.z0 - overlapRegion.z0; }
private: 
    plint originalId, overlapId;
    Box3D originalRegion, overlapRegion;
};


inline bool operator<(Overlap3D const& overlap1, Overlap3D const& overlap2)
{
    return
        (overlap1.getOriginalId() < overlap2.getOriginalId()) || (
            (overlap1.getOriginalId() == overlap2.getOriginalId()) && (
                (overlap1.getOverlapId() < overlap2.getOverlapId()) || (
                    (overlap1.getOverlapId() == overlap2.getOverlapId()) &&
                    (overlap1.getOriginalCoordinates() < overlap2.getOriginalCoordinates()) ) ) );
}


struct PeriodicOverlap3D {
    PeriodicOverlap3D(Overlap3D const& overlap_, plint normalX_, plint normalY_, plint normalZ_);
    Overlap3D overlap;
    plint      normalX;
    plint      normalY;
    plint      normalZ;
};


inline bool operator<( PeriodicOverlap3D const& overlap1,
                       PeriodicOverlap3D const& overlap2 )
{
    return overlap1.overlap < overlap2.overlap;
}

class LocalMultiBlockInfo3D {
public:
    LocalMultiBlockInfo3D( SparseBlockStructure3D const& sparseBlock,
                           ThreadAttribution const& attribution,
                           plint envelopeWidth_ );
    std::vector<plint> const& getBlocks() const;
    std::vector<Overlap3D> const& getNormalOverlaps() const;
    std::vector<PeriodicOverlap3D> const& getPeriodicOverlaps() const;
    std::vector<PeriodicOverlap3D> const& getPeriodicOverlapWithRemoteData() const;
    void swap(LocalMultiBlockInfo3D& rhs);
private:
    void computeMyBlocks(SparseBlockStructure3D const& sparseBlock,
                         ThreadAttribution const& attribution);
    void computeAllNormalOverlaps(SparseBlockStructure3D const& sparseBlock);
    void computeNormalOverlaps(SparseBlockStructure3D const& sparseBlock, plint blockId);
    void computeAllPeriodicOverlaps(SparseBlockStructure3D const& sparseBlock);
    void computePeriodicOverlaps(SparseBlockStructure3D const& sparseBlock, plint blockId);
private:
    plint                          envelopeWidth;
    std::vector<plint>             myBlocks;
    std::vector<Overlap3D>         normalOverlaps;
    std::vector<PeriodicOverlap3D> periodicOverlaps;
    std::vector<PeriodicOverlap3D> periodicOverlapWithRemoteData;
};

} // namespace plb

#endif  // LOCAL_MULTI_BLOCK_INFO_3D_H