localMultiBlockInfo2D.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_2D_H
#define LOCAL_MULTI_BLOCK_INFO_2D_H

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


namespace plb {

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

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


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


struct PeriodicOverlap2D {
    PeriodicOverlap2D(Overlap2D const& overlap_, plint normalX_, plint normalY_);
    Overlap2D overlap;
    plint      normalX;
    plint      normalY;
};


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

std::vector<Overlap2D> copyAllDataTransfer (
                           SparseBlockStructure2D const& block1,
                           SparseBlockStructure2D const& block2 );


std::vector<Overlap2D> copyDomainDataTransfer (
                           SparseBlockStructure2D const& block1, Box2D block1Domain,
                           SparseBlockStructure2D const& block2, Box2D block2Domain );

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

} // namespace plb

#endif  // LOCAL_MULTI_BLOCK_INFO_2D_H