gmQuadIntegrationRule.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_QUAD_INT_RULE_H_
#define _GEMA_QUAD_INT_RULE_H_

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

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

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

class GMC_API_EXPORT GmQuadGaussIntegrationRule : public GmLinearMultiTableIntegrationRule<2>
{
public:
  GmQuadGaussIntegrationRule(int xiRule, int etaRule)
    : GmLinearMultiTableIntegrationRule<2>(GM_GAUSS_RULE_TYPE, GM_QUAD_GIR_KEY,
                                           xiRule,  GmGaussIntegrationTables::lineRuleTable(xiRule),  GmGaussIntegrationTables::lineRuleDegree(xiRule),
                                           etaRule, GmGaussIntegrationTables::lineRuleTable(etaRule), GmGaussIntegrationTables::lineRuleDegree(etaRule))
  {
  }

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

class GMC_API_EXPORT GmQuadNewtonIntegrationRule : public GmLinearMultiTableIntegrationRule<2>
{
public:
  GmQuadNewtonIntegrationRule(int xiRule, int etaRule, bool closed)
    : GmLinearMultiTableIntegrationRule<2>(closed ? GM_CLOSED_NEWTON_RULE_TYPE : GM_OPEN_NEWTON_RULE_TYPE, GM_QUAD_NIR_KEY,
                                           xiRule,  GmNewtonIntegrationTables::lineRuleTable(xiRule,  closed), GmNewtonIntegrationTables::lineRuleDegree(xiRule),
                                           etaRule, GmNewtonIntegrationTables::lineRuleTable(etaRule, closed), GmNewtonIntegrationTables::lineRuleDegree(etaRule))
  {
  }

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

class GMC_API_EXPORT GmQuadLobattoIntegrationRule : public GmLinearMultiTableIntegrationRule<2>
{
public:
  GmQuadLobattoIntegrationRule(int xiRule, int etaRule)
    : GmLinearMultiTableIntegrationRule<2>(GM_LOBATTO_RULE_TYPE, GM_QUAD_LIR_KEY,
                                           xiRule,  GmLobattoIntegrationTables::lineRuleTable(xiRule),  GmLobattoIntegrationTables::lineRuleDegree(xiRule),
                                           etaRule, GmLobattoIntegrationTables::lineRuleTable(etaRule), GmLobattoIntegrationTables::lineRuleDegree(etaRule))
  {
  }

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


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


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

class GMC_API_EXPORT GmQuadGaussEdgeIntegrationRule : public GmQuadEdgeIntegrationRule
{
public:
  GmQuadGaussEdgeIntegrationRule(GmCellType type, int rule)
    : GmQuadEdgeIntegrationRule(type, new GmLineGaussIntegrationRule(rule)) {}

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

};

class GMC_API_EXPORT GmQuadLobattoEdgeIntegrationRule : public GmQuadEdgeIntegrationRule
{
public:
  GmQuadLobattoEdgeIntegrationRule(GmCellType type, int rule)
    : GmQuadEdgeIntegrationRule(type, new GmLineLobattoIntegrationRule(rule)) {}

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

#endif