gmpGemaCellMeshData.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_PLUGIN_GEMA_CELL_MESH_DATA_H_
#define _GEMA_PLUGIN_GEMA_CELL_MESH_DATA_H_

#include "gmpCellMeshData.h"
#include "gmpGemaCell.h"

#include <gmLuaCell.h>
#include <gmStateDump.h>


template <template <class> class Vector>
struct GMP_GEMAMESH_API_EXPORT GmpGemaCellMeshData : public GmpCellMeshData<Vector>
{
  GmpGemaCellMeshData(GmCellMesh* mesh)
    : GmpCellMeshData<Vector>(mesh)
  {}

  virtual ~GmpGemaCellMeshData() { releaseOwnMemory(); }

  virtual Vector<int>* cellNodesVector() { return &_cellNodeIndices; }

  virtual void updateCellNodeOffset(GmCell* c, int offset)
  {
    assert(offset >= 0  && offset < _cellNodeIndices.size());
    // This is ugly but we are sure that the cell is a decendent of GmGemaCell and also
    // that class sizes are independent of the type and size template parameters so we 
    // can get away with accessing the _nodeOffset field as is done and explained in 
    // cellMemory().
    // TODO: find a better way (without adding methods to GmCell)
    GmpGemaCell<GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>* gc = (GmpGemaCell<GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>*)c;
    gc->setOffset(offset);
  }

  // See comments on the base class
  virtual void releaseMemory(bool clearBoundaryData = true)
  {
    GmpCellMeshData::releaseMemory(clearBoundaryData);
    releaseOwnMemory();
  }

  int* cellNodesPtr(int offset) { return _cellNodeIndices.iptr(offset); }

  virtual size_t cellMemory() const 
  { 
    // - The base size of each cell is one id + a pointer to the property list + pointer to the cell node list
    // - If ghost nodes are allowed, each cell also stores a QVarLengthArray<int> with ghost entries (contributing  
    //   with the vector size + the number of ghost nodes)
    // - The property list has a size equal to the number of cells * the number of property sets
    // - The node list has a size equal to the number of cells * the number of nodes per cell (different 
    //   per cell type).
    // - If dump aux vectors are different from NULL, they should also be accounted for

    // In the code bellow we assume that the basic sizeof() of a cell type independs if it is a GmCell 
    // or a GmElement. It is also independent of the cell type or the use of hierarchical elements
    assert(sizeof(GmpGemaCell     <GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>) == sizeof(GmpGemaCell     <GmElement, GmLuaElement, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>));
    assert(sizeof(GmpGemaCell     <GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>) == sizeof(GmpGemaCell     <GmCell,    GmLuaCell,    GmpGemaCellMeshData<Vector>, GM_HEX8, 8, 8>));
    assert(sizeof(GmpGemaGhostCell<GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>) == sizeof(GmpGemaGhostCell<GmElement, GmLuaElement, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>));
    assert(sizeof(GmpGemaGhostCell<GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>) == sizeof(GmpGemaGhostCell<GmCell,    GmLuaCell,    GmpGemaCellMeshData<Vector>, GM_HEX8, 8, 8>));
    assert(sizeof(GmpGemaGhostCell<GmElement, GmLuaElement, GmpGemaCellMeshData<Vector>, GM_QUAD4, 4, 4>) == sizeof(GmpGemaGhostCell<GmpHElementBase<0>, GmLuaHElement, GmpGemaCellMeshData<Vector>, GM_HQUADP, 4, 4>));

    // Base size for the cell vector
    size_t size = _cells.usedMemory();
      
    // The size for each, independently allocated, cell structure
    size += _numCells * (_ghostEnabled ? sizeof(GmpGemaGhostCell<GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>) :
                                         sizeof(GmpGemaCell     <GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>));

    // Property set indices per cell
    size += _cellPropertyIndices.usedMemory();

    // Node indices per cell
    size += _cellNodeIndices.usedMemory();

    if(_maxNumGhostNodes > 0)  // A mesh can have ghost nodes enabled but no ghost nodes...
    {
      for(int i = 0; i<_numCells; i++)
      {
        // The cast bellow works since cell class layouts are independent of the element type and number of 
        // nodes (see asserts above). Keep in mind that we are NOT going to call any methods that depend 
        // on the cell type / number of nodes. Those would NOT work with the said cast.  
        GmpGemaGhostCell<GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>* c = (GmpGemaGhostCell<GmCell, GmLuaCell, GmpGemaCellMeshData<Vector>, GM_BAR2, 2, 2>*)_cells[i];

        size += c->_ghostList.capacity() * sizeof(int);
      }
    }

    // Account for dump vectors
    if(_cellDumpTypeActiveData)
      size += _numCells * sizeof(char);

    if(_cellDumpGhostData)
      size += _cellDumpGhostDataSize * sizeof(int);

    return size;
  }

  virtual bool addStateGeometryData(GmSimulationData* simData, GmMesh* mesh, GmpMeshLoaderCellAllocator alloc, 
                                    GmStateDump* state, int groupId)
  {
    // Adds the buffer item used to store cell nodes before calling the base class
    // This is needed to make sure that the node data vector is loaded before
    // the other cell information and so is available when recreating cell objects
    GmStateDumpSDVectorDataItem<Vector<int>>* cndi;
    cndi = new GmStateDumpSDVectorDataItem<Vector<int>>(state->nextIdInGroup(groupId), &_cellNodeIndices, 
                                                        false, state->logger(), false, "CellMeshDataCellNodes");
    state->addStateItem(cndi, groupId);

    // Call base class
    return GmpCellMeshData::addStateGeometryData(simData, mesh, alloc, state, groupId);
  }


  Vector<int> _cellNodeIndices;

private:

  void releaseOwnMemory()
  {
    _cellNodeIndices.clear();
  }
};

#endif