Skip to content
Snippets Groups Projects
Select Git revision
  • 6061d956d813a41db3de8c66531e0a5f49c743bb
  • master default protected
  • relaying
  • overlaps_tags_and_distributed_export
  • alphashapes
  • patches-4.14
  • steplayer
  • bl
  • pluginMeshQuality
  • fixBugsAmaury
  • hierarchical-basis
  • new_export_boris
  • oras_vs_osm
  • reassign_partitions
  • distributed_fwi
  • rename-classes
  • fix/fortran-api-example-t4
  • robust_partitions
  • reducing_files
  • fix_overlaps
  • 3115-issue-fix
  • gmsh_4_14_0
  • gmsh_4_13_1
  • gmsh_4_13_0
  • gmsh_4_12_2
  • gmsh_4_12_1
  • gmsh_4_12_0
  • gmsh_4_11_1
  • gmsh_4_11_0
  • gmsh_4_10_5
  • gmsh_4_10_4
  • gmsh_4_10_3
  • gmsh_4_10_2
  • gmsh_4_10_1
  • gmsh_4_10_0
  • gmsh_4_9_5
  • gmsh_4_9_4
  • gmsh_4_9_3
  • gmsh_4_9_2
  • gmsh_4_9_1
  • gmsh_4_9_0
41 results

CTestConfig.cmake

Blame
  • MTrihedron.h 4.94 KiB
    // Gmsh - Copyright (C) 1997-2019 C. Geuzaine, J.-F. Remacle
    //
    // See the LICENSE.txt file for license information. Please report all
    // issues on https://gitlab.onelab.info/gmsh/gmsh/issues.
    
    #ifndef MTRIHEDRON_H
    #define MTRIHEDRON_H
    
    #include "MElement.h"
    
    /*
     * MTrihedron
     * A MTrihedron is a plane element composed of
     * a quadrangle and two triangles.
     * It serves as an interface between two non-conforming
     * elements
     *
     *         v
     *         ^
     *         |
     *   3-----------2
     *   |'\   |     |
     *   |  '\ |     |
     *   |     +---- | --> u
     *   |      '\   |
     *   |        '\ |
     *   0-----------1
     *
     */
    
    class MTrihedron : public MElement {
    protected:
      MVertex *_v[4];
      void _getEdgeVertices(const int num, std::vector<MVertex *> &v) const
      {
        v[0] = _v[edges_trihedron(num, 0)];
        v[1] = _v[edges_trihedron(num, 1)];
      }
      void _getFaceVertices(const int num, std::vector<MVertex *> &v) const
      {
        if(num > 0) {
          v[0] = _v[faces_trihedron(num, 0)];
          v[1] = _v[faces_trihedron(num, 1)];
          v[2] = _v[faces_trihedron(num, 2)];
        }
        else {
          v[0] = _v[0];
          v[1] = _v[1];
          v[2] = _v[2];
          v[3] = _v[3];
        }
      }
    
    public:
      MTrihedron(MVertex *v0, MVertex *v1, MVertex *v2, MVertex *v3, int num = 0,
                 int part = 0)
        : MElement(num, part)
      {
        _v[0] = v0;
        _v[1] = v1;
        _v[2] = v2;
        _v[3] = v3;
      }
      MTrihedron(const std::vector<MVertex *> &v, int num = 0, int part = 0)
        : MElement(num, part)
      {
        for(int i = 0; i < 4; i++) _v[i] = v[i];
      }
      ~MTrihedron() {}
      virtual int getDim() const { return 3; } // Can have a volume...
      virtual std::size_t getNumVertices() const { return 4; }
      virtual MVertex *getVertex(int num) { return _v[num]; }
      virtual const MVertex *getVertex(int num) const { return _v[num]; }
      virtual void setVertex(int num, MVertex *v) { _v[num] = v; }
      virtual int getNumEdges() const { return 5; }
      virtual MEdge getEdge(int num) const
      {
        return MEdge(_v[edges_trihedron(num, 0)], _v[edges_trihedron(num, 1)]);
      }
      virtual int getNumEdgesRep(bool curved) { return 5; }
      virtual void getEdgeRep(bool curved, int num, double *x, double *y, double *z,
                              SVector3 *n)
      {
        MEdge e(getEdge(num));
        _getEdgeRep(e.getVertex(0), e.getVertex(1), x, y, z, n, 0);
      }
      virtual void getEdgeVertices(const int num, std::vector<MVertex *> &v) const
      {
        v.resize(2);
        _getEdgeVertices(num, v);
      }
      virtual int getNumFaces() { return 3; }
      virtual MFace getFace(int num) const
      {
        if(num > 0)
          return MFace(_v[faces_trihedron(num, 0)], _v[faces_trihedron(num, 1)],
                       _v[faces_trihedron(num, 2)]);
        else
          return MFace(_v[0], _v[1], _v[2], _v[3]);
      }
    
      virtual int getNumFacesRep(bool curved) { return 2; }
      virtual void getFaceRep(bool curved, int num, double *x, double *y, double *z,
                              SVector3 *n)
      {
        static const int f[2][3] = {{0, 1, 3}, {1, 2, 3}};
        _getFaceRep(getVertex(f[num][0]), getVertex(f[num][1]),
                    getVertex(f[num][2]), x, y, z, n);
      }
      virtual void getFaceVertices(const int num, std::vector<MVertex *> &v) const
      {
        v.resize((num == 0) ? 4 : 3);
        _getFaceVertices(num, v);
      }
      virtual int getType() const { return TYPE_TRIH; }
      virtual int getTypeForMSH() const { return MSH_TRIH_4; }
    
      virtual void reverse()
      {
        MVertex *tmp = _v[1];
        _v[1] = _v[3];
        _v[3] = tmp;
      }
      virtual int getVolumeSign() { return 0; };
      virtual double getVolume() { return 0; };
      virtual bool setVolumePositive() { return false; };
      virtual void getNode(int num, double &u, double &v, double &w) const
      {
        w = 0;
        switch(num) {
        case 0:
          u = -1.;
          v = -1.;
          break;
        case 1:
          u = 1.;
          v = -1.;
          break;
        case 2:
          u = 1.;
          v = 1.;
          break;
        case 3:
          u = -1.;
          v = 1.;
          break;
        default:
          u = 0.;
          v = 0.;
          break;
        }
      }
      virtual SPoint3 barycenterUVW() const { return SPoint3(0., 0., 0.); }
      virtual bool isInside(double u, double v, double w) const
      {
        double tol = getTolerance();
        if(u < -(1. + tol) || v < -(1. + tol) || u > (1. + tol) || v > (1. + tol) ||
           fabs(w) > tol)
          return false;
        return true;
      }
      static int edges_trihedron(const int edge, const int vert)
      {
        static const int e[5][2] = {
          {0, 1}, {1, 2}, {2, 3}, {3, 0}, {1, 3},
        };
        return e[edge][vert];
      }
      static int faces_trihedron(const int face, const int vert)
      {
        static const int f[3][4] = {
          {0, 1, 2, 3},
          {0, 3, 1, -1},
          {1, 3, 2, -1},
        };
        return f[face][vert];
      }
    
      // Return the number of nodes that this element must have with the other in
      // order to put an edge between them in the dual graph used during the
      // partitioning.
      virtual int numCommonNodesInDualGraph(const MElement *const other) const;
      virtual int getVertexSolin(int numEdge, int numVertex){return 0;}
      virtual MFace getFaceSolin(int numFace){return getFace(numFace);}
    };
    
    #endif