app-kersten/ThinSheet/thinSheetGeom.hh

Go to the documentation of this file.

#ifndef thinsheetgeom_hh
#define thinsheetgeom_hh

#include "geometry.hh"
#include "toolbox/array.hh"
#include "boost/shared_ptr.hpp"

namespace concepts {

  // ********************************************************** ThinMeshes2d **

  class ThinMeshes2d : public CellToCellMapping<2,2> {
  public:
    ThinMeshes2d(const Real d);

    virtual void thickness(const Real d) = 0;
    Mesh2* limitMesh() const { return limitMesh_.get(); }
    Mesh2* thinMesh()  const { return thinMesh_ .get(); }
    
    void addMesh(Mesh2* msh, bool holding = false);

    void connectOppositeEdges(const Edge2d* edge1, const Edge2d* edge2,
                              const Attribute attrib = Attribute(),
                              const Quad2dSubdivision* strategy = 0);

    virtual const Sequence<Edge2d*>& outerBoundary() const = 0;
    virtual const Sequence<Edge2d*>& innerBoundary() const = 0;

    void connectOuterMesh(const Sequence<Edge2d*>& innerBoundary,
                          Mesh2* msh = 0,
                          const Attribute attrib = Attribute());
    void connectInnerMesh(const Sequence<Edge2d*>& outerBoundary,
                          Mesh2* msh = 0,
                          const Attribute attrib = Attribute());

    // rebuilds the child -> parent mapping
    virtual void rebuild() = 0;

    void holdMe(const Mesh* msh) {
      if (msh) holdMeshes_.push_back(boost::shared_ptr<const Mesh>(msh));
    }
    void holdMe(const Connector* cntr) {
      if (cntr) holdCntr_.push_back(boost::shared_ptr<const Connector>(cntr));
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;

    // thickness of the sheet
    Real d_;

    // mesh of the asymptotic expansion
    std::auto_ptr<MutableMesh2> limitMesh_;
    // mesh with particular thickness
    std::auto_ptr<MutableMesh2> thinMesh_;
    // connecting meshes to the inner and outer
    std::auto_ptr<MutableMesh2> cMeshInn_, cMeshOut_;

    Sequence<boost::shared_ptr<const Mesh> > holdMeshes_;
    Sequence<boost::shared_ptr<const Connector> > holdCntr_;
  };

  // *************************************************** ThinEllipseMeshes2d **

  class ThinEllipseMeshes2d : public ThinMeshes2d {
  public:
    ThinEllipseMeshes2d(const Real a, const Real k, const uint n,
                        const Real D, const Real d = 0.0);
    virtual ~ThinEllipseMeshes2d();

    void thickness(const Real d);

    PointInCell<2> operator()(const PointInCell<2> P) const;

    inline const Sequence<Edge2d*>& outerBoundary() const {
      return outerMesh_->cells();
    }
    inline const Sequence<Edge2d*>& innerBoundary() const  {
      return innerMesh_->cells();
    }

    // rebuilds the child -> parent mapping
    virtual void rebuild() {
      conceptsAssert(thinRelat_.get(), Assertion());
      thinRelat_->rebuildCells();
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    // Sizes describing the ellipse
    const Real a_, k_, D_;
    // Number of sections
    const uint n_;

    // Edge parametrisation for the midline
    Sequence<MappingEdge2d*> inner_, midline_, outer_;

    EdgeMesh *innerMesh_, *outerMesh_, *midMesh_;

    // Interior and exterior boundary of the sheet.
    // Changed thickness will change this.
    std::auto_ptr<EdgeMesh> innerSheet_, outerSheet_;

    // Relation information between levels of the meshes
    std::auto_ptr<concepts::RelativeCells> limitRelat_, thinRelat_;
    
    Sequence<const concepts::Connector*> limitCntr_;

    std::map<const concepts::Connector*,
             std::pair<uint, const concepts::Connector*> > rmap_;
  };

  // *************************************************** ThinStraightMeshes2d **

  class ThinStraightMeshes2d : public ThinMeshes2d {
  public:
    ThinStraightMeshes2d(const Real L, const uint n,
                         const Real D, const Real d = 0.0);
    virtual ~ThinStraightMeshes2d();

    void thickness(const Real d);

    PointInCell<2> operator()(const PointInCell<2> P) const;

    inline const Sequence<Edge2d*>& outerBoundary() const {
      return outerMesh_->cells();
    }
    inline const Sequence<Edge2d*>& innerBoundary() const  {
      return innerMesh_->cells();
    }

    // rebuilds the child -> parent mapping
    virtual void rebuild() {
      conceptsAssert(thinRelat_.get(), Assertion());
      thinRelat_->rebuildCells();
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    // Sizes describing the sheet
    const Real L_, D_;
    // Number of sections
    const uint n_;

    // Edge parametrisation for the midline
    Sequence<MappingEdge2d*> inner_, midline_, outer_;

    EdgeMesh *innerMesh_, *outerMesh_, *midMesh_;

    // Interior and exterior boundary of the sheet.
    // Changed thickness will change this.
    std::auto_ptr<EdgeMesh> innerSheet_, outerSheet_;

    // Relation information between levels of the meshes
    std::auto_ptr<concepts::RelativeCells> limitRelat_, thinRelat_;
    
    Sequence<const concepts::Connector*> limitCntr_;

    std::map<const concepts::Connector*,
             std::pair<uint, const concepts::Connector*> > rmap_;
  };

  // ***************************************** generateThinMeshes2dFromInput **

  std::pair<ThinMeshes2d*,  PiecewiseFormulaBase<Real>*>
  generateThinMeshes2dFromInput(const InOutParameters input,
                                bool verbose = false);

  // ********************************************************* ThinSheetCell **

  template<int dim>
  class ThinSheetCell {
  public:
    virtual const Real d(const Array<Real>& xi) const = 0;
    virtual const bool constThickness() const = 0;
  };

  template<>
  class ThinSheetCell<2> {
  public:
    virtual const Real d(const Real& xi) const = 0;
    virtual const bool constThickness() const = 0;
  };

  // ******************************************************* ThinSheetQuad2d **

  class ThinSheetQuad2d : public Quad2d, public ThinSheetCell<2> {
  public:
    ThinSheetQuad2d(Quad& cntr, const MappingEdge2d& midline, const Real d);
    virtual ~ThinSheetQuad2d();

//     virtual ThinSheetQuad2d* child(uint i);
//     /** Returns a child. If no children exist, none are created and 0 is
//  returned.
//  @param i Index of the child to be returned.
//     */
//     virtual const ThinSheetQuad2d* child(uint i) const;

    virtual const Real d(const Real& xi) const { return d_; }
    virtual const bool constThickness() const { return true; }
    const Real curvature(const Real xi, uint n = 0) const;
    const MappingEdge2d* midline() const;
//     const Real midlineJacobian(const Real xi) const;

    const ThinSheetQuad2d* neighbour(uint i) const;
    void neighbour(uint i, const ThinSheetQuad2d* neigbour);
    const ThinSheetQuad2d* father() const { return father_; }
    const MappingEdge2d* edge(uint i) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    const Real d_;
    const MappingEdge2d* midline_;
    const MappingEdge2d* edges_[2];

//     /// Pointer to the element map
//     std::auto_ptr<MappingQuad2d> map_;

    const ThinSheetQuad2d* neighbour_[2];
    const ThinSheetQuad2d* father_;

//     /** Pointer to the first child. 
//  The children are stored in a linked list.
//     */
//     ThinSheetQuad2d* chld_;

//     /// Level of the element
//     uint l_;

//     /// Index of the element (ie. left or right child)
//     uint i_;

    ThinSheetQuad2d(Quad& cntr,
        const ThinSheetQuad2d& father,
        const Index& idx);

    virtual Quad2d* createChild_(Quad& cntr, const Index& idx) const;
  };

  // ************************************************************* ThinSheet **

  class ThinSheet : public Mesh2 {
  public:
    ThinSheet(const Real d) : d_(d) {}
    inline const Real d() const { return d_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << "ThinSheet(d = " << d_ << ")";
    }
  private:
    const Real d_;
  };

  // ****************************************************** ThinSheetParabel **

  class ThinSheetParabel : public ThinSheet {
  public:
    ThinSheetParabel(const Real d, const Real p, const Real R = 1.0);
    virtual ~ThinSheetParabel();

    inline uint ncell() const { return ncell_; }
    inline Scan2* scan() { return new S(&cell_); }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    class S : public Scan<Cell2> {
      uint idx_;
      Array<Quad2d*>* cell_;
    public:
      inline S(Array<Quad2d*>* cell) : idx_(0), cell_(cell) {}
      inline S(const S &scan) : idx_(scan.idx_),
        cell_(scan.cell_) {}

      inline bool eos() const { return idx_ == cell_->size(); }
      inline Cell2& operator++(int) { return *(*cell_)[idx_++]; }

      inline Scan2* clone() const { return new S(*this); }
    };

    uint ncell_;

    Array<Vertex*> vtx_;
    Array<Edge*> edg_;
    Array<Quad*> quad_;

    Array<Quad2d*> cell_;
  };

  // ****************************************************** ThinSheetEllipse **

  class ThinSheetEllipse : public ThinSheet {
  public:
    ThinSheetEllipse(const Real d, const Real a, const Real k,
         const Real R = 1.0);
    virtual ~ThinSheetEllipse();

    inline uint ncell() const { return ncell_; }
    inline Scan2* scan() { return new S(&cell_); }

    inline const Quad2d* cell(uint i) const { return cell_[i]; }

    virtual std::ostream& info(std::ostream& os) const;
  private:
    class S : public Scan<Cell2> {
      uint idx_;
      Array<Quad2d*>* cell_;
    public:
      inline S(Array<Quad2d*>* cell) : idx_(0), cell_(cell) {}
      inline S(const S &scan) : idx_(scan.idx_),
        cell_(scan.cell_) {}

      inline bool eos() const { return idx_ == cell_->size(); }
      inline Cell2& operator++(int) { return *(*cell_)[idx_++]; }

      inline Scan2* clone() const { return new S(*this); }
    };

    uint ncell_;

    Array<Vertex*> vtx_;
    Array<Edge*> edg_;
    Array<Quad*> quad_;

    Array<Quad2d*> cell_;

    const Real2d point_(const Real a, const Real b) const;
  };

  // ***************************************************** ThinSheetEllipse2 **

  class ThinSheetEllipse2 : public ThinSheet {
  public:
    ThinSheetEllipse2(const Real d, const Real a, const Real k,
                      const Real D, const Real R = 1.0);
    virtual ~ThinSheetEllipse2();

    inline uint ncell() const { return ncell_; }
    inline Scan2* scan() { return new S(&cell_); }

    inline const Quad2d* cell(uint i) const { return cell_[i]; }

    virtual std::ostream& info(std::ostream& os) const;
  private:
    class S : public Scan<Cell2> {
      uint idx_;
      Array<Quad2d*>* cell_;
    public:
      inline S(Array<Quad2d*>* cell) : idx_(0), cell_(cell) {}
      inline S(const S &scan) : idx_(scan.idx_),
        cell_(scan.cell_) {}

      inline bool eos() const { return idx_ == cell_->size(); }
      inline Cell2& operator++(int) { return *(*cell_)[idx_++]; }

      inline Scan2* clone() const { return new S(*this); }
    };

    uint ncell_;

    Array<Vertex*> vtx_;
    Array<Edge*> edg_;
    Array<Quad*> quad_;

    Array<Quad2d*> cell_;

    const Real2d point_(const Real a, const Real b) const;
  };

} // namespace concepts

#endif // thinsheetgeom_hh