Spacetree.h

Go to the documentation of this file.

// This file is part of the Peano project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
#include "AutomatonState.h"
#include "GridVertex.h"
#include "GridStatistics.h"
#include "GridControlEvent.h"
#include "GridTraversalEventGenerator.h"
 
#include "tarch/logging/Log.h"
 
#include "peano4/stacks/STDVectorStack.h"
 
#include "peano4/maps/STDStackMap.h"
#include "peano4/maps/HierarchicalStackMap.h"
 
#include <set>
#include <bitset>
 
namespace peano4 {
  namespace grid {
    class Spacetree;
    class TraversalObserver;
    struct GridTraversalEvent;
 
    namespace tests {
      class SpacetreeTest;
    }
  }
 
  namespace parallel {
    class SpacetreeSet;
  }
}
 
class peano4::grid::Spacetree {
  public:
    static constexpr int RankOfPeriodicBoundaryCondition = -2;
    static constexpr int NumberOfStationarySweepsToWaitAtLeastTillJoin = 2;
 
  private:
    static tarch::logging::Log  _log;
 
    friend class peano4::parallel::SpacetreeSet;
    friend class peano4::grid::tests::SpacetreeTest;
 
    bool isCellSplitCandidate(
      GridVertex                         coarseGridVertices[TwoPowerD],
      GridVertex                         fineGridVertices[TwoPowerD]
    ) const;
 
    int              _id;
 
    SpacetreeState   _spacetreeState;
 
    AutomatonState   _root;
 
    GridStatistics   _statistics;
 
    int            _masterId;
    std::set<int>  _childrenIds;
 
    const std::bitset<Dimensions>      _periodicBC;
 
    SplitSpecification   _splitTriggered;
 
    std::set<int>        _splitting;
 
    GridTraversalEventGenerator _gridTraversalEventGenerator;
 
    std::set<int>        _hasSplit;
 
 
    constexpr static int NoJoin = -1;
    std::set< int >      _joinTriggered;
 
    std::set< int >      _joining;
 
    //typedef peano4::maps::STDStackMap< peano4::stacks::GridVertexStack >   GridVertexStackMap;
    typedef peano4::maps::HierarchicalStackMap< peano4::stacks::GridVertexStack >   GridVertexStackMap;
 
    static GridVertexStackMap  _vertexStack;
 
    std::vector< peano4::grid::GridControlEvent >       _gridControlEvents;
 
    void evaluateGridControlEvents(
      const AutomatonState& fineGridState,
      GridVertex            coarseGridVertices[TwoPowerD],
      GridVertex            fineGridVertices[TwoPowerD]
    );
 
    void markVerticesAroundForkedCell(
      GridVertex            coarseGridVertices[TwoPowerD],
      GridVertex            fineGridVertices[TwoPowerD]
    ) const;
 
 
    bool isVertexAdjacentToLocalSpacetree(
      GridVertex  vertex,
      bool        splittingIsConsideredLocal,
      bool        joiningIsConsideredLocal
    ) const;
 
 
    bool doesRankIndexIdentifyHorizontalDataExchange(int rank, bool calledByReceivingProcess) const;
 
    void descend(
      const AutomatonState& state,
      GridVertex            vertices[TwoPowerD],
      TraversalObserver&    observer
    );
 
    static void incrementNumberOfAdjacentRefinedLocalCells(GridVertex  vertices[TwoPowerD]);
 
    static void refineState(
      const AutomatonState&              coarseGrid,
      AutomatonState                     fineGrid[ThreePowerD],
      tarch::la::Vector<Dimensions,int>  fineGridPosition = tarch::la::Vector<Dimensions,int>(0),
      int                                axis = Dimensions-1
    );
 
    bool isSpacetreeNodeLocal(
      GridVertex    vertices[TwoPowerD],
      bool          splittingIsConsideredLocal,
      bool          joiningIsConsideredLocal
    ) const;
 
 
 
    bool areAllVerticesRefined(
      GridVertex            vertices[TwoPowerD]
    ) const;
 
    bool areAllVerticesUnrefined(
      GridVertex            vertices[TwoPowerD]
    ) const;
 
    bool areAllVerticesNonHanging(
      GridVertex            vertices[TwoPowerD]
    ) const;
 
 
    void loadVertices(
      const AutomatonState&                        fineGridState,
      GridVertex                                   coarseGridVertices[TwoPowerD],
      GridVertex                                   fineGridVertices[TwoPowerD],
      const tarch::la::Vector<Dimensions,int>&     cellPositionWithin3x3Patch,
      TraversalObserver&                           observer
    );
 
    void storeVertices(
      const AutomatonState&                        fineGridState,
      GridVertex                                   coarseGridVertices[TwoPowerD],
      GridVertex                                   fineGridVertices[TwoPowerD],
      const tarch::la::Vector<Dimensions,int>&     cellPositionWithin3x3Patch,
      TraversalObserver&                           observer
    );
 
    static tarch::la::Vector<Dimensions,int> convertToIntegerVector( const std::bitset<Dimensions>& in );
 
    void updateVertexAfterLoad(
      GridVertex&                               vertex,
      GridVertex                                fineGridVertices[TwoPowerD],
      const tarch::la::Vector<Dimensions,int>&  fineVertexPositionWithinPatch,
      TraversalObserver&                        observer
    );
 
    void removeDuplicateEntriesFromAdjancyListInEvent(
      GridTraversalEvent&  event
    ) const;
 
 
 
 
    void receiveAndMergeUserData(const AutomatonState& state, TraversalObserver&  observer, const GridTraversalEvent&  enterCellTraversalEvent, GridVertex  fineGridVertices[TwoPowerD]);
 
    void sendUserData(const AutomatonState& state, TraversalObserver&  observer, const GridTraversalEvent&  enterCellTraversalEvent, GridVertex  fineGridVertices[TwoPowerD]);
 
 
    std::vector<int>  _splittedCells;
 
    void splitOrJoinCellBottomUp(
      GridVertex                                vertex[TwoPowerD],
      GridVertex                                fineGridVertices[TwoPowerD]
    );
 
    void splitCellTopDown(
      GridVertex                                vertex[TwoPowerD],
      GridVertex                                fineGridVertices[TwoPowerD]
    );
 
    void mergeCellFromWorkerWithMasterThroughoutJoin(
      GridVertex                                vertex[TwoPowerD],
      GridVertex                                fineGridVertices[TwoPowerD]
    );
 
    bool shouldEraseAdjacencyInformation(
      const GridVertex&                  vertex,
      GridVertex                         coarseGridVertices[TwoPowerD],
      tarch::la::Vector<Dimensions,int>  fineVertexPositionWithinPatch
    ) const;
 
    void updateVertexBeforeStore(
      GridVertex&                               vertex,
      GridVertex                                fineGridVertices[TwoPowerD],
      const tarch::la::Vector<Dimensions,int>&  fineVertexPositionWithinPatch
    );
 
    static bool restrictToCoarseGrid(
      const tarch::la::Vector<Dimensions,int>&  coarseVertexPosition,
      const tarch::la::Vector<Dimensions,int>&  fineVertexPosition
    );
 
    static void updateVertexRanksWithinCell(
      GridVertex  fineGridVertices[TwoPowerD],
      int         newId
    );
 
    tarch::la::Vector<TwoPowerD,int> getAdjacentRanksForNewVertex(
      GridVertex                                   coarseGridVertices[TwoPowerD],
      const tarch::la::Vector<Dimensions,int>&     vertexPositionWithin3x3Patch
    ) const;
 
    void split(int treeId, const SplitInstruction& instruction);
 
    std::set<int>  getNeighbourTrees( const GridVertex& vertex, bool calledByReceivingProcess ) const;
 
    int  getNeighbourTrees( GridVertex vertex[TwoPowerD], int faceNumber, bool calledByReceivingProcess ) const;
 
    bool isFaceAlongPeriodicBoundaryCondition(GridVertex vertex[TwoPowerD], int faceNumber, bool calledByReceivingProcess) const;
 
 
    void sendGridVertex( const GridVertex& vertex );
 
    void receiveAndMergeGridVertexAtHorizontalBoundary( GridVertex& vertex );
 
    void receiveAndMergeGridVertexAtVerticalBoundary( GridVertex& vertex );
 
    void mergeGridVertexRefinementStateAtHorizontalDomainBoundary( GridVertex& vertex, const GridVertex& inVertex, int neighbour );
    void mergeGridVertexAdjacencyListsAtHorizontalDomainBoundary( GridVertex& vertex, const GridVertex& inVertex, int neighbour );
 
    Spacetree(
      int newId,
      int masterId,
      const tarch::la::Vector<Dimensions,double>&  offset,
      const tarch::la::Vector<Dimensions,double>&  width,
      bool  traversalInverted
    );
 
    void joinWithMaster();
    void joinWithWorker(int id);
 
    bool mayJoinWithMaster() const;
 
    bool mayJoinWithWorker() const;
 
    bool maySplit() const;
 
    int getSplittingTree() const;
 
    void updateSplittingCounter( int treeId );
  public:
    Spacetree(
      const tarch::la::Vector<Dimensions,double>&  offset,
      const tarch::la::Vector<Dimensions,double>&  width,
      const std::bitset<Dimensions>&               periodicBC = 0
    );
 
    ~Spacetree();
 
    void traverse(TraversalObserver& observer, bool calledFromSpacetreeSet = false);
 
    GridStatistics getGridStatistics() const;
 
    std::string toString() const;
 
    bool isInvolvedInJoinOrFork() const;
};