grid.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 <list>
#include <map>
#include <set>
#include <vector>
 
#include "GridVertex.h"
 
namespace peano4 {
  struct SplitInstruction {
    enum class Mode { AggressiveTopDown, BottomUp };
 
    int  numberOfFineGridCells;
    Mode mode;
 
    static std::string toString(Mode mode);
    std::string        toString() const;
  };
 
  typedef std::map<int, SplitInstruction> SplitSpecification;
 
  namespace grid {
    struct GridStatistics;
    struct GridControlEvent;
 
    struct AutomatonState;
    struct GridControlEvent;
 
    struct GridVertex;
 
    void clear(GridStatistics& statistics, bool isGlobalMasterTree);
 
    std::vector<GridControlEvent> merge(std::vector<GridControlEvent> events, const double Tolerance = 0.1);
 
    GridVertex createVertex(
      GridVertex::State                            state,
      const tarch::la::Vector<Dimensions, double>& x,
      int                                          level,
      const tarch::la::Vector<TwoPowerD, int>&     adjacentRanks,
      bool                                         isNewFineGridVertex
    );
 
    bool isSpacetreeNodeRefined(GridVertex vertices[TwoPowerD]);
 
    bool willVertexBeRefined(const GridVertex& vertex);
 
    bool hasVertexBeenRefined(const GridVertex& vertex);
 
    std::bitset<TwoPowerD> willVerticesBeRefined(GridVertex vertices[TwoPowerD]);
    std::bitset<TwoPowerD> haveVerticesBeenRefined(GridVertex vertices[TwoPowerD]);
 
    bool isSpacetreeNodeLocal(
      GridVertex vertices[TwoPowerD], bool splittingIsConsideredLocal, bool joiningIsConsideredLocal, int id
    );
 
    enum class VertexType { New, Hanging, Persistent, Delete };
 
    enum class FaceType { New, Hanging, Persistent, Delete };
 
    enum class CellType { New, Persistent, Delete };
 
    std::string toString(VertexType type);
    std::string toString(FaceType type);
    std::string toString(CellType type);
 
    constexpr int InvalidRank(-1);
 
    enum class SpacetreeState {
      EmptyRun,
      NewRoot,
      NewFromSplit,
      Running,
      JoinTriggered,
      Joining,
      Joined
    };
 
    std::string toString(SpacetreeState state);
 
    bool overlaps(const tarch::la::Vector<Dimensions, double>& x, const GridControlEvent& event);
    bool overlaps(const AutomatonState& x, const GridControlEvent& event);
 
    bool isContained(const AutomatonState& x, const GridControlEvent& event, double upscaleAutomatonState = 1.0);
 
    void reduceGridControlEvents(std::vector<GridControlEvent>& events);
 
    std::string toString(const std::vector<GridControlEvent>& events);
    std::string toString(const std::list<GridControlEvent>& events);
 
    namespace internal {
      void removeEraseEventsThatAreCancelledByRefineEvents(
        const std::list<peano4::grid::GridControlEvent>& refineEvents,
        std::list<peano4::grid::GridControlEvent>&       eraseEvents
      );
 
      void mergeAdjacentRefinementEvents(std::list<peano4::grid::GridControlEvent>& inputEvents, int Tolerance);
 
      bool twoEventsOverlap(const peano4::grid::GridControlEvent& lhs, const peano4::grid::GridControlEvent& rhs);
 
      bool equals(const peano4::grid::GridControlEvent& lhs, const peano4::grid::GridControlEvent& rhs);
 
      bool refinementEventOverrulesCoarsening(
        const peano4::grid::GridControlEvent& refineEvent, const peano4::grid::GridControlEvent& eraseEvent
      );
 
      bool twoEventsAreAdjacent(
        const peano4::grid::GridControlEvent& lhs, const peano4::grid::GridControlEvent& rhs, double Tolerance
      );
 
      void sort(std::list<peano4::grid::GridControlEvent>& events);
 
      peano4::grid::GridControlEvent createBoundingBoxEvent(
        const peano4::grid::GridControlEvent& lhs, const peano4::grid::GridControlEvent& rhs
      );
    } // namespace internal
  }   // namespace grid
} // namespace peano4
 
peano4::grid::GridStatistics operator+(peano4::grid::GridStatistics lhs, peano4::grid::GridStatistics rhs);
 
std::ostream& operator<<(std::ostream& out, const peano4::SplitInstruction& instruction);
std::ostream& operator<<(std::ostream& out, const peano4::SplitInstruction::Mode& mode);