sfcdstr.hh

Go to the documentation of this file.

 
#ifndef sfcdstr_hh
#define sfcdstr_hh
 
#include <memory>
 
#include "basics.hh"
#include "geometry/cell1D.hh"
#include "geometry/cell2D.hh"
#include "geometry/cell3D.hh"
#include "geometry/mesh.hh"
#include "toolbox_p/using_p.hh"
#include "toolbox_p/communicators.hh"
#include "geometry_p/mesh_p.hh"
#include "sfc.hh"
 
namespace parallel {
 
  // ******************************************** SFCDstr **
 
  class SFCDstr : public concepts::OutputOperator {
  private:
 
    template<class T>
    class ListElmSFC {
    private:
      ListElmSFC<T>* lnk_;
      T*          cell_;
      Real3d      c_;
 
    public:
      inline ListElmSFC(Real3d& c, T* cell, ListElmSFC<T>* lnk = 0)
  : lnk_(lnk), cell_(cell), c_(c) {};
 
      inline ListElmSFC<T>** linkp() {return &lnk_;};
      inline ListElmSFC<T>* link() const {return lnk_;}
      inline const Real3d& center() const {return c_;};
      inline T* cell() const {return cell_;};
    };
 
    void refine1_(Cell1* cell, uint lvl, ListHead<ListElmSFC<Cell1> >& lst);
    void refine2_(Cell2* cell, uint lvl, ListHead<ListElmSFC<Cell2> >& lst);
    void refine3_(Cell3* cell, uint lvl, ListHead<ListElmSFC<Cell3> >& lst);
 
    template<class T>
    void sortList_(ListElmSFC<T>** root, Real& d, Real3d& pmin, ushort ori);
 
    template<class T>
    void boundingBox_(ListHead<ListElmSFC<T> >& lst, Real3d* pmin,
          Real* d, uint* npnt);
 
    void markOwnCells1_(ListHead<ListElmSFC<Cell1> >& cells, uint* ncntr0,
            DynArray<uchar>& cellmap);
    void markOwnCells2_(ListHead<ListElmSFC<Cell2> >& cells, uint* ncntr0,
      uint* ncntr1, DynArray<uchar>& cellmap);
    void markOwnCells3_(ListHead<ListElmSFC<Cell3> >& cells, uint* ncntr0,
      uint* ncntr1, uint* ncntr2, DynArray<uchar>& cellmap);
 
    bool mapCount1_(Cell1* cell, uint lvl, DynArray<uchar>& cellmap);
    bool mapCount2_(Cell2* cell, uint lvl, DynArray<uchar>& cellmap);
    bool mapCount3_(Cell3* cell, uint lvl, DynArray<uchar>& cellmap);
 
    void newCells1A_(concepts::Edge1d* edg, uint lvl, uint* n,
         concepts::MapEdge1d* mapcln, DynArray<uchar>& cellmap,
         DynArray<concepts::Vertex*>& vtxmap,
         Array<unique_ptr<Connector0> >& cntr0,
         Array<unique_ptr<Connector1> >& cntr1,
         Array<unique_ptr<Cell1> >& cell1);
 
    void newCells2A_(concepts::Triangle2d* tri, uint lvl, uint* n,
         concepts::MappingTriangle2d* mapcln,
         DynArray<uchar>& cellmap,
         DynArray<concepts::Vertex*>& vtxmap,
         DynArray<concepts::Edge*>& edgmap,
         Array<unique_ptr<Connector0> >& cntr0,
         Array<unique_ptr<Connector1> >& cntr1,
         Array<unique_ptr<Connector2> >& cntr2,
         Array<unique_ptr<Cell2> >& cell2);
    void newCells2B_(concepts::Quad2d* quad, uint lvl, uint* n,
         concepts::MappingQuad2d* mapcln,
         DynArray<uchar>& cellmap,
         DynArray<concepts::Vertex*>& vtxmap,
         DynArray<concepts::Edge*>& edgmap,
         Array<unique_ptr<Connector0> >& cntr0,
         Array<unique_ptr<Connector1> >& cntr1,
         Array<unique_ptr<Connector2> >& cntr2,
         Array<unique_ptr<Cell2> >& cell2);
    void newCells2C_(concepts::Triangle3d* tri, uint lvl, uint* n,
         concepts::MapTriangle3d* mapcln,
         DynArray<uchar>& cellmap,
         DynArray<concepts::Vertex*>& vtxmap,
         DynArray<concepts::Edge*>& edgmap,
         Array<unique_ptr<Connector0> >& cntr0,
         Array<unique_ptr<Connector1> >& cntr1,
         Array<unique_ptr<Connector2> >& cntr2,
         Array<unique_ptr<Cell2> >& cell2);
 
    void newCells3A_(concepts::Hexahedron3d* hex, uint lvl, uint* n,
         concepts::MapHexahedron3d* mapcln,
         DynArray<uchar>& cellmap,
         DynArray<concepts::Vertex*>& vtxmap,
         DynArray<concepts::Edge*>& edgmap,
         DynArray<Connector2*>& fcemap,
         Array<unique_ptr<Connector0> >& cntr0,
         Array<unique_ptr<Connector1> >& cntr1,
         Array<unique_ptr<Connector2> >& cntr2,
         Array<unique_ptr<Connector3> >& cntr3,
         Array<unique_ptr<Cell3> >& cell3);
 
    const Communicator& com_;
    uint maxpnt_;
    SFC  &sfc_;  
 
  public:
    SFCDstr(uint maxpnt, SFC& sfc, const Communicator& com);
    ~SFCDstr();
 
    Mesh* distribute(concepts::Mesh& msh, uint lvl);
    Mesh1* distribute1(concepts::Mesh1& msh, uint lvl);
    Mesh2* distribute2(concepts::Mesh2& msh, uint lvl);
    Mesh3* distribute3(concepts::Mesh3& msh, uint lvl);
 
    inline const Communicator& comm() const {return com_;};
 
  protected:
    std::ostream& info(std::ostream& os) const;
  };
 
} // namespace parallel
 
#endif // sfcdstr_hh