rocstarCgns Class Reference

Detailed Description

Definition at line 37 of file rocstarCgns.H.

Public Member Functions
	rocstarCgns (std::string fname)
	rocstarCgns (const std::vector< std::string > &fnames)
	~rocstarCgns ()
void	loadCgSeries ()
void	loadCgSeries (int nCg)
virtual void	closeCG ()
int	getNCgObj ()
std::string	getBaseName ()
std::string	getBaseName (int indx)
std::string	getCgFName (int indx)
std::string	getBaseItrName (int indx)
int	getNTStep (int indx)
double	getTimeStep (int indx)
std::string	getZoneItrName (int indx, int zidx)
std::string	getGridCrdPntr (int indx, int zidx)
std::string	getSolutionPntr (int indx, int zidx)
int	getNZone (int indx)
std::string	getZoneName (cgnsAnalyzer *cgObj, int zoneIdx)
std::string	getZoneName (int cgIdx, int zoneIdx)
	CGNS_ENUMT (ZoneType_t) getZoneType(int indx
std::string	getSectionName (int cgIdx, int zoneIdx)
int	getElementType (int cgIdx, int zoneIdx)
int	getZoneNVrtx (cgnsAnalyzer *cgObj, int zoneIdx)
int	getZoneNCell (cgnsAnalyzer *cgObj, int zoneIdx)
std::vector< double >	getZoneCoords (cgnsAnalyzer *cgObj, int zoneIdx, int dim)
std::vector< cgsize_t >	getZoneRealConn (cgnsAnalyzer *cgObj, int zoneIdx)
int	getZoneRealSecType (cgnsAnalyzer *cgObj, int zoneIdx)
int	getPaneBcflag (cgnsAnalyzer *cgObj, int zoneIdx)
int	getPanePatchNo (cgnsAnalyzer *cgObj, int zoneIdx)
int	getPaneCnstrType (cgnsAnalyzer *cgObj, int zoneIdx)
void	stitchGroup ()
void	stitchMe (cgnsAnalyzer *cgObj, int zoneIdx)
void	stitchFldBc (cgnsAnalyzer *cgObj, int zoneIdx)
void	stitchMe (rocstarCgns *cgObj)
void	setBurnBool (bool b)
void	loadGrid (const std::string &fname, int verb=0)
void	loadGrid (int verb=0)
void	loadZone (int zIdx, int verb=0)
int	getIndexFile ()
int	getIndexBase ()
int	getCellDim ()
std::string	getFileName ()
std::string	getZoneName ()
std::string	getZoneName (int nCgFile)
std::string	getSectionName ()
std::string	getBaseItrName ()
int	getNZone ()
int	getNTStep ()
double	getTimeStep ()
std::string	getZoneItrName ()
std::string	getGridCrdPntr ()
std::string	getSolutionPntr ()
int	getNVertex ()
int	getNElement ()
int	getPhysDim ()
int	getElementType ()
int	getNVrtxElem ()
	CGNS_ENUMT (MassUnits_t) getMassUnit()
	CGNS_ENUMT (LengthUnits_t) getLengthUnit()
	CGNS_ENUMT (TimeUnits_t) getTimeUnit()
	CGNS_ENUMT (TemperatureUnits_t) getTemperatureUnit()
	CGNS_ENUMT (AngleUnits_t) getAngleUnit()
bool	isStructured ()
std::vector< double >	getVertexCoords ()
std::vector< double >	getVertexCoords (int vrtxId)
double	getVrtXCrd (int vrtxId)
std::vector< double >	getVrtXCrd ()
double	getVrtYCrd (int vrtxId)
std::vector< double >	getVrtYCrd ()
double	getVrtZCrd (int vrtxId)
std::vector< double >	getVrtZCrd ()
std::vector< cgsize_t >	getElementConnectivity (int elemId)
void	getSectionNames (std::vector< std::string > &secNames)
void	getSectionConn (std::string secName, std::vector< cgsize_t > &conn, int &nElm)
vtkSmartPointer< vtkDataSet >	getSectionMesh (std::string secName)
void	clearAllSolutionData ()
void	getSolutionDataNames (std::vector< std::string > &list)
solution_type_t	getSolutionData (std::string sName, std::vector< double > &slnData)
solutionData *	getSolutionDataObj (std::string sName)
int	getNVertexSolution ()
int	getNCellSolution ()
solution_type_t	getSolutionDataStitched (std::string sName, std::vector< double > &slnData, int &outNData, int &outNDim)
void	appendSolutionData (std::string sName, std::vector< double > &slnData, solution_type_t dt, int inNData, int inNDim)
void	appendSolutionData (std::string sName, double slnData, solution_type_t dt, int inNData, int inNDim)
bool	delAppSlnData (std::string sName)
void	getAppendedSolutionDataName (std::vector< std::string > &appSName)
std::vector< std::string >	getSolutionNodeNames ()
std::vector< CGNS_ENUMT(GridLocation_t)>	getSolutionGridLocations ()
std::map< int, std::pair< int, keyValueList > >	getSolutionMap ()
std::map< std::string, CGNS_ENUMT(GridLocation_t)>	getSolutionNameLocMap ()
void	exportToMAdMesh (MAd::pMesh MAdMesh)
virtual void	stitchMesh (cgnsAnalyzer *inCg, bool withFields=false)
void	classifyMAdMeshOpt (MAd::pMesh MAdMesh)
void	classifyMAdMeshBnd (MAd::pMesh MAdMesh)
void	unclassifyMAdMeshBnd (MAd::pMesh MAdMesh)
void	checkVertex ()
bool	checkElmConn (int nSharedNde)
std::vector< double >	getElmCntCoords (MAd::pMesh msh)
void	exportToVTKMesh ()
vtkSmartPointer< vtkDataSet >	getVTKMesh ()
void	overwriteSolData (meshBase *mbObj)
void	overwriteSolData (const std::string &fname, const std::string &ndeName, int slnIdx, CGNS_ENUMT(DataType_t) dt, void *data)
void	writeSampleStructured ()
void	writeSampleUnstructured ()
bool	isMultiZone ()
bool	isCgRindNode (int cgNdeId)
bool	isCgRindCell (int cgCellId)
void	cleanRind ()

Public Attributes
int	zidx

Protected Member Functions
	CGNS_ENUMT (ElementType_t) sectionType
void	populateSolutionDataNames ()
void	buildVertexKDTree ()
void	buildElementKDTree ()
void	loadSolutionDataContainer (int verb=0)
virtual void	stitchFields (cgnsAnalyzer *inCg)

Protected Attributes
std::string	cgFileName
std::string	baseName
std::string	zoneName
std::string	sectionName
bool	isUnstructured
cgsize_t	rmin [3]
cgsize_t	rmax [3]
cgsize_t	cgCoreSize [9]
int	indexFile
int	indexBase
int	indexZone
int	indexCoord
int	indexSection
int	cellDim
int	physDim
int	nBase
int	nZone
int	nVertex
int	nRindNdeStr
int	nElem
int	nSection
int	nVrtxElem
std::string	baseItrName
std::string	zoneItrName
std::string	gridCrdPntr
std::string	flowSlnPntr
int	nTStep
double	timeLabel
std::vector< double >	xCrd
std::vector< double >	yCrd
std::vector< double >	zCrd
std::vector< cgsize_t >	elemConn
bool	solutionDataPopulated
int	nSolution
int	nField
std::vector< solutionData * >	slnDataCont
std::map< std::string, CGNS_ENUMT(GridLocation_t)>	solutionNameLocMap
std::map< int, std::pair< int, keyValueList > >	solutionMap
std::vector< std::string >	solutionName
std::vector< CGNS_ENUMT(GridLocation_t)>	solutionGridLocation
std::vector< std::string >	appendedSolutionName
std::map< int, int >	MAdToCgnsIds
std::map< int, int >	cgnsToMAdIds
ANNkd_tree *	kdTree
ANNkd_tree *	kdTreeElem
ANNpointArray	vrtxCrd
ANNpointArray	vrtxIdx
double	searchEps
std::vector< std::string >	zoneNames
std::vector< bool >	vrtDataMask
std::vector< bool >	elmDataMask
bool	isMltZone
std::vector< std::string >	multZoneNames
vtkSmartPointer< vtkDataSet >	vtkMesh
std::vector< int >	cgRindCellIds
std::vector< int >	cgRindNodeIds
int	_verb
bool	_rindOff

Private Attributes
std::string	myCgFName
std::string	baseCgFName
bool	_burn
std::vector< std::string >	cgFNames
int	padSize
std::vector< cgnsAnalyzer * >	myCgObjs
std::vector< int >	bcFlag
std::vector< int >	bFlag
std::vector< int >	patchNo

Inherits cgnsAnalyzer.

Constructor & Destructor Documentation

rocstarCgns() [1/2]

rocstarCgns::rocstarCgns

(

std::string

fname

)

Definition at line 37 of file rocstarCgns.C.

References baseCgFName, myCgFName, and padSize.

    : cgnsAnalyzer(fname), myCgFName(fname), _burn(0) {
  std::size_t _loc = myCgFName.find_last_of("_");
  baseCgFName = myCgFName.substr(0, _loc + 1);
  padSize = myCgFName.size() - baseCgFName.size() - 5;
}

rocstarCgns() [2/2]

rocstarCgns::rocstarCgns

(

const std::vector< std::string > &

fnames

)

Definition at line 44 of file rocstarCgns.C.

References baseCgFName.

    : cgnsAnalyzer(fnames[0]), _burn(0), cgFNames(fnames) {
  std::size_t _loc = fnames[0].find_last_of("_");
  baseCgFName = fnames[0].substr(0, _loc + 1);
}

~rocstarCgns()

rocstarCgns::~rocstarCgns

(

)

Definition at line 50 of file rocstarCgns.C.

References myCgObjs.

                          {
  // cleaning up
  for (int ic = 0; ic < myCgObjs.size(); ic++) delete myCgObjs[ic];
}

Member Function Documentation

appendSolutionData() [1/2]

void cgnsAnalyzer::appendSolutionData ( std::string  sName, std::vector< double > &  slnData, solution_type_t  dt, int  inNData, int  inNDim  )

inherited

Definition at line 1097 of file cgnsAnalyzer.C.

References solutionData::appendData(), and solutionData::solutionData().

Referenced by stitchFldBc().

                                                  {
  // load data if needed
  if (slnDataCont.empty()) loadSolutionDataContainer();

  solutionData *nwSlnPtr = new solutionData(sName, dt);
  nwSlnPtr->appendData(slnData, inNData, inNDim);
  slnDataCont.push_back(nwSlnPtr);
  appendedSolutionName.push_back(sName);
}

appendSolutionData() [2/2]

void cgnsAnalyzer::appendSolutionData ( std::string  sName, double  slnData, solution_type_t  dt, int  inNData, int  inNDim  )

inherited

Definition at line 1110 of file cgnsAnalyzer.C.

References solutionData::appendData(), and solutionData::solutionData().

                                                  {
  // load data if needed
  if (slnDataCont.empty()) loadSolutionDataContainer();
  solutionData *nwSlnPtr = new solutionData(sName, dt);
  // convert to vector
  std::vector<double> slnDataVec;
  slnDataVec.resize(inNData, slnData);
  nwSlnPtr->appendData(slnDataVec, inNData, inNDim);
  // register
  slnDataCont.push_back(nwSlnPtr);
  appendedSolutionName.push_back(sName);
}

buildElementKDTree()

void cgnsAnalyzer::buildElementKDTree ( )

protectedinherited

Definition at line 1406 of file cgnsAnalyzer.C.

                                      {
  // ANNpointArray vrtxIdx;
  if (vrtxIdx) annDeallocPts(vrtxIdx);
  // clearing onld instance
  vrtxIdx = annAllocPts(nElem, nVrtxElem);
  if (kdTreeElem) delete kdTreeElem;

  // filling up vertex coordinate array for the current mesh
  for (int iElem = 0; iElem < nElem; ++iElem) {
    for (int iVrtx = 1; iVrtx <= nVrtxElem; ++iVrtx) {
      vrtxIdx[iElem][iVrtx] = elemConn[(iElem - 1) * nVrtxElem + iVrtx];
    }
  }
  // building kdTree
  kdTreeElem = new ANNkd_tree(vrtxIdx, nElem, nVrtxElem);
}

buildVertexKDTree()

void cgnsAnalyzer::buildVertexKDTree ( )

protectedinherited

Definition at line 1389 of file cgnsAnalyzer.C.

Referenced by stitchMe().

                                     {
  // ANNpointArray vrtxCrd;
  if (vrtxCrd) annDeallocPts(vrtxCrd);
  // clearing onld instance
  vrtxCrd = annAllocPts(nVertex, physDim);
  if (kdTree) { delete kdTree; }

  // filling up vertex coordinate array for the current mesh
  for (int iVrt = 0; iVrt < nVertex; ++iVrt) {
    vrtxCrd[iVrt][0] = xCrd[iVrt];
    vrtxCrd[iVrt][1] = yCrd[iVrt];
    vrtxCrd[iVrt][2] = zCrd[iVrt];
  }
  // building kdTree
  kdTree = new ANNkd_tree(vrtxCrd, nVertex, physDim);
}

CGNS_ENUMT() [1/7]

rocstarCgns::CGNS_ENUMT

(

ZoneType_t

)

Referenced by getPaneBcflag(), getPaneCnstrType(), getPanePatchNo(), getZoneCoords(), getZoneRealConn(), getZoneRealSecType(), and stitchMe().

CGNS_ENUMT() [2/7]

cgnsAnalyzer::CGNS_ENUMT ( MassUnits_t  )

inherited

CGNS_ENUMT() [3/7]

cgnsAnalyzer::CGNS_ENUMT ( LengthUnits_t  )

inherited

CGNS_ENUMT() [4/7]

cgnsAnalyzer::CGNS_ENUMT ( TimeUnits_t  )

inherited

CGNS_ENUMT() [5/7]

cgnsAnalyzer::CGNS_ENUMT ( TemperatureUnits_t  )

inherited

CGNS_ENUMT() [6/7]

cgnsAnalyzer::CGNS_ENUMT ( AngleUnits_t  )

inherited

CGNS_ENUMT() [7/7]

cgnsAnalyzer::CGNS_ENUMT ( ElementType_t  )

protectedinherited

checkElmConn()

bool cgnsAnalyzer::checkElmConn ( int  nSharedNde )

inherited

Definition at line 1458 of file cgnsAnalyzer.C.

                                              {
  /*
  MatrixInt eConn(nElem, nVrtxElem);
  MatrixInt dummy(nElem, nElem);
  VectorInt elmIdx(nElem);
  for (int iElm = 0; iElm < nElem; ++iElm)
  {
    elmIdx(iElm) = iElm;
    for (int iNde = 0; iNde < nVrtxElem; ++iNde)
      eConn(iElm, iNde) = elemConn[iElm * nVrtxElem + iNde];
  }
  clock_t startTime = clock();
  dummy = eConn * eConn.transpose();
  std::cout << double(clock() - startTime) / (double) CLOCKS_PER_SEC << "
  seconds." << std::endl;
  */

  // building node to element map
  std::map<int, std::set<int>> nde2Elm;
  for (int iElm = 0; iElm < nElem; ++iElm)
    for (int iNde = 0; iNde < nVrtxElem; ++iNde)
      nde2Elm[elemConn[iElm * nVrtxElem + iNde]].insert(iElm);

  /*
  std::cout << "nde2Elm = " << std::endl;
  for (auto it = nde2Elm.begin(); it != nde2Elm.end(); ++it)
  {
    std::set<int> tmp = it->second;
    for (auto it2 = tmp.begin(); it2 != tmp.end(); ++it2)
      std::cout << *it2 << " ";
    std::cout << std::endl;
  }
  */

  // going through the list of elements and finding
  // those with less than nSharedNde
  std::vector<int> hangingElmIdx;
  for (int iElm = 0; iElm < nElem; ++iElm) {
    int nShrdNde = 0;
    for (int iNde = 0; iNde < nVrtxElem; ++iNde)
      nShrdNde += nde2Elm[iNde].size() > 1;
    if (nShrdNde < nSharedNde) hangingElmIdx.push_back(iElm);
  }

  std::cout << "Number of elements with less than " << nSharedNde
            << " shared node is " << hangingElmIdx.size() << std::endl;
  return !hangingElmIdx.empty();
}

checkVertex()

void cgnsAnalyzer::checkVertex ( )

inherited

Definition at line 1426 of file cgnsAnalyzer.C.

                               {
  // (re)building the kdTree
  buildVertexKDTree();
  // loop through vertices to find duplicated ones
  int nDupVer = 0;
  for (int iVrt = 0; iVrt < getNVertex(); ++iVrt) {
    ANNpoint qryVrtx;
    ANNidxArray nnIdx;
    ANNdistArray dists;
    qryVrtx = annAllocPt(physDim);
    qryVrtx[0] = getVrtXCrd(iVrt);
    qryVrtx[1] = getVrtYCrd(iVrt);
    qryVrtx[2] = getVrtZCrd(iVrt);
    nnIdx = new ANNidx[1];
    dists = new ANNdist[1];
    kdTree->annkSearch(qryVrtx, 2, nnIdx, dists);
    if (dists[1] < 1e-10) {
      nDupVer++;
      std::cout << "Vertex " << iVrt << " is duplicated."
                << " Distances = " << dists[0] << " " << dists[1] << std::endl;
    }
    delete[] nnIdx;
    delete[] dists;
    annDeallocPt(qryVrtx);
  }
  std::cout << "Found " << nDupVer << " duplicate vertex.\n";
}

classifyMAdMeshBnd()

void cgnsAnalyzer::classifyMAdMeshBnd ( MAd::pMesh  MAdMesh )

inherited

Definition at line 1378 of file cgnsAnalyzer.C.

                                                            {
  // finding boundary faces and classifying them as 2 dimensional
  MAd::pGEntity bnd = (MAd::pGEntity)MAd::GM_faceByTag(MAdMesh->model, 0);
  MAdMesh->classify_grid_boundaries(bnd);
}

classifyMAdMeshOpt()

void cgnsAnalyzer::classifyMAdMeshOpt ( MAd::pMesh  MAdMesh )

inherited

Definition at line 1349 of file cgnsAnalyzer.C.

                                                            {
  /*
    Here, the entities of the MAdLib mesh should be classified
    on their corresponding geometrical entities, like for boundary
    faces in 3D for instance. The implementation of this step
    is highly dependent on the implementation of Solver_mesh and
    Solver_model so it is up to the reader to add the right
    instructions here.

    Note that the geometrical entities have been created in the
    execution of 'exportToMAdModel'. Any mesh entity can be
    associated to a geometrical entity using the EN_setWhatIn(...)
    function of the MAdLib mesh interface.

    Note that all the steps involving geometrical entities can be
    replaced by appropriate constraints on boundary mesh entities
    (see AdaptInterface.h) but no mesh modification will therefore
    be applied on the boundaries, which can be problematic for some
    computations.
  */
  // finding boundary faces and classifying them as 2 dimensional
  // MAd::pGEntity bnd = (MAd::pGEntity) MAd::GM_faceByTag(MAdMesh->model, 0);
  // MAdMesh->classify_grid_boundaries(bnd);
  // classifying the rest of the domain (faces, edges, vertices)
  // the element geometric region properties will be used by them.
  MAdMesh->classify_unclassified_entities();
  MAdMesh->destroyStandAloneEntities();
}

cleanRind()

void cgnsAnalyzer::cleanRind ( )

inherited

Definition at line 1747 of file cgnsAnalyzer.C.

References ELEMENTAL, and NODAL.

Referenced by cgnsAnalyzer::stitchMesh().

                             {
  // sanity check
  // only supports structured meshes for now
  if (!isStructured()) return;
  if (_rindOff) return;
  std::cout << "Cleaning up rind data from the grid.\n";
  // create map btw real and rind node ids
  std::map<int, int> old2NewNdeIds;
  int nNewNde = 1;
  int nRindNde = 0;
  for (int iNde = 1; iNde <= nVertex; iNde++)
    if (isCgRindNode(iNde)) {
      old2NewNdeIds[iNde] = -1;
      nRindNde++;
    } else
      old2NewNdeIds[iNde] = nNewNde++;
  // sanity check
  if (nRindNde != cgRindNodeIds.size()) {
    std::cerr << "Problem occured during rind node removal.\n";
    throw;
  }
  // remove rind node coords
  nRindNde = 0;
  std::vector<double> nxCrd, nyCrd, nzCrd;
  for (int iVrt = 0; iVrt < nVertex; iVrt++) {
    if (old2NewNdeIds[iVrt + 1] < 0) {
      nRindNde++;
      continue;
    } else {
      nxCrd.push_back(xCrd[iVrt]);
      nyCrd.push_back(yCrd[iVrt]);
      nzCrd.push_back(zCrd[iVrt]);
    }
  }
  xCrd = nxCrd;
  yCrd = nyCrd;
  zCrd = nzCrd;
  // sanity check
  if (nRindNde != cgRindNodeIds.size()) {
    std::cerr << "Problem occured during rind coord removal.\n";
    throw;
  }
  // remove rind elements
  std::vector<cgsize_t> newElemConn;
  for (int iElm = 0; iElm < nElem; iElm++) {
    if (isCgRindCell(iElm + 1)) continue;
    for (int id = 0; id < 8; id++)
      newElemConn.push_back(old2NewNdeIds[elemConn[iElm * 8 + id]]);
  }
  elemConn = newElemConn;
  // update connectivity
  for (auto i : elemConn) i = old2NewNdeIds[i];
  // remove rind nodal data
  // remove rind elemental data
  if (!slnDataCont.empty()) {
    // internal data index start from zero
    std::vector<int> intRindCellId, intRindNodeId;
    for (auto i : cgRindNodeIds) intRindNodeId.push_back(i - 1);
    for (auto i : cgRindCellIds) intRindCellId.push_back(i - 1);
    // removing rind data
    std::cout << "Cleaning up rind solution data ";
    int cntr = 29;
    for (auto sd : slnDataCont) {
      std::cout << "..";
      cntr += 2;
      if (cntr > 70) {
        cntr = 0;
        std::cout << "\n";
      }
      // std::cerr << sd->getDataName() << std::endl;
      if (sd->getDataType() == solution_type_t::NODAL)
        sd->rmvDataIdx(intRindNodeId);
      else if (sd->getDataType() == solution_type_t::ELEMENTAL)
        sd->rmvDataIdx(intRindCellId);
    }
    std::cout << "\n";
  }
  // fix number of nodes
  nVertex -= cgRindNodeIds.size();
  // fix number of elements
  nElem -= cgRindCellIds.size();
  // setting flag
  _rindOff = true;
}

clearAllSolutionData()

void cgnsAnalyzer::clearAllSolutionData ( )

inherited

Definition at line 868 of file cgnsAnalyzer.C.

Referenced by stitchFldBc().

                                        {
  // clearing all data related maps and fields
  nSolution = 0;
  nField = 0;
  solutionNameLocMap.clear();
  solutionName.clear();
  solutionGridLocation.clear();
  solutionMap.clear();
  appendedSolutionName.clear();
  // clearing all solution data objects
  for (auto &it : slnDataCont) delete it;
  slnDataCont.clear();
  solutionDataPopulated = false;
}

closeCG()

void rocstarCgns::closeCG ( )

virtual

Reimplemented from cgnsAnalyzer.

Definition at line 83 of file rocstarCgns.C.

References myCgObjs.

                          {
  for (auto it = myCgObjs.begin() + 1; it != myCgObjs.end(); it++)
    (*it)->closeCG();
}

delAppSlnData()

bool cgnsAnalyzer::delAppSlnData ( std::string  sName )

inherited

Definition at line 1125 of file cgnsAnalyzer.C.

Referenced by stitchFldBc().

                                                {
  for (auto is = appendedSolutionName.begin(); is != appendedSolutionName.end();
       ++is)
    if (strcmp(sName.c_str(), (*is).c_str()) == 0) {
      delete getSolutionDataObj(sName);
      appendedSolutionName.erase(is);
      return true;
    }
  return false;
}

exportToMAdMesh()

void cgnsAnalyzer::exportToMAdMesh ( MAd::pMesh  MAdMesh )

inherited

Definition at line 1305 of file cgnsAnalyzer.C.

                                                         {
  // --- Build the vertices ---
  MAdToCgnsIds.clear();
  cgnsToMAdIds.clear();
  for (int iV = 0; iV < nVertex; ++iV) {
    MAdMesh->add_point(iV + 1, xCrd[iV], yCrd[iV], zCrd[iV]);
    cgnsToMAdIds[iV] = iV + 1;
    MAdToCgnsIds[iV + 1] = iV;
  }

  // --- Build the elements ---
  if (physDim == 3) switch (sectionType) {
      case CGNS_ENUMV(TETRA_4): {
        for (int iC = 0; iC < nElem; ++iC) {
          int iN = iC * 4;
          // the last argument for the next function is just a dummy now
          MAd::pGEntity geom =
              (MAd::pGEntity)MAd::GM_regionByTag(MAdMesh->model, 0);
          // geom->setPhysical(3,1);
          MAd::MDB_Tet *tet =
              MAdMesh->add_tet(elemConn[iN], elemConn[iN + 1], elemConn[iN + 2],
                               elemConn[iN + 3], geom);
          // changing tet ID
          tet->iD = iC + 1;
        }
      } break;
      case CGNS_ENUMV(TRI_3): {
        for (int iC = 0; iC < nElem; ++iC) {
          int iN = iC * 3;
          // the last argument for the next function is just a dummy now
          MAd::pGEntity geom =
              (MAd::pGEntity)MAd::GM_faceByTag(MAdMesh->model, 0);
          MAdMesh->add_triangle(elemConn[iN], elemConn[iN + 1],
                                elemConn[iN + 2], geom);
        }
      } break;
      default:
        std::cerr << "Current version only works for TRI and TET elements. "
                     "Element type "
                  << sectionType << " is not supported." << std::endl;
        break;
    }
}

exportToVTKMesh()

void cgnsAnalyzer::exportToVTKMesh ( )

inherited

Definition at line 1164 of file cgnsAnalyzer.C.

References NEM::MSH::New(), and points.

                                   {
  if (!vtkMesh) {
    // remove rind data if any
    cleanRind();
    // points to be pushed into dataSet
    vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
    // declare vtk dataset
    vtkSmartPointer<vtkUnstructuredGrid> dataSet_tmp =
        vtkSmartPointer<vtkUnstructuredGrid>::New();
    // allocate size for vtk point container
    points->SetNumberOfPoints(nVertex);
    for (int i = 0; i < nVertex; ++i) {
      points->SetPoint(i, xCrd[i], yCrd[i], zCrd[i]);
    }
    // add points to vtk mesh data structure
    dataSet_tmp->SetPoints(points);
    // allocate space for elements
    dataSet_tmp->Allocate(nElem);
    // add the elements
    for (int i = 0; i < nElem; ++i) {
      vtkSmartPointer<vtkIdList> vtkElmIds = vtkSmartPointer<vtkIdList>::New();
      std::vector<cgsize_t> cgnsElmIds(getElementConnectivity(i));
      vtkElmIds->SetNumberOfIds(cgnsElmIds.size());
      for (int j = 0; j < cgnsElmIds.size(); ++j) {
        vtkElmIds->SetId(j, cgnsElmIds[j] - 1);
      }
      switch (sectionType) {
        case CGNS_ENUMV(TETRA_4):
          dataSet_tmp->InsertNextCell(VTK_TETRA, vtkElmIds);
          break;
        case CGNS_ENUMV(HEXA_8):
          dataSet_tmp->InsertNextCell(VTK_HEXAHEDRON, vtkElmIds);
          break;
        case CGNS_ENUMV(TRI_3):
          dataSet_tmp->InsertNextCell(VTK_TRIANGLE, vtkElmIds);
          break;
        case CGNS_ENUMV(QUAD_4):
          dataSet_tmp->InsertNextCell(VTK_QUAD, vtkElmIds);
          break;
        case CGNS_ENUMV(TETRA_10):
          dataSet_tmp->InsertNextCell(VTK_QUADRATIC_TETRA, vtkElmIds);
          break;
        default:
          std::cerr << "Unknown element type " << sectionType << std::endl;
          break;
      }
    }
    vtkMesh = dataSet_tmp;
  }
}

getAppendedSolutionDataName()

void cgnsAnalyzer::getAppendedSolutionDataName ( std::vector< std::string > &  appSName )

inherited

Definition at line 1136 of file cgnsAnalyzer.C.

Referenced by cgnsAnalyzer::stitchFields().

                                    {
  appSName.insert(appSName.end(), appendedSolutionName.begin(),
                  appendedSolutionName.end());
}

getBaseItrName() [1/2]

std::string rocstarCgns::getBaseItrName

(

int

indx

)

Definition at line 102 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::getBaseItrName(), and myCgObjs.

                                              {
  if (indx < cgFNames.size()) return (myCgObjs[indx]->getBaseItrName());
  return ("INVALID");
}

getBaseItrName() [2/2]

std::string cgnsAnalyzer::getBaseItrName ( )

inherited

Definition at line 433 of file cgnsAnalyzer.C.

Referenced by getBaseItrName().

{ return baseItrName; }

getBaseName() [1/2]

std::string rocstarCgns::getBaseName

(

)

Definition at line 90 of file rocstarCgns.C.

References baseCgFName.

Referenced by getBaseName().

{ return (baseCgFName); }

getBaseName() [2/2]

std::string rocstarCgns::getBaseName

(

int

indx

)

Definition at line 92 of file rocstarCgns.C.

References getBaseName(), and myCgObjs.

                                           {
  if (indx < myCgObjs.size()) return (myCgObjs[indx]->getBaseName());
  return ("INVALID");
}

getCellDim()

int cgnsAnalyzer::getCellDim ( )

inherited

Definition at line 419 of file cgnsAnalyzer.C.

Referenced by stitchMe().

{ return cellDim; }

getCgFName()

std::string rocstarCgns::getCgFName

(

int

indx

)

Definition at line 97 of file rocstarCgns.C.

References cgFNames.

                                          {
  if (indx < cgFNames.size()) return (cgFNames[indx]);
  return ("INVALID");
}

getElementConnectivity()

std::vector< cgsize_t > cgnsAnalyzer::getElementConnectivity ( int  elemId )

inherited

Definition at line 525 of file cgnsAnalyzer.C.

Referenced by stitchMe(), and cgnsAnalyzer::stitchMesh().

                                                                   {
  std::vector<cgsize_t> elmConn;
  int nNdeElm = 0;
  if (elemId > nElem) {
    std::cerr << "Element index is out of bounds.\n";
    return elmConn;
  }
  // return the whole connectivity if requested
  if (elemId == -1) { return elemConn; }
  // returning individual element connectivity
  switch (sectionType) {
    case CGNS_ENUMV(TETRA_4): nNdeElm = 4; break;
    case CGNS_ENUMV(HEXA_8): nNdeElm = 8; break;
    case CGNS_ENUMV(TRI_3):
      nNdeElm = 3;
      elemConn.resize(3 * nElem, -1);
      break;
    case CGNS_ENUMV(QUAD_4): nNdeElm = 4; break;
    case CGNS_ENUMV(TETRA_10): nNdeElm = 10; break;
    default:
      std::cerr << "Unknown element type " << sectionType << std::endl;
      break;
  }
  for (int iNde = elemId * nNdeElm; iNde < (elemId + 1) * nNdeElm; ++iNde)
    elmConn.push_back(elemConn[iNde]);

  return elmConn;
}

getElementType() [1/2]

int rocstarCgns::getElementType	(	int	cgIdx,
		int	zoneIdx
	)

Definition at line 438 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::getElementType(), and myCgObjs.

                                                  {
  if (indx > cgFNames.size()) return (-1);
  myCgObjs[indx]->loadZone(zidx);
  return (myCgObjs[indx]->getElementType());
}

getElementType() [2/2]

int cgnsAnalyzer::getElementType ( )

inherited

Definition at line 451 of file cgnsAnalyzer.C.

Referenced by getElementType().

{ return sectionType; }

getElmCntCoords()

std::vector< double > cgnsAnalyzer::getElmCntCoords ( MAd::pMesh  msh )

inherited

Definition at line 1510 of file cgnsAnalyzer.C.

                                                            {
  std::vector<double> elmCntCrds;
  MAd::RIter ri = M_regionIter(msh);
  // int rCnt = 0;
  while (MAd::pRegion pr = RIter_next(ri)) {
    double xc[3];
    MAd::R_center(pr, xc);
    elmCntCrds.push_back(xc[0]);
    elmCntCrds.push_back(xc[1]);
    elmCntCrds.push_back(xc[2]);
  }
  return elmCntCrds;
}

getFileName()

std::string cgnsAnalyzer::getFileName ( )

inherited

Definition at line 421 of file cgnsAnalyzer.C.

Referenced by stitchMe().

{ return cgFileName; }

getGridCrdPntr() [1/2]

std::string rocstarCgns::getGridCrdPntr	(	int	indx,
		int	zidx
	)

Definition at line 123 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::getGridCrdPntr(), and myCgObjs.

                                                        {
  if (indx > cgFNames.size()) return ("INVALID");
  myCgObjs[indx]->loadZone(zidx);
  return (myCgObjs[indx]->getGridCrdPntr());
}

getGridCrdPntr() [2/2]

std::string cgnsAnalyzer::getGridCrdPntr ( )

inherited

Definition at line 441 of file cgnsAnalyzer.C.

Referenced by getGridCrdPntr().

{ return gridCrdPntr; }

getIndexBase()

int cgnsAnalyzer::getIndexBase ( )

inherited

Definition at line 417 of file cgnsAnalyzer.C.

Referenced by getPaneBcflag(), getPaneCnstrType(), getPanePatchNo(), getZoneCoords(), getZoneName(), getZoneNCell(), getZoneNVrtx(), getZoneRealConn(), getZoneRealSecType(), and stitchFldBc().

{ return indexBase; }

getIndexFile()

int cgnsAnalyzer::getIndexFile ( )

inherited

Definition at line 415 of file cgnsAnalyzer.C.

Referenced by getPaneBcflag(), getPaneCnstrType(), getPanePatchNo(), getZoneCoords(), getZoneName(), getZoneNCell(), getZoneNVrtx(), getZoneRealConn(), getZoneRealSecType(), and stitchFldBc().

{ return indexFile; }

getNCellSolution()

int cgnsAnalyzer::getNCellSolution ( )

inherited

Definition at line 1069 of file cgnsAnalyzer.C.

References ELEMENTAL.

                                   {
  int nCellData = 0;

  // loading data if not yet
  if (slnDataCont.empty()) loadSolutionDataContainer();

  // number of vertex solution data
  for (auto &is : slnDataCont)
    if (is->getDataType() == solution_type_t::ELEMENTAL) nCellData++;

  return nCellData;
}

getNCgObj()

int rocstarCgns::getNCgObj

(

)

Definition at line 88 of file rocstarCgns.C.

References myCgObjs.

Referenced by stitchGroup().

{ return (myCgObjs.size()); }

getNElement()

int cgnsAnalyzer::getNElement ( )

inherited

Definition at line 447 of file cgnsAnalyzer.C.

Referenced by stitchFldBc(), stitchMe(), and cgnsAnalyzer::stitchMesh().

{ return nElem; }

getNTStep() [1/2]

int rocstarCgns::getNTStep

(

int

indx

)

Definition at line 107 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::getNTStep(), and myCgObjs.

                                   {
  if (indx < cgFNames.size()) return (myCgObjs[indx]->getNTStep());
  return (-1);
}

getNTStep() [2/2]

int cgnsAnalyzer::getNTStep ( )

inherited

Definition at line 437 of file cgnsAnalyzer.C.

Referenced by getNTStep().

{ return nTStep; }

getNVertex()

int cgnsAnalyzer::getNVertex ( )

inherited

Definition at line 445 of file cgnsAnalyzer.C.

Referenced by stitchMe(), and cgnsAnalyzer::stitchMesh().

{ return nVertex; }

getNVertexSolution()

int cgnsAnalyzer::getNVertexSolution ( )

inherited

Definition at line 1056 of file cgnsAnalyzer.C.

References NODAL.

                                     {
  int nVrtData = 0;

  // loading data if not yet
  if (slnDataCont.empty()) loadSolutionDataContainer();

  // number of vertex solution data
  for (auto &is : slnDataCont)
    if (is->getDataType() == solution_type_t::NODAL) nVrtData++;

  return nVrtData;
}

getNVrtxElem()

int cgnsAnalyzer::getNVrtxElem ( )

inherited

Definition at line 453 of file cgnsAnalyzer.C.

{ return nVrtxElem; }

getNZone() [1/2]

int rocstarCgns::getNZone

(

int

indx

)

Definition at line 403 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::getNZone(), and myCgObjs.

                                  {
  if (indx > cgFNames.size()) return (-1);
  return (myCgObjs[indx]->getNZone());
}

getNZone() [2/2]

int cgnsAnalyzer::getNZone ( )

inherited

Definition at line 435 of file cgnsAnalyzer.C.

Referenced by getNZone().

{ return nZone; }

getPaneBcflag()

int rocstarCgns::getPaneBcflag	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 533 of file rocstarCgns.C.

References CGNS_ENUMT(), cgnsAnalyzer::getIndexBase(), and cgnsAnalyzer::getIndexFile().

Referenced by stitchFldBc().

                                                               {
  if (cg_goto(cgObj->getIndexFile(), cgObj->getIndexBase(), "Zone_t", zoneIdx,
              "IntegralData_t", 1, "end"))
    cg_error_exit();
  int nArr;
  int iArr;
  if (cg_narrays(&nArr)) cg_error_exit();
  for (iArr = 1; iArr <= nArr; iArr++) {
    char arrName[33];
    CGNS_ENUMT(DataType_t) dt;
    int dd;
    cgsize_t dimVec[3];
    if (cg_array_info(iArr, arrName, &dt, &dd, dimVec)) cg_error_exit();
    if (!strcmp(arrName, "bcflag")) break;
  }
  if (iArr > nArr) {
    std::cerr << "Can not find bcflag." << std::endl;
    cg_error_exit();
  }
  int bcflag;
  if (cg_array_read(iArr, &bcflag)) cg_error_exit();
  return (bcflag);
}

getPaneCnstrType()

int rocstarCgns::getPaneCnstrType	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 581 of file rocstarCgns.C.

References CGNS_ENUMT(), cgnsAnalyzer::getIndexBase(), and cgnsAnalyzer::getIndexFile().

Referenced by stitchFldBc().

                                                                  {
  if (cg_goto(cgObj->getIndexFile(), cgObj->getIndexBase(), "Zone_t", zoneIdx,
              "IntegralData_t", 1, "end"))
    cg_error_exit();
  int nArr;
  int iArr;
  if (cg_narrays(&nArr)) cg_error_exit();
  for (iArr = 1; iArr <= nArr; iArr++) {
    char arrName[33];
    CGNS_ENUMT(DataType_t) dt;
    int dd;
    cgsize_t dimVec[3];
    if (cg_array_info(iArr, arrName, &dt, &dd, dimVec)) cg_error_exit();
    if (!strcmp(arrName, "cnstr_type")) break;
  }
  if (iArr > nArr) {
    std::cerr << "Can not find cnstr_type." << std::endl;
    cg_error_exit();
  }
  int cnstrType;
  if (cg_array_read(iArr, &cnstrType)) cg_error_exit();
  return (cnstrType);
}

getPanePatchNo()

int rocstarCgns::getPanePatchNo	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 557 of file rocstarCgns.C.

References CGNS_ENUMT(), cgnsAnalyzer::getIndexBase(), cgnsAnalyzer::getIndexFile(), and patchNo.

Referenced by stitchFldBc().

                                                                {
  if (cg_goto(cgObj->getIndexFile(), cgObj->getIndexBase(), "Zone_t", zoneIdx,
              "IntegralData_t", 1, "end"))
    cg_error_exit();
  int nArr;
  int iArr;
  if (cg_narrays(&nArr)) cg_error_exit();
  for (iArr = 1; iArr <= nArr; iArr++) {
    char arrName[33];
    CGNS_ENUMT(DataType_t) dt;
    int dd;
    cgsize_t dimVec[3];
    if (cg_array_info(iArr, arrName, &dt, &dd, dimVec)) cg_error_exit();
    if (!strcmp(arrName, "patchNo")) break;
  }
  if (iArr > nArr) {
    std::cerr << "Can not find patchNo." << std::endl;
    cg_error_exit();
  }
  int patchNo;
  if (cg_array_read(iArr, &patchNo)) cg_error_exit();
  return (patchNo);
}

getPhysDim()

int cgnsAnalyzer::getPhysDim ( )

inherited

Definition at line 449 of file cgnsAnalyzer.C.

Referenced by stitchMe(), and cgnsAnalyzer::stitchMesh().

{ return physDim; }

getSectionConn()

void cgnsAnalyzer::getSectionConn ( std::string  secName, std::vector< cgsize_t > &  conn, int &  nElm  )

inherited

Definition at line 595 of file cgnsAnalyzer.C.

References CGNS_ENUMT().

                                                                        {
  std::vector<std::string> secNames;
  getSectionNames(secNames);
  auto it = std::find(secNames.begin(), secNames.end(), secName);
  if (it == secNames.end()) {
    std::cerr << "No section found named " << secName << "\n";
    nElm = 0;
    return;
  }
  // reading connectivities
  int nBdry, parentFlag, nVrtxElem;
  cgsize_t eBeg, eEnd;
  char sectionname[33];
  CGNS_ENUMT(ElementType_t) secTyp;
  int iSec = it - secNames.begin() + 1;
  if (cg_section_read(indexFile, indexBase, indexZone, iSec, sectionname,
                      &secTyp, &eBeg, &eEnd, &nBdry, &parentFlag) != CG_OK)
    std::cerr << "Error in load, " << cg_get_error() << std::endl;
  switch (secTyp) {
    case CGNS_ENUMV(TETRA_4): nVrtxElem = 4; break;
    case CGNS_ENUMV(HEXA_8): nVrtxElem = 8; break;
    case CGNS_ENUMV(TRI_3): nVrtxElem = 3; break;
    case CGNS_ENUMV(QUAD_4): nVrtxElem = 4; break;
    case CGNS_ENUMV(TETRA_10): nVrtxElem = 10; break;
    default: std::cerr << "Unknown element type " << secTyp << std::endl; break;
  }
  nElm = eEnd - eBeg + 1;
  conn.resize(nVrtxElem * nElm, -1);
  if (cg_elements_read(indexFile, indexBase, indexZone, iSec, &conn[0],
                       nullptr) != CG_OK)
    std::cerr << "Error in load, " << cg_get_error() << std::endl;
  if (_verb)
    std::cout << "Size of connectivity vector = " << conn.size() << std::endl;
}

getSectionMesh()

vtkSmartPointer< vtkDataSet > cgnsAnalyzer::getSectionMesh ( std::string  secName )

inherited

Definition at line 631 of file cgnsAnalyzer.C.

References CGNS_ENUMT(), NEM::MSH::New(), and points.

                                                                          {
  // rind information test
  int rdata[2];
  if (cg_goto(indexFile, indexBase, "Zone_t", indexZone, "GridCoordinates", 0,
              "end"))
    cg_error_exit();
  if (cg_rind_read(rdata)) cg_error_exit();
  int nRindNde = rdata[1];
  cgsize_t one = 1;
  cgsize_t rmax = nVertex + nRindNde;
  // reading all coordinates
  std::vector<double> xCrdR, yCrdR, zCrdR;
  xCrdR.resize(rmax, 0);
  yCrdR.resize(rmax, 0);
  zCrdR.resize(rmax, 0);
  if (cg_coord_read(indexFile, indexBase, indexZone, "CoordinateX",
                    CGNS_ENUMV(RealDouble), &one, &rmax, &xCrdR[0]) != CG_OK)
    std::cerr << "Error in load, " << cg_get_error() << std::endl;
  if (cg_coord_read(indexFile, indexBase, indexZone, "CoordinateY",
                    CGNS_ENUMV(RealDouble), &one, &rmax, &yCrdR[0]) != CG_OK)
    std::cerr << "Error in load, " << cg_get_error() << std::endl;
  if (cg_coord_read(indexFile, indexBase, indexZone, "CoordinateZ",
                    CGNS_ENUMV(RealDouble), &one, &rmax, &zCrdR[0]) != CG_OK)
    std::cerr << "Error in load, " << cg_get_error() << std::endl;
  int nElmSec;
  std::vector<cgsize_t> connSec;
  getSectionConn(secName, connSec, nElmSec);
  CGNS_ENUMT(ElementType_t) secTyp = getSectionType(secName);

  // points to be pushed into dataSet
  vtkSmartPointer<vtkPoints> points = vtkSmartPointer<vtkPoints>::New();
  // declare vtk dataset
  vtkSmartPointer<vtkUnstructuredGrid> dataSet_tmp =
      vtkSmartPointer<vtkUnstructuredGrid>::New();

  // allocate size for vtk point container
  points->SetNumberOfPoints(rmax);
  for (int i = 0; i < rmax; ++i)
    points->SetPoint(i, xCrdR[i], yCrdR[i], zCrdR[i]);

  // add points to vtk mesh data structure
  dataSet_tmp->SetPoints(points);

  // allocate space for elements
  dataSet_tmp->Allocate(nElmSec);
  // add the elements
  int nNdeElm = connSec.size() / nElmSec;
  for (int i = 0; i < nElmSec; i++) {
    vtkSmartPointer<vtkIdList> vtkElmIds = vtkSmartPointer<vtkIdList>::New();
    vtkElmIds->SetNumberOfIds(nNdeElm);
    for (int j = 0; j < nNdeElm; ++j)
      vtkElmIds->SetId(j, connSec[i * nNdeElm + j] - 1);
    switch (secTyp) {
      case CGNS_ENUMV(TETRA_4):
        dataSet_tmp->InsertNextCell(VTK_TETRA, vtkElmIds);
        break;
      case CGNS_ENUMV(HEXA_8):
        dataSet_tmp->InsertNextCell(VTK_HEXAHEDRON, vtkElmIds);
        break;
      case CGNS_ENUMV(TRI_3):
        dataSet_tmp->InsertNextCell(VTK_TRIANGLE, vtkElmIds);
        break;
      case CGNS_ENUMV(QUAD_4):
        dataSet_tmp->InsertNextCell(VTK_QUAD, vtkElmIds);
        break;
      case CGNS_ENUMV(TETRA_10):
        dataSet_tmp->InsertNextCell(VTK_QUADRATIC_TETRA, vtkElmIds);
        break;
      default:
        std::cerr << "Unknown element type " << sectionType << std::endl;
        break;
    }
  }
  return (dataSet_tmp);
}

getSectionName() [1/2]

std::string rocstarCgns::getSectionName	(	int	cgIdx,
		int	zoneIdx
	)

Definition at line 432 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::getSectionName(), and myCgObjs.

                                                        {
  if (indx > cgFNames.size()) return ("INVALID");
  myCgObjs[indx]->loadZone(zidx);
  return (myCgObjs[indx]->getSectionName());
}

getSectionName() [2/2]

std::string cgnsAnalyzer::getSectionName ( )

inherited

Definition at line 431 of file cgnsAnalyzer.C.

Referenced by getSectionName().

{ return sectionName; }

getSectionNames()

void cgnsAnalyzer::getSectionNames ( std::vector< std::string > &  secNames )

inherited

Definition at line 554 of file cgnsAnalyzer.C.

References CGNS_ENUMT().

                                                              {
  // reading section names
  int nBdry, parentFlag;
  cgsize_t eBeg, eEnd;
  CGNS_ENUMT(ElementType_t) secTyp;
  char sectionname[33];
  if (cg_nsections(indexFile, indexBase, indexZone, &nSection) != CG_OK)
    std::cerr << "Error in reading sections, " << cg_get_error();
  for (int iSec = 1; iSec <= nSection; iSec++) {
    if (cg_section_read(indexFile, indexBase, indexZone, iSec, sectionname,
                        &secTyp, &eBeg, &eEnd, &nBdry, &parentFlag) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error() << std::endl;
    names.push_back(sectionname);
    if (_verb)
      std::cout << "Section " << names[iSec] << " Type = " << secTyp
                << " eBeg = " << eBeg << " eEnd = " << eEnd
                << " nBdry = " << nBdry << std::endl;
  }
}

getSolutionData()

solution_type_t cgnsAnalyzer::getSolutionData ( std::string  sName, std::vector< double > &  slnData  )

inherited

Definition at line 935 of file cgnsAnalyzer.C.

References CGNS_ENUMT(), solutionData::dataType, ELEMENTAL, NODAL, and UNKNOWN.

                                                                          {
  CGNS_ENUMT(DataType_t) dt;
  char fieldName[33];
  int slnCntr = -1;
  int slnIndx = -1;
  int fldIndx = -1;
  int dataType = -1;
  // find the solution index
  for (auto &it : solutionMap) {
    std::pair<int, keyValueList> slnIndxListPair = it.second;
    keyValueList fldIndxSln = slnIndxListPair.second;
    for (auto &it2 : fldIndxSln) {
      slnCntr++;
      if (!((it2.second).compare(sName))) {
        fldIndx = it2.first;
        slnIndx = slnIndxListPair.first;
        break;
      }
    }
    if (slnIndx != -1) break;
  }
  // fail check
  if (slnIndx == -1) {
    std::cerr << "The solution name " << sName << " does not exist.\n";
    return solution_type_t::UNKNOWN;
  }
  // check if data exists
  if (cg_field_info(indexFile, indexBase, indexZone, slnIndx, fldIndx, &dt,
                    fieldName) != CG_OK)
    std::cerr << "Error in reading solution, " << cg_get_error() << std::endl;
  // reading actual data from the file
  cgsize_t one = 1;
  dataType = solutionGridLocation[slnCntr];
  if (isUnstructured) {
    if (dataType == CGNS_ENUMV(Vertex)) {
      slnData.resize(nVertex, -1.0);
      rmax[0] = nVertex;
    } else if (dataType == CGNS_ENUMV(CellCenter)) {
      slnData.resize(nElem, -1.0);
      rmax[0] = nElem;
    } else {
      std::cerr << "Unknown data gird location "
                << solutionGridLocation[slnCntr] << std::endl;
      return solution_type_t::UNKNOWN;
    }
  } else {
    if (dataType == CGNS_ENUMV(Vertex)) {
      slnData.resize(nVertex, -1.0);
      rmax[0] = cgCoreSize[0];
      rmax[1] = cgCoreSize[1];
      rmax[2] = cgCoreSize[2];
    } else if (dataType == CGNS_ENUMV(CellCenter)) {
      slnData.resize(nElem, -1.0);
      rmax[0] = cgCoreSize[3];
      rmax[1] = cgCoreSize[4];
      rmax[2] = cgCoreSize[5];
    } else {
      std::cerr << "Unknown data gird location "
                << solutionGridLocation[slnCntr] << std::endl;
      return solution_type_t::UNKNOWN;
    }
  }

  if (isUnstructured) {
    if (dt == CGNS_ENUMV(RealDouble)) {
      // for double solution data
      if (cg_field_read(indexFile, indexBase, indexZone, slnIndx, fieldName, dt,
                        &one, &rmax[0], &slnData[0]) != CG_OK)
        std::cerr << "Error in reading solution data, " << cg_get_error()
                  << std::endl;
    } else if (dt == CGNS_ENUMV(Integer)) {
      // for integer solution data
      std::vector<int> tmpSlnData;
      tmpSlnData.resize(rmax[0], -1);
      if (cg_field_read(indexFile, indexBase, indexZone, slnIndx, fieldName, dt,
                        &one, &rmax[0], &tmpSlnData[0]) != CG_OK)
        std::cerr << "Error in reading solution data, " << cg_get_error()
                  << std::endl;
      slnData.clear();
      for (int &it : tmpSlnData) slnData.push_back(it);
    }
  } else {
    if (cg_field_read(indexFile, indexBase, indexZone, slnIndx, fieldName, dt,
                      &rmin[0], &rmax[0], &slnData[0]) != CG_OK)
      std::cerr << "Error in reading solution data, " << cg_get_error()
                << std::endl;
  }

  // returns the type of the data
  return (dataType == 2 ? solution_type_t::NODAL : solution_type_t::ELEMENTAL);
}

getSolutionDataNames()

void cgnsAnalyzer::getSolutionDataNames ( std::vector< std::string > &  list )

inherited

Definition at line 918 of file cgnsAnalyzer.C.

Referenced by cgnsAnalyzer::stitchFields(), and stitchFldBc().

                                                                  {
  populateSolutionDataNames();
  for (auto &it : solutionMap) {
    std::pair<int, keyValueList> slnIndxListPair = it.second;
    keyValueList fldIndxSln = slnIndxListPair.second;
    for (auto &it2 : fldIndxSln) { list.push_back(it2.second); }
  }
}

getSolutionDataObj()

solutionData * cgnsAnalyzer::getSolutionDataObj ( std::string  sName )

inherited

Definition at line 1032 of file cgnsAnalyzer.C.

References solutionData::appendData(), solutionData::dataType, NODAL, solutionData::slnData, solutionData::solutionData(), and UNKNOWN.

Referenced by cgnsAnalyzer::stitchFields().

                                                              {
  // return pointer if already loaded
  if (!slnDataCont.empty()) {
    for (auto &is : slnDataCont) {
      if (!strcmp((is->getDataName()).c_str(), sName.c_str())) { return is; }
    }
  }
  // load if needed
  std::vector<double> slnData;
  solution_type_t dataType = getSolutionData(sName, slnData);
  if (dataType == solution_type_t::UNKNOWN) {
    std::cerr << "Unknown data type is not supported.!\n";
    return nullptr;
  }
  // allocating new data object
  solutionData *slnDataObjPtr = new solutionData(sName, dataType);
  if (dataType == solution_type_t::NODAL) {
    slnDataObjPtr->appendData(slnData, slnData.size(), 1);
  } else {
    slnDataObjPtr->appendData(slnData, slnData.size(), 1);
  }
  return slnDataObjPtr;
}

getSolutionDataStitched()

solution_type_t cgnsAnalyzer::getSolutionDataStitched ( std::string  sName, std::vector< double > &  slnData, int &  outNData, int &  outNDim  )

inherited

Definition at line 1082 of file cgnsAnalyzer.C.

References UNKNOWN.

                  {
  // load data if needed
  if (slnDataCont.empty()) loadSolutionDataContainer();

  for (auto &is : slnDataCont) {
    if (!strcmp((is->getDataName()).c_str(), sName.c_str())) {
      is->getData(slnData, outNData, outNDim);
      return (is->getDataType());
    }
  }
  return solution_type_t::UNKNOWN;
}

getSolutionGridLocations()

std::vector< CGNS_ENUMT(GridLocation_t)> cgnsAnalyzer::getSolutionGridLocations ( )

inherited

Definition at line 1149 of file cgnsAnalyzer.C.

Referenced by stitchFldBc().

                                       {
  return solutionGridLocation;
}

getSolutionMap()

std::map< int, std::pair< int, keyValueList > > cgnsAnalyzer::getSolutionMap ( )

inherited

Definition at line 1154 of file cgnsAnalyzer.C.

Referenced by stitchFldBc().

                                                                     {
  return solutionMap;
}

getSolutionNameLocMap()

std::map< std::string, CGNS_ENUMT(GridLocation_t)> cgnsAnalyzer::getSolutionNameLocMap ( )

inherited

Definition at line 1160 of file cgnsAnalyzer.C.

Referenced by stitchFldBc().

                                    {
  return solutionNameLocMap;
}

getSolutionNodeNames()

std::vector< std::string > cgnsAnalyzer::getSolutionNodeNames ( )

inherited

Definition at line 1143 of file cgnsAnalyzer.C.

Referenced by stitchFldBc().

                                                        {
  return solutionName;
}

getSolutionPntr() [1/2]

std::string rocstarCgns::getSolutionPntr	(	int	indx,
		int	zidx
	)

Definition at line 129 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::getSolutionPntr(), and myCgObjs.

                                                         {
  if (indx > cgFNames.size()) return ("INVALID");
  myCgObjs[indx]->loadZone(zidx);
  return (myCgObjs[indx]->getSolutionPntr());
}

getSolutionPntr() [2/2]

std::string cgnsAnalyzer::getSolutionPntr ( )

inherited

Definition at line 443 of file cgnsAnalyzer.C.

Referenced by getSolutionPntr().

{ return flowSlnPntr; }

getTimeStep() [1/2]

double rocstarCgns::getTimeStep

(

int

indx

)

Definition at line 112 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::getTimeStep(), and myCgObjs.

                                        {
  if (indx < cgFNames.size()) return (myCgObjs[indx]->getTimeStep());
  return (-1);
}

getTimeStep() [2/2]

double cgnsAnalyzer::getTimeStep ( )

inherited

Definition at line 455 of file cgnsAnalyzer.C.

Referenced by getTimeStep(), and stitchMe().

{ return timeLabel; }

getVertexCoords() [1/2]

std::vector< double > cgnsAnalyzer::getVertexCoords ( )

inherited

Definition at line 482 of file cgnsAnalyzer.C.

                                                {
  std::vector<double> crd;
  for (int iVrt = 0; iVrt < nVertex; ++iVrt) {
    crd.push_back(xCrd[iVrt]);
    crd.push_back(yCrd[iVrt]);
    crd.push_back(zCrd[iVrt]);
  }
  return crd;
}

getVertexCoords() [2/2]

std::vector< double > cgnsAnalyzer::getVertexCoords ( int  vrtxId )

inherited

Definition at line 492 of file cgnsAnalyzer.C.

                                                          {
  std::vector<double> crd;
  if (vrtxId > nVertex || vrtxId < 0) {
    std::cerr << "Requested index is out of bounds." << std::endl;
    return crd;
  }
  crd.push_back(xCrd[vrtxId]);
  crd.push_back(yCrd[vrtxId]);
  crd.push_back(zCrd[vrtxId]);
  return crd;
}

getVrtXCrd() [1/2]

double cgnsAnalyzer::getVrtXCrd ( int  vrtxId )

inherited

Definition at line 504 of file cgnsAnalyzer.C.

Referenced by stitchMe(), and cgnsAnalyzer::stitchMesh().

{ return xCrd[vrtxId]; }

getVrtXCrd() [2/2]

std::vector< double > cgnsAnalyzer::getVrtXCrd ( )

inherited

Definition at line 506 of file cgnsAnalyzer.C.

{ return xCrd; }

getVrtYCrd() [1/2]

double cgnsAnalyzer::getVrtYCrd ( int  vrtxId )

inherited

Definition at line 508 of file cgnsAnalyzer.C.

Referenced by stitchMe(), and cgnsAnalyzer::stitchMesh().

{ return yCrd[vrtxId]; }

getVrtYCrd() [2/2]

std::vector< double > cgnsAnalyzer::getVrtYCrd ( )

inherited

Definition at line 510 of file cgnsAnalyzer.C.

{ return yCrd; }

getVrtZCrd() [1/2]

double cgnsAnalyzer::getVrtZCrd ( int  vrtxId )

inherited

Definition at line 512 of file cgnsAnalyzer.C.

Referenced by stitchMe(), and cgnsAnalyzer::stitchMesh().

{ return zCrd[vrtxId]; }

getVrtZCrd() [2/2]

std::vector< double > cgnsAnalyzer::getVrtZCrd ( )

inherited

Definition at line 514 of file cgnsAnalyzer.C.

{ return zCrd; }

getVTKMesh()

vtkSmartPointer< vtkDataSet > cgnsAnalyzer::getVTKMesh ( )

inherited

Definition at line 473 of file cgnsAnalyzer.C.

                                                     {
  if (vtkMesh)
    return vtkMesh;
  else {
    exportToVTKMesh();
    return vtkMesh;
  }
}

getZoneCoords()

std::vector< double > rocstarCgns::getZoneCoords	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx,
		int	dim
	)

Definition at line 462 of file rocstarCgns.C.

References CGNS_ENUMT(), cgnsAnalyzer::getIndexBase(), cgnsAnalyzer::getIndexFile(), and getZoneNVrtx().

Referenced by stitchMe().

                                                        {
  std::vector<double> crds;
  if (cg_goto(cgObj->getIndexFile(), cgObj->getIndexBase(), "Zone_t", zoneIdx,
              "GridCoordinates_t", 1, "end"))
    cg_error_exit();
  char arrName[33];
  CGNS_ENUMT(DataType_t) dt;
  int dd;
  cgsize_t dimVec[3];
  if (cg_array_info(dim, arrName, &dt, &dd, dimVec)) cg_error_exit();
  crds.resize(dimVec[0], 0);
  if (cg_array_read(dim, &crds[0])) cg_error_exit();
  // removing extra values that rocstar puts at the end
  for (int iEx = dimVec[0]; iEx > getZoneNVrtx(cgObj, zoneIdx); iEx--)
    crds.pop_back();
  return (crds);
}

getZoneItrName() [1/2]

std::string rocstarCgns::getZoneItrName	(	int	indx,
		int	zidx
	)

Definition at line 117 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::getZoneItrName(), and myCgObjs.

                                                        {
  if (indx > cgFNames.size()) return ("INVALID");
  myCgObjs[indx]->loadZone(zidx);
  return (myCgObjs[indx]->getZoneItrName());
}

getZoneItrName() [2/2]

std::string cgnsAnalyzer::getZoneItrName ( )

inherited

Definition at line 439 of file cgnsAnalyzer.C.

Referenced by getZoneItrName().

{ return zoneItrName; }

getZoneName() [1/4]

std::string rocstarCgns::getZoneName	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 408 of file rocstarCgns.C.

References cgnsAnalyzer::getIndexBase(), and cgnsAnalyzer::getIndexFile().

                                                                   {
  char zonename[33];
  cgsize_t tmp[9];
  if (cg_zone_read(cgObj->getIndexFile(), cgObj->getIndexBase(), zoneIdx,
                   zonename, tmp))
    cg_error_exit();
  return (zonename);
}

getZoneName() [2/4]

std::string rocstarCgns::getZoneName	(	int	cgIdx,
		int	zoneIdx
	)

Definition at line 417 of file rocstarCgns.C.

References cgnsAnalyzer::getIndexBase(), cgnsAnalyzer::getIndexFile(), and myCgObjs.

                                                         {
  char zonename[33];
  cgsize_t tmp[9];
  if (cg_zone_read(myCgObjs[cgIdx]->getIndexFile(),
                   myCgObjs[cgIdx]->getIndexBase(), zoneIdx, zonename, tmp))
    cg_error_exit();
  return (zonename);
}

getZoneName() [3/4]

std::string cgnsAnalyzer::getZoneName ( )

inherited

Definition at line 425 of file cgnsAnalyzer.C.

Referenced by stitchGroup(), stitchMe(), and cgnsAnalyzer::stitchMesh().

{ return zoneName; }

getZoneName() [4/4]

std::string cgnsAnalyzer::getZoneName ( int  nCgFile )

inherited

Definition at line 427 of file cgnsAnalyzer.C.

                                               {
  return zoneNames[iCgFile];
}

getZoneNCell()

int rocstarCgns::getZoneNCell	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 453 of file rocstarCgns.C.

References cgnsAnalyzer::getIndexBase(), and cgnsAnalyzer::getIndexFile().

Referenced by stitchMe().

                                                              {
  char zonename[33];
  cgsize_t size[3];
  if (cg_zone_read(cgObj->getIndexFile(), cgObj->getIndexBase(), zoneIdx,
                   zonename, size))
    cg_error_exit();
  return (size[1]);
}

getZoneNVrtx()

int rocstarCgns::getZoneNVrtx	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 444 of file rocstarCgns.C.

References cgnsAnalyzer::getIndexBase(), and cgnsAnalyzer::getIndexFile().

Referenced by getZoneCoords(), and stitchMe().

                                                              {
  char zonename[33];
  cgsize_t size[3];
  if (cg_zone_read(cgObj->getIndexFile(), cgObj->getIndexBase(), zoneIdx,
                   zonename, size))
    cg_error_exit();
  return (size[0]);
}

getZoneRealConn()

std::vector< cgsize_t > rocstarCgns::getZoneRealConn	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 481 of file rocstarCgns.C.

References CGNS_ENUMT(), cgnsAnalyzer::getIndexBase(), and cgnsAnalyzer::getIndexFile().

Referenced by stitchMe().

                                                                {
  std::vector<cgsize_t> conn;
  int secidx = 1;
  char secname[33];
  CGNS_ENUMT(ElementType_t) et;
  cgsize_t st, en;
  int nbndry, parflag;
  if (cg_section_read(cgObj->getIndexFile(), cgObj->getIndexBase(), zoneIdx,
                      secidx, secname, &et, &st, &en, &nbndry, &parflag))
    cg_error_exit();
  // making sure we read real one otherwise next one is the real one
  if (std::string(secname).find("real") == std::string::npos)
    if (cg_section_read(cgObj->getIndexFile(), cgObj->getIndexBase(), zoneIdx,
                        ++secidx, secname, &et, &st, &en, &nbndry, &parflag))
      cg_error_exit();
  int nVrtxElm;
  switch (et) {
    case CGNS_ENUMV(TETRA_4): nVrtxElm = 4; break;
    case CGNS_ENUMV(HEXA_8): nVrtxElm = 8; break;
    case CGNS_ENUMV(TRI_3): nVrtxElm = 3; break;
    case CGNS_ENUMV(QUAD_4): nVrtxElm = 4; break;
    default: std::cerr << "Unknown element type " << st << std::endl; break;
  }
  conn.resize((en - st + 1) * nVrtxElm, -1);
  if (cg_elements_read(cgObj->getIndexFile(), cgObj->getIndexBase(), zoneIdx,
                       secidx, &conn[0], NULL))
    cg_error_exit();
  return (conn);
}

getZoneRealSecType()

int rocstarCgns::getZoneRealSecType	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 512 of file rocstarCgns.C.

References CGNS_ENUMT(), cgnsAnalyzer::getIndexBase(), and cgnsAnalyzer::getIndexFile().

Referenced by stitchMe().

                                                                    {
  std::vector<int> conn;
  int secidx = 1;
  char secname[33];
  CGNS_ENUMT(ElementType_t) et;
  cgsize_t st, en;
  int nbndry, parflag;
  if (cg_section_read(cgObj->getIndexFile(), cgObj->getIndexBase(), zoneIdx,
                      secidx, secname, &et, &st, &en, &nbndry, &parflag))
    cg_error_exit();
  // making sure we read real one otherwise next one is the real one
  if (std::string(secname).find("real") == std::string::npos)
    if (cg_section_read(cgObj->getIndexFile(), cgObj->getIndexBase(), zoneIdx,
                        ++secidx, secname, &et, &st, &en, &nbndry, &parflag))
      cg_error_exit();
  return (et);
}

isCgRindCell()

bool cgnsAnalyzer::isCgRindCell ( int  cgCellId )

inherited

Definition at line 1738 of file cgnsAnalyzer.C.

                                            {
  // for structured zones we should avoid writing rind cells
  if (!cgRindCellIds.empty()) {
    auto it = std::find(cgRindCellIds.begin(), cgRindCellIds.end(), cgCellId);
    return (it != cgRindCellIds.end());
  } else
    return false;
}

isCgRindNode()

bool cgnsAnalyzer::isCgRindNode ( int  cgNdeId )

inherited

Definition at line 1729 of file cgnsAnalyzer.C.

                                            {
  // for structured zones we should avoid writing rind cells
  if (!cgRindNodeIds.empty()) {
    auto it = std::find(cgRindNodeIds.begin(), cgRindNodeIds.end(), cgNodeId);
    return (it != cgRindNodeIds.end());
  } else
    return false;
}

isMultiZone()

bool cgnsAnalyzer::isMultiZone ( )

inherited

isStructured()

bool cgnsAnalyzer::isStructured ( )

inherited

Definition at line 471 of file cgnsAnalyzer.C.

Referenced by stitchMe().

{ return !isUnstructured; }

loadCgSeries() [1/2]

void rocstarCgns::loadCgSeries

(

)

Definition at line 75 of file rocstarCgns.C.

References cgFNames, cgnsAnalyzer::cgnsAnalyzer(), cgnsAnalyzer::loadGrid(), and myCgObjs.

                               {
  for (int i = 0; i < cgFNames.size(); ++i) {
    cgnsAnalyzer *cgTmp = new cgnsAnalyzer(cgFNames[i]);
    cgTmp->loadGrid();
    myCgObjs.push_back(cgTmp);
  }
}

loadCgSeries() [2/2]

void rocstarCgns::loadCgSeries

(

int

nCg

)

Definition at line 59 of file rocstarCgns.C.

References baseCgFName, cgFNames, cgnsAnalyzer::cgnsAnalyzer(), cgnsAnalyzer::loadGrid(), myCgObjs, and padSize.

                                      {
  for (int iCg = 0; iCg < nCg; iCg++) {
    std::ostringstream suffix1;
    std::ostringstream suffix2;
    suffix1 << iCg;
    std::string tmp = suffix1.str();
    for (int iPad = 0; iPad < padSize - tmp.size(); iPad++) suffix2 << "0";
    suffix2 << tmp << ".cgns";
    std::string fName = baseCgFName + suffix2.str();
    cgnsAnalyzer *cgTmp = new cgnsAnalyzer(fName);
    cgTmp->loadGrid();
    myCgObjs.push_back(cgTmp);
    cgFNames.push_back(fName);
  }
}

loadGrid() [1/2]

void cgnsAnalyzer::loadGrid ( const std::string &  fname, int  verb = 0  )

inlineinherited

Definition at line 147 of file cgnsAnalyzer.H.

Referenced by loadCgSeries().

                                                      {
    cgFileName = fname;
    loadGrid(verb);
  };

loadGrid() [2/2]

void cgnsAnalyzer::loadGrid ( int  verb = 0 )

inherited

Definition at line 104 of file cgnsAnalyzer.C.

                                    {
  // cgns related variables
  // int i, j, k;
  char basename[33] /*, zonename[33]*/;

  // open CGNS file for read
  if (cg_open(cgFileName.c_str(), CG_MODE_MODIFY, &indexFile)) cg_error_exit();

  // reading base information
  cg_nbases(indexFile, &nBase);
  if (nBase > 1)
    std::cerr << "There are " << nBase
              << " bases in the file (not supported).\n";
  else
    indexBase = 1;
  if (cg_base_read(indexFile, indexBase, basename, &cellDim, &physDim))
    cg_error_exit();
  baseName = basename;

  // reading units
  if (cg_goto(indexFile, indexBase, "end")) cg_error_exit();
  if (cg_units_read(&massU, &lengthU, &timeU, &tempU, &angleU)) cg_error_exit();
  if (verb > 0)
    std::cout << " ------------------------------------------------\n"
              << "Base name = " << baseName << "\ncellDim = " << cellDim
              << "\nphysDim = " << physDim << "\nUnits " << massU << " "
              << lengthU << " " << timeU << " " << tempU << " " << angleU
              << std::endl;

  // reading base iterative data
  char bitername[33];
  if (cg_biter_read(indexFile, indexBase, bitername, &nTStep)) cg_error_exit();
  baseItrName = bitername;
  if (nTStep != 1) std::cerr << "More than one time step is not supported.\n";
  // int nArrays;
  std::cout << baseItrName << std::endl;
  if (cg_goto(indexFile, indexBase, bitername, 0, "end")) cg_error_exit();
  if (cg_array_read_as(1, CGNS_ENUMV(RealDouble), &timeLabel)) cg_error_exit();
  if (verb > 0) std::cout << "Time label = " << timeLabel << std::endl;

  // reading zone information
  cg_nzones(indexFile, indexBase, &nZone);
  if (nZone > 1) {
    // std::cout << "There are " << nZone << " zones in the file (not
    // supported).\n";
    isMltZone = true;
  }
  loadZone(1, verb);
}

loadSolutionDataContainer()

void cgnsAnalyzer::loadSolutionDataContainer ( int  verb = 0 )

protectedinherited

Definition at line 1617 of file cgnsAnalyzer.C.

References solutionData::getNData(), and solutionData::getNDim().

Referenced by stitchFldBc().

                                                     {
  // look at the solution names of current grid
  std::vector<std::string> crntCgList;
  getSolutionDataNames(crntCgList);
  if (verb > 0)
    for (auto &it : crntCgList) std::cout << it << std::endl;
  // load solution data container if empty
  if (slnDataCont.empty()) {
    for (auto &is : crntCgList) {
      solutionData *slnDataPtr = getSolutionDataObj(is);
      if (verb > 0)
        std::cout << is << " number of data read " << slnDataPtr->getNData()
                  << " " << slnDataPtr->getNDim() << std::endl;
      slnDataCont.push_back(slnDataPtr);
    }
  }
  // information
  std::cout << "  Number of Solution Field = " << slnDataCont.size()
            << std::endl;
}

loadZone()

void cgnsAnalyzer::loadZone ( int  zIdx, int  verb = 0  )

inherited

Definition at line 154 of file cgnsAnalyzer.C.

Referenced by stitchFldBc(), and stitchMe().

                                              {
  char zonename[33];
  indexZone = zIdx;
  // reading zone type and name
  cg_zone_read(indexFile, indexBase, indexZone, zonename, cgCoreSize);
  cg_zone_type(indexFile, indexBase, indexZone, &zoneType);
  zoneName = zonename;
  zoneNames.push_back(zoneName);
  if (verb) std::cout << "Zone name = " << zoneName << std::endl;

  // type of zone
  if (zoneType == CGNS_ENUMV(ZoneTypeNull)) {
    if (verb) std::cout << "Zone type = CG_ZoneTypeNull\n";
  } else if (zoneType == CGNS_ENUMV(Structured)) {
    isUnstructured = false;
    if (verb) std::cout << "Zone type = CG_Structured\n";
    std::cerr << "Warning: Structured meshes only supported experimentally.\n";
  } else if (zoneType == CGNS_ENUMV(Unstructured)) {
    isUnstructured = true;
    if (verb) std::cout << "Zone type = CG_Unstructured\n";
  } else if (zoneType == CGNS_ENUMV(ZoneTypeUserDefined)) {
    if (verb) std::cout << "Zone type = CG_ZoneTypeUserDefined\n";
  }

  // reading zone iterative data, in the case of Rocstar outputs
  // there should be two additional nodes bellow this
  // containing grid coordinate pointer and flow solution pointer
  char zitername[33];
  if (cg_ziter_read(indexFile, indexBase, indexZone, zitername))
    cg_error_exit();
  zoneItrName = zitername;
  if (verb) std::cout << "Zone iterative name = " << zoneItrName << std::endl;
  char gridcoorpntr[33], flowslnpntr[33];
  if (cg_goto(indexFile, indexBase, zonename, 0, zitername, 0, "end"))
    cg_error_exit();
  // readin flow solution and grid coordiate pointers if they exist at all
  // if (!cg_goto(indexFile, indexBase, zonename, 0, zitername, 0,
  // "GridCoordiatesPointers", 0, "end"))
  if (!cg_goto(indexFile, indexBase, "Zone_t", indexZone, "ZoneIterativeData_t",
               1, "end")) {
    if (!cg_array_read_as(1, CGNS_ENUMV(Character), gridcoorpntr))
      gridCrdPntr = gridcoorpntr;
    else
      gridCrdPntr = "NA";
    if (verb)
      std::cout << "Grid coordinate pointer = " << gridcoorpntr << std::endl;
    if (!cg_array_read_as(2, CGNS_ENUMV(Character), flowslnpntr))
      flowSlnPntr = flowslnpntr;
    else
      flowSlnPntr = "NA";
    if (verb)
      std::cout << "Flow solution pointer = " << flowslnpntr << std::endl;
  } else {
    std::cout << "This zone does not containing grid/flow pointers.\n";
  }

  // finding number of vertices and elements
  if (zoneType == CGNS_ENUMV(Unstructured)) {
    nVertex = cgCoreSize[0];
    nElem = cgCoreSize[1];
    rmax[0] = nVertex;
    rmax[1] = nVertex;
    rmax[2] = nVertex;
  } else {
    // for strucutred meshes we have to
    // take into account number of rind nodes in each
    // direction. In rocstar case they are equal in each direction
    int rdata[2];
    if (cg_goto(indexFile, indexBase, "Zone_t", zIdx, "GridCoordinates", 0,
                "end"))
      cg_error_exit();
    if (cg_rind_read(rdata)) cg_error_exit();
    nRindNdeStr = rdata[1];
    // assuming same number in each direction and same number
    // of rind cells layers as the number of rind node layers
    // (true condition for Rocflo)
    std::cout << "nRindNdeStr = " << nRindNdeStr << "\n";
    // number of real vertices + nRindNode in each direction
    cgCoreSize[0] += 2 * nRindNdeStr;
    cgCoreSize[1] += 2 * nRindNdeStr;
    cgCoreSize[2] += 2 * nRindNdeStr;
    // each rind node adds a row of elements as well
    cgCoreSize[3] += 2 * nRindNdeStr;
    cgCoreSize[4] += 2 * nRindNdeStr;
    cgCoreSize[5] += 2 * nRindNdeStr;
    nVertex = cgCoreSize[0] * cgCoreSize[1] * cgCoreSize[2];
    nElem = cgCoreSize[3] * cgCoreSize[4] * cgCoreSize[5];
    rmin[0] = 1;
    rmin[1] = 1;
    rmin[2] = 1;
    rmax[0] = cgCoreSize[0];
    rmax[1] = cgCoreSize[1];
    rmax[2] = cgCoreSize[2];
    std::cout << " Number of rind node for structured zone = " << nRindNdeStr
              << std::endl;
  }
  if (verb)
    std::cout << "Number of vertex = " << nVertex
              << "\nNumber of elements = " << nElem << std::endl;

  // capturing rinde node ids
  int ndId = 0;
  if (nRindNdeStr != 0)
    for (int i = rmin[2]; i <= rmax[2]; i++)
      for (int j = rmin[1]; j <= rmax[1]; j++)
        for (int k = rmin[0]; k <= rmax[0]; k++) {
          ndId++;
          if ((i <= nRindNdeStr || (rmax[2] - i) < nRindNdeStr) ||
              (j <= nRindNdeStr || (rmax[1] - j) < nRindNdeStr) ||
              (k <= nRindNdeStr || (rmax[0] - k) < nRindNdeStr))
            cgRindNodeIds.push_back(ndId);
        }
  std::cout << "Total number of rind nodes = " << cgRindNodeIds.size() << "\n";

  // reading coordinates
  cgsize_t one = 1;
  if (zoneType == CGNS_ENUMV(Unstructured)) {
    // reading coordinates X
    xCrd.resize(nVertex, 0);
    if (cg_coord_read(indexFile, indexBase, indexZone, "CoordinateX",
                      CGNS_ENUMV(RealDouble), &one, &rmax[0],
                      &xCrd[0]) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error() << std::endl;

    // reading coordinates Y
    yCrd.resize(nVertex, 0);
    if (cg_coord_read(indexFile, indexBase, indexZone, "CoordinateY",
                      CGNS_ENUMV(RealDouble), &one, &rmax[1],
                      &yCrd[0]) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error() << std::endl;

    // reading coordinates Z
    zCrd.resize(nVertex, 0);
    if (cg_coord_read(indexFile, indexBase, indexZone, "CoordinateZ",
                      CGNS_ENUMV(RealDouble), &one, &rmax[2],
                      &zCrd[0]) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error() << std::endl;
  } else if (zoneType == CGNS_ENUMV(Structured)) {
    // rind information in case any (testing)

    // reading coordinates X
    xCrd.resize(nVertex, 0);
    if (cg_coord_read(indexFile, indexBase, indexZone, "CoordinateX",
                      CGNS_ENUMV(RealDouble), &rmin[0], &rmax[0],
                      &xCrd[0]) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error() << std::endl;

    // reading coordinates Y
    yCrd.resize(nVertex, 0);
    if (cg_coord_read(indexFile, indexBase, indexZone, "CoordinateY",
                      CGNS_ENUMV(RealDouble), &rmin[0], &rmax[0],
                      &yCrd[0]) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error() << std::endl;

    // reading coordinates Z
    zCrd.resize(nVertex, 0);
    if (cg_coord_read(indexFile, indexBase, indexZone, "CoordinateZ",
                      CGNS_ENUMV(RealDouble), &rmin[0], &rmax[0],
                      &zCrd[0]) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error() << std::endl;
  } else {
    std::cerr << "Error in load, only CG_Structured and CG_Unstructured girds "
                 "are supported.\n ";
    exit(0);
  }

  // reading connectivity only if CG_Unstructured
  if (zoneType == CGNS_ENUMV(Unstructured)) {
    int indexSection, nBdry, parentFlag;
    cgsize_t eBeg, eEnd;
    char sectionname[33];
    if (cg_nsections(indexFile, indexBase, indexZone, &nSection) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error();
    if (nSection > 1)
      if (verb)
        std::cout << nSection
                  << " element connectivity sections were found (real+virtual "
                     "in case of rocstar)"
                  << ", only first section will be read for now." << std::endl;
    indexSection = 1;
    if (cg_section_read(indexFile, indexBase, indexZone, indexSection,
                        sectionname, &sectionType, &eBeg, &eEnd, &nBdry,
                        &parentFlag) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error() << std::endl;
    sectionName = sectionname;
    if (verb)
      std::cout << "Section " << sectionname << " eBeg = " << eBeg
                << " eEnd = " << eEnd << " nBdry = " << nBdry << std::endl;
    switch (sectionType) {
      case CGNS_ENUMV(TETRA_4): nVrtxElem = 4; break;
      case CGNS_ENUMV(HEXA_8): nVrtxElem = 8; break;
      case CGNS_ENUMV(TRI_3): nVrtxElem = 3; break;
      case CGNS_ENUMV(QUAD_4): nVrtxElem = 4; break;
      case CGNS_ENUMV(TETRA_10): nVrtxElem = 10; break;
      default:
        std::cerr << "Unknown element type " << sectionType << std::endl;
        break;
    }
    elemConn.resize(nVrtxElem * nElem, -1);
    if (cg_elements_read(indexFile, indexBase, indexZone, indexSection,
                         &elemConn[0], nullptr) != CG_OK)
      std::cerr << "Error in load, " << cg_get_error() << std::endl;
    // reduce by 1 to base the node index to zero
    // using lambda function
    // std::for_each(elemConn.begin(), elemConn.end(), [](int& d) { d -= 1; });
    if (verb)
      std::cout << "Size of connectivity vector = " << elemConn.size()
                << std::endl;
  } else if (zoneType == CGNS_ENUMV(Structured)) {
    // Generating connectivity for structured meshes since file does not contain
    // data
    std::cerr << "Warning: converting implicit structured connectivity to "
                 "8-Node hexahedrals.\n";
    sectionType = CGNS_ENUMV(HEXA_8);
    elemConn.resize(8 * nElem, -1);
    int iElm;
    int bs, d1, d2, d3, d4 /*,d5*/;
    iElm = 0;
    bs = 0;
    d4 = cgCoreSize[1] * cgCoreSize[0];
    for (int k = 1; k < cgCoreSize[2]; k++) {
      d1 = d4 * (k - 1);
      for (int j = 1; j < cgCoreSize[1]; j++) {
        d2 = d1 + (cgCoreSize[0]) * (j - 1);
        for (int i = 1; i < cgCoreSize[0]; i++) {
          // rind detector
          d3 = d2 + i;
          elemConn[bs] = d3;
          elemConn[bs + 1] = d3 + 1;
          elemConn[bs + 2] = d3 + 1 + cgCoreSize[0];
          elemConn[bs + 3] = d3 + cgCoreSize[0];
          elemConn[bs + 4] = d3 + d4;
          elemConn[bs + 5] = d3 + 1 + d4;
          elemConn[bs + 6] = d3 + 1 + cgCoreSize[0] + d4;
          elemConn[bs + 7] = d3 + cgCoreSize[0] + d4;
          // std::cout << "Elem conn = "
          //     << elemConn[bs] << " "
          //     << elemConn[bs+1] << " "
          //     << elemConn[bs+2] << " "
          //     << elemConn[bs+3] << " "
          //     << elemConn[bs+4] << " "
          //     << elemConn[bs+5] << " "
          //     << elemConn[bs+6] << " "
          //     << elemConn[bs+7] << "\n";
          bs += 8;
          iElm += 1;
          if ((k <= nRindNdeStr || (cgCoreSize[2] - k) <= nRindNdeStr) ||
              (j <= nRindNdeStr || (cgCoreSize[1] - j) <= nRindNdeStr) ||
              (i <= nRindNdeStr || (cgCoreSize[0] - i) <= nRindNdeStr))
            cgRindCellIds.push_back(iElm);
        }
      }
    }
    // auto it1 = max_element(std::begin(elemConn), std::end(elemConn));
    // auto it2 = min_element(std::begin(elemConn), std::end(elemConn));
    // std::cout << "Max Conn = " << *it1 << std::endl;
    // std::cout << "Min Conn = " << *it2 << std::endl;
    // std::cerr << "nElm = " << iElm << "\n";
  }
}

overwriteSolData() [1/2]

void cgnsAnalyzer::overwriteSolData ( meshBase *  mbObj )

inherited

Definition at line 1215 of file cgnsAnalyzer.C.

References meshBase::getCellDataArray(), and meshBase::getPointDataArray().

                                                   {
  // loading data if not yet
  if (slnDataCont.empty()) loadSolutionDataContainer();
  // write individual data fields
  int iSol = -1;
  for (auto &is : solutionMap) {
    std::pair<int, keyValueList> slnPair = is.second;
    int slnIdx = slnPair.first;
    keyValueList fldLst = slnPair.second;
    for (auto &ifl : fldLst) {
      iSol++;
      std::vector<double> newData;
      if (solutionGridLocation[iSol] == CGNS_ENUMV(Vertex)) {
        mbObj->getPointDataArray(ifl.second, newData);
      } else {
        // gs field is weird in irocstar files we don't write it back
        // if (/*!(ifl->second).compare("gs") ||*/
        // !(ifl.second).compare("mdot_old"))
        //
        //  TJW: Removed condition above because we now write out gs
        //  We don't write out mdot_old because it is only on burning surfaces;
        //  when we stitch burning with non-interacting surfaces (which don't
        //  have mdot_old), the VTK stitcher utility only keeps fields that both
        //  surfaces have
        if (!(ifl.second).compare("mdot_old")) { continue; }
        mbObj->getCellDataArray(ifl.second, newData);
      }
      std::cout << "Writing " << newData.size() << " to " << ifl.second
                << " located in " << solutionName[iSol] << std::endl;
      // write to file
      if (!(ifl.second)
               .compare(
                   "bflag"))  // cg_io complains if this isn't CG_Integer type
      // if (slnDataCont[slnIdx]->getDataType() == CGNS_ENUMV(Integer) ||
      // !(ifl.second).compare("bflag"))
      {
        // need to cast to int before passing as void*
        std::vector<int> newDataToInt(newData.begin(), newData.end());
        overwriteSolData(ifl.second, solutionName[iSol], slnIdx,
                         CGNS_ENUMV(Integer), &newDataToInt[0]);
      } else
        overwriteSolData(ifl.second, solutionName[iSol], slnIdx,
                         CGNS_ENUMV(RealDouble), &newData[0]);
    }
  }
}

overwriteSolData() [2/2]

void cgnsAnalyzer::overwriteSolData ( const std::string &  fname, const std::string &  ndeName, int  slnIdx, CGNS_ENUMT(DataType_t)  dt, void *  data  )

inherited

Definition at line 1262 of file cgnsAnalyzer.C.

References CGNS_ENUMT(), and data.

                                                                           {
  // write solution to file
  CGNS_ENUMT(GridLocation_t) gloc(solutionNameLocMap[fname]);
  int fldIdx;
  if (cg_field_write(indexFile, indexBase, indexZone, slnIdx, dt, fname.c_str(),
                     data, &fldIdx))
    cg_error_exit();
  // finding range of data
  double *tmpData = (double *)data;
  double min = tmpData[0];
  double max = tmpData[0];
  int nItr = 0;
  if (gloc == CGNS_ENUMV(Vertex)) {
    nItr = nVertex;
  } else {
    nItr = nElem;
  }
  for (int it = 0; it < nItr; ++it) {
    min = std::min(tmpData[it], min);
    max = std::max(tmpData[it], max);
  }
  // writing range descriptor
  std::ostringstream os;
  os << min << ", " << max;
  std::string range = os.str();
  if (cg_goto(indexFile, indexBase, "Zone_t", indexZone, "FlowSolution_t",
              slnIdx, "DataArray_t", fldIdx, "end"))
    cg_error_exit();
  if (cg_descriptor_write("Range", range.c_str())) cg_error_exit();
  // write DimensionalExponents and units for cell data
  if (gloc == CGNS_ENUMV(CellCenter)) {
    if (cg_goto(indexFile, indexBase, "Zone_t", indexZone, "FlowSolution_t",
                slnIdx, "DataArray_t", fldIdx, "end"))
      cg_error_exit();
    // dummy exponents and units
    float exponents[5] = {0, 0, 0, 0, 0};
    if (cg_exponents_write(CGNS_ENUMV(RealSingle), exponents)) cg_error_exit();
    if (cg_descriptor_write("Units", "dmy")) cg_error_exit();
  }
}

populateSolutionDataNames()

void cgnsAnalyzer::populateSolutionDataNames ( )

protectedinherited

Definition at line 884 of file cgnsAnalyzer.C.

References CGNS_ENUMT().

                                             {
  // only one time needed for each zone
  if (solutionDataPopulated) return;
  // populating solution data
  char fieldName[33];
  char solName[33];
  CGNS_ENUMT(GridLocation_t) gloc;
  int nFlds;
  int cntr = 0;
  CGNS_ENUMT(DataType_t) dt;
  // number of solution fields
  cg_nsols(indexFile, indexBase, indexZone, &nSolution);
  for (int iSol = 1; iSol <= nSolution; ++iSol) {
    std::pair<int, keyValueList> slnPair;
    keyValueList fldIndxSln;
    cg_sol_info(indexFile, indexBase, indexZone, iSol, solName, &gloc);
    cg_nfields(indexFile, indexBase, indexZone, iSol, &nFlds);
    solutionNameLocMap[solName] = gloc;
    for (int iFld = 1; iFld <= nFlds; ++iFld) {
      // name and location
      solutionName.push_back(solName);
      solutionGridLocation.push_back(gloc);
      // field information
      cg_field_info(indexFile, indexBase, indexZone, iSol, iFld, &dt,
                    fieldName);
      fldIndxSln[iFld] = fieldName;
    }
    slnPair.first = iSol;
    slnPair.second = fldIndxSln;
    solutionMap[cntr++] = slnPair;
  }
  solutionDataPopulated = true;
}

setBurnBool()

void rocstarCgns::setBurnBool ( bool  b )

inline

Definition at line 87 of file rocstarCgns.H.

{ _burn = b; };

stitchFields()

void cgnsAnalyzer::stitchFields ( cgnsAnalyzer *  inCg )

protectedvirtualinherited

Definition at line 1638 of file cgnsAnalyzer.C.

References cgnsAnalyzer::getAppendedSolutionDataName(), solutionData::getData(), solutionData::getDataName(), solutionData::getDataType(), cgnsAnalyzer::getSolutionDataNames(), cgnsAnalyzer::getSolutionDataObj(), solutionData::nData, and NODAL.

Referenced by stitchFldBc(), and stitchMe().

                                                  {
  // look at the solution names of current grid
  std::vector<std::string> crntCgList;
  getSolutionDataNames(crntCgList);

  // load solution data container if empty
  if (slnDataCont.empty()) loadSolutionDataContainer();

  // now going through the list of inCg and stitch only repeating data
  std::vector<std::string> inCgList;
  inCg->getSolutionDataNames(inCgList);
  for (auto &id : inCgList) {
    bool isRptData = false;
    for (auto &is : crntCgList)
      if (!strcmp(id.c_str(), is.c_str())) {
        isRptData = true;
        std::cout << id << " is an existing field.\n";
        break;
      }

    if (isRptData) {
      std::vector<double> inCgSlnData;
      int outNData, outNDim;
      solutionData *inCgSlnDataPtr = inCg->getSolutionDataObj(id);
      if (inCgSlnDataPtr->getDataType() == solution_type_t::NODAL) {
        inCgSlnDataPtr->getData(inCgSlnData, outNData, outNDim, vrtDataMask);
        // testing
        // std::cout << " will append " << outNData << " data points.\n";
      } else {
        inCgSlnDataPtr->getData(inCgSlnData, outNData, outNDim, elmDataMask);
        // testing
        // std::cout << " will append " << outNData << " data points.\n";
      }
      // attaching data
      int nData = slnDataCont.size();
      for (int icd = 0; icd < nData; icd++) {
        if (!strcmp((slnDataCont[icd]->getDataName()).c_str(), id.c_str())) {
          std::cout << "To -> " << slnDataCont[icd]->getDataName() << std::endl;
          // std::cout << "Current size = " << icnt->getNData() << std::endl;
          slnDataCont[icd]->appendData(inCgSlnData, inCgSlnData.size(), 1);
          // std::cout << "Size after = " << icnt->getNData() << std::endl;
        }
      }
    }
  }

  // now go through appended data to the current grid and see if they
  // also existing in inCg and thus stitch them as well.
  std::vector<std::string> inCgAppLst;
  inCg->getAppendedSolutionDataName(inCgAppLst);
  if (appendedSolutionName.empty() || inCgAppLst.empty()) return;
  for (auto &id : inCgAppLst) {
    bool isRptData = false;
    // std::cout << "Remote CG field name = " << id.c_str() << std::endl;
    for (auto &is : appendedSolutionName) {
      // std::cout << "Current CG field name = " << is.c_str() << std::endl;
      // std::cout << " strcmp = " << strcmp(id.c_str(), is.c_str()) <<
      // std::endl;
      if (strcmp(id.c_str(), is.c_str()) == 0) {
        isRptData = true;
        // std::cout << id << " is an existing field.\n";
        break;
      }
    }

    if (isRptData) {
      std::vector<double> inCgSlnData;
      int outNData, outNDim;
      solutionData *inCgSlnDataPtr = inCg->getSolutionDataObj(id);
      if (inCgSlnDataPtr->getDataType() == solution_type_t::NODAL) {
        inCgSlnDataPtr->getData(inCgSlnData, outNData, outNDim, vrtDataMask);
        // testing
        // std::cout << " will append " << outNData << " data points.\n";
      } else {
        inCgSlnDataPtr->getData(inCgSlnData, outNData, outNDim, elmDataMask);
        // testing
        std::cout << " will append " << outNData << " data points.\n";
      }
      // attaching data
      for (auto &icnt : slnDataCont) {
        if (!strcmp((icnt->getDataName()).c_str(), id.c_str())) {
          // std::cout << "To -> " << icnt->getDataName() << std::endl;
          // std::cout << "Current size = " << icnt->getNData() << std::endl;
          icnt->appendData(inCgSlnData, inCgSlnData.size(), 1);
          // std::cout << "Size after = " << icnt->getNData() << std::endl;
        }
      }
    }
  }
}

stitchFldBc()

void rocstarCgns::stitchFldBc	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 256 of file rocstarCgns.C.

References _burn, cgnsAnalyzer::appendSolutionData(), cgnsAnalyzer::clearAllSolutionData(), cgnsAnalyzer::delAppSlnData(), ELEMENTAL, cgnsAnalyzer::getIndexBase(), cgnsAnalyzer::getIndexFile(), cgnsAnalyzer::getNElement(), getPaneBcflag(), getPaneCnstrType(), getPanePatchNo(), cgnsAnalyzer::getSolutionDataNames(), cgnsAnalyzer::getSolutionGridLocations(), cgnsAnalyzer::getSolutionMap(), cgnsAnalyzer::getSolutionNameLocMap(), cgnsAnalyzer::getSolutionNodeNames(), cgnsAnalyzer::indexBase, cgnsAnalyzer::indexFile, cgnsAnalyzer::indexZone, cgnsAnalyzer::loadSolutionDataContainer(), cgnsAnalyzer::loadZone(), cgnsAnalyzer::solutionGridLocation, cgnsAnalyzer::solutionMap, cgnsAnalyzer::solutionName, cgnsAnalyzer::solutionNameLocMap, and cgnsAnalyzer::stitchFields().

Referenced by stitchMe().

                                                              {
  // load proper zone
  // asking object to load its zone information
  // this should refresh vertex coordinates and
  // element connectivity tables
  cgObj->loadZone(zoneIdx);
  cgObj->clearAllSolutionData();
  // next two line just o triger  cgObj->populateSolutionDataNames();
  std::vector<std::string> listTmp;
  cgObj->getSolutionDataNames(listTmp);

  // treating special first time use case
  if (solutionMap.empty()) {
    // populate solution data of current instance for
    // stitching
    // cgObj->clearAllSolutionData();
    // cgObj->populateSolutionDataNames();
    solutionName = cgObj->getSolutionNodeNames();
    solutionGridLocation = cgObj->getSolutionGridLocations();
    solutionMap = cgObj->getSolutionMap();
    solutionNameLocMap = cgObj->getSolutionNameLocMap();
    // change current instance needed data and ask it
    // to load data into its container directly.
    indexFile = cgObj->getIndexFile();
    indexBase = cgObj->getIndexBase();
    indexZone = zoneIdx;
    loadSolutionDataContainer();
    // append Rocstar specific BCs as solution fields
    if (!_burn) {
      appendSolutionData("patchNo", getPanePatchNo(cgObj, zoneIdx),
                         solution_type_t::ELEMENTAL, cgObj->getNElement(), 1);
      appendSolutionData("bcflag", getPaneBcflag(cgObj, zoneIdx),
                         solution_type_t::ELEMENTAL, cgObj->getNElement(), 1);
      appendSolutionData("cnstr_type", getPaneCnstrType(cgObj, zoneIdx),
                         solution_type_t::ELEMENTAL, cgObj->getNElement(), 1);
    }
    return;
  }
  // Rocstar specific BCs remove the old exisiting field
  if (!_burn) {
    cgObj->delAppSlnData("patchNo");
    cgObj->appendSolutionData("patchNo", getPanePatchNo(cgObj, zoneIdx),
                              solution_type_t::ELEMENTAL, cgObj->getNElement(),
                              1);
    cgObj->delAppSlnData("bcflag");
    cgObj->appendSolutionData("bcflag", getPaneBcflag(cgObj, zoneIdx),
                              solution_type_t::ELEMENTAL, cgObj->getNElement(),
                              1);
    cgObj->delAppSlnData("cnstr_type");
    cgObj->appendSolutionData("cnstr_type", getPaneCnstrType(cgObj, zoneIdx),
                              solution_type_t::ELEMENTAL, cgObj->getNElement(),
                              1);
  }
  // call current object stitch field
  stitchFields(cgObj);
}

stitchGroup()

void rocstarCgns::stitchGroup

(

)

Definition at line 137 of file rocstarCgns.C.

References getNCgObj(), cgnsAnalyzer::getZoneName(), myCgObjs, and stitchMe().

                              {
  for (int iObj = 0; iObj < getNCgObj(); iObj++) {
    std::cout << "Reading " << myCgObjs[iObj]->getFileName() << std::endl;
    for (int iz = 1; iz <= myCgObjs[iObj]->getNZone(); iz++) {
      std::cout << "Zone " << getZoneName(myCgObjs[iObj], iz) << std::endl;
      stitchMe(myCgObjs[iObj], iz);
    }
  }
}

stitchMe() [1/2]

void rocstarCgns::stitchMe	(	cgnsAnalyzer *	cgObj,
		int	zoneIdx
	)

Definition at line 147 of file rocstarCgns.C.

References cgnsAnalyzer::buildVertexKDTree(), cgnsAnalyzer::cellDim, CGNS_ENUMT(), cgnsAnalyzer::elemConn, cgnsAnalyzer::elmDataMask, cgnsAnalyzer::getCellDim(), cgnsAnalyzer::getElementConnectivity(), cgnsAnalyzer::getFileName(), cgnsAnalyzer::getNElement(), cgnsAnalyzer::getNVertex(), cgnsAnalyzer::getPhysDim(), cgnsAnalyzer::getTimeStep(), cgnsAnalyzer::getVrtXCrd(), cgnsAnalyzer::getVrtYCrd(), cgnsAnalyzer::getVrtZCrd(), getZoneCoords(), cgnsAnalyzer::getZoneName(), getZoneNCell(), getZoneNVrtx(), getZoneRealConn(), getZoneRealSecType(), cgnsAnalyzer::isStructured(), cgnsAnalyzer::isUnstructured, cgnsAnalyzer::kdTree, cgnsAnalyzer::loadZone(), cgnsAnalyzer::nElem, cgnsAnalyzer::nVertex, cgnsAnalyzer::physDim, cgnsAnalyzer::searchEps, stitchFldBc(), cgnsAnalyzer::timeLabel, cgnsAnalyzer::vrtDataMask, cgnsAnalyzer::xCrd, cgnsAnalyzer::yCrd, cgnsAnalyzer::zCrd, and cgnsAnalyzer::zoneNames.

Referenced by stitchGroup().

                                                           {
  // load proper zone
  // asking object to load its zone information
  // this should refresh vertex coordinates and
  // element connectivity tables
  cgObj->loadZone(zoneIdx);

  // check if this is the first object being stitched
  if (nVertex == 0) {
    // copying from the object
    isUnstructured = !cgObj->isStructured();
    cellDim = cgObj->getCellDim();
    physDim = cgObj->getPhysDim();
    massU = cgObj->getMassUnit();
    lengthU = cgObj->getLengthUnit();
    timeU = cgObj->getTimeUnit();
    tempU = cgObj->getTemperatureUnit();
    angleU = cgObj->getAngleUnit();
    timeLabel = cgObj->getTimeStep();
    // using the very first zone as the initial
    // vertex and element informaiton
    nVertex = getZoneNVrtx(cgObj, 1);
    nElem = getZoneNCell(cgObj, 1);
    xCrd = getZoneCoords(cgObj, 1, 1);
    yCrd = getZoneCoords(cgObj, 1, 2);
    zCrd = getZoneCoords(cgObj, 1, 3);
    sectionType = (CGNS_ENUMT(ElementType_t))getZoneRealSecType(cgObj, 1);
    elemConn = getZoneRealConn(cgObj, 1);
    stitchFldBc(cgObj, zoneIdx);
    return;
  }

  // (re)building the kdTree
  buildVertexKDTree();

  // clear old masks
  vrtDataMask.clear();
  elmDataMask.clear();

  // adding new mesh non-repeating vertices
  std::vector<int> newVrtIdx;
  std::vector<int> rptVrtIdx;
  std::map<int, int> rptVrtMap;  // <newMeshIdx, currentMeshIdx>
  std::vector<double> newXCrd;
  std::vector<double> newYCrd;
  std::vector<double> newZCrd;
  int nNewVrt = 0;
  for (int iVrt = 0; iVrt < cgObj->getNVertex(); iVrt++) {
    ANNpoint qryVrtx;
    ANNidxArray nnIdx;
    ANNdistArray dists;
    qryVrtx = annAllocPt(physDim);
    qryVrtx[0] = cgObj->getVrtXCrd(iVrt);
    qryVrtx[1] = cgObj->getVrtYCrd(iVrt);
    qryVrtx[2] = cgObj->getVrtZCrd(iVrt);
    nnIdx = new ANNidx[1];
    dists = new ANNdist[1];
    kdTree->annkSearch(qryVrtx, 1, nnIdx, dists);
    if (dists[0] > searchEps) {
      nNewVrt++;
      vrtDataMask.push_back(true);
      newVrtIdx.push_back(nVertex + nNewVrt);
      newXCrd.push_back(qryVrtx[0]);
      newYCrd.push_back(qryVrtx[1]);
      newZCrd.push_back(qryVrtx[2]);
    } else {
      vrtDataMask.push_back(false);
      newVrtIdx.push_back(nnIdx[0] + 1);
      rptVrtIdx.push_back(iVrt);
      rptVrtMap[iVrt] = nnIdx[0] + 1;
    }
    delete[] nnIdx;
    delete[] dists;
    annDeallocPt(qryVrtx);
  }
  std::cout << "Found " << nNewVrt << " new vertices.\n";
  std::cout << "Number of repeating index " << rptVrtIdx.size() << std::endl;

  // currently implemented to add all new elements
  std::vector<int> newElemConn;
  int nNewElem = 0;
  for (int iElem = 0; iElem < cgObj->getNElement(); iElem++) {
    std::vector<cgsize_t> rmtElemConn = cgObj->getElementConnectivity(iElem);
    // just adding all elements
    elmDataMask.push_back(true);
    nNewElem++;
    newElemConn.insert(newElemConn.end(), rmtElemConn.begin(),
                       rmtElemConn.end());
  }
  std::cout << "Found " << nNewElem << " new elements.\n";

  // switching connectivity table to global
  for (int iIdx = 0; iIdx < newElemConn.size(); iIdx++) {
    newElemConn[iIdx] = newVrtIdx[newElemConn[iIdx] - 1];
  }

  // stitching field values if requested
  stitchFldBc(cgObj, zoneIdx);

  // updating internal datastructure
  nVertex += nNewVrt;
  nElem += nNewElem;
  xCrd.insert(xCrd.end(), newXCrd.begin(), newXCrd.end());
  yCrd.insert(yCrd.end(), newYCrd.begin(), newYCrd.end());
  zCrd.insert(zCrd.end(), newZCrd.begin(), newZCrd.end());
  elemConn.insert(elemConn.end(), newElemConn.begin(), newElemConn.end());
  zoneNames.push_back(cgObj->getFileName() + "->" + cgObj->getZoneName());
}

stitchMe() [2/2]

void rocstarCgns::stitchMe

(

rocstarCgns *

cgObj

)

Definition at line 313 of file rocstarCgns.C.

References cgnsAnalyzer::buildVertexKDTree(), cgnsAnalyzer::elemConn, cgnsAnalyzer::elmDataMask, cgnsAnalyzer::getElementConnectivity(), cgnsAnalyzer::getNElement(), cgnsAnalyzer::getNVertex(), cgnsAnalyzer::getVrtXCrd(), cgnsAnalyzer::getVrtYCrd(), cgnsAnalyzer::getVrtZCrd(), cgnsAnalyzer::kdTree, cgnsAnalyzer::nElem, cgnsAnalyzer::nVertex, cgnsAnalyzer::physDim, cgnsAnalyzer::searchEps, cgnsAnalyzer::stitchFields(), cgnsAnalyzer::vrtDataMask, cgnsAnalyzer::xCrd, cgnsAnalyzer::yCrd, and cgnsAnalyzer::zCrd.

                                             {
  std::cout << "Stitching rocstarCGNS to myself.\n";
  // check if this is the first object being stitched
  if (nVertex == 0) {
    std::cerr << "This rocstarCgns object needs to be initialized first.\n";
    exit(-1);
  }

  // (re)building the kdTree
  buildVertexKDTree();

  // clear old masks
  vrtDataMask.clear();
  elmDataMask.clear();

  // adding new mesh non-repeating vertices
  std::vector<int> newVrtIdx;
  std::vector<int> rptVrtIdx;
  std::map<int, int> rptVrtMap;  // <newMeshIdx, currentMeshIdx>
  std::vector<double> newXCrd;
  std::vector<double> newYCrd;
  std::vector<double> newZCrd;
  int nNewVrt = 0;
  for (int iVrt = 0; iVrt < cgObj->getNVertex(); iVrt++) {
    ANNpoint qryVrtx;
    ANNidxArray nnIdx;
    ANNdistArray dists;
    qryVrtx = annAllocPt(physDim);
    qryVrtx[0] = cgObj->getVrtXCrd(iVrt);
    qryVrtx[1] = cgObj->getVrtYCrd(iVrt);
    qryVrtx[2] = cgObj->getVrtZCrd(iVrt);
    nnIdx = new ANNidx[1];
    dists = new ANNdist[1];
    kdTree->annkSearch(qryVrtx, 1, nnIdx, dists);
    if (dists[0] > searchEps) {
      nNewVrt++;
      vrtDataMask.push_back(true);
      newVrtIdx.push_back(nVertex + nNewVrt);
      newXCrd.push_back(qryVrtx[0]);
      newYCrd.push_back(qryVrtx[1]);
      newZCrd.push_back(qryVrtx[2]);
    } else {
      vrtDataMask.push_back(false);
      newVrtIdx.push_back(nnIdx[0] + 1);
      rptVrtIdx.push_back(iVrt);
      rptVrtMap[iVrt] = nnIdx[0] + 1;
    }
    delete[] nnIdx;
    delete[] dists;
    annDeallocPt(qryVrtx);
  }
  std::cout << "Found " << nNewVrt << " new vertices.\n";
  std::cout << "Number of repeating index " << rptVrtIdx.size() << std::endl;

  // currently implemented to add all new elements
  std::vector<int> newElemConn;
  int nNewElem = 0;
  for (int iElem = 0; iElem < cgObj->getNElement(); iElem++) {
    std::vector<cgsize_t> rmtElemConn = cgObj->getElementConnectivity(iElem);

    // just adding all elements
    elmDataMask.push_back(true);
    nNewElem++;
    newElemConn.insert(newElemConn.end(), rmtElemConn.begin(),
                       rmtElemConn.end());
  }
  std::cout << "Found " << nNewElem << " new elements.\n";

  // switching conncetivity table to global
  for (int iIdx = 0; iIdx < newElemConn.size(); iIdx++) {
    newElemConn[iIdx] = newVrtIdx[newElemConn[iIdx] - 1];
  }

  // stitching field values if requested
  // stitchFldBc(cgObj, zoneIdx);
  stitchFields((cgnsAnalyzer *)cgObj);

  // updating internal datastructure
  nVertex += nNewVrt;
  nElem += nNewElem;
  xCrd.insert(xCrd.end(), newXCrd.begin(), newXCrd.end());
  yCrd.insert(yCrd.end(), newYCrd.begin(), newYCrd.end());
  zCrd.insert(zCrd.end(), newZCrd.begin(), newZCrd.end());
  elemConn.insert(elemConn.end(), newElemConn.begin(), newElemConn.end());
  // zoneNames.push_back(cgObj->getFileName()+"->"+cgObj->getZoneName());
}

stitchMesh()

void cgnsAnalyzer::stitchMesh ( cgnsAnalyzer *  inCg, bool  withFields = false  )

virtualinherited

Definition at line 1527 of file cgnsAnalyzer.C.

References cgnsAnalyzer::cleanRind(), cgnsAnalyzer::getElementConnectivity(), cgnsAnalyzer::getNElement(), cgnsAnalyzer::getNVertex(), cgnsAnalyzer::getPhysDim(), cgnsAnalyzer::getVrtXCrd(), cgnsAnalyzer::getVrtYCrd(), cgnsAnalyzer::getVrtZCrd(), and cgnsAnalyzer::getZoneName().

                                                                 {
  // sanity check
  if (physDim != inCg->getPhysDim()) {
    std::cerr << "Error : Stitching mesh should have same dimensions."
              << std::endl;
    return;
  }

  // removing rind data (if any)
  cleanRind();
  inCg->cleanRind();

  // (re)building the kdTree
  buildVertexKDTree();

  // clear old masks
  vrtDataMask.clear();
  elmDataMask.clear();

  // adding new mesh non-repeating vertices
  std::vector<int> newVrtIdx;
  std::vector<int> rptVrtIdx;
  std::map<int, int> rptVrtMap;  // <newMeshIdx, currentMeshIdx>
  std::vector<double> newXCrd;
  std::vector<double> newYCrd;
  std::vector<double> newZCrd;
  int nNewVrt = 0;
  for (int iVrt = 0; iVrt < inCg->getNVertex(); ++iVrt) {
    ANNpoint qryVrtx;
    ANNidxArray nnIdx;
    ANNdistArray dists;
    qryVrtx = annAllocPt(physDim);
    qryVrtx[0] = inCg->getVrtXCrd(iVrt);
    qryVrtx[1] = inCg->getVrtYCrd(iVrt);
    qryVrtx[2] = inCg->getVrtZCrd(iVrt);
    nnIdx = new ANNidx[1];
    dists = new ANNdist[1];
    kdTree->annkSearch(qryVrtx, 1, nnIdx, dists);
    if (dists[0] > searchEps) {
      nNewVrt++;
      vrtDataMask.push_back(true);
      newVrtIdx.push_back(nVertex + nNewVrt);
      newXCrd.push_back(qryVrtx[0]);
      newYCrd.push_back(qryVrtx[1]);
      newZCrd.push_back(qryVrtx[2]);
    } else {
      vrtDataMask.push_back(false);
      newVrtIdx.push_back(nnIdx[0] + 1);
      rptVrtIdx.push_back(iVrt);
      rptVrtMap[iVrt] = nnIdx[0] + 1;
    }
    delete[] nnIdx;
    delete[] dists;
    annDeallocPt(qryVrtx);
  }
  std::cout << "Found " << nNewVrt << " new vertices.\n";
  std::cout << "Number of repeating index " << rptVrtIdx.size() << std::endl;

  // currently implemented to add all new elements
  std::vector<int> newElemConn;
  int nNewElem = 0;
  for (int iElem = 0; iElem < inCg->getNElement(); ++iElem) {
    std::vector<cgsize_t> rmtElemConn = inCg->getElementConnectivity(iElem);

    // just adding all elements
    elmDataMask.push_back(true);
    nNewElem++;
    newElemConn.insert(newElemConn.end(), rmtElemConn.begin(),
                       rmtElemConn.end());
  }
  std::cout << "Found " << nNewElem << " new elements.\n";

  // switching connectivity table to global
  for (int iIdx = 0; iIdx < newElemConn.size(); ++iIdx) {
    newElemConn[iIdx] = newVrtIdx[newElemConn[iIdx] - 1];
  }

  // stitching field values if requested
  if (withFields) stitchFields(inCg);

  // updating internal data structure
  nVertex += nNewVrt;
  nElem += nNewElem;
  xCrd.insert(xCrd.end(), newXCrd.begin(), newXCrd.end());
  yCrd.insert(yCrd.end(), newYCrd.begin(), newYCrd.end());
  zCrd.insert(zCrd.end(), newZCrd.begin(), newZCrd.end());
  elemConn.insert(elemConn.end(), newElemConn.begin(), newElemConn.end());
  zoneNames.push_back(inCg->getZoneName());
}

unclassifyMAdMeshBnd()

void cgnsAnalyzer::unclassifyMAdMeshBnd ( MAd::pMesh  MAdMesh )

inherited

Definition at line 1384 of file cgnsAnalyzer.C.

                                                              {
  // finding boundary faces and classifying them as 2 dimensional
  MAdMesh->unclassify_grid_boundaries();
}

writeSampleStructured()

void cgnsAnalyzer::writeSampleStructured ( )

inherited

Definition at line 707 of file cgnsAnalyzer.C.

                                         {
  /*
     dimension statements (note that tri-dimensional arrays
     x,y,z must be dimensioned exactly as [N][17][21] (N>=9)
     for this particular case or else they will be written to
     the CGNS file incorrectly!  Other options are to use 1-D
     arrays, use dynamic memory, or pass index values to a
     subroutine and dimension exactly there):
  */
  double x[9][17][21], y[9][17][21], z[9][17][21];
  cgsize_t isize[3][3];
  int ni, nj, nk, i, j, k;
  int indexFile, icelldim, iphysdim, indexBase;
  int indexZone, indexCoord;
  char basename[33], zonename[33];

  /* create grid points for simple example: */
  ni = 21;
  nj = 17;
  nk = 9;
  for (k = 0; k < nk; ++k) {
    for (j = 0; j < nj; ++j) {
      for (i = 0; i < ni; ++i) {
        x[k][j][i] = i;
        y[k][j][i] = j;
        z[k][j][i] = k;
      }
    }
  }
  printf("\ncreated simple 3-D grid points");

  /* WRITE X, Y, Z GRID POINTS TO CGNS FILE */
  /* open CGNS file for write */
  if (cg_open(cgFileName.c_str(), CG_MODE_WRITE, &indexFile)) cg_error_exit();
  /* create base (user can give any name) */
  strcpy(basename, "Base");
  icelldim = 3;
  iphysdim = 3;
  cg_base_write(indexFile, basename, icelldim, iphysdim, &indexBase);
  /* define zone name (user can give any name) */
  strcpy(zonename, "Zone  1");
  /* vertex size */
  isize[0][0] = 21;
  isize[0][1] = 17;
  isize[0][2] = 9;
  /* cell size */
  isize[1][0] = isize[0][0] - 1;
  isize[1][1] = isize[0][1] - 1;
  isize[1][2] = isize[0][2] - 1;
  /* boundary vertex size (always zero for structured grids) */
  isize[2][0] = 0;
  isize[2][1] = 0;
  isize[2][2] = 0;
  /* create zone */
  cg_zone_write(indexFile, indexBase, zonename, *isize, CGNS_ENUMV(Structured),
                &indexZone);
  /* write grid coordinates (user must use SIDS-standard names here) */
  cg_coord_write(indexFile, indexBase, indexZone, CGNS_ENUMV(RealDouble),
                 "CoordinateX", x, &indexCoord);
  cg_coord_write(indexFile, indexBase, indexZone, CGNS_ENUMV(RealDouble),
                 "CoordinateY", y, &indexCoord);
  cg_coord_write(indexFile, indexBase, indexZone, CGNS_ENUMV(RealDouble),
                 "CoordinateZ", z, &indexCoord);
}

writeSampleUnstructured()

void cgnsAnalyzer::writeSampleUnstructured ( )

inherited

Definition at line 772 of file cgnsAnalyzer.C.

                                           {
  /*
     dimension statements (note that tri-dimensional arrays
     x,y,z must be dimensioned exactly as [N][17][21] (N>=9)
     for this particular case or else they will be written to
     the CGNS file incorrectly!  Other options are to use 1-D
     arrays, use dynamic memory, or pass index values to a
     subroutine and dimension exactly there):
  */
  double x[9][17][21], y[9][17][21], z[9][17][21];
  cgsize_t isize[3][3];
  int ni, nj, nk, i, j, k;
  int indexFile, icelldim, iphysdim, indexBase;
  int indexZone, indexCoord, indexSection;
  int index_flow, index_field;
  char basename[33], zonename[33];

  /* create gridpoints for simple example: */
  ni = 21;
  nj = 17;
  nk = 9;
  for (k = 0; k < nk; ++k) {
    for (j = 0; j < nj; ++j) {
      for (i = 0; i < ni; ++i) {
        x[k][j][i] = i;
        y[k][j][i] = j;
        z[k][j][i] = k;
      }
    }
  }
  printf("\nCreated simple 3-D grid points");

  /* WRITE X, Y, Z GRID POINTS TO CGNS FILE */
  /* open CGNS file for write */
  if (cg_open(cgFileName.c_str(), CG_MODE_WRITE, &indexFile)) cg_error_exit();
  /* create base (user can give any name) */
  strcpy(basename, "Base");
  icelldim = 3;
  iphysdim = 3;
  cg_base_write(indexFile, basename, icelldim, iphysdim, &indexBase);
  /* define zone name (user can give any name) */
  strcpy(zonename, "Zone  1");
  /* vertex size */
  isize[0][0] = 21 * 17 * 9;
  isize[0][1] = 20 * 16 * 8;
  isize[0][2] = 0;
  /* create zone */
  cg_zone_write(indexFile, indexBase, zonename, *isize,
                CGNS_ENUMV(Unstructured), &indexZone);
  /* write grid coordinates (user must use SIDS-standard names here) */
  cg_coord_write(indexFile, indexBase, indexZone, CGNS_ENUMV(RealDouble),
                 "CoordinateX", x, &indexCoord);
  cg_coord_write(indexFile, indexBase, indexZone, CGNS_ENUMV(RealDouble),
                 "CoordinateY", y, &indexCoord);
  cg_coord_write(indexFile, indexBase, indexZone, CGNS_ENUMV(RealDouble),
                 "CoordinateZ", z, &indexCoord);
  /* write connectivities */
  cgsize_t elemConn[8][20 * 16 * 8];
  int iElem = -1;
  /* index of first element */
  int nElemStart = 1;
  for (k = 1; k < nk; ++k) {
    for (j = 1; j < nj; ++j) {
      for (i = 1; i < ni; ++i) {
        iElem++;
        int ifirstNode = i + (j - 1) * ni + (k - 1) * ni * nj;
        elemConn[0][iElem] = ifirstNode;
        elemConn[1][iElem] = ifirstNode + 1;
        elemConn[2][iElem] = ifirstNode + 1 + ni;
        elemConn[3][iElem] = ifirstNode + ni;
        elemConn[4][iElem] = ifirstNode + ni * nj;
        elemConn[5][iElem] = ifirstNode + ni * nj + 1;
        elemConn[6][iElem] = ifirstNode + ni * nj + 1 + ni;
        elemConn[7][iElem] = ifirstNode + ni * nj + ni;
      }
    }
  }
  /* index of last element */
  int nElemEnd = iElem;
  /* unsorted boundary elements */
  int nBdyElem = 0;
  /* write HEX_8 element connectivity (user can give any name) */
  cg_section_write(indexFile, indexBase, indexZone, "Elem", CGNS_ENUMV(HEXA_8),
                   nElemStart, nElemEnd, nBdyElem, elemConn[0], &indexSection);
  /* write vertex based field data */
  std::string solName = "solution";
  cg_sol_write(indexFile, indexBase, indexZone, solName.c_str(),
               CGNS_ENUMV(Vertex), &index_flow);
  std::vector<double> T;
  T.resize(isize[0][0], 10);
  cg_field_write(indexFile, indexBase, indexZone, index_flow,
                 CGNS_ENUMV(RealDouble), "T", &T[0], &index_field);
  /* close CGNS file */
  cg_close(indexFile);
}

Member Data Documentation

_burn

bool rocstarCgns::_burn

private

Definition at line 93 of file rocstarCgns.H.

Referenced by stitchFldBc().

_rindOff

bool cgnsAnalyzer::_rindOff

protectedinherited

Definition at line 340 of file cgnsAnalyzer.H.

_verb

int cgnsAnalyzer::_verb

protectedinherited

Definition at line 339 of file cgnsAnalyzer.H.

appendedSolutionName

std::vector<std::string> cgnsAnalyzer::appendedSolutionName

protectedinherited

Definition at line 318 of file cgnsAnalyzer.H.

baseCgFName

std::string rocstarCgns::baseCgFName

private

Definition at line 92 of file rocstarCgns.H.

Referenced by getBaseName(), loadCgSeries(), and rocstarCgns().

baseItrName

std::string cgnsAnalyzer::baseItrName

protectedinherited

Definition at line 301 of file cgnsAnalyzer.H.

baseName

std::string cgnsAnalyzer::baseName

protectedinherited

Definition at line 276 of file cgnsAnalyzer.H.

bcFlag

std::vector<int> rocstarCgns::bcFlag

private

Definition at line 100 of file rocstarCgns.H.

bFlag

std::vector<int> rocstarCgns::bFlag

private

Definition at line 101 of file rocstarCgns.H.

cellDim

int cgnsAnalyzer::cellDim

protectedinherited

Definition at line 292 of file cgnsAnalyzer.H.

Referenced by stitchMe().

cgCoreSize

cgsize_t cgnsAnalyzer::cgCoreSize[9]

protectedinherited

Definition at line 288 of file cgnsAnalyzer.H.

cgFileName

std::string cgnsAnalyzer::cgFileName

protectedinherited

Definition at line 271 of file cgnsAnalyzer.H.

cgFNames

std::vector<std::string> rocstarCgns::cgFNames

private

Definition at line 94 of file rocstarCgns.H.

Referenced by CGNS_ENUMT(), getBaseItrName(), getCgFName(), getElementType(), getGridCrdPntr(), getNTStep(), getNZone(), getSectionName(), getSolutionPntr(), getTimeStep(), getZoneItrName(), and loadCgSeries().

cgnsToMAdIds

std::map<int, int> cgnsAnalyzer::cgnsToMAdIds

protectedinherited

Definition at line 321 of file cgnsAnalyzer.H.

cgRindCellIds

std::vector<int> cgnsAnalyzer::cgRindCellIds

protectedinherited

Definition at line 336 of file cgnsAnalyzer.H.

cgRindNodeIds

std::vector<int> cgnsAnalyzer::cgRindNodeIds

protectedinherited

Definition at line 337 of file cgnsAnalyzer.H.

elemConn

std::vector<cgsize_t> cgnsAnalyzer::elemConn

protectedinherited

Definition at line 307 of file cgnsAnalyzer.H.

Referenced by stitchMe().

elmDataMask

std::vector<bool> cgnsAnalyzer::elmDataMask

protectedinherited

Definition at line 331 of file cgnsAnalyzer.H.

Referenced by stitchMe().

flowSlnPntr

std::string cgnsAnalyzer::flowSlnPntr

protectedinherited

Definition at line 302 of file cgnsAnalyzer.H.

gridCrdPntr

std::string cgnsAnalyzer::gridCrdPntr

protectedinherited

Definition at line 302 of file cgnsAnalyzer.H.

indexBase

int cgnsAnalyzer::indexBase

protectedinherited

Definition at line 289 of file cgnsAnalyzer.H.

Referenced by stitchFldBc().

indexCoord

int cgnsAnalyzer::indexCoord

protectedinherited

Definition at line 290 of file cgnsAnalyzer.H.

indexFile

int cgnsAnalyzer::indexFile

protectedinherited

Definition at line 289 of file cgnsAnalyzer.H.

Referenced by stitchFldBc().

indexSection

int cgnsAnalyzer::indexSection

protectedinherited

Definition at line 291 of file cgnsAnalyzer.H.

indexZone

int cgnsAnalyzer::indexZone

protectedinherited

Definition at line 290 of file cgnsAnalyzer.H.

Referenced by stitchFldBc().

isMltZone

bool cgnsAnalyzer::isMltZone

protectedinherited

Definition at line 333 of file cgnsAnalyzer.H.

isUnstructured

bool cgnsAnalyzer::isUnstructured

protectedinherited

Definition at line 277 of file cgnsAnalyzer.H.

Referenced by stitchMe().

kdTree

ANNkd_tree* cgnsAnalyzer::kdTree

protectedinherited

Definition at line 323 of file cgnsAnalyzer.H.

Referenced by stitchMe().

kdTreeElem

ANNkd_tree* cgnsAnalyzer::kdTreeElem

protectedinherited

Definition at line 324 of file cgnsAnalyzer.H.

MAdToCgnsIds

std::map<int, int> cgnsAnalyzer::MAdToCgnsIds

protectedinherited

Definition at line 320 of file cgnsAnalyzer.H.

multZoneNames

std::vector<std::string> cgnsAnalyzer::multZoneNames

protectedinherited

Definition at line 334 of file cgnsAnalyzer.H.

myCgFName

std::string rocstarCgns::myCgFName

private

Definition at line 87 of file rocstarCgns.H.

Referenced by rocstarCgns().

myCgObjs

std::vector<cgnsAnalyzer *> rocstarCgns::myCgObjs

private

Definition at line 96 of file rocstarCgns.H.

Referenced by CGNS_ENUMT(), closeCG(), getBaseItrName(), getBaseName(), getElementType(), getGridCrdPntr(), getNCgObj(), getNTStep(), getNZone(), getSectionName(), getSolutionPntr(), getTimeStep(), getZoneItrName(), getZoneName(), loadCgSeries(), stitchGroup(), and ~rocstarCgns().

nBase

int cgnsAnalyzer::nBase

protectedinherited

Definition at line 293 of file cgnsAnalyzer.H.

nElem

int cgnsAnalyzer::nElem

protectedinherited

Definition at line 297 of file cgnsAnalyzer.H.

Referenced by stitchMe().

nField

int cgnsAnalyzer::nField

protectedinherited

Definition at line 311 of file cgnsAnalyzer.H.

nRindNdeStr

int cgnsAnalyzer::nRindNdeStr

protectedinherited

Definition at line 296 of file cgnsAnalyzer.H.

nSection

int cgnsAnalyzer::nSection

protectedinherited

Definition at line 298 of file cgnsAnalyzer.H.

nSolution

int cgnsAnalyzer::nSolution

protectedinherited

Definition at line 310 of file cgnsAnalyzer.H.

nTStep

int cgnsAnalyzer::nTStep

protectedinherited

Definition at line 303 of file cgnsAnalyzer.H.

nVertex

int cgnsAnalyzer::nVertex

protectedinherited

Definition at line 295 of file cgnsAnalyzer.H.

Referenced by stitchMe().

nVrtxElem

int cgnsAnalyzer::nVrtxElem

protectedinherited

Definition at line 299 of file cgnsAnalyzer.H.

nZone

int cgnsAnalyzer::nZone

protectedinherited

Definition at line 294 of file cgnsAnalyzer.H.

padSize

int rocstarCgns::padSize

private

Definition at line 95 of file rocstarCgns.H.

Referenced by loadCgSeries(), and rocstarCgns().

patchNo

std::vector<int> rocstarCgns::patchNo

private

Definition at line 102 of file rocstarCgns.H.

Referenced by getPanePatchNo().

physDim

int cgnsAnalyzer::physDim

protectedinherited

Definition at line 292 of file cgnsAnalyzer.H.

Referenced by stitchMe().

rmax

cgsize_t cgnsAnalyzer::rmax[3]

protectedinherited

Definition at line 287 of file cgnsAnalyzer.H.

rmin

cgsize_t cgnsAnalyzer::rmin[3]

protectedinherited

Definition at line 287 of file cgnsAnalyzer.H.

searchEps

double cgnsAnalyzer::searchEps

protectedinherited

Definition at line 327 of file cgnsAnalyzer.H.

Referenced by stitchMe().

sectionName

std::string cgnsAnalyzer::sectionName

protectedinherited

Definition at line 276 of file cgnsAnalyzer.H.

slnDataCont

std::vector<solutionData *> cgnsAnalyzer::slnDataCont

protectedinherited

Definition at line 312 of file cgnsAnalyzer.H.

solutionDataPopulated

bool cgnsAnalyzer::solutionDataPopulated

protectedinherited

Definition at line 309 of file cgnsAnalyzer.H.

solutionGridLocation

std::vector<CGNS_ENUMT(GridLocation_t)> cgnsAnalyzer::solutionGridLocation

protectedinherited

Definition at line 317 of file cgnsAnalyzer.H.

Referenced by stitchFldBc().

solutionMap

std::map<int, std::pair<int, keyValueList> > cgnsAnalyzer::solutionMap

protectedinherited

Definition at line 315 of file cgnsAnalyzer.H.

Referenced by stitchFldBc().

solutionName

std::vector<std::string> cgnsAnalyzer::solutionName

protectedinherited

Definition at line 316 of file cgnsAnalyzer.H.

Referenced by stitchFldBc().

solutionNameLocMap

std::map<std::string, CGNS_ENUMT(GridLocation_t)> cgnsAnalyzer::solutionNameLocMap

protectedinherited

Definition at line 313 of file cgnsAnalyzer.H.

Referenced by stitchFldBc().

timeLabel

double cgnsAnalyzer::timeLabel

protectedinherited

Definition at line 304 of file cgnsAnalyzer.H.

Referenced by stitchMe().

vrtDataMask

std::vector<bool> cgnsAnalyzer::vrtDataMask

protectedinherited

Definition at line 330 of file cgnsAnalyzer.H.

Referenced by stitchMe().

vrtxCrd

ANNpointArray cgnsAnalyzer::vrtxCrd

protectedinherited

Definition at line 325 of file cgnsAnalyzer.H.

vrtxIdx

ANNpointArray cgnsAnalyzer::vrtxIdx

protectedinherited

Definition at line 326 of file cgnsAnalyzer.H.

vtkMesh

vtkSmartPointer<vtkDataSet> cgnsAnalyzer::vtkMesh

protectedinherited

Definition at line 335 of file cgnsAnalyzer.H.

xCrd

std::vector<double> cgnsAnalyzer::xCrd

protectedinherited

Definition at line 306 of file cgnsAnalyzer.H.

Referenced by stitchMe().

yCrd

std::vector<double> cgnsAnalyzer::yCrd

protectedinherited

Definition at line 306 of file cgnsAnalyzer.H.

Referenced by stitchMe().

zCrd

std::vector<double> cgnsAnalyzer::zCrd

protectedinherited

Definition at line 306 of file cgnsAnalyzer.H.

Referenced by stitchMe().

zidx

int rocstarCgns::zidx

Definition at line 67 of file rocstarCgns.H.

zoneItrName

std::string cgnsAnalyzer::zoneItrName

protectedinherited

Definition at line 301 of file cgnsAnalyzer.H.

zoneName

std::string cgnsAnalyzer::zoneName

protectedinherited

Definition at line 276 of file cgnsAnalyzer.H.

zoneNames

std::vector<std::string> cgnsAnalyzer::zoneNames

protectedinherited

Definition at line 329 of file cgnsAnalyzer.H.

Referenced by stitchMe().

---

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

• rocstarCgns.H
• rocstarCgns.C