app-kersten/ThinSheet/asympEdges.hh

Go to the documentation of this file.

#ifndef AsympEdges_hh
#define AsympEdges_hh


#include "basics.hh"
#include "geometry.hh"
#include "toolbox/sequence.hh"

namespace concepts {

  // ***************************************************** splitbySemicolon **

  /* Split a string into a sequence of substrings, where semicolons
     separate them.
   */
  Sequence<std::string> splitbySemicolon(const std::string s) {
    Sequence<std::string> seq;
    
    uint cnt = 0;
    while(cnt < s.size()) {
      uint n = s.find(";",cnt);
      std::string sub = s.substr(cnt, n);
      // delete whitespaces
      uint c2 = 0;
      while(c2 != sub.npos) {
  c2 = sub.find(" ");
  if (c2 != sub.npos)
    sub = sub.erase(c2, 1);
    }
      seq.push_back(sub);
      
      if (n == s.npos)
  cnt = s.size();
      else
  cnt = n+1;
    }
    
    return seq;
  }

  // ***************************************************************** match **

  int match(const Connector1& edg, const Connector0& vtx, int& idx) {
    for (idx = 0; idx < 2; ++idx)
      if (*edg.vertex(idx) == vtx) return 1;
    return 0;
  }

  // ****************************************************** ParseInputString **

  /* Class for parsing a string with input variables of the form
     <pre>"attrib = 1;"</pre>

     @author Kersten Schmidt, 2007
  */
  class ParseInputString {
  public:
    ParseInputString() {}
    virtual ~ParseInputString() {}
    void parse(const std::map<int, std::string> map) {
      std::map<int, std::string>::const_iterator i = map.begin();
      for(; i != map.end(); ++i)
  parse(i->second);
    }
    inline void parse(const std::string data) {
      this->evaluate_(splitbySemicolon(data));
    }
  private:
    virtual void evaluate_(const Sequence<std::string> substrings) = 0;
  };

  // *********************************************** ParseThinSheetThickness **

  /* Class for parsing a string with thicknesses of thin sheets.

     With
     <pre>"attrib = 1; thickness = 0.2;"</pre>
     the edges with attribute 1 get thickness 0.2.

     @author Kersten Schmidt, 2007
  */
  class ParseThinSheetThickness : public ParseInputString,
          public HashMap<double> {
  public:
    ParseThinSheetThickness(const std::map<int, std::string> map) { 
      parse(map);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    virtual void evaluate_(const Sequence<std::string> substrings);
  };

  template<class F>
  std::ostream& operator<<(std::ostream& os, const typename std::list<F>& l) {
    os << "std::list(";
    for(typename std::list<F>::
    const_iterator i = l.begin(); i != l.end();) {
      pointerOutput(os, *i);
      if (++i != l.end()) os << ", ";
    }
    return os << ")";
  }

  // ********************************************************* ThinSheetRule **

  /* Defines a rule, where is a top and the bottom of a sheet.
   */
  class ThinSheetRule : public OutputOperator {
  public:
    virtual Z2 top(const Real2d& vtx0, const Real2d& vtx1) const = 0;
  protected:
    virtual std::ostream& info(std::ostream& os) const {
      return os << "ThinSheetRule()";
    }
  };

  // **************************************************** ThinSheetRuleCoord **

  class ThinSheetRuleCoord : public ThinSheetRule {
  public:
    enum directions {LEFT = 0, RIGHT = 1, TOP = 2, BOTTOM = 3};
    ThinSheetRuleCoord(enum directions dir) : dir_(dir) {}
    virtual ~ThinSheetRuleCoord() {}
    virtual Z2 top(const Real2d& vtx0, const Real2d& vtx1) const;
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    enum directions dir_;
  };

  // ******************************************************** ThinSheetEdges **

  /* Holds thickness of thin sheets, which are edges in a mesh
   */
  class ThinSheetEdges : public OutputOperator {
  public:
    class List : public Sequence<const Connector1*> {
    public:
      Z2 top;
    protected:
      virtual std::ostream& info(std::ostream& os) const;
    };

    ThinSheetEdges(Mesh2& msh, const HashMap<double> thickness,
       const ThinSheetRule& rule);

    bool exists(const Connector1* edge) const;

    bool exists(const Connector2* cell, const uint i) const;

    double thickness(const uint attrib) const;

    Z2 top(const Connector1* edge);

    bool top(const Quad* cell, const uint i);

    Z2 edgeDirection(const Connector1* edge) const;

    void rebuild();

    bool takeChildren_(const Connector1* edge, Sequence<List>::iterator& i,
           Sequence<const Connector1*>::iterator& ie);

  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    HashMap<double> thickness_;
    HashMap<uint> edgeToList_;
    HashMap<Z2> edgeDirection_;

    Sequence<List> edges_;

    bool appended_(const Connector1* edge) const;

    bool fitToList_(const Connector1* edge, const Z2 top,
        const List& list, uint& vidx, bool& front);

    void append_(const Cell2& cell, const ThinSheetRule* rule);

    void append_(const Connector1* edge, const Z2 top);
  };

} // namespace concepts

#endif // AsympEdges_hh