geometry/meshImport2Dgeneral.hh

Go to the documentation of this file.

/* Meshes Combining cells to a mesh to represent a computational
   domain Importing more genereal 2D meshes from text files

   @author Peter Kauf, 2005
 */

#ifndef meshImport2Dgeneral_hh
#define meshImport2Dgeneral_hh

#include "toolbox/inputOutput.hh"
#include "meshImport2D.hh"
#include "elementMaps.hh"

namespace concepts {

  // ****************************************************************** File **

  class File {
    public:
    enum types {ATTRIBUTES, EDGCORR, EDGRADIA, DEFFILE};
      File(const std::string file_name, enum types file_type);
      File(const File& file);
      const enum types type() const { return type_; }
      const std::string name() const { return name_; }
    protected:
      enum types type_;
      std::string name_;
  };

  class AttributesFile : public File {
    public:
      AttributesFile(const std::string file_name);
  };

  class EdgCorrFile : public File {
    public:
      EdgCorrFile(const std::string file_name);
  };

  class EdgRadiaFile : public File {
    public:
      EdgRadiaFile(const std::string file_name);
  };

  class DefFile : public File {
  public:
      DefFile(const std::string file_name);    
  };

  //******************************************************Import2DMeshGeneral**

  /* Imports 2D mesh with triangles and quadrilaterals (possibly mixed).

     The class can import the same meshes like Import2DMesh, but
     allowes also additional properties. For the notation of
     coordinates, elements and attributes respectivly boundary files
     see Import2DMesh. Note that despite using edge correlations you have to 
     specify the attributes for every edge / node, also for all of the 
     periodic ones. Assigning different attributes to periodic objects in the 
     attribute file will randomly pick one of the attributes. Be carefull to 
     be consistent since there is no assertion for this case !

     PERIODIC BOUNDARY = topological edge correlation

     If you want to read in periodic boundary conditions in the sense
     that opposite edges on the boundary are identified, you have to use
     this routine with an EdgCorr file. The routine is not made for the
     case, where "only" vertices on the boundary are identified, because
     this could lead to problems with edge identification. 

     For this an additional file has to be provided, in which the
     edges have to be identified. In the first column is a counter. 
     The following four columns contain the number of nodes of two
     identified edges.

     The order of the endpoints of the edges is important, e.g. 
     <pre>1 1 2 5 6</pre>
     means a identification of vertices 1-6 and 2-5.

     <pre>
     6    5   4
     ----------------------------
     |    |   |
     |    |   |
     |    |   |
     |    |   |
     |    |   |
     ----------------------------
     1    2   3</pre>

     The identification of the horizontal edges in the sketch above is
     achieved by the following file.

     <pre>1 1 2 5 6
     2 2 3 4 5</pre>

     If we want to identify the left boundary edge with the right boundary
     edge, we will have to write:
     <pre>3 1 6 4 3</pre>
     or
     <pre>3 6 1 3 4</pre>
     or
     <pre>3 3 4 6 1</pre>
     or
     <pre>3 4 3 1 6</pre>

     but not
     <pre>3 1 6 3 4</pre>
     or
     <pre>3 6 1 4 3</pre>.

     CURVED EDGES (circular arc)

     It is also possible to create cells (only quads) with circular
     edges. The edges and the corresponding radia have to be listed in
     a "EdgRadia" file. In the first column stands a counter. The
     following two columns contain the edge and the fourth one the
     radius, e.g.

     <pre>1 1 2 34.342</pre>

     This means that the edge with vertices 1 and 2 will be the segment of
     a circle of radius 34.342. The orientation of the curvature is
     indicated by the order of the vertices and the sign of the radius.

     r > 0 means, the arc is on the right side of line from 1st to 2nd
     vertex. This is like in the above example (the length of the
     vertical line corresponds to the radius):
                   
     <pre>
                    |
                    |
                    |
         1 -        |        - 2
             -      |       -
                -   |    -
                   --</pre>

     To get the circle bended on the other side one should write:

     <pre>2 1 34.342</pre>
     or
     <pre>1 2 -34.342</pre>

     The circle is determined geometrically by drawing a circle of radius
     34.342 around the first vertex and around the second vertex and then
     (depending on orientation) declare one of the two intersecting points
     as the middle point of the circle of which the edge will be a segment. 
     This implies that the radius must be bigger than half the distance of
     the two vertices.

     One word of caution: The Edgecorrelation routine gives back results
     for a special class of meshes which should not be further used.
     For the class of meshes with no inner cells (i.e. no cells which have
     all their edges in the interior of the mesh), you will impose further
     periodicity conditions in the interior by applying edgcorrelation. Here
     is an example:

     <pre>
     7    6   5
     ----------------------------
     |    |   |
     |        9 |   |
   8 |----------|---------------| 4
     |    |   |
     |    |   |
     ----------------------------
     1    2   3</pre>

     By identifying (1,2) <--> (6,7), (2,3) <--> (5,6), (3,4) <--> (8,1) and
     (4,5) <--> (7,8) you will automatically identify (8,9) with (9,4) and 
     (2,9) with (9,6). Thus for proper results you must only use meshes with 
     at least one inner cell when applying edgecorrelation.



     @author Peter Kauf, 2005
     @test test::MeshImp2DTest
     @ingroup geometry

  */

  class Import2dMeshGeneral : public Import2dMeshBase {
  public:
    Import2dMeshGeneral(const std::string coord, const std::string elms,
                        const File file, const uint idxStart = 1);
    Import2dMeshGeneral(const std::string coord, const std::string elms,
                        const File file_1, const File file_2,
                        const uint idxStart = 1);
    Import2dMeshGeneral(const std::string coord, const std::string elms,
                        const File file_1, const File file_2,
                        const File file_3, const uint idxStart = 1);
    virtual ~Import2dMeshGeneral();

    void addInfiniteQuad(const InOutParameters input);
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    void construct_(const Array<const File*> files);
    void delete_();
    bool has_EdgCorr_, has_EdgRadia_;
    MultiArray<2, MultiIndex<2> > EdgCorr_;
    std::multimap<uint, uint> VtxCorr_;
    std::vector<uint> KeyVector_;
    // belongs to the insert algorithm:
    bool is_paired_(const uint key, const uint a) const;
    // belongs to the insert algorithm:
    void add_(uint a, uint b);
    // belongs to the insert algorithm:
    void complete_(uint a, uint b);
    // belongs to the insert algorithm:
    bool build_(uint a, uint b);
    // putting the correlations of a and b and all implied correlations
    // into VtxCorr_
    void insert_(uint a, uint b);
    void vtxcorr_(const std::string vtxcorr);
    void edgcorr_(const std::string edgcorr);
    // different Vertex generation routine!
    virtual void createEntity_(const MultiIndex<1>& idx);
    // different Edge generation routine!
    virtual void createEntity_(const MultiIndex<2>& idx);
    virtual void createEntity_(const MultiIndex<3>& idx)
      throw (concepts::MissingFeature)
    {Import2dMeshBase::createEntity_(idx);}
    virtual void createEntity_(const MultiIndex<4>& idx)
      throw (concepts::MissingFeature)
    {Import2dMeshBase::createEntity_(idx);}
    MultiArray<2, Real> EdgRadia_;
    void edgradia_(std::string edgradia);
    MultiArray<2, MappingEdge2d*> Edges_;
    std::vector<MappingEdge2d*> edges_vec_;
    virtual void createCell_(const MultiIndex<3>& idx)
      throw(concepts::MissingFeature);
    virtual void createCell_(const MultiIndex<4>& idx)
      throw(concepts::MissingFeature);
  }; //  Import2dMeshGeneral

  // ****************************************** import2dMeshGeneralFromInput **

  Import2dMeshGeneral* 
  import2dMeshGeneralFromInput(const InOutParameters input,
                               bool verbose = false);


} // namespace concepts

#endif //meshImport2Dgeneral.hh