gmNfFileFormat.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 _GM_NF_FILE_FORMAT_H_
#define _GM_NF_FILE_FORMAT_H_
 
#include "gmFileFormat.h"
 
#include "gmValueInfo.h"
#include <nfr.h>
 
class GmNfFileFormat : public GmFileFormat
{
public:
  // Supported element types and file section names
  struct SupportedTypesT
  {
    struct GaussNumbering {
      const char* _rst;
      QVector<int> _numbering;
    };
    const char* _nfSecName;          
    const char* _ruleName;           
    const char* _afterMaterial;      
    const char* _afterNode;          
    int _accept;                     
    QVector<int> _nodeNumbering;     
    QHash<int, GaussNumbering> _gaussData; 
    bool        _needsIntId;         
 
    SupportedTypesT() : _nfSecName(""),  _ruleName(""), _afterMaterial(""), _afterNode(""),  _accept(0), _needsIntId(false) {}
 
    SupportedTypesT(const char* nfSecName, const char* ruleName, const char* afterMaterial, const char* afterNode, 
                    bool needsIntId, const QVector<int>& nodeNumbering, const QHash<int, GaussNumbering>& gaussNodeNumbering)
        : _nfSecName(nfSecName), _ruleName(ruleName), _afterMaterial(afterMaterial), _afterNode(afterNode), _accept(1), 
          _nodeNumbering(nodeNumbering), _gaussData(gaussNodeNumbering), _needsIntId(needsIntId) {
    }
  };
 
  // See comments on the base class
  virtual const char* formatName() const { return "Neutral file"; }
 
  // See comments on the base class
  virtual bool supportsMultipleIterations() const { return true; }
 
  // See comments on the base class
  virtual bool supportsSplitVectors() const { return true; }
 
  // See comments on the base class
  virtual bool acceptsNodeDimension(int ndim) const { return ndim == 2 || ndim == 3; }
 
  // See comments on the base class
  virtual bool acceptsDataType(const GmValueInfo* info, int nodeDim, int dimFilter = -1) const
  {
    // The neutral file format accepts scalar, vector and tensor values
    Q_UNUSED(info); Q_UNUSED(nodeDim); Q_UNUSED(dimFilter);
    return true;
  }
 
  // See comments on the base class
  virtual bool acceptsMultipleGaussProfiles() const { return false; }
 
  virtual bool acceptsGaussRuleForElement(GmCellType type, const GmIntegrationRule* ir) const;
 
  // See comments on the base class
  virtual bool acceptsDiscontinuitySet(GmDiscontinuitySet::DiscontinuityType type) const { Q_UNUSED(type); return false; }
 
  virtual int acceptsCellType(GmCellType type) const { return supportedTypesList()[type]._accept; }
 
  virtual const QVector<int>& cellNumbering(GmCellType type) const { return supportedTypesList()[type]._nodeNumbering; }
 
  virtual const QVector<int>& gaussNumbering(GmCellType type, int numIp) const { 
        static QVector<int> empty;
 
        const auto& it = supportedTypesList()[type]._gaussData.find(numIp);
        if (it != supportedTypesList()[type]._gaussData.end())
      return it.value()._numbering;
        else
      return empty;
  }
  //NF does not index cell types with integers
  virtual int fileCellType(GmCellType type) const { Q_UNUSED(type); return -1; }
 
  virtual const char* fileCellTypeName(GmCellType type) const {return supportedTypesList()[type]._nfSecName; }
 
  // See comments on the base class
  virtual bool supportsMeshChanges() const { return false; }
 
 
  static void registerSupportedCellType(GmCellType type, SupportedTypesT& cellData)
  {
    assert(supportedTypesList()[type]._accept == 0); // types should be registered only once
 
    if (cellData._accept) {
          //Build node numbering (gema order) if not provided
      if(cellData._nodeNumbering.isEmpty()) {
        GmCellGeometry g(type);
        for (int i = 0, n = g.numNodes(); i < n; i++)
          cellData._nodeNumbering.append(i);
      }
 
          auto endIt = cellData._gaussData.end();
      for(auto it = cellData._gaussData.begin(); it != endIt; ++it) {
                //Entry exists, but numbering is empty -> build gema order
                int nip = it.key();
                auto& vec = it.value()._numbering;
        if(vec.isEmpty()) {
          for (int i = 0; i < nip; i++)
            vec.append(i);
        }
          }
    }
 
    supportedTypesList()[type] = cellData;
  }
protected:
  
  static inline SupportedTypesT* supportedTypesList()
  {
    static SupportedTypesT supportedTypes[GM_NUM_CELL_TYPES];
    return supportedTypes;
  }
 
  // Old code, needed by file reader //
 
  //static const SupportedTypesT supportedTypes[];
  //static const int supportedTypesSize;
 
  struct nfrType {
    NfrResultType  nfType;
    GmValueSetKind gmKind;
    GmDimType      gmType;
    int            nfSize;
  };
 
  struct nfrElement {
    NfrElementType    nfEleType;
    NfrQuadratureType nfQuadType;
    double            nfQuadNatCrd[200];
  };
 
  static const nfrType    nfrTypeTable[];
  static const nfrElement nfrElementTable[];
 
  //int nf2gmCellNodeIndex(GmCellType type, int nfId);
  //int nf2gmCellGaussIndex(GmCellType type, int ngp, int nfId);
 
  unsigned int offset(unsigned int n) { return n == 1 ? 0 : n-1 + offset(n-1); }
};
 
 
#endif // _GM_NF_FILE_FORMAT_H_