cgnsAnalyzer Class Reference

Detailed Description

Definition at line 105 of file cgnsAnalyzer.H.

Public Member Functions
	cgnsAnalyzer (std::string fname, int verb=0)
virtual	~cgnsAnalyzer ()
void	loadGrid (const std::string &fname, int verb=0)
virtual void	closeCG ()
void	loadGrid (int verb=0)
void	loadZone (int zIdx, int verb=0)
int	getIndexFile ()
int	getIndexBase ()
int	getCellDim ()
std::string	getFileName ()
std::string	getBaseName ()
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()
	CGNS_ENUMT (ZoneType_t) getZoneType()
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 ()

Protected Member Functions
void	populateSolutionDataNames ()
void	buildVertexKDTree ()
void	buildElementKDTree ()
void	loadSolutionDataContainer (int verb=0)
virtual void	stitchFields (cgnsAnalyzer *inCg)
	CGNS_ENUMT (ZoneType_t) zoneType
	CGNS_ENUMT (ElementType_t) sectionType
	CGNS_ENUMT (MassUnits_t) massU
	CGNS_ENUMT (LengthUnits_t) lengthU
	CGNS_ENUMT (TimeUnits_t) timeU
	CGNS_ENUMT (TemperatureUnits_t) tempU
	CGNS_ENUMT (AngleUnits_t) angleU

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

Inherited by rocstarCgns.

Constructor & Destructor Documentation

cgnsAnalyzer()

cgnsAnalyzer::cgnsAnalyzer ( std::string  fname, int  verb = 0  )

inlineexplicit

Definition at line 107 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::loadCgSeries().

      : cgFileName(std::move(fname)),
        isUnstructured(false),
        zoneType(CGNS_ENUMV(ZoneTypeNull)),
        indexFile(-1),
        indexBase(-1),
        indexZone(-1),
        indexCoord(-1),
        cellDim(0),
        physDim(0),
        nVertex(0),
        nRindNdeStr(0),
        nElem(0),
        nVrtxElem(0),
        solutionDataPopulated(false),
        kdTree(nullptr),
        kdTreeElem(nullptr),
        vrtxCrd(nullptr),
        vrtxIdx(nullptr),
        searchEps(1e-9),
        isMltZone(false),
        vtkMesh(nullptr),
        _verb(verb),
        _rindOff(false) {
    cgRindCellIds.clear();
    cgRindNodeIds.clear();
  };

~cgnsAnalyzer()

virtual cgnsAnalyzer::~cgnsAnalyzer ( )

inlinevirtual

Definition at line 136 of file cgnsAnalyzer.H.

                          {
    // close file if still open
    if (indexFile > 0) cg_close(indexFile);
    delete kdTree;
    delete kdTreeElem;
    if (vrtxCrd) annDeallocPts(vrtxCrd);
    if (vrtxIdx) annDeallocPts(vrtxIdx);
    clearAllSolutionData();
  };

Member Function Documentation

appendSolutionData() [1/2]

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

Definition at line 1097 of file cgnsAnalyzer.C.

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

Referenced by rocstarCgns::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
	)

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 ( )

protected

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 ( )

protected

Definition at line 1389 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::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/13]

cgnsAnalyzer::CGNS_ENUMT

(

MassUnits_t

)

CGNS_ENUMT() [2/13]

cgnsAnalyzer::CGNS_ENUMT

(

LengthUnits_t

)

CGNS_ENUMT() [3/13]

cgnsAnalyzer::CGNS_ENUMT

(

TimeUnits_t

)

CGNS_ENUMT() [4/13]

cgnsAnalyzer::CGNS_ENUMT

(

TemperatureUnits_t

)

CGNS_ENUMT() [5/13]

cgnsAnalyzer::CGNS_ENUMT

(

AngleUnits_t

)

CGNS_ENUMT() [6/13]

cgnsAnalyzer::CGNS_ENUMT

(

ZoneType_t

)

CGNS_ENUMT() [7/13]

cgnsAnalyzer::CGNS_ENUMT ( ZoneType_t  )

protected

CGNS_ENUMT() [8/13]

cgnsAnalyzer::CGNS_ENUMT ( ElementType_t  )

protected

CGNS_ENUMT() [9/13]

cgnsAnalyzer::CGNS_ENUMT ( MassUnits_t  )

protected

CGNS_ENUMT() [10/13]

cgnsAnalyzer::CGNS_ENUMT ( LengthUnits_t  )

protected

CGNS_ENUMT() [11/13]

cgnsAnalyzer::CGNS_ENUMT ( TimeUnits_t  )

protected

CGNS_ENUMT() [12/13]

cgnsAnalyzer::CGNS_ENUMT ( TemperatureUnits_t  )

protected

CGNS_ENUMT() [13/13]

cgnsAnalyzer::CGNS_ENUMT ( AngleUnits_t  )

protected

checkElmConn()

bool cgnsAnalyzer::checkElmConn

(

int

nSharedNde

)

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

(

)

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

)

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

)

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

(

)

Definition at line 1747 of file cgnsAnalyzer.C.

References ELEMENTAL, and NODAL.

Referenced by 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

(

)

Definition at line 868 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::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()

virtual void cgnsAnalyzer::closeCG ( )

inlinevirtual

Reimplemented in rocstarCgns.

Definition at line 153 of file cgnsAnalyzer.H.

References CGNS_ENUMT(), and data.

                         {
    if (indexFile > 0) {
      cg_close(indexFile);
      indexFile = -1;
    }
  };

delAppSlnData()

bool cgnsAnalyzer::delAppSlnData

(

std::string

sName

)

Definition at line 1125 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::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

)

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

(

)

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

)

Definition at line 1136 of file cgnsAnalyzer.C.

Referenced by stitchFields().

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

getBaseItrName()

std::string cgnsAnalyzer::getBaseItrName

(

)

Definition at line 433 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::getBaseItrName().

{ return baseItrName; }

getBaseName()

std::string cgnsAnalyzer::getBaseName

(

)

Definition at line 423 of file cgnsAnalyzer.C.

{ return baseName; }

getCellDim()

int cgnsAnalyzer::getCellDim

(

)

Definition at line 419 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::stitchMe().

{ return cellDim; }

getElementConnectivity()

std::vector< cgsize_t > cgnsAnalyzer::getElementConnectivity

(

int

elemId

)

Definition at line 525 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::stitchMe(), and 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()

int cgnsAnalyzer::getElementType

(

)

Definition at line 451 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::getElementType().

{ return sectionType; }

getElmCntCoords()

std::vector< double > cgnsAnalyzer::getElmCntCoords

(

MAd::pMesh

msh

)

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

(

)

Definition at line 421 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::stitchMe().

{ return cgFileName; }

getGridCrdPntr()

std::string cgnsAnalyzer::getGridCrdPntr

(

)

Definition at line 441 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::getGridCrdPntr().

{ return gridCrdPntr; }

getIndexBase()

int cgnsAnalyzer::getIndexBase

(

)

Definition at line 417 of file cgnsAnalyzer.C.

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

{ return indexBase; }

getIndexFile()

int cgnsAnalyzer::getIndexFile

(

)

Definition at line 415 of file cgnsAnalyzer.C.

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

{ return indexFile; }

getNCellSolution()

int cgnsAnalyzer::getNCellSolution

(

)

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;
}

getNElement()

int cgnsAnalyzer::getNElement

(

)

Definition at line 447 of file cgnsAnalyzer.C.

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

{ return nElem; }

getNTStep()

int cgnsAnalyzer::getNTStep

(

)

Definition at line 437 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::getNTStep().

{ return nTStep; }

getNVertex()

int cgnsAnalyzer::getNVertex

(

)

Definition at line 445 of file cgnsAnalyzer.C.

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

{ return nVertex; }

getNVertexSolution()

int cgnsAnalyzer::getNVertexSolution

(

)

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

(

)

Definition at line 453 of file cgnsAnalyzer.C.

{ return nVrtxElem; }

getNZone()

int cgnsAnalyzer::getNZone

(

)

Definition at line 435 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::getNZone().

{ return nZone; }

getPhysDim()

int cgnsAnalyzer::getPhysDim

(

)

Definition at line 449 of file cgnsAnalyzer.C.

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

{ return physDim; }

getSectionConn()

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

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

)

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()

std::string cgnsAnalyzer::getSectionName

(

)

Definition at line 431 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::getSectionName().

{ return sectionName; }

getSectionNames()

void cgnsAnalyzer::getSectionNames

(

std::vector< std::string > &

secNames

)

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
	)

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

)

Definition at line 918 of file cgnsAnalyzer.C.

Referenced by stitchFields(), and rocstarCgns::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

)

Definition at line 1032 of file cgnsAnalyzer.C.

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

Referenced by 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
	)

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

(

)

Definition at line 1149 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::stitchFldBc().

                                       {
  return solutionGridLocation;
}

getSolutionMap()

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

(

)

Definition at line 1154 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::stitchFldBc().

                                                                     {
  return solutionMap;
}

getSolutionNameLocMap()

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

(

)

Definition at line 1160 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::stitchFldBc().

                                    {
  return solutionNameLocMap;
}

getSolutionNodeNames()

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

(

)

Definition at line 1143 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::stitchFldBc().

                                                        {
  return solutionName;
}

getSolutionPntr()

std::string cgnsAnalyzer::getSolutionPntr

(

)

Definition at line 443 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::getSolutionPntr().

{ return flowSlnPntr; }

getTimeStep()

double cgnsAnalyzer::getTimeStep

(

)

Definition at line 455 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::getTimeStep(), and rocstarCgns::stitchMe().

{ return timeLabel; }

getVertexCoords() [1/2]

std::vector< double > cgnsAnalyzer::getVertexCoords

(

)

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

)

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

)

Definition at line 504 of file cgnsAnalyzer.C.

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

{ return xCrd[vrtxId]; }

getVrtXCrd() [2/2]

std::vector< double > cgnsAnalyzer::getVrtXCrd

(

)

Definition at line 506 of file cgnsAnalyzer.C.

{ return xCrd; }

getVrtYCrd() [1/2]

double cgnsAnalyzer::getVrtYCrd

(

int

vrtxId

)

Definition at line 508 of file cgnsAnalyzer.C.

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

{ return yCrd[vrtxId]; }

getVrtYCrd() [2/2]

std::vector< double > cgnsAnalyzer::getVrtYCrd

(

)

Definition at line 510 of file cgnsAnalyzer.C.

{ return yCrd; }

getVrtZCrd() [1/2]

double cgnsAnalyzer::getVrtZCrd

(

int

vrtxId

)

Definition at line 512 of file cgnsAnalyzer.C.

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

{ return zCrd[vrtxId]; }

getVrtZCrd() [2/2]

std::vector< double > cgnsAnalyzer::getVrtZCrd

(

)

Definition at line 514 of file cgnsAnalyzer.C.

{ return zCrd; }

getVTKMesh()

vtkSmartPointer< vtkDataSet > cgnsAnalyzer::getVTKMesh

(

)

Definition at line 473 of file cgnsAnalyzer.C.

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

getZoneItrName()

std::string cgnsAnalyzer::getZoneItrName

(

)

Definition at line 439 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::getZoneItrName().

{ return zoneItrName; }

getZoneName() [1/2]

std::string cgnsAnalyzer::getZoneName

(

)

Definition at line 425 of file cgnsAnalyzer.C.

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

{ return zoneName; }

getZoneName() [2/2]

std::string cgnsAnalyzer::getZoneName

(

int

nCgFile

)

Definition at line 427 of file cgnsAnalyzer.C.

                                               {
  return zoneNames[iCgFile];
}

isCgRindCell()

bool cgnsAnalyzer::isCgRindCell

(

int

cgCellId

)

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

)

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

(

)

isStructured()

bool cgnsAnalyzer::isStructured

(

)

Definition at line 471 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::stitchMe().

{ return !isUnstructured; }

loadGrid() [1/2]

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

inline

Definition at line 147 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::loadCgSeries().

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

loadGrid() [2/2]

void cgnsAnalyzer::loadGrid

(

int

verb = 0

)

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 )

protected

Definition at line 1617 of file cgnsAnalyzer.C.

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

Referenced by rocstarCgns::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
	)

Definition at line 154 of file cgnsAnalyzer.C.

Referenced by rocstarCgns::stitchFldBc(), and rocstarCgns::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

)

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
	)

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 ( )

protected

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;
}

stitchFields()

void cgnsAnalyzer::stitchFields ( cgnsAnalyzer *  inCg )

protectedvirtual

Definition at line 1638 of file cgnsAnalyzer.C.

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

Referenced by rocstarCgns::stitchFldBc(), and rocstarCgns::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;
        }
      }
    }
  }
}

stitchMesh()

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

virtual

Definition at line 1527 of file cgnsAnalyzer.C.

References cleanRind(), getElementConnectivity(), getNElement(), getNVertex(), getPhysDim(), getVrtXCrd(), getVrtYCrd(), getVrtZCrd(), and 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

)

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

(

)

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

(

)

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

_rindOff

bool cgnsAnalyzer::_rindOff

protected

Definition at line 340 of file cgnsAnalyzer.H.

_verb

int cgnsAnalyzer::_verb

protected

Definition at line 339 of file cgnsAnalyzer.H.

appendedSolutionName

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

protected

Definition at line 318 of file cgnsAnalyzer.H.

baseItrName

std::string cgnsAnalyzer::baseItrName

protected

Definition at line 301 of file cgnsAnalyzer.H.

baseName

std::string cgnsAnalyzer::baseName

protected

Definition at line 276 of file cgnsAnalyzer.H.

cellDim

int cgnsAnalyzer::cellDim

protected

Definition at line 292 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

cgCoreSize

cgsize_t cgnsAnalyzer::cgCoreSize[9]

protected

Definition at line 288 of file cgnsAnalyzer.H.

cgFileName

std::string cgnsAnalyzer::cgFileName

protected

Definition at line 271 of file cgnsAnalyzer.H.

cgnsToMAdIds

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

protected

Definition at line 321 of file cgnsAnalyzer.H.

cgRindCellIds

std::vector<int> cgnsAnalyzer::cgRindCellIds

protected

Definition at line 336 of file cgnsAnalyzer.H.

cgRindNodeIds

std::vector<int> cgnsAnalyzer::cgRindNodeIds

protected

Definition at line 337 of file cgnsAnalyzer.H.

elemConn

std::vector<cgsize_t> cgnsAnalyzer::elemConn

protected

Definition at line 307 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

elmDataMask

std::vector<bool> cgnsAnalyzer::elmDataMask

protected

Definition at line 331 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

flowSlnPntr

std::string cgnsAnalyzer::flowSlnPntr

protected

Definition at line 302 of file cgnsAnalyzer.H.

gridCrdPntr

std::string cgnsAnalyzer::gridCrdPntr

protected

Definition at line 302 of file cgnsAnalyzer.H.

indexBase

int cgnsAnalyzer::indexBase

protected

Definition at line 289 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchFldBc().

indexCoord

int cgnsAnalyzer::indexCoord

protected

Definition at line 290 of file cgnsAnalyzer.H.

indexFile

int cgnsAnalyzer::indexFile

protected

Definition at line 289 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchFldBc().

indexSection

int cgnsAnalyzer::indexSection

protected

Definition at line 291 of file cgnsAnalyzer.H.

indexZone

int cgnsAnalyzer::indexZone

protected

Definition at line 290 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchFldBc().

isMltZone

bool cgnsAnalyzer::isMltZone

protected

Definition at line 333 of file cgnsAnalyzer.H.

isUnstructured

bool cgnsAnalyzer::isUnstructured

protected

Definition at line 277 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

kdTree

ANNkd_tree* cgnsAnalyzer::kdTree

protected

Definition at line 323 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

kdTreeElem

ANNkd_tree* cgnsAnalyzer::kdTreeElem

protected

Definition at line 324 of file cgnsAnalyzer.H.

MAdToCgnsIds

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

protected

Definition at line 320 of file cgnsAnalyzer.H.

multZoneNames

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

protected

Definition at line 334 of file cgnsAnalyzer.H.

nBase

int cgnsAnalyzer::nBase

protected

Definition at line 293 of file cgnsAnalyzer.H.

nElem

int cgnsAnalyzer::nElem

protected

Definition at line 297 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

nField

int cgnsAnalyzer::nField

protected

Definition at line 311 of file cgnsAnalyzer.H.

nRindNdeStr

int cgnsAnalyzer::nRindNdeStr

protected

Definition at line 296 of file cgnsAnalyzer.H.

nSection

int cgnsAnalyzer::nSection

protected

Definition at line 298 of file cgnsAnalyzer.H.

nSolution

int cgnsAnalyzer::nSolution

protected

Definition at line 310 of file cgnsAnalyzer.H.

nTStep

int cgnsAnalyzer::nTStep

protected

Definition at line 303 of file cgnsAnalyzer.H.

nVertex

int cgnsAnalyzer::nVertex

protected

Definition at line 295 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

nVrtxElem

int cgnsAnalyzer::nVrtxElem

protected

Definition at line 299 of file cgnsAnalyzer.H.

nZone

int cgnsAnalyzer::nZone

protected

Definition at line 294 of file cgnsAnalyzer.H.

physDim

int cgnsAnalyzer::physDim

protected

Definition at line 292 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

rmax

cgsize_t cgnsAnalyzer::rmax[3]

protected

Definition at line 287 of file cgnsAnalyzer.H.

rmin

cgsize_t cgnsAnalyzer::rmin[3]

protected

Definition at line 287 of file cgnsAnalyzer.H.

searchEps

double cgnsAnalyzer::searchEps

protected

Definition at line 327 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

sectionName

std::string cgnsAnalyzer::sectionName

protected

Definition at line 276 of file cgnsAnalyzer.H.

slnDataCont

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

protected

Definition at line 312 of file cgnsAnalyzer.H.

solutionDataPopulated

bool cgnsAnalyzer::solutionDataPopulated

protected

Definition at line 309 of file cgnsAnalyzer.H.

solutionGridLocation

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

protected

Definition at line 317 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchFldBc().

solutionMap

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

protected

Definition at line 315 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchFldBc().

solutionName

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

protected

Definition at line 316 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchFldBc().

solutionNameLocMap

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

protected

Definition at line 313 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchFldBc().

timeLabel

double cgnsAnalyzer::timeLabel

protected

Definition at line 304 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

vrtDataMask

std::vector<bool> cgnsAnalyzer::vrtDataMask

protected

Definition at line 330 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

vrtxCrd

ANNpointArray cgnsAnalyzer::vrtxCrd

protected

Definition at line 325 of file cgnsAnalyzer.H.

vrtxIdx

ANNpointArray cgnsAnalyzer::vrtxIdx

protected

Definition at line 326 of file cgnsAnalyzer.H.

vtkMesh

vtkSmartPointer<vtkDataSet> cgnsAnalyzer::vtkMesh

protected

Definition at line 335 of file cgnsAnalyzer.H.

xCrd

std::vector<double> cgnsAnalyzer::xCrd

protected

Definition at line 306 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

yCrd

std::vector<double> cgnsAnalyzer::yCrd

protected

Definition at line 306 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

zCrd

std::vector<double> cgnsAnalyzer::zCrd

protected

Definition at line 306 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

zoneItrName

std::string cgnsAnalyzer::zoneItrName

protected

Definition at line 301 of file cgnsAnalyzer.H.

zoneName

std::string cgnsAnalyzer::zoneName

protected

Definition at line 276 of file cgnsAnalyzer.H.

zoneNames

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

protected

Definition at line 329 of file cgnsAnalyzer.H.

Referenced by rocstarCgns::stitchMe().

---

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

• cgnsAnalyzer.H
• cgnsAnalyzer.C