gmShape.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together 
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND, 
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR 
** A PARTICULAR PURPOSE.
**
************************************************************************/
 
#ifndef _GEMA_SHAPE_H_
#define _GEMA_SHAPE_H_
 
#include "gmCell.h"
 
class GmSpinLock;
class GmSimulationData;
 
class GMC_API_EXPORT GmShape
{
public:
 
  virtual GmCellType elemType() const = 0;
 
  virtual int numFunctions() const = 0;
 
  virtual int numNaturalCoord() const = 0;
 
  virtual int numCartesianCoord() const = 0;
 
  virtual void naturalCoordLimits(int coord, double* min, double* max) const = 0;
 
  virtual void nodeNaturalCoord(int node, GmVector& coord) const = 0;
 
  virtual void naturalCenter(GmVector& coord) const = 0;
 
  void fillNaturalCoordinates(GmMatrix& coord, bool transposed = false) const;
 
  virtual bool translateEdgePoint(int edge, const GmVector& srcEdgeCoord, GmVector& elementCoord) const = 0;
 
  virtual bool translateFacePoint(int face, const GmVector& srcFaceCoord, GmVector& elementCoord) const = 0;
 
  virtual bool cartesianToNatural(const GmVector& coord, const GmMatrix& X, GmVector& ncoord, bool* inside) const
  {
    return cartesianToNatural(coord, X, _preferGeometricConfig, _gradTolConfig, _maxGradIterConfig, 
                              _outsideNatTolConfig, ncoord, inside);
  }
 
  virtual bool cartesianToNatural(const GmVector& coord, const GmMatrix& X, bool preferGeometric, double gradTol, 
                                  int maxGradIter, double outsideNatTol, GmVector& ncoord, bool* inside) const
  {
    if(preferGeometric && hasGeometryBasedCartesianToNatural())
      return geometryBasedCartesianToNatural(coord, X, outsideNatTol, ncoord, inside);
    else
      return gradientBasedCartesianToNatural(coord, X, gradTol, maxGradIter, outsideNatTol, ncoord, inside);
  }
 
  virtual void naturalToCartesian(const GmVector& ncoord, const GmMatrix& X, GmVector& coord) const;
 
  virtual void shapeValues(const GmVector& ncoord, GmVector& N) const = 0;
 
  virtual void shapePartials(const GmVector& ncoord, GmMatrix& dN, bool transposed = false) const = 0;
 
  virtual double shapeCartesianPartialsFromCoord   (const GmVector& ncoord, const GmMatrix& X, GmMatrix& dN, bool transposed = false) const;
  virtual double shapeCartesianPartialsFromJacobian(const GmVector& ncoord, const GmMatrix& J, GmMatrix& dN, bool transposed = false) const;
 
  virtual double shapeCartesianPartialsFromPJ(const GmMatrix& P, const GmMatrix& J, GmMatrix& dN, bool transposed = false) const = 0;
 
  virtual void jacobian(const GmVector& ncoord, const GmMatrix& X, GmMatrix& J, bool transposed = false) const
  {
    GmMatrix P;
    jacobianAndPartials(ncoord, X, J, P, transposed);
  }
 
  virtual double scaledJacobianDet(const GmMatrix& J) const = 0;
 
  virtual void jacobianAndPartials(const GmVector& ncoord, const GmMatrix& X, GmMatrix& J, GmMatrix& P, bool transposed = false) const = 0;
 
  virtual double borderScalingFactor(int border, const GmVector& borderCoord, const GmVector& elementCoord, 
                                     const GmMatrix& X, bool transposed = false) const = 0;
 
  virtual double edgeScalingFactor(int border, const GmVector& borderCoord, const GmVector& elementCoord,
                                   const GmMatrix& X, bool transposed = false) const = 0;
 
  virtual double faceScalingFactor(int border, const GmVector& borderCoord, const GmVector& elementCoord,
                                   const GmMatrix& X, bool transposed = false) const = 0;
 
  virtual void jacobianRotation(const GmMatrix& J, GmMatrix& R) const = 0;
  virtual const GmMatrix& gaussExtrapolationMatrix(const GmIntegrationRule* ir) const;
  virtual bool            pointExtrapolationMatrix(const GmMatrix& points, GmMatrix& em) const;
 
  double interpolate(const GmVector& nodeValues, const GmVector& ncoord) const;
 
  static bool initShapeFunctions();
  static void setConfigOptions(const GmSimulationData* simData);
  static const GmShape* shapeFromElementType      (GmCellType etype, int P, int Q);
  static const GmShape* linearShapeFromElementType(GmCellType etype, int P, int Q);
 
protected:
  virtual void jacIndependentNatCoord(const GmVector& ncoord, const GmMatrix& X, GmMatrix& J, GmMatrix& P, bool transposed) const;
  virtual void jacDependentNatCoord  (const GmVector& ncoord, const GmMatrix& X, GmMatrix& J, GmMatrix& P, bool transposed) const;
 
  bool ginv(const GmMatrix& A, GmMatrix& inv) const;
 
  static void jacRotation2D(const GmMatrix&J, GmMatrix& R);
  static void jacRotation3D(const GmMatrix&J, GmMatrix& R);
 
#if defined ENABLE_TESTS 
  friend void shapeMappingTests();
#endif
  virtual bool gradientBasedCartesianToNatural(const GmVector& coord, const GmMatrix& X, double tol, 
                                               int maxIter, double natTol, GmVector& ncoord, bool* inside) const = 0;
 
  bool gradientBasedCartesianToNaturalQuadHex(const GmVector& coord, const GmMatrix& X, double tol,
                                              int maxIter, double natTol, GmVector& ncoord, bool* inside, double alpha = _newtonAlpha) const;
  bool gradientBasedCartesianToNaturalTriTet (const GmVector& coord, const GmMatrix& X, double tol,
                                              int maxIter, double natTol, GmVector& ncoord, bool* inside, double alpha = _newtonAlpha) const;
  bool gradientBasedCartesianToNaturalBar    (const GmVector& coord, const GmMatrix& X, double tol,
                                              int maxIter, double natTol, GmVector& ncoord, bool* inside, double alpha = _newtonAlpha) const;
  bool gradientBasedCartesianToNaturalWedge  (const GmVector& coord, const GmMatrix& X, double tol,
                                              int maxIter, double natTol, GmVector& ncoord, bool* inside, double alpha = _newtonAlpha) const;
 
  virtual bool hasGeometryBasedCartesianToNatural() const { return false; }
 
  virtual bool geometryBasedCartesianToNatural(const GmVector& coord, const GmMatrix& X, double natTol,
                                               GmVector& ncoord, bool* inside) const
  {
    Q_UNUSED(coord); Q_UNUSED(X); Q_UNUSED(natTol); Q_UNUSED(ncoord); Q_UNUSED(inside);
    return false;
  }
 
  bool checkAndClampNaturalCoordinate(double& ncoord, double min, double max, double natTol) const;
  bool checkAndClampBarycentricNaturalCoordinates(GmVector& ncoord, double natTol) const;
 
private:
  static const void* _shapePointersList[GM_NUM_CELL_TYPES]; 
  static GmSpinLock  _hElementsLock;                        
 
  static bool   _preferGeometricConfig;  
  static double _gradTolConfig;          
  static int    _maxGradIterConfig;      
  static double _outsideNatTolConfig;    
  static double _newtonAlpha;            
 
  static QMap<QPair<GmCellType, int>, GmMatrix> _emCache;       
  static QMutex                                 _emCacheMutex;  
};
 
 
#endif