geometry_p/mesh_p.hh

Go to the documentation of this file.

/* -*- c++ -*-
 * Meshes for parallel computing
 * These objects are created by a distributor and not by hand
 */

#ifndef mesh_p_hh
#define mesh_p_hh

#include <memory>

#include "basics/exceptions.hh"
#include "basics/outputOperator.hh"
#include "geometry/elementMaps.hh"
#include "geometry/elementMaps3D.hh"
#include "geometry/mesh.hh"
#include "toolbox_p/using_p.hh"
#include "toolbox_p/communicators.hh"

namespace concepts {

  // ******************************************* Scanners **

  template <>
  class Scan<Connector0> :
    public Scan<Connector> {
  public:
    Connector0& operator++(int) = 0;
  };

  template <>
  class Scan<Connector1> :
    public Scan<Connector> {
  public:
    Connector1& operator++(int) = 0;
  };

  template <>
  class Scan<Connector2> :
    public Scan<Connector> {
  public:
    Connector2& operator++(int) = 0;
  };

  typedef Scan<Connector0> ScanCntr0;
  typedef Scan<Connector1> ScanCntr1;
  typedef Scan<Connector2> ScanCntr2;

}  // namespace concepts



namespace parallel {

  // ********************************************** Lists **

  template<class T>
  class ListElm {
  private:
    ListElm<T>* lnk_;
    T*          elm_;

  public:
    inline ListElm(T* elm, ListElm<T>* lnk = 0) : lnk_(lnk), elm_(elm) {};

    inline ListElm<T>** linkp() {return &lnk_;};
    inline ListElm<T>* link() const {return lnk_;};
    inline T* elm() const {return elm_;}
  };

  template<class ListNode>
  class ListHead : public concepts::OutputOperator {
  private:
    ListNode* root_;

  public:
    inline ListHead(ListNode* root = 0) : root_(root) {};
    inline ~ListHead() {
      while (root_)
  {ListNode* foo = root_; root_ = root_->link(); delete foo;}
    };

    inline ListNode** rootp() {return &root_;};
    inline ListNode* root() const {return root_;};
  };

  typedef ListElm<Connector0>  Cntr0LstEl;
  typedef ListElm<Connector1>  Cntr1LstEl;
  typedef ListElm<Connector2>  Cntr2LstEl;
  typedef ListElm<Cell1>       Cell1LstEl;
  typedef ListElm<Cell2>       Cell2LstEl;
  typedef ListElm<Cell3>       Cell3LstEl;

  typedef ListHead<Cntr0LstEl> Cntr0Lst;
  typedef ListHead<Cntr1LstEl> Cntr1Lst;
  typedef ListHead<Cntr2LstEl> Cntr2Lst;
  typedef ListHead<Cell1LstEl> Cell1Lst;
  typedef ListHead<Cell2LstEl> Cell2Lst;
  typedef ListHead<Cell3LstEl> Cell3Lst;
  


  // *********************************************** Mesh **
  
  class Mesh : public concepts::OutputOperator {
  private:
    const Communicator& com_;
  public:
    Mesh(const Communicator& com) : com_(com) {};
    virtual ~Mesh() {};

    inline const Communicator& comm() const {return com_;};

    virtual uint nglobcell() const = 0;

    virtual uint nloccell() const = 0;

    virtual Scan<Cell>* globscan() = 0;

    virtual Scan<Cell>* locscan() = 0;

  protected:
    virtual std::ostream& info(std::ostream& os) const;
  };
  

  // ********************************************** Mesh1 **

  class Mesh1 : public Mesh {
  private:
    class LocalS : public Scan<Cell1> {
      uint  n_;
      uint  idx_;
      Array<auto_ptr<Cell1> > *cell_;
    public:
      inline LocalS(uint n, Array<auto_ptr<Cell1> > *cell)
  : n_(n), idx_(0), cell_(cell) {};
      inline LocalS(const LocalS& scan) : n_(scan.n_), idx_(scan.idx_),
            cell_(scan.cell_) {};
      inline bool eos() const {return idx_ == n_;};
      inline Cell1& operator++(int) {return *((*cell_)[idx_++]);};
      inline concepts::Scan1* clone() const {return new LocalS(*this);};
    };

    class GlobalS : public Scan<Cell1> {
      uint  n_;
      uint  idx_;
      Array<auto_ptr<Cell1> > *cell_;
    public:
      inline GlobalS(uint n, Array<auto_ptr<Cell1> > *cell)
  : n_(n), idx_(0), cell_(cell) {
  throw conceptsException(MissingFeature("GlobalS not yet implemented"));
      };
      inline GlobalS(const GlobalS& scan) {
  throw conceptsException(MissingFeature("GlobalS not yet implemented"));
      };
      inline bool eos() const {return 1;};
      inline Cell1& operator++(int) {return *((*cell_)[idx_++]);};
      inline concepts::Scan1* clone() const {return new GlobalS(*this);};      
    };

    template<class T>
    class CapS : public Scan<T> {
    private:
      ListElm<T>* cntr_;
    public:
      inline CapS(ListElm<T>* cntr) : cntr_(cntr) {};
      inline CapS(const CapS<T>& scan) : cntr_(scan.cntr_) {};
      inline bool eos() const {return (!cntr_);};
      inline T& operator++(int) {
  ListElm<T>* foo = cntr_;  cntr_ = cntr_->link();
  return *(foo->elm());};
      inline Scan<T>* clone() const {return new CapS(*this);};
    };

    uint ngcell_;
    uint nlcell_;

    Array<auto_ptr<Connector0> >* cntr0_;
    uint                          ncntr0_;

    Array<auto_ptr<Connector1> >* cntr1_;
    Array<auto_ptr<Cell1> >*      cell_;

    Array<auto_ptr<concepts::Map1d> >* map_;
    uint                               nmap_;

    Array<Cntr0Lst>* cap0_;
    Array<Cell1Lst>* cap1_;

  public:
    inline Mesh1(Array<auto_ptr<Connector0> >* cntr0,
     Array<auto_ptr<Connector1> >* cntr1,
     Array<auto_ptr<Cell1> >* cell, uint ngcell,
     Array<auto_ptr<concepts::Map1d> >* map,
     Array<Cntr0Lst>* cap0, Array<Cell1Lst>* cap1,
     const Communicator& com);
    inline ~Mesh1();

    inline uint nglobcell() const {return ngcell_;};
    inline uint nloccell() const {return nlcell_;};

    inline concepts::Scan1* globscan() {return new GlobalS(nlcell_, cell_);};

    inline concepts::Scan1* locscan() {return new LocalS(nlcell_, cell_);};

    inline concepts::ScanCntr0* cap0scan(uint i) {
      return new CapS<Connector0>((*cap0_)[i].root());
    };
    inline concepts::Scan1* cap1scan(uint i) {
      return new CapS<Cell1>((*cap1_)[i].root());
    };

  protected:
    std::ostream& info(std::ostream& os) const;
  };


  Mesh1::Mesh1(Array<auto_ptr<Connector0> >* cntr0,
         Array<auto_ptr<Connector1> >* cntr1,
         Array<auto_ptr<Cell1> >* cell, uint ngcell,
         Array<auto_ptr<concepts::Map1d> >* map,
         Array<Cntr0Lst>* cap0, Array<Cell1Lst>* cap1,
         const Communicator& com)
    : Mesh(com), ngcell_(ngcell), nlcell_(cell->cursize()), cntr0_(cntr0),
      ncntr0_(cntr0->cursize()), cntr1_(cntr1), cell_(cell), map_(map),
      nmap_(map ? map->cursize() : 0), cap0_(cap0), cap1_(cap1) {
  }

  Mesh1::~Mesh1() {
    delete cap0_;
    delete cap1_;
    delete cell_;  delete map_;
    delete cntr1_;  delete cntr0_;
  }


  // ********************************************** Mesh2 **

  class Mesh2 : public Mesh {
  private:
    class LocalS : public Scan<Cell2> {
      uint n_;
      uint idx_;
      Array<auto_ptr<Cell2> > *cell_;
    public:
      inline LocalS(uint n, Array<auto_ptr<Cell2> > *cell)
  : n_(n), idx_(0), cell_(cell) {};
      inline LocalS(const LocalS& scan) : n_(scan.n_), idx_(scan.idx_),
            cell_(scan.cell_) {};
      inline bool eos() const {return idx_ == n_;};
      inline Cell2& operator++(int) {return *((*cell_)[idx_++]);};
      inline concepts::Scan2* clone() const {return new LocalS(*this);};
    };

    class GlobalS : public Scan<Cell2> {
      uint  n_;
      uint  idx_;
      Array<auto_ptr<Cell2> > *cell_;
    public:
      inline GlobalS(uint n, Array<auto_ptr<Cell2> > *cell)
  : n_(n), idx_(0), cell_(cell) {
  throw conceptsException(MissingFeature("GlobalS not yet implemented"));
      };
      inline GlobalS(const GlobalS& scan) {
  throw conceptsException(MissingFeature("GlobalS not yet implemented"));
      };
      inline bool eos() const {return 1;};
      inline Cell2& operator++(int) {return *((*cell_)[idx_++]);};
      inline concepts::Scan2* clone() const {return new GlobalS(*this);};      
    };

    template<class T>
    class CapS : public Scan<T> {
    private:
      ListElm<T>* cntr_;
    public:
      inline CapS(ListElm<T>* cntr) : cntr_(cntr) {};
      inline CapS(const CapS<T>& scan) : cntr_(scan.cntr_) {};
      inline bool eos() const {return (!cntr_);};
      inline T& operator++(int) {
  ListElm<T>* foo = cntr_;  cntr_ = cntr_->link();
  return *(foo->elm());};
      inline Scan<T>* clone() const {return new CapS(*this);};
    };


    uint ngcell_;
    uint nlcell_;

    Array<auto_ptr<Connector0> >* cntr0_;
    uint                          ncntr0_;
    Array<auto_ptr<Connector1> >* cntr1_;
    uint                          ncntr1_;

    Array<auto_ptr<Connector2> >* cntr2_;
    Array<auto_ptr<Cell2> >*      cell_;

    Array<auto_ptr<concepts::Map2d> >* map_;
    uint                               nmap_;

    Array<Cntr0Lst>* cap0_;
    Array<Cntr1Lst>* cap1_;
    Array<Cell2Lst>* cap2_;

  public:
    inline Mesh2(Array<auto_ptr<Connector0> >* cntr0,
     Array<auto_ptr<Connector1> >* cntr1,
     Array<auto_ptr<Connector2> >* cntr2,
     Array<auto_ptr<Cell2> >* cell, uint ngcell,
     Array<auto_ptr<concepts::Map2d> >* map,
     Array<Cntr0Lst>* cap0, Array<Cntr1Lst>* cap1,
     Array<Cell2Lst>* cap2, const Communicator& com);
    inline ~Mesh2();

    inline uint nglobcell() const {return ngcell_;};
    inline uint nloccell() const {return nlcell_;};

    inline concepts::Scan2* globscan() {return new GlobalS(nlcell_, cell_);};

    inline concepts::Scan2* locscan() {return new LocalS(nlcell_, cell_);};

    inline concepts::ScanCntr0* cap0scan(uint i) {
      return new CapS<Connector0>((*cap0_)[i].root());
    };
    inline concepts::ScanCntr1* cap1scan(uint i) {
      return new CapS<Connector1>((*cap1_)[i].root());
    };
    inline concepts::Scan2* cap2scan(uint i) {
      return new CapS<Cell2>((*cap2_)[i].root());
    };

  protected:
    std::ostream& info(std::ostream& os) const;
  };


  Mesh2::Mesh2(Array<auto_ptr<Connector0> >* cntr0,
         Array<auto_ptr<Connector1> >* cntr1,
         Array<auto_ptr<Connector2> >* cntr2,
         Array<auto_ptr<Cell2> >* cell, uint ngcell,
         Array<auto_ptr<concepts::Map2d> >* map,
         Array<Cntr0Lst>* cap0, Array<Cntr1Lst>* cap1,
         Array<Cell2Lst>* cap2, const Communicator& com)
    : Mesh(com), ngcell_(ngcell), nlcell_(cell->cursize()), cntr0_(cntr0),
      ncntr0_(cntr0->cursize()), cntr1_(cntr1), ncntr1_(cntr1->cursize()),
      cntr2_(cntr2), cell_(cell), map_(map), nmap_(map ? map->cursize() : 0),
      cap0_(cap0), cap1_(cap1), cap2_(cap2) {
  }

  Mesh2::~Mesh2() {
    delete cap2_;  delete cap1_;  delete cap0_;
    delete cell_;  delete map_;
    delete cntr2_;  delete cntr1_;  delete cntr0_;
  }


  // ********************************************** Mesh3 **

  class Mesh3 : public Mesh {
  private:
    class LocalS : public concepts::Scan<Cell3> {
      uint n_;
      uint idx_;
      Array<auto_ptr<Cell3> > *cell_;
    public:
      inline LocalS(uint n, Array<auto_ptr<Cell3> > *cell)
  : n_(n), idx_(0), cell_(cell) {};
      inline LocalS(const LocalS& scan) : n_(scan.n_), idx_(scan.idx_),
            cell_(scan.cell_) {};
      inline bool eos() const {return idx_ == n_;};
      inline Cell3& operator++(int) {return *((*cell_)[idx_++]);};
      inline concepts::Scan3* clone() const {return new LocalS(*this);};
    };

    class GlobalS : public concepts::Scan<Cell3> {
      uint  n_;
      uint  idx_;
      Array<auto_ptr<Cell3> > *cell_;
    public:
      inline GlobalS(uint n, Array<auto_ptr<Cell3> > *cell)
  : n_(n), idx_(0), cell_(cell) {
  throw conceptsException(MissingFeature("GlobalS not yet implemented"));
      };
      inline GlobalS(const GlobalS& scan) {
  throw conceptsException(MissingFeature("GlobalS not yet implemented"));
      };
      inline bool eos() const {return 1;};
      inline Cell3& operator++(int) {return *((*cell_)[idx_++]);};
      inline concepts::Scan3* clone() const {return new GlobalS(*this);};      
    };

    template<class T>
    class CapS : public Scan<T> {
    private:
      ListElm<T>* cntr_;
    public:
      inline CapS(ListElm<T>* cntr) : cntr_(cntr) {};
      inline CapS(const CapS<T>& scan) : cntr_(scan.cntr_) {};
      inline bool eos() const {return (!cntr_);};
      inline T& operator++(int) {
  ListElm<T>* foo = cntr_;  cntr_ = cntr_->link();
  return *(foo->elm());};
      inline concepts::Scan<T>* clone() const {return new CapS(*this);};
    };

    uint ngcell_;
    uint nlcell_;

    Array<auto_ptr<Connector0> >* cntr0_;
    uint                          ncntr0_;
    Array<auto_ptr<Connector1> >* cntr1_;
    uint                          ncntr1_;
    Array<auto_ptr<Connector2> >* cntr2_;
    uint                          ncntr2_;

    Array<auto_ptr<Connector3> >* cntr3_;
    Array<auto_ptr<Cell3> >*      cell_;

    Array<auto_ptr<concepts::Map3d> >* map_;
    uint                               nmap_;

    Array<Cntr0Lst>* cap0_;
    Array<Cntr1Lst>* cap1_;
    Array<Cntr2Lst>* cap2_;
    Array<Cell3Lst>* cap3_;

  public:
    inline Mesh3(Array<auto_ptr<Connector0> >* cntr0,
     Array<auto_ptr<Connector1> >* cntr1,
     Array<auto_ptr<Connector2> >* cntr2,
     Array<auto_ptr<Connector3> >* cntr3,
     Array<auto_ptr<Cell3> >* cell, uint ngcell,
     Array<auto_ptr<concepts::Map3d> >* map,
     Array<Cntr0Lst>* cap0, Array<Cntr1Lst>* cap1,
     Array<Cntr2Lst>* cap2, Array<Cell3Lst>* cap3_,
     const Communicator& com);
    inline ~Mesh3();

    inline uint nglobcell() const {return ngcell_;};
    inline uint nloccell() const {return nlcell_;};

    inline concepts::Scan3* globscan() {return new GlobalS(nlcell_, cell_);};

    inline concepts::Scan3* locscan() {return new LocalS(nlcell_, cell_);};

    inline concepts::ScanCntr0* cap0scan(uint i) {
      return new CapS<Connector0>((*cap0_)[i].root());
    };
    inline concepts::ScanCntr1* cap1scan(uint i) {
      return new CapS<Connector1>((*cap1_)[i].root());
    };
    inline concepts::ScanCntr2* cap2scan(uint i) {
      return new CapS<Connector2>((*cap2_)[i].root());
    };
    inline concepts::Scan3* cap3scan(uint i) {
      return new CapS<Cell3>((*cap3_)[i].root());
    };

  protected:
    std::ostream& info(std::ostream& os) const;
  };


  Mesh3::Mesh3(Array<auto_ptr<Connector0> >* cntr0,
         Array<auto_ptr<Connector1> >* cntr1,
         Array<auto_ptr<Connector2> >* cntr2,
         Array<auto_ptr<Connector3> >* cntr3,
         Array<auto_ptr<Cell3> >* cell, uint ngcell,
         Array<auto_ptr<concepts::Map3d> >* map,
         Array<Cntr0Lst>* cap0, Array<Cntr1Lst>* cap1,
         Array<Cntr2Lst>* cap2, Array<Cell3Lst>* cap3,
         const Communicator& com)
    : Mesh(com), ngcell_(ngcell), nlcell_(cell->cursize()), cntr0_(cntr0),
      ncntr0_(cntr0->cursize()), cntr1_(cntr1), ncntr1_(cntr1->cursize()),
      cntr2_(cntr2), ncntr2_(cntr2->cursize()), cntr3_(cntr3), cell_(cell),
      map_(map), nmap_(map ? map->cursize() : 0), cap0_(cap0), cap1_(cap1),
      cap2_(cap2), cap3_(cap3) {
  }

  Mesh3::~Mesh3() {
    delete cap3_;  delete cap2_;  delete cap1_;  delete cap0_;
    delete cell_;  delete map_;
    delete cntr3_;  delete cntr2_;  delete cntr1_;  delete cntr0_;
  }


} // namespace parallel

#endif // mesh_p_hh