gmWedgeIntegrationRule.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_WEDGE_INT_RULE_H_
#define _GEMA_WEDGE_INT_RULE_H_

#include "gmIntegrationRule.h"
#include "gmBorderIntegrationRule.h"
#include "gmBarIntegrationRule.h"  // Needed by edge rules
#include "gmQuadIntegrationRule.h" // Needed by face rules
#include "gmTriIntegrationRule.h"  // Needed by face rules

//--------------------------------------------------------
// Element rules
//--------------------------------------------------------


class GMC_API_EXPORT GmWedgeGaussIntegrationRule : public GmIntegrationRule
{
public:
  GmWedgeGaussIntegrationRule(int triRule, int linearRule);

  GmWedgeGaussIntegrationRule(GmIntegrationRuleType irType, int rule1, int rule2, int rule3)
    : GmWedgeGaussIntegrationRule(rule1, rule2)
  {
    assert(irType == GM_GAUSS_RULE_TYPE); Q_UNUSED(irType); Q_UNUSED(rule3);
  }

  // See comments on the base class
  bool isValid() const { return _tTable; }

  // See comments on the base class
  virtual int numPoints() const { assert(isValid()); return _trule * _lrule; }

  virtual void integrationPoint(int index, GmVector& naturalCoord, double* weight) const;

  // See comments on the base class
  virtual int numNaturalCoord() const { assert(isValid()); return 3; }

  // See comments on the base class. 
  virtual int degree() const { assert(isValid()); return _degree; } 

  // See comments on the base class
  virtual GmIntegrationRuleType ruleType() const { return GM_GAUSS_RULE_TYPE; }

  // See comments on the base class. 
  virtual QString ruleName() const { return makeRuleName(GM_GAUSS_RULE_TYPE, _trule, _lrule); }

  // See comments on the base class
  virtual int rulePar(int num) const { return (num == 1) ? _trule : (num == 2 ? _lrule : -1); }

  // See comments on the base class
  virtual int ruleParNumPoints(int num) const { return (num == 1) ? _tTable->size() : (num == 2 ? _lTable->size() : -1); }

  // See comments on the base class
  virtual int cacheKey() const { return makeCacheKey(GM_WEDGE_GIR_KEY, false, _trule, _lrule); }

private:
  int _trule;            
  int _lrule;            
  int _degree;           
  const QVector<QPair<GmVector, double>>* _tTable;  
  const QVector<QPair<double, double>>*   _lTable;  
};

//--------------------------------------------------------
// Border rules
//--------------------------------------------------------

class GMC_API_EXPORT GmWedgeGaussFaceIntegrationRule : public GmProxyBorderIntegrationRule
{
public:
  GmWedgeGaussFaceIntegrationRule(GmCellType type, GmCellFaceType faceType, int rule1, int rule2)
    : GmProxyBorderIntegrationRule(type, 3, faceType == GM_QUAD_FACE ? 
                                            (GmIntegrationRule*) new GmQuadGaussIntegrationRule(rule1, rule2) :
                                            (GmIntegrationRule*) new GmTriGaussIntegrationRule(rule1), true) {}

  GmWedgeGaussFaceIntegrationRule(GmCellType type, GmCellFaceType faceType, GmIntegrationRuleType irType, int rule1, int rule2)
    : GmWedgeGaussFaceIntegrationRule(type, faceType, rule1, rule2) { Q_UNUSED(irType); }
};

class GMC_API_EXPORT GmWedgeGaussEdgeIntegrationRule : public GmProxyBorderIntegrationRule
{
public:
  GmWedgeGaussEdgeIntegrationRule(GmCellType type, int rule)
    : GmProxyBorderIntegrationRule(type, 3, new GmLineGaussIntegrationRule(rule), false) {}

  GmWedgeGaussEdgeIntegrationRule(GmCellType type, GmIntegrationRuleType irType, int rule)
    : GmWedgeGaussEdgeIntegrationRule(type, rule) { Q_UNUSED(irType); }
};


#endif