• Main Page
  • Namespaces
  • Data Structures
  • Files
  • File List
  • Globals

/export/development/ViennaGrid/release/ViennaGrid-1.0.0/viennagrid/topology/hexahedron.hpp

Go to the documentation of this file.
00001 #ifndef VIENNAGRID_CONFIG_HEXAHEDRON_HPP
00002 #define VIENNAGRID_CONFIG_HEXAHEDRON_HPP
00003 
00004 /* =======================================================================
00005    Copyright (c) 2011, Institute for Microelectronics,
00006                        Institute for Analysis and Scientific Computing,
00007                        TU Wien.
00008 
00009                             -----------------
00010                      ViennaGrid - The Vienna Grid Library
00011                             -----------------
00012 
00013    Authors:      Karl Rupp                           rupp@iue.tuwien.ac.at
00014                  Josef Weinbub                    weinbub@iue.tuwien.ac.at
00015                
00016    (A list of additional contributors can be found in the PDF manual)
00017 
00018    License:      MIT (X11), see file LICENSE in the base directory
00019 ======================================================================= */
00020 
00021 #include "viennagrid/forwards.h"
00022 #include "viennagrid/topology/line.hpp"
00023 #include "viennagrid/topology/quadrilateral.hpp"
00024 
00029 namespace viennagrid
00030 {
00031 
00033   template <>
00034   struct hypercube_tag<3>
00035   {
00036     enum{ dim = 3 };
00037     static std::string name() { return "Hexahedron"; }
00038   };
00039   
00040 
00041   namespace topology
00042   {
00043 
00045     template <>
00046     struct bndcells<hexahedron_tag, 0>
00047     {
00048       typedef point_tag             tag;
00049 
00050       enum{ num = 8 };     //8 vertices
00051     };
00052 
00054     template <>
00055     struct bndcells<hexahedron_tag, 1>
00056     {
00057       typedef hypercube_tag<1>              tag;
00058 
00059       enum{ num = 12 };     //12 edges
00060     };
00061 
00063     template <>
00064     struct bndcells<hexahedron_tag, 2>
00065     {
00066       typedef quadrilateral_tag     tag;
00067 
00068       enum{ num = 6 };     //6 facets
00069     };
00070     
00071     
00072     
00073     
00075     template <>
00076     struct bndcell_filler<hexahedron_tag, 1>
00077     {
00078       //fill edges:
00079       template <typename ElementType, typename Vertices, typename Orientations, typename Segment>
00080       static void fill(ElementType ** elements, Vertices ** vertices, Orientations * orientations, Segment & seg)
00081       {
00082         Vertices * edgevertices[2];
00083         ElementType edge;
00084 
00085         //fill edges according to reference orientation (use monospaced font for Full-HD ascii-art):
00086         //
00087         //              e11
00088         //    v6-----------------v7
00089         // e9  /|            e10/|
00090         //    / |   e8      v5 / |
00091         // v4------------------  |e7
00092         //   |  |e6           |  |
00093         // e2|  |______e5_____|__|
00094         //   |  /v2         e4| /  v3
00095         //   | /e1            |/ e3
00096         // v0 ----------------  v1
00097         //           e0 
00098         //
00099         edgevertices[0] = vertices[0];
00100         edgevertices[1] = vertices[1];
00101         edge.vertices(edgevertices);
00102         elements[0] = seg.push_back(edge, orientations);
00103 
00104         edgevertices[0] = vertices[0];
00105         edgevertices[1] = vertices[2];
00106         edge.vertices(edgevertices);
00107         elements[1] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 1);
00108 
00109         edgevertices[0] = vertices[0];
00110         edgevertices[1] = vertices[4];
00111         edge.vertices(edgevertices);
00112         elements[2] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 2);
00113 
00114         edgevertices[0] = vertices[1];
00115         edgevertices[1] = vertices[3];
00116         edge.vertices(edgevertices);
00117         elements[3] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 3);
00118 
00119         edgevertices[0] = vertices[1];
00120         edgevertices[1] = vertices[5];
00121         edge.vertices(edgevertices);
00122         elements[4] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 4);
00123 
00124         edgevertices[0] = vertices[2];
00125         edgevertices[1] = vertices[3];
00126         edge.vertices(edgevertices);
00127         elements[5] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 5);
00128         
00129         edgevertices[0] = vertices[2];
00130         edgevertices[1] = vertices[5];
00131         edge.vertices(edgevertices);
00132         elements[6] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 6);
00133         
00134         edgevertices[0] = vertices[3];
00135         edgevertices[1] = vertices[7];
00136         edge.vertices(edgevertices);
00137         elements[7] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 7);
00138         
00139         edgevertices[0] = vertices[4];
00140         edgevertices[1] = vertices[5];
00141         edge.vertices(edgevertices);
00142         elements[8] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 8);
00143         
00144         edgevertices[0] = vertices[4];
00145         edgevertices[1] = vertices[6];
00146         edge.vertices(edgevertices);
00147         elements[9] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 9);
00148         
00149         edgevertices[0] = vertices[5];
00150         edgevertices[1] = vertices[7];
00151         edge.vertices(edgevertices);
00152         elements[10] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 10);
00153         
00154         edgevertices[0] = vertices[6];
00155         edgevertices[1] = vertices[7];
00156         edge.vertices(edgevertices);
00157         elements[11] = seg.push_back(edge, (orientations == NULL) ? NULL : orientations + 11);
00158       }
00159     };
00160     
00162     template <>
00163     struct bndcell_filler<hexahedron_tag, 2>
00164     {
00165       //fill facets:
00166       template <typename ElementType, typename Vertices, typename Orientations, typename Segment>
00167       static void fill(ElementType ** elements, Vertices ** vertices, Orientations * orientations, Segment & seg)
00168       {
00169         Vertices * facetvertices[4];
00170         ElementType facet;
00171 
00172         //fill edges according to reference orientation (use monospaced font for Full-HD ascii-art):
00173         //
00174         //              
00175         //    v6-----------------v7
00176         //     /|      f5       /|
00177         //    / |           v5 / |
00178         // v4------------------  |
00179         //   |f2|  (f4-back)  |f3|
00180         //   |  |_____________|__|
00181         //   |  /v2   f1      | /  v3
00182         //   | /              |/ 
00183         // v0 ----------------  v1
00184         //       (f0-bottom)
00185         //
00186         // orientation is such that facet normals point out of the cell
00187         facetvertices[0] = vertices[0];
00188         facetvertices[1] = vertices[1];
00189         facetvertices[2] = vertices[2];
00190         facetvertices[3] = vertices[3];
00191         facet.vertices(facetvertices);
00192         elements[0] = seg.push_back(facet, (orientations == NULL) ? NULL : orientations );
00193         elements[0]->fill(seg);
00194 
00195         facetvertices[0] = vertices[0];
00196         facetvertices[1] = vertices[1];
00197         facetvertices[2] = vertices[4];
00198         facetvertices[3] = vertices[5];
00199         facet.vertices(facetvertices);
00200         elements[1] = seg.push_back(facet, (orientations == NULL) ? NULL : orientations + 1);
00201         elements[1]->fill(seg);
00202 
00203         facetvertices[0] = vertices[0];
00204         facetvertices[1] = vertices[2];
00205         facetvertices[2] = vertices[4];
00206         facetvertices[3] = vertices[6];
00207         facet.vertices(facetvertices);
00208         elements[2] = seg.push_back(facet, (orientations == NULL) ? NULL : orientations + 2);
00209         elements[2]->fill(seg);
00210 
00211         facetvertices[0] = vertices[1];
00212         facetvertices[1] = vertices[3];
00213         facetvertices[2] = vertices[5];
00214         facetvertices[3] = vertices[7];
00215         facet.vertices(facetvertices);
00216         elements[3] = seg.push_back(facet, (orientations == NULL) ? NULL : orientations + 3);
00217         elements[3]->fill(seg);
00218 
00219         facetvertices[0] = vertices[2];
00220         facetvertices[1] = vertices[3];
00221         facetvertices[2] = vertices[6];
00222         facetvertices[3] = vertices[7];
00223         facet.vertices(facetvertices);
00224         elements[4] = seg.push_back(facet, (orientations == NULL) ? NULL : orientations + 4);
00225         elements[4]->fill(seg);
00226 
00227         facetvertices[0] = vertices[4];
00228         facetvertices[1] = vertices[5];
00229         facetvertices[2] = vertices[6];
00230         facetvertices[3] = vertices[7];
00231         facet.vertices(facetvertices);
00232         elements[5] = seg.push_back(facet, (orientations == NULL) ? NULL : orientations + 5);
00233         elements[5]->fill(seg);
00234         
00235       }
00236     };
00237     
00238   } //topology
00239 }
00240 
00241 #endif
00242 

Generated on Wed Sep 14 2011 19:21:30 for ViennaGrid by  doxygen 1.7.1