triangleShellFE.h

Go to the documentation of this file.

#ifndef __TRIANGLESHELLFE_H
#define __TRIANGELSHELLFE_H

#include <aol.h>

namespace shellFE {

template<typename DataTypeContainer>
class ShellElementWithTangentSpaceAtVertex {

  typedef typename DataTypeContainer::RealType        RealType;
  typedef typename DataTypeContainer::DomVecType      DomVecType;
  typedef typename DataTypeContainer::Point3DType     Point3DType;
  typedef typename DataTypeContainer::TangentVecType  TangentVecType;
  typedef typename DataTypeContainer::Indices3DType   Indices3DType;
  typedef std::vector<Point3DType>                    VertexIterator;
  typedef std::vector<TangentVecType>                 TangentVecIterator;
  
protected:   
    // global indices of element an nodes
    int _globIdx;
    Indices3DType _globNodeIdx;
    Point3DType _nodes[3];
    TangentVecType _edges[3]; // Notation:   e_i = N_{i-1} - N_{i+1} = N_{i+2} - N_{i+1}, i = 0,1,2
    
public:
  
  ShellElementWithTangentSpaceAtVertex () : _globIdx(-1) {}
  
  ShellElementWithTangentSpaceAtVertex( const int globalIdx, const Indices3DType globalNodeIndex, const VertexIterator &nodes  ) : 
     _globIdx(globalIdx),
     _globNodeIdx ( globalNodeIndex )
    {
         // fill nodes and edges
        for ( int i = 0; i < 3; ++i ) _nodes[i] = nodes[ _globNodeIdx[i] ];
        for ( int i = 0; i < 3; ++i ) _edges[i] = getNode((i+2)%3) - getNode((i+1)%3);
    }
  
  ~ShellElementWithTangentSpaceAtVertex(){}

  
  void updateNodesAndEdges( const VertexIterator &nodes ){
      for ( int i = 0; i < 3; ++i ) _nodes[i] = nodes[ _globNodeIdx[i] ];
      for ( int i = 0; i < 3; ++i ) _edges[i] = getNode((i+2)%3) - getNode((i+1)%3);
  }

  void printNodes() const { cout << "node0 = " << getNode(0).transpose() << endl << "node1 = " << getNode(1).transpose() << endl << "node2 = " << getNode(2).transpose() << endl;}

  void print() const {
      cout << endl << "Element " << _globIdx << endl;
      printNodes();
  }
  
  //The following methods compute the weighted/normalized normal of the triangle elements and its area under the assumption that the triangle is flat
  void getWeightedNormalForFlattenedTriangle ( TangentVecType &normal ) const {
    TangentVecType dx1 = getNode(1), dx2 = getNode(2);
    dx1 -= getNode(0);
    dx2 -= getNode(0);
    normal = TangentVecType( dx1.cross(dx2) );
  }

  void getNormalizedNormalForFlattenedTriangle ( TangentVecType &normal ) const {
    getWeightedNormalForFlattenedTriangle ( normal );
    normal.normalize();
  }

  inline RealType getAreaOfFlattenedTriangle() const {
    TangentVecType n; getWeightedNormalForFlattenedTriangle ( n );
    return n.norm() / 2.;
  }
    
  // get and set functions
  int getGlobalElementIdx() const { return _globIdx;}
  const Indices3DType & getGlobalNodeIdx( ) const{ return _globNodeIdx;}
  int getGlobalNodeIdx(int localIndex) const{ return _globNodeIdx[localIndex];}
  void setGlobalNodeIdx(int localIndex, int globalIndex) { _globNodeIdx[localIndex] = globalIndex;}
  
  const Point3DType& getNode ( int i ) const { return _nodes[i];}
  Point3DType& getNode ( int i ) { return _nodes[i];}
  void setNode ( int i, const Point3DType& node ) {_nodes[i] = node;}
  
  const TangentVecType& getEdge(int i) const { return _edges[i]; }

  const TangentVecType& operator[] ( int i ) const { return getNode(i);}
  TangentVecType& operator[] ( int i ) {return getNode(i);}

};


} //end namespace


#endif