PNTMesh::pntMesh Class Reference

Detailed Description

Definition at line 98 of file pntMesh.H.

Public Member Functions
	pntMesh ()
	pntMesh (const std::string &ifname)
	pntMesh (const meshBase *imb, int dim, int nBlk, const BlockMap &elmBlkMap)
	~pntMesh ()=default
bool	isCompatible () const
int	getNumberOfPoints () const
int	getNumberOfCells () const
int	getNumberOfBlocks () const
std::vector< double >	getPointCrd (int id) const
std::vector< int >	getElmConn (int id) const
std::vector< int >	getElmConn (int id, VTKCellType vct) const
std::vector< int >	getPntConn (std::vector< int > &ci, elementType et, int eo) const
std::string	getBlockName (int id) const
elementType	getBlockElmType (int id) const
elementType	getElmType (int id) const
int	getElmOrder (int id) const
VTKCellType	getVtkCellTag (elementType et, int order) const
void	write (const std::string &fname) const

Private Member Functions
void	pntPopulate (const meshBase *imb)
void	updElmBlk (int blkId)

Private Attributes
std::string	ifname
int	numVertices
int	numElements
int	numDimensions
int	numBlocks
int	numSurfaces
int	numSurfInternal
int	numSurfBoundary
std::vector< std::vector< double > >	pntCrds
std::vector< std::vector< int > >	elmConn
std::vector< elementType >	elmTyp
std::vector< int >	elmOrd
std::vector< int >	elmBlkId
std::vector< int >	elmLocalId
std::vector< std::vector< int > >	elmSrfId
std::vector< blockType >	elmBlks
bool	isSupported
std::set< std::set< int > >	connSet
std::map< std::set< int >, int >	surfConnToId
std::map< int, std::set< int > >	surfIdToConn
std::vector< bool >	surfOnBndr
std::map< int, std::vector< std::pair< int, int > > >	surfAdjRefNum
std::map< int, std::vector< int > >	surfAdjElmNum

Constructor & Destructor Documentation

pntMesh() [1/3]

PNTMesh::pntMesh::pntMesh

(

)

Definition at line 173 of file pntMesh.C.

    : ifname(""), isSupported(true)
{}

pntMesh() [2/3]

PNTMesh::pntMesh::pntMesh ( const std::string &  ifname )

explicit

Definition at line 177 of file pntMesh.C.

References PNTMesh::blockType::adjBlkId, PNTMesh::blockType::adjElmId, PNTMesh::blockType::adjRefId, PNTMesh::bcTagNum(), PNTMesh::blockType::eConn, elmBlks, elmConn, elmOrd, elmTyp, PNTMesh::elmTypeNum(), PNTMesh::elmTypeStr(), PNTMesh::blockType::eTpe, PNTMesh::blockType::glbSrfId, isSupported, PNTMesh::blockType::nodesPerElement, numBlocks, PNTMesh::blockType::numBoundarySurfacesInBlock, numDimensions, numElements, PNTMesh::blockType::numElementsInBlock, numSurfaces, numSurfBoundary, numSurfInternal, PNTMesh::blockType::numSurfPerEleInBlock, numVertices, PNTMesh::blockType::ordEquat, PNTMesh::blockType::ordIntrp, pntCrds, PNTMesh::blockType::regionName, PNTMesh::blockType::srfBCEleRef, PNTMesh::blockType::srfBCTag, PNTMesh::TETRAHEDRON, and PNTMesh::TRIANGLE.

    : ifname(ifname), isSupported(true)
{

  // NOTE: If file is very large different means are needed
  // current implementation is focused on the speed of reading
  // information from the file.

  std::ifstream fs(ifname);
  if (!fs.good())
  {
    std::cout << "Error opening file " << ifname << std::endl;
    exit(1);
  }

  // read entire file into buffer and then pass to stream
  std::stringstream ss;
  ss << fs.rdbuf();

  /////////////////////////////
  // processing CARD 01
  // //////////////////////////
  // header
  int dmi;
  std::string dms;

  ss >> numVertices;
  ss >> numElements;
  ss >> numDimensions;
  ss >> numBlocks;
  ss >> numSurfaces;
  ss >> numSurfInternal;
  ss >> numSurfBoundary;
  ss >> dmi; // dummy
  ss >> dmi;
  ss >> dmi;

  std::cout << "Reading PNT Mesh..." << std::endl;
  std::cout << "Number of vertices : " << numVertices << std::endl;
  std::cout << "Number of eLements : " << numElements << std::endl;
  std::cout << "Number of dimensions : " << numDimensions << std::endl;
  std::cout << "Number of blocks : " << numBlocks << std::endl;
  std::cout << "Number of surfaces : " << numSurfaces << std::endl;
  std::cout << "Number of internals surface : " << numSurfInternal << std::endl;
  std::cout << "Number of boundary surface  : " << numSurfBoundary << std::endl;

  /////////////////////////////
  // processing CARD 02
  // //////////////////////////
  // nodal coords
  pntCrds.resize(numVertices, std::vector<double>(3, 0));
  for (int id = 0; id < numDimensions; id++)
    for (int iv = 0; iv < numVertices; iv++)
      ss >> pntCrds[iv][id];

  /////////////////////////////
  // processing CARD 03
  // //////////////////////////
  // block data
  elmBlks.resize(numBlocks);
  for (int iBlk = 0; iBlk < numBlocks; iBlk++)
  {
    blockType nb;

    // block header
    ss >> nb.numElementsInBlock;
    ss >> nb.numBoundarySurfacesInBlock;
    ss >> nb.nodesPerElement;
    ss >> dmi;
    ss >> nb.ordIntrp;
    ss >> nb.ordEquat;
    ss >> dms;
    std::cout << dms << std::endl;
    nb.eTpe = elmTypeNum(dms);
    ss >> nb.regionName;

    std::cout << "================================================"
              << std::endl;
    std::cout << "Processing block " << nb.regionName << std::endl;
    std::cout << "Num Elements : " << nb.numElementsInBlock << std::endl;
    std::cout << "Num Boundary Surfaces : " << nb.numBoundarySurfacesInBlock
              << std::endl;
    std::cout << "Num Nodes/Element : " << nb.nodesPerElement << std::endl;
    std::cout << "Element order : " << nb.ordIntrp << std::endl;
    std::cout << "Equation order : " << nb.ordEquat << std::endl;
    std::cout << "Element Type : " << elmTypeStr(nb.eTpe) << std::endl;

    // make sure all blocks are tetrahedral or triangular
    if (nb.eTpe != elementType::TETRAHEDRON
        && nb.eTpe != elementType::TRIANGLE)
      isSupported = false;

    // element connectivity array
    std::cout << "Reading block...";
    nb.eConn.resize(nb.numElementsInBlock);
    for (int ibe = 0; ibe < nb.numElementsInBlock; ibe++)
    {
      std::vector<idTyp> conn;
      conn.resize(nb.nodesPerElement);
      for (int ine = 0; ine < nb.nodesPerElement; ine++)
      {
        ss >> conn[ine];
        --conn[ine]; // pnt mesh is 1-indexed
      }
      nb.eConn[ibe] = conn;
      elmConn.push_back(conn);
      elmTyp.push_back(nb.eTpe);
      elmOrd.push_back(nb.ordIntrp);
    }

    // surface boundary tags
    std::cout << "...";
    nb.srfBCTag.resize(nb.numBoundarySurfacesInBlock);
    for (int ist = 0; ist < nb.numBoundarySurfacesInBlock; ist++)
    {
      ss >> dms;
      nb.srfBCTag[ist] = bcTagNum(dms);
    }

    // element surface reference number
    std::cout << "...";
    nb.srfBCEleRef.resize(2 * nb.numBoundarySurfacesInBlock);
    for (int ise = 0; ise < nb.numBoundarySurfacesInBlock; ise++)
    {
      idTyp er;
      ss >> er;
      nb.srfBCEleRef.push_back(er);
      ss >> er;
      nb.srfBCEleRef.push_back(er);
    }

    // adjacancy header
    std::cout << "...";
    ss >> dmi;
    ss >> nb.numSurfPerEleInBlock;
    int ni = nb.numSurfPerEleInBlock * nb.numElementsInBlock;
    nb.glbSrfId.resize(ni);
    nb.adjBlkId.resize(ni);
    nb.adjElmId.resize(ni);
    nb.adjRefId.resize(ni);

    // global surface ids 
    std::cout << "...";
    for (int i = 0; i < ni; i++)
      ss >> nb.glbSrfId[i];

    // adjacent block ids
    std::cout << "...";
    for (int i = 0; i < ni; i++)
      ss >> nb.adjBlkId[i];

    // adjacent element ids
    std::cout << "...";
    for (int i = 0; i < ni; i++)
      ss >> nb.adjElmId[i];

    // adjacent reference ids
    std::cout << "..." << std::endl;
    for (int i = 0; i < ni; i++)
      ss >> nb.adjRefId[i];

    // block finishes
    elmBlks[iBlk] = nb;
  }

  // closing the file
  fs.close();
}

pntMesh() [3/3]

PNTMesh::pntMesh::pntMesh	(	const meshBase *	imb,
		int	dim,
		int	nBlk,
		const BlockMap &	elmBlkMap
	)

Definition at line 351 of file pntMesh.C.

References elmBlkId, elmBlks, elmConn, elmLocalId, PNTMesh::elmNumNde(), PNTMesh::elmNumSrf(), elmOrd, elmTyp, meshBase::getDataSet(), meshBase::getNumberOfCells(), meshBase::getNumberOfPoints(), numBlocks, numElements, numVertices, pntCrds, pntPopulate(), and PNTMesh::v2pEMap().

    : numDimensions(dim), numBlocks(nBlk), numSurfaces(0), numSurfInternal(0),
      numSurfBoundary(0)
{
  numVertices = imb->getNumberOfPoints();
  numElements = imb->getNumberOfCells();

  // populating point coordinates
  pntCrds.resize(numVertices);
  for (int ipt = 0; ipt < numVertices; ipt++)
  {
    std::vector<double> crds;
    crds.resize(3, 0.);
    imb->getDataSet()->GetPoint(ipt, &crds[0]);
    pntCrds[ipt] = crds;
  }

  // populating cell connectivity
  elmConn.resize(numElements);
  elmTyp.resize(numElements);
  for (int i = 0; i < numElements; ++i)
  {
    vtkIdList *point_ids = imb->getDataSet()->GetCell(i)->GetPointIds();
    int numComponent = point_ids->GetNumberOfIds();
    std::vector<int> cn;
    cn.resize(numComponent);
    for (int j = 0; j < numComponent; ++j)
      cn[j] = point_ids->GetId(j);
    elmConn[i] = cn;

    VTKCellType type_id = static_cast<VTKCellType>(imb->getDataSet()->GetCellType(i));
    elmTyp[i] = v2pEMap(type_id);
  }

  // populating element block ids, and order
  elmBlkId.resize(numElements, -1);
  elmLocalId.resize(numElements, -1);
  elmOrd.resize(numElements, -1);
  for (int iBlk = 0; iBlk < numBlocks; iBlk++)
  {
    int lid = 0;
    for (auto it = elmBlkMap[iBlk].elmIds.begin();
         it != elmBlkMap[iBlk].elmIds.end();
         it++)
    {
      elmBlkId[*it] = iBlk;
      elmLocalId[*it] = lid++;
      elmOrd[*it] = elmBlkMap[iBlk].ordIntrp;
    }
  }

  // analyzing element blocks and populating some of the
  // fileds
  elmBlks = elmBlkMap;
  for (int iBlk = 0; iBlk < numBlocks; iBlk++)
  {
    elmBlks[iBlk].numElementsInBlock = elmBlks[iBlk].elmIds.size();
    elmBlks[iBlk].nodesPerElement = elmNumNde(elmBlks[iBlk].eTpe,
                                              elmBlks[iBlk].ordIntrp);
    elmBlks[iBlk].numSurfPerEleInBlock = elmNumSrf(elmBlks[iBlk].eTpe);
    std::cout << "Block Name = " << elmBlks[iBlk].regionName << std::endl;
    std::cout << "Block size = " << elmBlks[iBlk].numElementsInBlock
              << std::endl;
  }

  //populate remaining fields
  pntPopulate(imb);
}

~pntMesh()

PNTMesh::pntMesh::~pntMesh ( )

default

Member Function Documentation

getBlockElmType()

PNTMesh::elementType PNTMesh::pntMesh::getBlockElmType

(

int

id

)

const

Definition at line 527 of file pntMesh.C.

References elmBlks, id, and numBlocks.

{
  if (id >= numBlocks || id < 0)
  {
    std::cerr << "Invalid Block Id " << std::endl;
    throw;
  }
  return elmBlks[id].eTpe;
}

getBlockName()

std::string PNTMesh::pntMesh::getBlockName

(

int

id

)

const

Definition at line 517 of file pntMesh.C.

References elmBlks, id, and numBlocks.

{
  if (id >= numBlocks || id < 0)
  {
    std::cerr << "Invalid Block Id " << std::endl;
    throw;
  }
  return elmBlks[id].regionName;
}

getElmConn() [1/2]

std::vector<int> PNTMesh::pntMesh::getElmConn ( int  id ) const

inline

Definition at line 114 of file pntMesh.H.

References id.

Referenced by meshBase::exportPntToVtk(), and getElmConn().

{ return elmConn[id]; }

getElmConn() [2/2]

std::vector< int > PNTMesh::pntMesh::getElmConn	(	int	id,
		VTKCellType	vct
	)		const

Definition at line 421 of file pntMesh.C.

References getElmConn().

{
  std::vector<int> ci = getElmConn(id);
  std::vector<int> co;
  co = ci;
  if (vct == VTK_QUADRATIC_TRIANGLE)
  {
    co[0] = ci[0];
    co[1] = ci[2];
    co[2] = ci[4];
    co[3] = ci[1];
    co[4] = ci[3];
    co[5] = ci[5];
  }
  else if (vct == VTK_QUADRATIC_HEXAHEDRON)
  {
    co[0] = ci[0];
    co[1] = ci[2];
    co[2] = ci[8];
    co[3] = ci[6];
    co[4] = ci[18];
    co[5] = ci[20];
    co[6] = ci[26];
    co[7] = ci[24];
    co[8] = ci[1];
    co[9] = ci[5];
    co[10] = ci[7];
    co[11] = ci[3];
    co[12] = ci[19];
    co[13] = ci[23];
    co[14] = ci[25];
    co[15] = ci[21];
    co[16] = ci[9];
    co[17] = ci[11];
    co[18] = ci[17];
    co[19] = ci[15];
    co[20] = ci[12];
    co[21] = ci[14];
    co[22] = ci[10];
    co[23] = ci[16];
    co[24] = ci[4];
    co[25] = ci[22];
    co[26] = ci[13];
  }
  return co;
}

getElmOrder()

int PNTMesh::pntMesh::getElmOrder

(

int

id

)

const

Definition at line 547 of file pntMesh.C.

References elmOrd, id, and numElements.

Referenced by meshBase::exportPntToVtk().

{
  if (id >= numElements || id < 0)
  {
    std::cerr << "Invalid Element ID " << std::endl;
    throw;
  }
  return elmOrd[id];
}

getElmType()

PNTMesh::elementType PNTMesh::pntMesh::getElmType

(

int

id

)

const

Definition at line 537 of file pntMesh.C.

References elmTyp, id, and numElements.

Referenced by meshBase::exportPntToVtk().

{
  if (id >= numElements || id < 0)
  {
    std::cerr << "Invalid Element ID " << std::endl;
    throw;
  }
  return elmTyp[id];
}

getNumberOfBlocks()

int PNTMesh::pntMesh::getNumberOfBlocks ( ) const

inline

Definition at line 111 of file pntMesh.H.

{ return numBlocks; }

getNumberOfCells()

int PNTMesh::pntMesh::getNumberOfCells ( ) const

inline

Definition at line 110 of file pntMesh.H.

Referenced by meshBase::exportPntToVtk().

{ return numElements; }

getNumberOfPoints()

int PNTMesh::pntMesh::getNumberOfPoints ( ) const

inline

Definition at line 109 of file pntMesh.H.

Referenced by meshBase::exportPntToVtk().

{ return numVertices; }

getPntConn()

std::vector< int > PNTMesh::pntMesh::getPntConn	(	std::vector< int > &	ci,
		elementType	et,
		int	eo
	)		const

Definition at line 469 of file pntMesh.C.

References PNTMesh::BRICK, PNTMesh::HEXAGON, PNTMesh::LAGRANGE_BRICK, and PNTMesh::TRIANGLE.

Referenced by write().

{
  std::vector<int> co;
  co = ci;
  if (et == elementType::TRIANGLE && eo == 2)
  {
    co[0] = ci[0];
    co[2] = ci[1];
    co[4] = ci[2];
    co[1] = ci[3];
    co[3] = ci[4];
    co[5] = ci[5];
  }
  else if ((et == elementType::HEXAGON || et == elementType::LAGRANGE_BRICK ||
              et == elementType::BRICK) &&
             eo == 2)
  {
    co[0] = ci[0];
    co[2] = ci[1];
    co[8] = ci[2];
    co[6] = ci[3];
    co[18] = ci[4];
    co[20] = ci[5];
    co[26] = ci[6];
    co[24] = ci[7];
    co[1] = ci[8];
    co[5] = ci[9];
    co[7] = ci[10];
    co[3] = ci[11];
    co[19] = ci[12];
    co[23] = ci[13];
    co[25] = ci[14];
    co[21] = ci[15];
    co[9] = ci[16];
    co[11] = ci[17];
    co[17] = ci[18];
    co[15] = ci[19];
    co[12] = ci[20];
    co[14] = ci[21];
    co[10] = ci[22];
    co[16] = ci[23];
    co[4] = ci[24];
    co[22] = ci[25];
    co[13] = ci[26];
  }
  return co;
}

getPointCrd()

std::vector<double> PNTMesh::pntMesh::getPointCrd ( int  id ) const

inline

Definition at line 113 of file pntMesh.H.

References id.

Referenced by meshBase::exportPntToVtk().

{ return pntCrds[id]; }

getVtkCellTag()

VTKCellType PNTMesh::pntMesh::getVtkCellTag	(	elementType	et,
		int	order
	)		const

Definition at line 558 of file pntMesh.C.

References PNTMesh::BRICK, PNTMesh::HEXAGON, PNTMesh::LAGRANGE_BRICK, PNTMesh::PRISMATIC, PNTMesh::QUADRILATERAL, PNTMesh::TETRAHEDRON, and PNTMesh::TRIANGLE.

Referenced by meshBase::exportPntToVtk().

{
  if (et == elementType::TRIANGLE)
    switch (order)
    {
      case 1: return VTK_TRIANGLE;
      case 2: return VTK_QUADRATIC_TRIANGLE;
      default: return VTK_HIGHER_ORDER_TRIANGLE;
    }

  if (et == elementType::QUADRILATERAL)
    switch (order)
    {
      case 1: return VTK_QUAD;
      case 2: return VTK_QUADRATIC_QUAD;
      default: return VTK_HIGHER_ORDER_QUAD;
    }

  if (et == elementType::TETRAHEDRON)
    switch (order)
    {
      case 1: return VTK_TETRA;
      case 2: return VTK_QUADRATIC_TETRA;
      default: return VTK_HIGHER_ORDER_TETRAHEDRON;
    }

  if (et == elementType::HEXAGON
      || et == elementType::BRICK
      || et == elementType::LAGRANGE_BRICK)
    switch (order)
    {
      case 1: return VTK_HEXAHEDRON;
      case 2: return VTK_QUADRATIC_HEXAHEDRON;
      default: return VTK_HIGHER_ORDER_HEXAHEDRON;
    }

  if (et == elementType::PRISMATIC)
    switch (order)
    {
      case 1: return VTK_WEDGE;
      case 2: return VTK_QUADRATIC_WEDGE;
      default: return VTK_HIGHER_ORDER_WEDGE;
    }

  std::cerr << "Unknown element type "
            << static_cast<std::underlying_type<elementType>::type>(et)
            << " order " << order << std::endl;
  throw;
}

isCompatible()

bool PNTMesh::pntMesh::isCompatible ( ) const

inline

Definition at line 108 of file pntMesh.H.

{ return isSupported; }

pntPopulate()

void PNTMesh::pntMesh::pntPopulate ( const meshBase *  imb )

private

Definition at line 793 of file pntMesh.C.

References connSet, elmSrfId, meshBase::getDataSet(), NEM::MSH::New(), numBlocks, numSurfaces, numSurfBoundary, numSurfInternal, surfAdjElmNum, surfAdjRefNum, surfConnToId, surfIdToConn, surfOnBndr, and updElmBlk().

Referenced by pntMesh().

{
  // acquiring dataset
  vtkSmartPointer<vtkDataSet> ds = imb->getDataSet();
  if (!ds) {
    std::cerr << "No dataset is associated to the meshbase." << std::endl;
    exit(1);
  }

  // loop through cells and obtain different quantities needed
  int srfId = 0;
  int nCl = ds->GetNumberOfCells();
  elmSrfId.resize(nCl);
  for (int ic = 0; ic < nCl; ic++)
  {
    vtkCell *vc = ds->GetCell(ic);
    if (vc->GetCellDimension() == 2)
    {
      //for 2D cells
      int ne = vc->GetNumberOfEdges();
      for (int ie = 0; ie < ne; ie++)
      {
        numSurfInternal++;
        vtkCell *ve = vc->GetEdge(ie);
        vtkIdList *pidl = ve->GetPointIds();

        // edge connectivity
        std::set<int> econn;
        std::map<std::set<int>, int>::const_iterator itSrfId;
        std::pair<int, int> adjPair;
        std::vector<int> adjCellId;
        for (int ipt = 0; ipt < pidl->GetNumberOfIds(); ipt++)
          econn.insert(pidl->GetId(ipt));
        auto ret1 = connSet.insert(econn);
        bool isNew = ret1.second;
        if (isNew)
        {
          // global surface connectivity
          surfConnToId[econn] = srfId;
          surfIdToConn[srfId] = econn;
          // global reference number
          adjPair.first = ic;
          adjPair.second = ie + 1;
        }
        else
        {
          // if edge is already accounted update reference
          // number for its second neighbor cell
          itSrfId = surfConnToId.find(econn);
          if (itSrfId != surfConnToId.end())
          {
            adjPair.first = ic;
            adjPair.second = ie + 1;
          }
          else
          {
            std::cerr << "Found a repeated surface connectivity without id.";
            exit(1);
          }
        }

        // getting neighbour list
        bool isBndrSrf = false;
        adjCellId.push_back(ic + 1);
        vtkSmartPointer<vtkIdList> cidl = vtkSmartPointer<vtkIdList>::New();
        ds->GetCellNeighbors(ic, pidl, cidl);
        if (cidl->GetNumberOfIds() == 0)
        {
          isBndrSrf = true;
          adjPair.second = 0;
          adjCellId.push_back(0);
          numSurfBoundary++;
        }

        // updating adjacency information
        if (isNew)
        {
          // element global surface id
          elmSrfId[ic].push_back(srfId);
          surfOnBndr.push_back(isBndrSrf);
          surfAdjRefNum[srfId].push_back(adjPair);
          surfAdjElmNum[srfId].insert(surfAdjElmNum[srfId].end(),
                                      adjCellId.begin(),
                                      adjCellId.end());
        }
        else
        {
          // element global surface id
          elmSrfId[ic].push_back(itSrfId->second);
          surfAdjRefNum[itSrfId->second].push_back(adjPair);
          surfAdjElmNum[itSrfId->second].insert(
              surfAdjElmNum[itSrfId->second].end(),
              adjCellId.begin(),
              adjCellId.end());
        }

        // finally increment surface id number if needed
        if (isNew) srfId++;
      }
    }
    else if (vc->GetCellDimension() == 3)
    {
      //for 3D cells
      int nfc = vc->GetNumberOfFaces();
      for (int ifc = 0; ifc < nfc; ifc++)
      {
        numSurfInternal++;
        vtkCell *vf = vc->GetFace(ifc);
        vtkIdList *pidl = vf->GetPointIds();

        // surface connectivity
        std::set<int> econn;
        std::map<std::set<int>, int>::const_iterator itSrfId;
        std::pair<int, int> adjPair;
        std::vector<int> adjCellId;
        for (int ipt = 0; ipt < pidl->GetNumberOfIds(); ipt++)
          econn.insert(pidl->GetId(ipt));
        auto ret1 = connSet.insert(econn);
        bool isNew = ret1.second;
        if (isNew)
        {
          // global surface connectivity
          surfConnToId[econn] = srfId;
          surfIdToConn[srfId] = econn;
          // global reference number
          adjPair.first = ic;
          adjPair.second = ifc + 1;
        }
        else
        {
          // if edge is already accounted update reference
          // number for its second neighbor cell
          itSrfId = surfConnToId.find(econn);
          if (itSrfId != surfConnToId.end())
          {
            adjPair.first = ic;
            adjPair.second = ifc + 1;
          }
          else
          {
            std::cerr << "Found a repeated surface connectivity without id.";
            exit(1);
          }
        }

        // getting neighbour list
        bool isBndrSrf = false;
        adjCellId.push_back(ic + 1);
        vtkSmartPointer<vtkIdList> cidl = vtkSmartPointer<vtkIdList>::New();
        ds->GetCellNeighbors(ic, pidl, cidl);
        if (cidl->GetNumberOfIds() == 0)
        {
          isBndrSrf = true;
          adjPair.second = 0;
          adjCellId.push_back(0);
          numSurfBoundary++;
        }

        // updating adjacency information
        if (isNew)
        {
          // element global surface id
          elmSrfId[ic].push_back(srfId);
          surfOnBndr.push_back(isBndrSrf);
          surfAdjRefNum[srfId].push_back(adjPair);
          surfAdjElmNum[srfId].insert(surfAdjElmNum[srfId].end(),
                                      adjCellId.begin(),
                                      adjCellId.end());
        }
        else
        {
          // element global surface id
          elmSrfId[ic].push_back(itSrfId->second);
          surfAdjRefNum[itSrfId->second].push_back(adjPair);
          surfAdjElmNum[itSrfId->second].insert(
              surfAdjElmNum[itSrfId->second].end(),
              adjCellId.begin(),
              adjCellId.end());
        }
        // finally increment surface id number if needed
        if (isNew) srfId++;
      }
    }
  }
  numSurfInternal += numSurfBoundary;
  numSurfInternal /= 2;
  numSurfInternal -= numSurfBoundary;
  numSurfaces = numSurfInternal + numSurfBoundary;
  std::cout << "Number of boundary surfaces (edges) = " << numSurfBoundary
            << std::endl;
  std::cout << "Number of internal surfaces (edges) = " << numSurfInternal
            << std::endl;
  std::cout << "Total number of surfaces (edges) = " << numSurfaces
            << std::endl;
  std::cout << "Srf ID = " << srfId << std::endl;

  // testing
  /*
  for (auto itt1 = surfAdjElmNum.begin(); itt1 != surfAdjElmNum.end(); itt1++)
  {
    std::cout << "/////////\n";
    for (auto itt2 = (itt1->second).begin(); itt2 != (itt1->second).end(); itt2++)
      std::cout << *itt2 << std::endl;
  }
  */

  /*
  for (auto it = elmSrfId.begin(); it!=elmSrfId.end(); it++)
    std::cout << "Number of element surfaces = " << it->size() << std::endl;
  */

  // preparing element blocks
  for (int iBlk = 0; iBlk < numBlocks; iBlk++)
    updElmBlk(iBlk);
  std::cout << "Finished processing blocks." << std::endl;
}

updElmBlk()

void PNTMesh::pntMesh::updElmBlk ( int  blkId )

private

Definition at line 1011 of file pntMesh.C.

References elmBlkId, elmBlks, elmConn, elmLocalId, elmSrfId, surfAdjRefNum, and surfOnBndr.

Referenced by pntPopulate().

{
  std::cout << "Working on block " << blkId << std::endl;
  elmBlks[blkId].numBoundarySurfacesInBlock = 0;
  // block's first element global index
  int frstElmGlbIdx = elmBlks[blkId].elmIds[0];
  // TODO: Removing the first element to avoid additional tag
  surfaceBCTag sbc = elmBlks[blkId].srfBCTag[0];
  elmBlks[blkId].srfBCTag.pop_back();
  // looping through elements in block
  for (auto ie = elmBlks[blkId].elmIds.begin();
       ie != elmBlks[blkId].elmIds.end();
       ie++)
  {
    // connectivity
    std::cout << "Working on element " << *ie << std::endl;
    elmBlks[blkId].eConn.push_back(elmConn[*ie]);

    // surface related calculations
    // looping through element surfaces
    int srfRefId = 0;
    for (auto is = elmSrfId[*ie].begin();
         is != elmSrfId[*ie].end();
         is++)
    {
      // incrementing reference id
      srfRefId++;
      // adjacent element information
      int adjElmId = surfAdjRefNum[*is][0].first == *ie
                     ? surfAdjRefNum[*is][1].first
                     : surfAdjRefNum[*is][0].first;
      int adjRefId = surfAdjRefNum[*is][0].first == *ie
                     ? surfAdjRefNum[*is][1].second
                     : surfAdjRefNum[*is][0].second;

      if (surfOnBndr[*is])
      {
        // number of boundary surfaces
        elmBlks[blkId].numBoundarySurfacesInBlock++;
        // TODO: duplicating surface boundary condition tag 
        // with index 0 for now
        elmBlks[blkId].srfBCTag.push_back(sbc);
        // element's boundary surface reference number
        elmBlks[blkId].srfBCEleRef.push_back(*ie + 1 - frstElmGlbIdx); // local element indx
        elmBlks[blkId].srfBCEleRef.push_back(srfRefId); // ref surface number
        // adjacency information
        elmBlks[blkId].adjElmId.push_back(0);
        elmBlks[blkId].adjBlkId.push_back(0);
        elmBlks[blkId].adjRefId.push_back(0);
      }
      else
      {
        // adjacency information
        elmBlks[blkId].adjElmId.push_back(elmLocalId[adjElmId] + 1);
        elmBlks[blkId].adjBlkId.push_back(elmBlkId[adjElmId] + 1);
        elmBlks[blkId].adjRefId.push_back(adjRefId);
      }

      // global surface id
      elmBlks[blkId].glbSrfId.push_back(*is + 1);
    }
  }
}

write()

void PNTMesh::pntMesh::write

(

const std::string &

fname

)

const

Definition at line 609 of file pntMesh.C.

References PNTMesh::bcTagStr(), elmBlks, PNTMesh::elmTypeStr(), getPntConn(), id, numBlocks, numDimensions, numElements, numSurfaces, numSurfBoundary, numSurfInternal, numVertices, and pntCrds.

Referenced by NEM::DRV::VtkToPntConversionDriver::execute().

{
  std::ofstream outputStream(fname.c_str());
  if (!outputStream.good())
  {
    std::cout << "Output file stream is bad" << std::endl;
    exit(1);
  }

  // ---------  writing pntmesh header ----------- //
  outputStream << std::setw(10) << numVertices
               << std::setw(10) << numElements
               << std::setw(10) << numDimensions
               << std::setw(10) << numBlocks
               << std::setw(10) << numSurfaces
               << std::setw(10) << numSurfInternal
               << std::setw(10) << numSurfBoundary
               << std::setw(10) << 0
               << std::setw(10) << 0
               << std::setw(10) << 0
               << std::endl;

  // ---------  writing node coords ----------- //
  int lb = 0;
  for (int id = 0; id < numDimensions; id++)
  {
    for (int iv = 0; iv < numVertices; iv++)
    {
      outputStream << std::setw(15)
                   << std::scientific
                   << std::setprecision(8)
                   << pntCrds[iv][id];
      if (++lb == 8)
      {
        outputStream << std::endl;
        lb = 0;
      }
    }
  }
  outputStream << std::endl;

  // ---------  writing element blocks ----------- //
  for (int ib = 0; ib < numBlocks; ib++)
  {
    // block header
    outputStream << std::setw(10) << elmBlks[ib].numElementsInBlock
                 << std::setw(10) << elmBlks[ib].numBoundarySurfacesInBlock
                 << std::setw(10) << elmBlks[ib].nodesPerElement
                 << std::setw(10) << 0
                 << std::setw(10) << elmBlks[ib].ordIntrp
                 << std::setw(10) << elmBlks[ib].ordEquat
                 << std::endl;

    // element type and region name
    outputStream << std::setw(16) << std::left << elmTypeStr(elmBlks[ib].eTpe)
                 << std::setw(16) << std::left << elmBlks[ib].regionName
                 << std::endl;

    // element connectivity
    lb = 1;
    for (int ie = 0; ie < elmBlks[ib].numElementsInBlock; ie++)
    {
      std::vector<int> econn;
      econn = elmBlks[ib].eConn[ie];
      econn = getPntConn(econn, elmBlks[ib].eTpe, elmBlks[ib].ordIntrp);
      for (int im = 0; im < econn.size(); im++, lb++)
      {
        outputStream << std::setw(10) << std::right << econn[im] + 1;
        if (lb == 12)
        {
          lb = 0;
          outputStream << std::endl;
        }
      }
    }
    if (lb != 1)
      outputStream << std::endl;

    // BC tags
    lb = 1;
    for (auto it = elmBlks[ib].srfBCTag.begin();
         it != elmBlks[ib].srfBCTag.end(); it++, lb++)
    {
      outputStream << std::setw(16) << std::left << bcTagStr(*it);
      if (lb == 7)
      {
        lb = 0;
        outputStream << std::endl;
      }
    }
    if (lb != 1)
      outputStream << std::endl;

    // element number/ref number pairs
    lb = 1;
    for (auto it = elmBlks[ib].srfBCEleRef.begin();
         it != elmBlks[ib].srfBCEleRef.end();
         it++, lb++)
    {
      outputStream << std::setw(10) << std::right << *it;
      if (lb == 12)
      {
        lb = 0;
        outputStream << std::endl;
      }
    }
    if (lb != 1)
      outputStream << std::endl;

    // adjacency header
    outputStream << std::setw(10) << elmBlks[ib].numElementsInBlock
                 << std::setw(10) << elmBlks[ib].numSurfPerEleInBlock
                 << std::endl;

    // global surface array
    lb = 1;
    for (auto it = elmBlks[ib].glbSrfId.begin();
         it != elmBlks[ib].glbSrfId.end();
         it++, lb++)
    {
      outputStream << std::setw(10) << std::right << *it;
      if (lb == 12)
      {
        lb = 0;
        outputStream << std::endl;
      }
    }
    if (lb != 1)
      outputStream << std::endl;

    // adjacency block array
    lb = 1;
    for (auto it = elmBlks[ib].adjBlkId.begin();
         it != elmBlks[ib].adjBlkId.end();
         it++, lb++)
    {
      outputStream << std::setw(10) << std::right << *it;
      if (lb == 12)
      {
        lb = 0;
        outputStream << std::endl;
      }
    }
    if (lb != 1)
      outputStream << std::endl;

    // adjacency element array
    lb = 1;
    for (auto it = elmBlks[ib].adjElmId.begin();
         it != elmBlks[ib].adjElmId.end();
         it++, lb++)
    {
      outputStream << std::setw(10) << std::right << *it;
      if (lb == 12)
      {
        lb = 0;
        outputStream << std::endl;
      }
    }
    if (lb != 1)
      outputStream << std::endl;

    // adjacency reference array
    lb = 1;
    for (auto it = elmBlks[ib].adjRefId.begin();
         it != elmBlks[ib].adjRefId.end();
         it++, lb++)
    {
      outputStream << std::setw(10) << std::right << *it;
      if (lb == 12)
      {
        lb = 0;
        outputStream << std::endl;
      }
    }
    if (lb != 1)
      outputStream << std::endl;
  }

  // closing the stream
  outputStream.close();
}

Member Data Documentation

connSet

std::set<std::set<int> > PNTMesh::pntMesh::connSet

private

Definition at line 155 of file pntMesh.H.

Referenced by pntPopulate().

elmBlkId

std::vector<int> PNTMesh::pntMesh::elmBlkId

private

Definition at line 147 of file pntMesh.H.

Referenced by pntMesh(), and updElmBlk().

elmBlks

std::vector<blockType> PNTMesh::pntMesh::elmBlks

private

Definition at line 150 of file pntMesh.H.

Referenced by getBlockElmType(), getBlockName(), pntMesh(), updElmBlk(), and write().

elmConn

std::vector<std::vector<int> > PNTMesh::pntMesh::elmConn

private

Definition at line 144 of file pntMesh.H.

Referenced by pntMesh(), and updElmBlk().

elmLocalId

std::vector<int> PNTMesh::pntMesh::elmLocalId

private

Definition at line 148 of file pntMesh.H.

Referenced by pntMesh(), and updElmBlk().

elmOrd

std::vector<int> PNTMesh::pntMesh::elmOrd

private

Definition at line 146 of file pntMesh.H.

Referenced by getElmOrder(), and pntMesh().

elmSrfId

std::vector<std::vector<int> > PNTMesh::pntMesh::elmSrfId

private

Definition at line 149 of file pntMesh.H.

Referenced by pntPopulate(), and updElmBlk().

elmTyp

std::vector<elementType> PNTMesh::pntMesh::elmTyp

private

Definition at line 145 of file pntMesh.H.

Referenced by getElmType(), and pntMesh().

ifname

std::string PNTMesh::pntMesh::ifname

private

Definition at line 135 of file pntMesh.H.

isSupported

bool PNTMesh::pntMesh::isSupported

private

Definition at line 152 of file pntMesh.H.

Referenced by pntMesh().

numBlocks

int PNTMesh::pntMesh::numBlocks

private

Definition at line 139 of file pntMesh.H.

Referenced by getBlockElmType(), getBlockName(), pntMesh(), pntPopulate(), and write().

numDimensions

int PNTMesh::pntMesh::numDimensions

private

Definition at line 138 of file pntMesh.H.

Referenced by pntMesh(), and write().

numElements

int PNTMesh::pntMesh::numElements

private

Definition at line 137 of file pntMesh.H.

Referenced by getElmOrder(), getElmType(), pntMesh(), and write().

numSurfaces

int PNTMesh::pntMesh::numSurfaces

private

Definition at line 140 of file pntMesh.H.

Referenced by pntMesh(), pntPopulate(), and write().

numSurfBoundary

int PNTMesh::pntMesh::numSurfBoundary

private

Definition at line 142 of file pntMesh.H.

Referenced by pntMesh(), pntPopulate(), and write().

numSurfInternal

int PNTMesh::pntMesh::numSurfInternal

private

Definition at line 141 of file pntMesh.H.

Referenced by pntMesh(), pntPopulate(), and write().

numVertices

int PNTMesh::pntMesh::numVertices

private

Definition at line 136 of file pntMesh.H.

Referenced by pntMesh(), and write().

pntCrds

std::vector<std::vector<double> > PNTMesh::pntMesh::pntCrds

private

Definition at line 143 of file pntMesh.H.

Referenced by pntMesh(), and write().

surfAdjElmNum

std::map<int, std::vector<int> > PNTMesh::pntMesh::surfAdjElmNum

private

Definition at line 160 of file pntMesh.H.

Referenced by pntPopulate().

surfAdjRefNum

std::map<int, std::vector<std::pair<int, int> > > PNTMesh::pntMesh::surfAdjRefNum

private

Definition at line 159 of file pntMesh.H.

Referenced by pntPopulate(), and updElmBlk().

surfConnToId

std::map<std::set<int>, int> PNTMesh::pntMesh::surfConnToId

private

Definition at line 156 of file pntMesh.H.

Referenced by pntPopulate().

surfIdToConn

std::map<int, std::set<int> > PNTMesh::pntMesh::surfIdToConn

private

Definition at line 157 of file pntMesh.H.

Referenced by pntPopulate().

surfOnBndr

std::vector<bool> PNTMesh::pntMesh::surfOnBndr

private

Definition at line 158 of file pntMesh.H.

Referenced by pntPopulate(), and updElmBlk().

---

The documentation for this class was generated from the following files:

• pntMesh.H
• pntMesh.C