gmDiscontinuity.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2023 by Carlos Augusto Teixeira 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_DISCONTINUITY_H_
#define _GEMA_DISCONTINUITY_H_
 
#include "gmLog.h"
#include "gmPODVector.h"
 
class GmDiscontinuitySet;
class GmCellMesh;
 
class GMC_API_EXPORT GmDiscontinuity
{
public:
  virtual ~GmDiscontinuity() {}
 
  int index() const { return _index; }
 
  QString id() const { return _id; }
 
  int cellGroupIndex() const { return _groupIndex; }
 
  void setCellGroupIndex(int group) { _groupIndex = group; }
 
  virtual int propertyIndex(int propertySet) const { return _psIndex[propertySet]; }
 
  virtual int numElements() const = 0;
 
  virtual int numPoints() const = 0;
 
  virtual int numIntersections() const = 0;
 
  virtual bool extendGeometry(GmCellMesh* sMesh, double size, const GmLogCategory& logger) = 0;
 
  virtual void clearGeometry() = 0;
 
  virtual void printGeometry(const GmLogCategory& logger, GmLogLevel level) const = 0;
 
  virtual size_t usedGeometryMemory() const = 0;
 
  virtual bool findIntersections(const GmLogCategory& logger) { Q_UNUSED(logger);  return true; }
 
  virtual void printIntersections(const GmLogCategory& logger, GmLogLevel level) const { Q_UNUSED(logger); Q_UNUSED(level); }
 
  virtual size_t usedIntersectionMemory() const { return 0; }
 
private:
  Q_DISABLE_COPY(GmDiscontinuity);
 
protected:
  GmDiscontinuity(const GmDiscontinuitySet* ds, int index, QString id, int groupIndex, const QVector<int>& psIndex)
    : _ds(ds), _index(index), _id(id), _groupIndex(groupIndex), _psIndex(psIndex) {}
 
  virtual void setGeometry(double* dvec, int nd, int* ivec, int ni) = 0;
  virtual bool loadGeometryFromTable(LuaTable& tab, const GmLogCategory& logger) = 0;
 
  template <class T, class V>
  static T* loadIntoVector(LuaTable& tab, V validator, int n, int* realSize, 
                           QString discontinuityId, const char* msg, const GmLogCategory& logger);
 
  friend class GmDiscontinuitySet;
 
  const GmDiscontinuitySet* _ds; 
  int          _index;      
  QString      _id;         
  int          _groupIndex; 
  QVector<int> _psIndex;    
};
 
 
template <class T, class V>
T* GmDiscontinuity::loadIntoVector(LuaTable& tab, V validator, int n, int* realSize, 
                                   QString discontinuityId, const char* msg, const GmLogCategory& logger)
{
  S_TRACE();
  assert(realSize);
  assert(tab.isValid());
 
  *realSize = 0;
  int npoints = tab.size();
 
  //Cannot have empty points/triangles data
  //if(!npoints) return NULL; //Conflict with current load of dump
 
  int nreal   = 0;
 
  GmPODVector<T, size_t, GmPODVectorStdGrow<size_t>, true> tvec;
  if(!tvec.resize(npoints * n))
  {
    gmFatalMsg(logger, QObject::tr("Error allocating memory for %1 %2 points for discontinuity %3.").arg(npoints).arg(msg).arg(discontinuityId));
    return NULL;
  }
 
  for(int i = 0, k = 0; i < npoints; i++)
  {
    LuaStackBalancer b(tab.env());
    LuaTable entry = tab.getIndex(i + 1).value<LuaTable>();
    if(!entry.isValid())
    {
      gmFatalMsg(logger, QObject::tr("Invalid %1 entry %2 for discontinuity %3. Expecting a table.").arg(msg).arg(i + 1).arg(discontinuityId));
      return NULL;
    }
 
    int status;
    for(int j = 0; j < n; j++)
    {
      T v = validator(j, entry.getIndex(j + 1), &status);
      if(status == -1) // Entry should be ignored
        break;
      if(status == -2)
      {
        gmFatalMsg(logger, QObject::tr("Invalid %1 entry %2, column %3, for discontinuity %4.").arg(msg).arg(i + 1).arg(j + 1).arg(discontinuityId));
        return NULL;
      }
      tvec[k+j] = v;
    }
 
    if(status == -1)
      continue;
    
    k += n;
    nreal++;
  }
 
  *realSize = nreal;
 
  // Notice that GmPODVector will store internally, after a shrink, a NULL vector if size is 0.
  // Since the discontinuity objects can't handle properly a NULL vector for a 0 sized list,
  // we will return a 0 length vector for those cases (which was the case on previous versions
  // of this method, before support for partitioned meshes). This also allows us to keep returning 
  // NULL for the error case.
  if(!nreal)
    return new T[0];  // This will return a non NULLpointer to an "empty" vec
 
  if(nreal != npoints)
  {
    tvec.resize(nreal * n);
    tvec.shrink();
  }
  return tvec.takeData();
}
#endif // _GEMA_DISCONTINUITY_H_