gmIntegrationRule.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_INT_RULE_H_
#define _GEMA_INT_RULE_H_
 
#include "gmCoreConfig.h"
#include "gmVector.h"
#include "gmCellType.h"
 
#include <QString>
#include <QMutex>
#include <assert.h>
 
 
enum GmIntegrationRuleCacheKeyBase
{
  GM_LINE_GIR_KEY  =  10000000,  
  GM_QUAD_GIR_KEY  =  20000000,  
  GM_TRI_GIR_KEY   =  30000000,  
  GM_HEX_GIR_KEY   =  40000000,  
  GM_TET_GIR_KEY   =  50000000,  
  GM_WEDGE_GIR_KEY =  60000000,  
  GM_PYRA_GIR_KEY  =  70000000,  
  GM_INT_GIR_KEY   =  80000000,  
                           
  GM_LINE_NIR_KEY  =  90000000,  
  GM_QUAD_NIR_KEY  = 100000000,  
  GM_TRI_NIR_KEY   = 110000000,  
  GM_HEX_NIR_KEY   = 120000000,  
  GM_TET_NIR_KEY   = 130000000,  
  GM_INT_NIR_KEY   = 140000000,  
                              
  GM_LINE_LIR_KEY  = 150000000,  
  GM_QUAD_LIR_KEY  = 160000000,  
  GM_HEX_LIR_KEY   = 170000000,  
 
  //-----------
  GM_USER_IR_KEY   = 180000000, 
};
 
enum GmIntegrationRuleType
{
  // Please, pretty please, do NOT change the order of the following enum.
  // For that, and also when adding entries, you MUST update the implementation 
  // for the GmIntegrationRule::makeRuleName() method and for the 
  // GmCellGeometryIntegrationRuleSetDefaultRules and GmCellGeometryIntegrationRuleSet 
  // classes. You will also need to change all instantiation of those template classes.
  // --------------------------------------
  GM_GAUSS_RULE_TYPE,         
  GM_LOBATTO_RULE_TYPE,       
  GM_CLOSED_NEWTON_RULE_TYPE, 
  GM_OPEN_NEWTON_RULE_TYPE,   
 
  // --------------------------------------
  // --- Do not add rules  below this line
  // --------------------------------------
  GM_NUM_RULE_TYPES,          
  GM_AUTO_RULE_TYPE,          
};
 
class GMC_API_EXPORT GmIntegrationRule
{
public:
  virtual ~GmIntegrationRule() {}
 
  virtual bool isValid() const = 0;
 
  virtual int numPoints() const = 0;
 
  virtual void integrationPoint(int index, GmVector& naturalCoord, double* weight) const = 0;
 
  virtual int numNaturalCoord() const = 0;
 
  virtual int degree() const = 0;
 
  virtual GmIntegrationRuleType ruleType() const = 0;
 
  virtual QString ruleName() const = 0;
 
  virtual int rulePar(int num) const = 0;
 
  virtual int ruleParNumPoints(int num) const = 0;
 
  virtual int cacheKey() const = 0;
 
  virtual const QVector<int>& closestIntegrationIndex(GmCellType type, int P, int Q, int nodeIndex) const;
 
  static GmIntegrationRule* instance(GmCellType type, int P, int Q, GmIntegrationRuleType irType, int rule1 = -1, int rule2 = -1, int rule3 = -1);
 
protected:
  int makeCacheKey(GmIntegrationRuleCacheKeyBase base, bool closed, int rule1, int rule2 = -1, int rule3 = -1) const
  {
    assert(rule1 < 100 && rule2 < 100 && rule3 < 100);
    assert(base >= 10000000);
    int key = base + (closed * 1000000) + rule1;
    if(rule2 != -1) key += rule2 * 100;
    if(rule3 != -1) key += rule3 * 10000;
    return key;
  }
 
  QString makeRuleName(GmIntegrationRuleType irType, int rule1, int rule2 = -1, int rule3 = -1) const;
 
private:
  static QMap<QPair<GmCellType, int>, QVector<QVector<int> > > _cipCache;      
 
  static QMutex _cipCacheMutex;
};
 
template <int N>
class GMC_API_EXPORT GmLinearMultiTableIntegrationRule : public GmIntegrationRule
{
  static_assert(N >= 1 && N <= 3, "Unexpeced number of tables");
 
public:
  // See comments on the base class
  bool isValid() const { return _tables[0]; }
 
  // See comments on the base class
  virtual int numPoints() const { assert(isValid());  return _nip; }
 
  virtual void integrationPoint(int index, GmVector& naturalCoord, double* weight) const;
 
  // See comments on the base class
  virtual int numNaturalCoord() const { assert(isValid()); return N; }
 
  // 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 _rtype; }
 
  // See comments on the base class
  virtual QString ruleName() const { return makeRuleName(_rtype, _rules[0], _rules[1], _rules[2]); }
 
  // See comments on the base class
  virtual int rulePar(int num) const { assert(num >= 1 && num <= 3); return _rules[num-1]; }
 
  // See comments on the base class
  virtual int ruleParNumPoints(int num) const 
  {
    assert(num >= 1 && num <= 3); 
    return _tables[num-1] ? _tables[num-1]->size() : -1;
  }
 
  // See comments on the base class
  virtual int cacheKey() const { return makeCacheKey(_keyBase, _rtype == GM_CLOSED_NEWTON_RULE_TYPE, _rules[0], _rules[1], _rules[2]); }
 
protected:
  GmLinearMultiTableIntegrationRule(GmIntegrationRuleType ruleType, GmIntegrationRuleCacheKeyBase cacheKeyBase,
                                    int rule1,      const QVector<QPair<double, double>>* table1, int degree1,
                                    int rule2 = -1, const QVector<QPair<double, double>>* table2 = NULL, int degree2 = 0,
                                    int rule3 = -1, const QVector<QPair<double, double>>* table3 = NULL, int degree3 = 0);
 
  GmIntegrationRuleType _rtype;    
  int                   _degree;   
  int                   _nip;      
  int                   _rules[3]; 
  const QVector<QPair<double, double>>* _tables[3];  
  GmIntegrationRuleCacheKeyBase         _keyBase;    
};
 
template <int N>
class GMC_API_EXPORT GmSingleTableIntegrationRule : public GmIntegrationRule
{
public:
  // See comments on the base class
  bool isValid() const { return _table; }
 
  // See comments on the base class
  virtual int numPoints() const { assert(isValid()); return _table->size(); }
 
  virtual void integrationPoint(int index, GmVector& naturalCoord, double* weight) const;
 
  // See comments on the base class
  virtual int numNaturalCoord() const { assert(isValid()); return N; }
 
  // 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 _rtype; }
 
  // See comments on the base class
  virtual QString ruleName() const { return makeRuleName(_rtype, _rule); }
 
  // See comments on the base class
  virtual int rulePar(int num) const { return (num == 1) ? _rule : -1; }
 
  // See comments on the base class
  virtual int ruleParNumPoints(int num) const { return (num == 1) ? numPoints() : -1; }
 
  // See comments on the base class
  virtual int cacheKey() const { return makeCacheKey(_keyBase, _rtype == GM_CLOSED_NEWTON_RULE_TYPE, _rule); }
 
protected:
  GmSingleTableIntegrationRule(GmIntegrationRuleType ruleType, GmIntegrationRuleCacheKeyBase cacheKeyBase,
                               int rule, const QVector<QPair<GmVector, double>>* table, int degree);
 
  GmIntegrationRuleType _rtype;    
  int                   _degree;   
  int                   _rule;     
  const QVector<QPair<GmVector, double>>* _table;    
  GmIntegrationRuleCacheKeyBase           _keyBase;  
};
 
template <int N> using GmBarycentricSingleTableIntegrationRule = GmSingleTableIntegrationRule<N>;
 
template <int N>
class GMC_API_EXPORT GmReducedBarycentricSingleTableIntegrationRule : public GmBarycentricSingleTableIntegrationRule<N>
{
public:
  virtual void integrationPoint(int index, GmVector& naturalCoord, double* weight) const;
 
  using GmBarycentricSingleTableIntegrationRule<N>::GmBarycentricSingleTableIntegrationRule;
};
 
 
#endif