gmHexIntegrationRule.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_HEX_INT_RULE_H_
#define _GEMA_HEX_INT_RULE_H_

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

#include "gmGaussIntegrationTables.h"
#include "gmLobattoIntegrationTables.h"
#include "gmNewtonCotesIntegrationTables.h"

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


class GMC_API_EXPORT GmHexGaussIntegrationRule : public GmLinearMultiTableIntegrationRule<3>
{
public:
  GmHexGaussIntegrationRule(int xiRule, int etaRule, int zetaRule)
    : GmLinearMultiTableIntegrationRule<3>(GM_GAUSS_RULE_TYPE, GM_HEX_GIR_KEY,
                                           xiRule,   GmGaussIntegrationTables::lineRuleTable(xiRule),   GmGaussIntegrationTables::lineRuleDegree(xiRule),
                                           etaRule,  GmGaussIntegrationTables::lineRuleTable(etaRule),  GmGaussIntegrationTables::lineRuleDegree(etaRule),
                                           zetaRule, GmGaussIntegrationTables::lineRuleTable(zetaRule), GmGaussIntegrationTables::lineRuleDegree(zetaRule))
  {
  }

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

class GMC_API_EXPORT GmHexNewtonIntegrationRule : public GmLinearMultiTableIntegrationRule<3>
{
public:
  GmHexNewtonIntegrationRule(int xiRule, int etaRule, int zetaRule, bool closed)
    : GmLinearMultiTableIntegrationRule<3>(closed ? GM_CLOSED_NEWTON_RULE_TYPE : GM_OPEN_NEWTON_RULE_TYPE, GM_HEX_NIR_KEY,
                                           xiRule,   GmNewtonIntegrationTables::lineRuleTable(xiRule,  closed),  GmNewtonIntegrationTables::lineRuleDegree(xiRule),
                                           etaRule,  GmNewtonIntegrationTables::lineRuleTable(etaRule, closed),  GmNewtonIntegrationTables::lineRuleDegree(etaRule),
                                           zetaRule, GmNewtonIntegrationTables::lineRuleTable(zetaRule, closed), GmNewtonIntegrationTables::lineRuleDegree(zetaRule))
  {
  }

  GmHexNewtonIntegrationRule(GmIntegrationRuleType irType, int rule1, int rule2, int rule3)
    : GmHexNewtonIntegrationRule(rule1, rule2, rule3, irType == GM_CLOSED_NEWTON_RULE_TYPE)
  {
    assert(irType == GM_CLOSED_NEWTON_RULE_TYPE || irType == GM_OPEN_NEWTON_RULE_TYPE); 
  }
};

class GMC_API_EXPORT GmHexLobattoIntegrationRule : public GmLinearMultiTableIntegrationRule<3>
{
public:
  GmHexLobattoIntegrationRule(int xiRule, int etaRule, int zetaRule)
    : GmLinearMultiTableIntegrationRule<3>(GM_LOBATTO_RULE_TYPE, GM_HEX_LIR_KEY,
                                           xiRule,   GmLobattoIntegrationTables::lineRuleTable(xiRule),   GmLobattoIntegrationTables::lineRuleDegree(xiRule),
                                           etaRule,  GmLobattoIntegrationTables::lineRuleTable(etaRule),  GmLobattoIntegrationTables::lineRuleDegree(etaRule),
                                           zetaRule, GmLobattoIntegrationTables::lineRuleTable(zetaRule), GmLobattoIntegrationTables::lineRuleDegree(zetaRule))
  {
  }

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

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

class GMC_API_EXPORT GmHexFaceIntegrationRule : public GmProxyBorderIntegrationRule
{
protected:
  GmHexFaceIntegrationRule(GmCellType type, GmIntegrationRule* ir)
    : GmProxyBorderIntegrationRule(type, 3, ir, true) {}
};

class GMC_API_EXPORT GmHexGaussFaceIntegrationRule : public GmHexFaceIntegrationRule
{
public:
  GmHexGaussFaceIntegrationRule(GmCellType type, int rule1, int rule2)
    : GmHexFaceIntegrationRule(type, new GmQuadGaussIntegrationRule(rule1, rule2)) {}

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

class GMC_API_EXPORT GmHexLobattoFaceIntegrationRule : public GmHexFaceIntegrationRule
{
public:
  GmHexLobattoFaceIntegrationRule(GmCellType type, int rule1, int rule2)
    : GmHexFaceIntegrationRule(type, new GmQuadLobattoIntegrationRule(rule1, rule2)) {}

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

class GMC_API_EXPORT GmHexEdgeIntegrationRule : public GmProxyBorderIntegrationRule
{
protected:
  GmHexEdgeIntegrationRule(GmCellType type, GmIntegrationRule* ir)
    : GmProxyBorderIntegrationRule(type, 3, ir, false) {}
};

class GMC_API_EXPORT GmHexGaussEdgeIntegrationRule: public GmHexEdgeIntegrationRule
{
public:
  GmHexGaussEdgeIntegrationRule(GmCellType type, int rule) 
    : GmHexEdgeIntegrationRule(type, new GmLineGaussIntegrationRule(rule)) {}

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

class GMC_API_EXPORT GmHexLobattoEdgeIntegrationRule: public GmHexEdgeIntegrationRule
{
public:
  GmHexLobattoEdgeIntegrationRule(GmCellType type, int rule)
    : GmHexEdgeIntegrationRule(type, new GmLineLobattoIntegrationRule(rule)) {}

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


#endif