NEM::MSH::foamGeoMesh Class Reference

A concrete implementation of geoMeshBase representing a mesh in a fvMesh. More...

Detailed Description

Definition at line 52 of file foamGeoMesh.H.

Public Member Functions
	foamGeoMesh ()
	Create a foamMesh from mesh in current directory. More...
	foamGeoMesh (Foam::fvMesh *foamMesh, const std::string &phyGrpArrayName=std::string())
	Construct a foamGeoMesh from an existing fvMesh. More...
	~foamGeoMesh () override
	foamGeoMesh destructor More...
void	write (const std::string &fileName) override
	Writes foam mesh into current directory. More...
void	report (std::ostream &out) const override
	Reports data about mesh. More...
const Foam::fvMesh &	getFoamMesh () const
	Copy the mesh. More...
void	setFoamMesh (std::unique_ptr< Foam::fvMesh > foamMesh)
	Set the foamGeoMesh's mesh to foamMesh. More...
void	resetNative () override
	Resets the class members and initiates an empty foam mesh. More...
virtual void	takeGeoMesh (geoMeshBase *otherGeoMesh)
	Take the GeoMesh of another geoMeshBase. More...
virtual void	reconstructGeo ()
	Construct the geometry from the mesh alone. More...
virtual void	mergeGeoMesh (geoMeshBase *otherGeoMesh)
	Merge mesh data from a new geoMesh to an existing geoMesh. More...
const std::string &	getGeoEntArrayName () const
	Get the name of the geometric entities array. More...
void	setGeoEntArrayName (const std::string &geoEntArrayName)
	Set the name of the geometric entities array. More...
double	getAngleThreshold () const
	Get the angle threshold used for surface classification. More...
void	setAngleThreshold (double angleThreshold)
	Set the angle threshold used for surface classification. More...
nemId_t	getNumberOfPoints () const
	Get the number of points in mesh. More...
nemId_t	getNumberOfCells () const
	Get the number of cells in mesh. More...
void	getPoint (nemId_t id, std::array< double, 3 > *x) const
	Get the coordinate of a point. More...
std::array< double, 3 >	getPoint (nemId_t id) const
	Get the coordinate of a point. More...
void	getCell (nemId_t cellId, vtkGenericCell *cell) const
	Get cell. More...
vtkCell *	getCell (nemId_t cellId) const
	Get cell. More...
void	getCellBounds (nemId_t cellId, std::array< double, 6 > *bounds) const
	Get cell bounds. More...
std::array< double, 6 >	getCellBounds (nemId_t cellId) const
	Get cell bounds. More...
VTKCellType	getCellType (nemId_t cellId) const
	Get VTK cell type. More...
void	getCellPoints (nemId_t cellId, vtkIdList *ptIds) const
	Get list of point ids defining specified cell. More...
void	getPointCells (nemId_t ptId, vtkIdList *cellIds) const
	Get list of cell ids using specified point. More...
void	getCellNeighbors (nemId_t cellId, vtkIdList *ptIds, vtkIdList *cellIds) const
	Get list of cells sharing points ptIds excluding cellId. More...
int	getNumberOfPointDataArrays () const
	Get number of arrays in the point data. More...
void	getPointDataArrayCopy (const std::string &arrayName, vtkAbstractArray *array, int *arrayIdx=nullptr) const
	Get copy of point data array by name. More...
vtkSmartPointer< vtkAbstractArray >	getPointDataArrayCopy (const std::string &arrayName, int *arrayIdx=nullptr) const
	Create and return a copy of point data array by name. More...
void	getPointDataArrayCopy (int arrayIdx, vtkAbstractArray *array) const
	Get copy of point data array by index. More...
vtkSmartPointer< vtkAbstractArray >	getPointDataArrayCopy (int arrayIdx) const
	Create and return a copy of point data array by index. More...
int	getNumberOfCellDataArrays () const
	Get number of arrays in the cell data. More...
void	getCellDataArrayCopy (const std::string &arrayName, vtkAbstractArray *array, int *arrayIdx=nullptr) const
	Get copy of cell data array by name. More...
vtkSmartPointer< vtkAbstractArray >	getCellDataArrayCopy (const std::string &arrayName, int *arrayIdx=nullptr) const
	Create and return a copy of cell data array by name. More...
void	getCellDataArrayCopy (int arrayIdx, vtkAbstractArray *array) const
	Get copy of cell data array by index. More...
vtkSmartPointer< vtkAbstractArray >	getCellDataArrayCopy (int arrayIdx) const
	Create and return a copy of cell data array by index. More...
int	getNumberOfFieldDataArrays () const
	Get number of arrays in the field data. More...
void	getFieldDataArrayCopy (const std::string &arrayName, vtkAbstractArray *array, int *arrayIdx=nullptr) const
	Get copy of field data array by name. More...
vtkSmartPointer< vtkAbstractArray >	getFieldDataArrayCopy (const std::string &arrayName, int *arrayIdx=nullptr) const
	Create and return a copy of field data array by name. More...
void	getFieldDataArrayCopy (int arrayIdx, vtkAbstractArray *array) const
	Get copy of field data array by index. More...
vtkSmartPointer< vtkAbstractArray >	getFieldDataArrayCopy (int arrayIdx) const
	Create and return a copy of field data array by index. More...

Static Public Member Functions
static foamGeoMesh *	New ()

Protected Member Functions
int	setPointDataArray (vtkAbstractArray *array)
	Set point data. More...
int	setCellDataArray (vtkAbstractArray *array)
	Set cell data. More...
int	setFieldDataArray (vtkAbstractArray *array)
	Set field data. More...
void	unsetPointDataArray (int arrayIdx)
	Remove point data array by index. More...
void	unsetPointDataArray (const std::string &arrayName)
	Remove point data array by name. More...
void	unsetCellDataArray (int arrayIdx)
	Remove cell data array by index. More...
void	unsetCellDataArray (const std::string &arrayName)
	Remove cell data array by name. More...
void	unsetFieldDataArray (int arrayIdx)
	Remove field data array by index. More...
void	unsetFieldDataArray (const std::string &arrayName)
	Remove field data array by name. More...
const GeoMesh &	getGeoMesh () const
	Get the underlying geometry object. More...
void	setGeoMesh (const geoMeshBase::GeoMesh &geoMesh)
	Set the underlying geometry object. More...

Static Protected Attributes
static constexpr auto	GEO_ENT_DEFAULT_NAME = "GeoEnt"

Private Member Functions
void	InitializeFoam ()
	Initializes arguments and runtime objects. More...

Static Private Member Functions
static GeoMesh	foam2GM (Foam::fvMesh *foamMesh, const std::string &phyGrpArrayName=std::string())
	Create a GeoMesh from a fvMesh. More...
static std::unique_ptr< Foam::fvMesh >	GM2foam (const GeoMesh &geoMesh, Foam::Time *runTime, const std::string &phyGrpArrayName=std::string())
	Create a fvMesh from geoMeshBase. More...

Private Attributes
std::unique_ptr< Foam::dictionary >	controlDict_
std::unique_ptr< Foam::dictionary >	fvSchemes_
std::unique_ptr< Foam::dictionary >	fvSolution_
std::unique_ptr< Foam::Time >	runTime_
std::unique_ptr< Foam::fvMesh >	fmesh_

Inherits NEM::MSH::geoMeshBase.

Constructor & Destructor Documentation

foamGeoMesh() [1/2]

NEM::MSH::foamGeoMesh::foamGeoMesh

(

)

Parameters

fileName	name of file
phyGrpArrayName	name of a volScalarField defining the physical group of each cell

Returns

new foamGeoMesh from mesh Construct a foamGeoMesh with an empty mesh

Definition at line 95 of file foamGeoMesh.C.

References InitializeFoam().

Referenced by NEM::MSH::vtkStandardNewMacro().

: foamGeoMesh(nullptr) { InitializeFoam(); }

foamGeoMesh() [2/2]

NEM::MSH::foamGeoMesh::foamGeoMesh ( Foam::fvMesh *  foamMesh, const std::string &  phyGrpArrayName = std::string()  )

explicit

Parameters

foamMesh	existing foamMesh
phyGrpArrayName	name of a volScalarField defining the physical group of each cell

Definition at line 97 of file foamGeoMesh.C.

    : geoMeshBase(foam2GM(foamMesh, phyGrpArrayName)), fmesh_(foamMesh) {
  std::cout << "foamGeoMesh Constructed" << std::endl;
}

~foamGeoMesh()

NEM::MSH::foamGeoMesh::~foamGeoMesh ( )

override

Definition at line 103 of file foamGeoMesh.C.

                          {
  std::cout << "foamGeoMesh destructed" << std::endl;
}

Member Function Documentation

foam2GM()

geoMeshBase::GeoMesh NEM::MSH::foamGeoMesh::foam2GM ( Foam::fvMesh *  foamMesh, const std::string &  phyGrpArrayName = std::string()  )

staticprivate

Assumes gmsh has already been initialized.

Parameters

foamMesh	fv mesh
phyGrpArrayName	name of cell data array describing physical group of each cell

Returns

GeoMesh

Definition at line 107 of file foamGeoMesh.C.

References nemAux::getRandomString(), NEM::MSH::GmshInterface::Initialize(), and NEM::MSH::New().

Referenced by setFoamMesh(), and NEM::MSH::vtkStandardNewMacro().

                                                                            {
  // create vtk database
  vtkSmartPointer<vtkUnstructuredGrid> vtkdataSet =
      vtkSmartPointer<vtkUnstructuredGrid>::New();

  // Check for cellsets and cellzones
  if (!foamMesh) {
    return {vtkdataSet, "", "", {}};
  } else {
    const Foam::cellZoneMesh &cellZones =
        foamMesh->cellZones();  // get cellZoneMesh
    Foam::label zoneI = cellZones.size();

    // creating equivalent vtk topology from fvMesh
    // by default polyhedral cells will be decomposed to
    // tets and pyramids. Additional points will be added
    // to underlying fvMesh.
    std::cout << "Performing topological decomposition.\n";
    auto objVfoam = Foam::vtk::vtuAdaptor();
    vtkdataSet = objVfoam.internal(*foamMesh);

    // Check for cellZones and extract physical groups
    Foam::List<Foam::scalar> physGrps(foamMesh->nCells(), 0.0);
    if (zoneI > 0) {
      for (int i = 0; i < zoneI; i++) {
        const Foam::cellZone &cz = cellZones[i];
        forAll (cz, j)
          physGrps[cz[j]] = i;
      }

      vtkSmartPointer<vtkDoubleArray> pg =
          vtkSmartPointer<vtkDoubleArray>::New();
      pg->SetName(phyGrpArrayName.c_str());
      pg->SetNumberOfComponents(1);
      for (int i = 0; i < foamMesh->nCells(); i++)
        pg->InsertNextTuple1(physGrps[i]);
      vtkdataSet->GetCellData()->AddArray(pg);
    }

    // Create boundary patches arrays and add to VTK
    const Foam::polyBoundaryMesh &patches = foamMesh->boundaryMesh();
    Foam::wordList patchNames = patches.names();
    Foam::wordList patchTypes = patches.types();
    // const Foam::labelList &patchIds = patches.patchID();
    Foam::label patchSize = patches.size();
    std::vector<int> face_patch_map;  // Which patch the current face is in
    Foam::label nFaces = foamMesh->nFaces();
    for (int i = 0; i < nFaces; i++)
      face_patch_map.push_back(int(patches.whichPatch(i)));

    // Create sideSets
    vtkSmartPointer<vtkPolyData> sideSet = vtkSmartPointer<vtkPolyData>::New();
    Foam::faceList allFaces = foamMesh->faces();
    Foam::labelList faceOwners = foamMesh->faceOwner();
    Foam::pointField allPoints = foamMesh->points();

    // Filter internal faces out
    int nonInternalFaces = 0;
    for (int i = 0; i < patchSize; i++) nonInternalFaces += patches[i].size();
    Foam::faceList sideSetOnlyFaces(nonInternalFaces);
    Foam::labelList sideSetOnlyFaceLabels(nonInternalFaces);
    Foam::labelList sideSetOnlyOwners(nonInternalFaces);
    int indx = 0;
    for (int i = 0; i < static_cast<int>(face_patch_map.size()); i++) {
      if (face_patch_map[i] != -1) {
        sideSetOnlyFaces[indx] = allFaces[i];
        sideSetOnlyOwners[indx] = faceOwners[i];
        sideSetOnlyFaceLabels[indx] = i;
        indx++;
      }
    }

    sideSet->SetPoints(vtkdataSet->GetPoints());
    sideSet->Allocate();

    // Start adding cells (2D faces)
    std::vector<int> facePntIds;
    for (int i = 0; i < sideSetOnlyFaces.size(); i++) {
      if (sideSetOnlyFaces[i].size() == 3) {
        // add triangle face (#5)
        vtkSmartPointer<vtkIdList> vtkCellIds =
            vtkSmartPointer<vtkIdList>::New();
        vtkCellIds->SetNumberOfIds(sideSetOnlyFaces[i].size());
        for (int j = 0; j < sideSetOnlyFaces[i].size(); j++)
          vtkCellIds->SetId(j, sideSetOnlyFaces[i][j]);
        sideSet->InsertNextCell(5, vtkCellIds);
      } else if (sideSetOnlyFaces[i].size() == 4) {
        // add quad face (#9)
        vtkSmartPointer<vtkIdList> vtkCellIds =
            vtkSmartPointer<vtkIdList>::New();
        vtkCellIds->SetNumberOfIds(sideSetOnlyFaces[i].size());
        for (int j = 0; j < sideSetOnlyFaces[i].size(); j++)
          vtkCellIds->SetId(j, sideSetOnlyFaces[i][j]);
        sideSet->InsertNextCell(9, vtkCellIds);
      } else if (sideSetOnlyFaces[i].size() > 4) {
        //  add polygon face (#7)
        vtkSmartPointer<vtkIdList> vtkCellIds =
            vtkSmartPointer<vtkIdList>::New();
        vtkCellIds->SetNumberOfIds(sideSetOnlyFaces[i].size());
        for (int j = 0; j < sideSetOnlyFaces[i].size(); j++)
          vtkCellIds->SetId(j, sideSetOnlyFaces[i][j]);
        sideSet->InsertNextCell(7, vtkCellIds);
      } else {
        Foam::Info << "Face type not supported yet!" << Foam::nl;
      }
    }

    auto sideSetEntities = vtkSmartPointer<vtkIntArray>::New();
    sideSetEntities->SetName("GeoEnt");

    auto sideSetOrigCellId = vtkSmartPointer<vtkIdTypeArray>::New();
    sideSetOrigCellId->SetName("OrigCellIds");
    sideSetOrigCellId->SetNumberOfComponents(2);

    auto sideSetCellFaceId = vtkSmartPointer<vtkIntArray>::New();
    sideSetCellFaceId->SetName("CellFaceIds");
    sideSetCellFaceId->SetNumberOfComponents(2);

    auto sideSetPatchId = vtkSmartPointer<vtkIntArray>::New();
    sideSetPatchId->SetName("PatchIds");

    auto sideSetPatchName = vtkSmartPointer<vtkStringArray>::New();
    sideSetPatchName->SetName("PatchNames");

    for (int i = 0; i < sideSetOnlyFaces.size(); i++) {
      sideSetEntities->InsertNextValue(
          static_cast<int>(physGrps[sideSetOnlyOwners[i]]));
      sideSetOrigCellId->InsertNextTuple2(sideSetOnlyOwners[i],-1);
    }

    for (int i = 0; i < sideSetOnlyOwners.size(); i++) {
      const Foam::cell& facesCell = foamMesh->cells()[sideSetOnlyOwners[i]];
      for (int j = 0; j < facesCell.size(); j++) {
        if (foamMesh->faces()[facesCell[j]] == sideSetOnlyFaces[i]) {
          sideSetCellFaceId->InsertNextTuple2(j,-1);
        }
      }
    }

    for (int i = 0; i < sideSetOnlyFaces.size(); i++) {
      sideSetPatchId->InsertNextValue(face_patch_map[sideSetOnlyFaceLabels[i]]);
      sideSetPatchName->InsertNextValue(
          patchNames[face_patch_map[sideSetOnlyFaceLabels[i]]]);
    }

    // Add arrays to sideSet
    sideSet->GetCellData()->AddArray(sideSetPatchId);
    sideSet->GetFieldData()->AddArray(sideSetPatchName);

    // Create sideSet struct
    auto sideSetStruct =
        SideSet(sideSet, sideSetEntities, sideSetOrigCellId, sideSetCellFaceId);

    std::string gmshMesh = "foamGeoMesh_" + nemAux::getRandomString(6);
#ifdef HAVE_GMSH
    GmshInterface::Initialize();
    gmsh::model::add(gmshMesh);
    gmsh::model::setCurrent(gmshMesh);

    {  // Add geometric entities and physical groups
      std::set<std::pair<int, int>> dim_phyGrp;
      int idx = 0;
      auto phyGrpArray = vtkArrayDownCast<vtkDataArray>(
          vtkdataSet->GetCellData()->GetArray(phyGrpArrayName.c_str(), idx));
      vtkSmartPointer<vtkGenericCell> vtkGC =
          vtkSmartPointer<vtkGenericCell>::New();

      if (idx != -1) {
        // First sort
        for (vtkIdType i = 0; i < vtkdataSet->GetNumberOfCells(); ++i) {
          vtkGC->SetCellType(vtkdataSet->GetCellType(i));
          int dim = vtkGC->GetCellDimension();
          int phyGrp = static_cast<int>(phyGrpArray->GetComponent(i, 0));

          dim_phyGrp.insert({dim, phyGrp});
        }

        // then add. Each phyGrp gets its own geoEnt
        for (const auto &dp : dim_phyGrp) {
          gmsh::model::addDiscreteEntity(dp.first, dp.second);
          gmsh::model::addPhysicalGroup(dp.first, {dp.second}, dp.second);
        }
      }
    }
#endif
    return {vtkdataSet, gmshMesh, phyGrpArrayName, sideSetStruct};
  }
}

getAngleThreshold()

double NEM::MSH::geoMeshBase::getAngleThreshold ( ) const

inlineinherited

Returns

angle threshold (in radians)

Definition at line 171 of file geoMeshBase.H.

{ return _angleThreshold; }

getCell() [1/2]

void NEM::MSH::geoMeshBase::getCell ( nemId_t  cellId, vtkGenericCell *  cell  ) const

inlineinherited

Parameters

cellId	cell id
cell	cell

Definition at line 214 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                                           {
    _geoMesh.mesh->GetCell(cellId, cell);
  }

getCell() [2/2]

vtkCell* NEM::MSH::geoMeshBase::getCell ( nemId_t  cellId ) const

inlineinherited

Parameters

cellId

cell id

Returns

cell

Definition at line 222 of file geoMeshBase.H.

                                         {
    return _geoMesh.mesh->GetCell(cellId);
  }

getCellBounds() [1/2]

void NEM::MSH::geoMeshBase::getCellBounds ( nemId_t  cellId, std::array< double, 6 > *  bounds  ) const

inlineinherited

Parameters

cellId	cell id
bounds	array of bounds as (x_min,x_max, y_min,y_max, z_min,z_max)

Definition at line 230 of file geoMeshBase.H.

                                                                        {
    _geoMesh.mesh->GetCellBounds(cellId, bounds->data());
  }

getCellBounds() [2/2]

std::array<double, 6> NEM::MSH::geoMeshBase::getCellBounds ( nemId_t  cellId ) const

inlineinherited

Parameters

cellId

cell id

Returns

array of bounds as (x_min,x_max, y_min,y_max, z_min,z_max)

Definition at line 238 of file geoMeshBase.H.

                                                          {
    std::array<double, 6> bounds{};
    getCellBounds(cellId, &bounds);
    return bounds;
  }

getCellDataArrayCopy() [1/4]

void NEM::MSH::geoMeshBase::getCellDataArrayCopy ( const std::string &  arrayName, vtkAbstractArray *  array, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
array	cell data array
arrayIdx	array index

Definition at line 180 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

Referenced by NEM::MSH::diffMesh().

                                                            {
  getArrCopy(_geoMesh.mesh->GetCellData(), arrayName, arrayIdx, array);
}

getCellDataArrayCopy() [2/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getCellDataArrayCopy ( const std::string &  arrayName, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
arrayIdx	array index

Returns

pointer to copy of array

Definition at line 186 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                     {
  return getArrCopy(_geoMesh.mesh->GetCellData(), arrayName, arrayIdx);
}

getCellDataArrayCopy() [3/4]

void NEM::MSH::geoMeshBase::getCellDataArrayCopy ( int  arrayIdx, vtkAbstractArray *  array  ) const

inherited

Parameters

arrayIdx	array index
array	cell data array

Definition at line 191 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                                      {
  getArrCopy(_geoMesh.mesh->GetCellData(), arrayIdx, array);
}

getCellDataArrayCopy() [4/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getCellDataArrayCopy ( int  arrayIdx ) const

inherited

Parameters

arrayIdx

array index

Returns

pointer to copy of array

Definition at line 196 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                        {
  return getArrCopy(_geoMesh.mesh->GetCellData(), arrayIdx);
}

getCellNeighbors()

void NEM::MSH::geoMeshBase::getCellNeighbors ( nemId_t  cellId, vtkIdList *  ptIds, vtkIdList *  cellIds  ) const

inlineinherited

Parameters

cellId	id of cell to exclude
ptIds	point id
cellIds	list of cell ids

Definition at line 273 of file geoMeshBase.H.

                                                  {
    _geoMesh.mesh->GetCellNeighbors(cellId, ptIds, cellIds);
  }

getCellPoints()

void NEM::MSH::geoMeshBase::getCellPoints ( nemId_t  cellId, vtkIdList *  ptIds  ) const

inlineinherited

Parameters

cellId	cell id
ptIds	list of point ids

Definition at line 256 of file geoMeshBase.H.

                                                             {
    _geoMesh.mesh->GetCellPoints(cellId, ptIds);
  }

getCellType()

VTKCellType NEM::MSH::geoMeshBase::getCellType ( nemId_t  cellId ) const

inlineinherited

Parameters

cellId

cell id

Returns

VTK cell type (see vtk documentation for specifics)

Definition at line 248 of file geoMeshBase.H.

                                                {
    return static_cast<VTKCellType>(_geoMesh.mesh->GetCellType(cellId));
  }

getFieldDataArrayCopy() [1/4]

void NEM::MSH::geoMeshBase::getFieldDataArrayCopy ( const std::string &  arrayName, vtkAbstractArray *  array, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
array	field data array
arrayIdx	array index

Definition at line 201 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                             {
  getArrCopy(_geoMesh.mesh->GetFieldData(), arrayName, arrayIdx, array);
}

getFieldDataArrayCopy() [2/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getFieldDataArrayCopy ( const std::string &  arrayName, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
arrayIdx	array index

Returns

pointer to copy of array

Definition at line 207 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                     {
  return getArrCopy(_geoMesh.mesh->GetFieldData(), arrayName, arrayIdx);
}

getFieldDataArrayCopy() [3/4]

void NEM::MSH::geoMeshBase::getFieldDataArrayCopy ( int  arrayIdx, vtkAbstractArray *  array  ) const

inherited

Parameters

arrayIdx	array index
array	field data array

Definition at line 212 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                                       {
  getArrCopy(_geoMesh.mesh->GetFieldData(), arrayIdx, array);
}

getFieldDataArrayCopy() [4/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getFieldDataArrayCopy ( int  arrayIdx ) const

inherited

Parameters

arrayIdx

array index

Returns

pointer to copy of array

Definition at line 217 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                        {
  return getArrCopy(_geoMesh.mesh->GetFieldData(), arrayIdx);
}

getFoamMesh()

const Foam::fvMesh& NEM::MSH::foamGeoMesh::getFoamMesh ( ) const

inline

Returns

fvMesh

Definition at line 105 of file foamGeoMesh.H.

Referenced by MeshManipulationFoam::addArtificialThicknessElements(), and MeshManipulationFoam::addCohesiveElements().

{ return *fmesh_; }

getGeoEntArrayName()

const std::string& NEM::MSH::geoMeshBase::getGeoEntArrayName ( ) const

inlineinherited

Returns

name of geometric entities array

Definition at line 157 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

{ return _geoMesh.link; }

getGeoMesh()

const GeoMesh& NEM::MSH::geoMeshBase::getGeoMesh ( ) const

inlineprotectedinherited

Note

This is not a copy; Gmsh does not support cloning a model.

Definition at line 533 of file geoMeshBase.H.

Referenced by NEM::MSH::exoGeoMesh::addCellsToBlock(), NEM::MSH::exoGeoMesh::addElemBlock(), NEM::MSH::exoGeoMesh::addElemBlockProperty(), NEM::MSH::exoGeoMesh::addNodeSet(), NEM::MSH::exoGeoMesh::addSideSet(), NEM::MSH::exoGeoMesh::exoGeoMesh(), NEM::MSH::exoGeoMesh::getElemBlock(), NEM::MSH::exoGeoMesh::getElemBlockId(), NEM::MSH::exoGeoMesh::getSideSet(), NEM::MSH::vtkGeoMesh::getVtkMesh(), NEM::MSH::inpGeoMesh::inpGeoMesh(), NEM::MSH::exoGeoMesh::reassignCells(), NEM::MSH::oshGeoMesh::reconstructGeo(), NEM::MSH::exoGeoMesh::reconstructGeo(), NEM::MSH::geoMeshBase::report(), NEM::MSH::exoGeoMesh::resetElemBlocks(), NEM::MSH::smeshGeoMesh::resetNative(), NEM::MSH::gmshGeoMesh::resetNative(), NEM::MSH::inpGeoMesh::resetNative(), resetNative(), NEM::MSH::oshGeoMesh::resetNative(), NEM::MSH::exoGeoMesh::resetNative(), NEM::MSH::exoGeoMesh::scaleNodes(), NEM::MSH::oshGeoMesh::setOshMesh(), NEM::MSH::exoGeoMesh::setPhysGrpPropertyName(), NEM::MSH::exoGeoMesh::setSideSetObjId(), NEM::MSH::exoGeoMesh::stitch(), NEM::MSH::gmshGeoMesh::write(), NEM::MSH::vtkGeoMesh::write(), and NEM::MSH::exoGeoMesh::write().

{ return _geoMesh; }

getNumberOfCellDataArrays()

int NEM::MSH::geoMeshBase::getNumberOfCellDataArrays ( ) const

inlineinherited

Returns

number of arrays in the cell data

Definition at line 318 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                        {
    return _geoMesh.mesh->GetCellData()->GetNumberOfArrays();
  }

getNumberOfCells()

nemId_t NEM::MSH::geoMeshBase::getNumberOfCells ( ) const

inlineinherited

Returns

number of cells in mesh

Definition at line 190 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

{ return _geoMesh.mesh->GetNumberOfCells(); }

getNumberOfFieldDataArrays()

int NEM::MSH::geoMeshBase::getNumberOfFieldDataArrays ( ) const

inlineinherited

Returns

number of arrays in the field data

Definition at line 355 of file geoMeshBase.H.

                                         {
    return _geoMesh.mesh->GetFieldData()->GetNumberOfArrays();
  }

getNumberOfPointDataArrays()

int NEM::MSH::geoMeshBase::getNumberOfPointDataArrays ( ) const

inlineinherited

Returns

number of arrays in the point data

Definition at line 281 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                         {
    return _geoMesh.mesh->GetPointData()->GetNumberOfArrays();
  }

getNumberOfPoints()

nemId_t NEM::MSH::geoMeshBase::getNumberOfPoints ( ) const

inlineinherited

Returns

number of points in mesh

Definition at line 183 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                    {
    return _geoMesh.mesh->GetNumberOfPoints();
  }

getPoint() [1/2]

void NEM::MSH::geoMeshBase::getPoint ( nemId_t  id, std::array< double, 3 > *  x  ) const

inlineinherited

Parameters

id	point id
x	array of coordinates as (x,y,z)

Definition at line 196 of file geoMeshBase.H.

Referenced by NEM::MSH::diffMesh().

                                                          {
    _geoMesh.mesh->GetPoint(id, x->data());
  }

getPoint() [2/2]

std::array<double, 3> NEM::MSH::geoMeshBase::getPoint ( nemId_t  id ) const

inlineinherited

Parameters

id

point id

Returns

array of coordinates as (x,y,z)

Definition at line 204 of file geoMeshBase.H.

                                                 {
    std::array<double, 3> x{};
    getPoint(id, &x);
    return x;
  }

getPointCells()

void NEM::MSH::geoMeshBase::getPointCells ( nemId_t  ptId, vtkIdList *  cellIds  ) const

inlineinherited

Parameters

ptId	point id
cellIds	list of cell ids

Definition at line 264 of file geoMeshBase.H.

                                                             {
    _geoMesh.mesh->GetPointCells(ptId, cellIds);
  }

getPointDataArrayCopy() [1/4]

void NEM::MSH::geoMeshBase::getPointDataArrayCopy ( const std::string &  arrayName, vtkAbstractArray *  array, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
array	point data array
arrayIdx	array index

Definition at line 159 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

Referenced by NEM::MSH::diffMesh().

                                                             {
  getArrCopy(_geoMesh.mesh->GetPointData(), arrayName, arrayIdx, array);
}

getPointDataArrayCopy() [2/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getPointDataArrayCopy ( const std::string &  arrayName, int *  arrayIdx = nullptr  ) const

inherited

Optionally, get array index.

Parameters

arrayName	array name
arrayIdx	array index

Returns

pointer to copy of array

Definition at line 165 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                     {
  return getArrCopy(_geoMesh.mesh->GetPointData(), arrayName, arrayIdx);
}

getPointDataArrayCopy() [3/4]

void NEM::MSH::geoMeshBase::getPointDataArrayCopy ( int  arrayIdx, vtkAbstractArray *  array  ) const

inherited

Parameters

arrayIdx	array index
array	point data array

Definition at line 170 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                                                                       {
  getArrCopy(_geoMesh.mesh->GetPointData(), arrayIdx, array);
}

getPointDataArrayCopy() [4/4]

vtkSmartPointer< vtkAbstractArray > NEM::MSH::geoMeshBase::getPointDataArrayCopy ( int  arrayIdx ) const

inherited

Parameters

arrayIdx

array index

Returns

pointer to copy of array

Definition at line 175 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, and NEM::MSH::geoMeshBase::GeoMesh::mesh.

                        {
  return getArrCopy(_geoMesh.mesh->GetPointData(), arrayIdx);
}

GM2foam()

std::unique_ptr< Foam::fvMesh > NEM::MSH::foamGeoMesh::GM2foam ( const GeoMesh &  geoMesh, Foam::Time *  runTime, const std::string &  phyGrpArrayName = std::string()  )

staticprivate

Parameters

geoMesh	GeoMesh
runTime	TODO
phyGrpArrayName	name of cell data array describing physical group of each cell

Returns

fvMesh

Definition at line 297 of file foamGeoMesh.C.

References NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::New(), NEM::MSH::geoMeshBase::SideSet::sides, and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

Referenced by resetNative().

                                      {
  int numPoints = static_cast<int>(geoMesh.mesh->GetNumberOfPoints());
  int numCells = static_cast<int>(geoMesh.mesh->GetNumberOfCells());

  Foam::pointField pointData(numPoints);
  Foam::pointField pointData2(numPoints);
  Foam::cellShapeList cellShapeData(numCells);
  Foam::cellShapeList cellShapeData2(numCells);

  if (numPoints > 0) {
    // Fetch all points and coordinates
    std::vector<std::vector<double>> verts;
    verts.resize(numPoints);
    for (int ipt = 0; ipt < numPoints; ipt++) {
      std::vector<double> getPt = std::vector<double>(3);
      geoMesh.mesh->GetPoint(ipt, &getPt[0]);
      verts[ipt].resize(3);
      verts[ipt][0] = getPt[0];
      verts[ipt][1] = getPt[1];
      verts[ipt][2] = getPt[2];
    }

    // Gets Ids for cells
    std::vector<std::vector<int>> cellIds;
    cellIds.resize(numCells);

    // Gets celltypes for all cells in mesh
    std::vector<int> typeCell;
    typeCell.resize(numCells);

    for (int i = 0; i < numPoints; i++) {
      pointData[i] = Foam::vector(verts[i][0], verts[i][1], verts[i][2]);
      pointData2[i] = Foam::vector(verts[i][0], verts[i][1], verts[i][2]);
    }

    for (int i = 0; i < numCells; i++) {
      vtkIdList *ptIds = vtkIdList::New();
      geoMesh.mesh->GetCellPoints(i, ptIds);
      int numIds = static_cast<int>(ptIds->GetNumberOfIds());
      cellIds[i].resize(numIds);
      for (int j = 0; j < numIds; j++) cellIds[i][j] = static_cast<int>(ptIds->GetId(j));
      Foam::labelList meshPoints(numIds);
      for (int k = 0; k < numIds; k++) meshPoints[k] = cellIds[i][k];
      typeCell[i] = geoMesh.mesh->GetCellType(i);
      if (typeCell[i] == 12) {
        cellShapeData[i] = Foam::cellShape("hex", meshPoints, true);
        cellShapeData2[i] = Foam::cellShape("hex", meshPoints, true);
      } else if (typeCell[i] == 14) {
        cellShapeData[i] = Foam::cellShape("pyr", meshPoints, true);
        cellShapeData2[i] = Foam::cellShape("pyr", meshPoints, true);
      } else if (typeCell[i] == 10) {
        cellShapeData[i] = Foam::cellShape("tet", meshPoints, true);
        cellShapeData2[i] = Foam::cellShape("tet", meshPoints, true);
      } else {
        std::cerr << "Only Hexahedral, Tetrahedral,"
                  << " and Pyramid cells are supported in foamGeoMesh!"
                  << std::endl;
        throw;
      }
    }
  } else {
    return nullptr;
  }

  // Foam::word regName = Foam::polyMesh::defaultRegion;
  Foam::word regName = "";

  // Get patch names from mesh
  int idx1 = 0;
  int idx2 = 0;
  std::map<int, std::string> ptchNameIDMap;
  Foam::faceListList bndryFaces(0);
  Foam::wordList BndryPatchNames(0);
  Foam::wordList BndryPatchTypes(0);
  Foam::wordList boundaryPatchPhysicalTypes(0);
  int totalPatches;
  std::vector<int> startIds;
  std::vector<int> nFacesInPatch;
  Foam::PtrList<Foam::polyPatch> patchPtrList(0);
  Foam::cellList cellLst2(0);
  Foam::faceList faceLst2(0);

  if (geoMesh.sideSet.sides) {
    auto ptchIds = vtkIntArray::FastDownCast(
        geoMesh.sideSet.sides->GetCellData()->GetArray("PatchIds", idx1));
    auto ptchNms = vtkStringArray::SafeDownCast(
        geoMesh.sideSet.sides->GetFieldData()->GetAbstractArray("PatchNames",
                                                                idx2));

    if (idx1 != -1 && idx2 != -1) {
      // Patches exist
      for (int i = 0; i < ptchIds->GetNumberOfTuples(); ++i) {
        // Get patch Id
        auto cc = ptchIds->GetTypedComponent(i, 0);
        int id_p = cc;

        // Get patch name
        std::string nm = ptchNms->GetValue(i);

        // Create maps
        ptchNameIDMap[id_p] = nm;
      }

      totalPatches = static_cast<int>(ptchNameIDMap.size());
      std::vector<int> faceCounts(totalPatches,
                                  0);  // Counts faces for each patch
      std::vector<std::vector<int>> facePatchIds;
      facePatchIds.resize(totalPatches);
      for (int i = 0; i < ptchIds->GetNumberOfTuples(); ++i) {
        // Get patch Id
        auto cc = ptchIds->GetTypedComponent(i, 0);
        int id_p = cc;
        faceCounts[id_p] += 1;
        facePatchIds[id_p].push_back(i);
      }

      BndryPatchNames.setSize(totalPatches);
      BndryPatchTypes.setSize(totalPatches);

      auto iter = ptchNameIDMap.begin();
      int r_indx = 0;
      while (iter != ptchNameIDMap.end()) {
        BndryPatchNames[r_indx] = iter->second;
        BndryPatchTypes[r_indx] = "patch";
        iter++;
        r_indx++;
      }

      // Start pulling out cell (2D faces) point order from sideSets and create
      // faceList. Append those into faceListList at the end of every patch.
      bndryFaces.clear();
      for (int i = 0; i < totalPatches; i++) {
        Foam::faceList thisPatch(0);
        thisPatch.clear();
        for (int j : facePatchIds[i]) {
          vtkIdList *ptIds = vtkIdList::New();
          geoMesh.sideSet.sides->GetCellPoints(j, ptIds);
          int numIds = static_cast<int>(ptIds->GetNumberOfIds());
          Foam::labelList lstLbl(0);
          lstLbl.clear();
          for (int k = 0; k < numIds; k++) {
            lstLbl.append(static_cast<int>(ptIds->GetId(k)));
          }
          if (!lstLbl.empty()) thisPatch.append(Foam::face(lstLbl));
        }
        bndryFaces.append(thisPatch);
        nFacesInPatch.push_back(thisPatch.size());
      }
      boundaryPatchPhysicalTypes.resize(totalPatches,
                                        Foam::polyPatch::typeName);
    }
  }

  {
    Foam::polyMesh tmpfm(
        Foam::IOobject(regName, runTime->timeName(), *runTime,
                       Foam::IOobject::NO_READ, Foam::IOobject::AUTO_WRITE),
        std::move(pointData),       // Vertices
        cellShapeData,              // Cell shape and points
        bndryFaces,                 // Boundary faces
        BndryPatchNames,            // Boundary Patch Names
        BndryPatchTypes,            // Boundary Patch Types
        "defaultPatch",             // Default Patch Name
        Foam::polyPatch::typeName,  // Default Patch Type
        Foam::wordList());

    const Foam::polyBoundaryMesh &patches2 = tmpfm.boundaryMesh();

    for (int i = 0; i < patches2.size(); i++) {
      auto *tmpPtch = new Foam::polyPatch(patches2[i]);
      patchPtrList.append(tmpPtch);
    }

    // Get pointField (points), faceList (faces), and cellList (cells).
    const Foam::cellList &cellLst = tmpfm.cells();
    cellLst2 = cellLst;
    const Foam::faceList &faceLst = tmpfm.faces();
    faceLst2 = faceLst;
  }

  auto fm = std::unique_ptr<Foam::fvMesh>(new Foam::fvMesh(
      Foam::IOobject(regName, runTime->timeName(), *runTime,
                     Foam::IOobject::NO_READ, Foam::IOobject::AUTO_WRITE),
      std::move(pointData2), std::move(faceLst2), std::move(cellLst2)));

  // Add boundary patches to fvMesh using patchPtrList
  fm->addFvPatches(patchPtrList, true);

  // Get Physical Groups Vector from GeoMesh
  std::vector<double> allGroups;
  int idx;
  vtkSmartPointer<vtkDataArray> cd =
      geoMesh.mesh->GetCellData()->GetArray(phyGrpArrayName.c_str(), idx);
  if (idx != -1) {
    // allGroups.resize(cd->GetNumberOfTuples());
    double x[1];
    for (nemId_t i = 0; i < cd->GetNumberOfTuples(); ++i) {
      cd->GetTuple(i, x);
      allGroups.push_back(x[0]);
    }

    // Figure out number of physical groups
    std::vector<double> scratchVec = allGroups;
    std::sort(scratchVec.begin(), scratchVec.end());
    scratchVec.erase(unique(scratchVec.begin(), scratchVec.end()),
                     scratchVec.end());
    int totalGroups = static_cast<int>(scratchVec.size());

    // Create cellZones
    Foam::label zoneI;
    for (int i = 0; i < totalGroups; i++) {
      Foam::labelList currentGroupList;
      //for (int j : allGroups) {
      for (int j = 0; j < static_cast<int>(allGroups.size()); j++) {
        if (static_cast<int>(allGroups[j]) == i) currentGroupList.append(j);
      }

      const Foam::cellZoneMesh &cellZones = fm->cellZones();
      zoneI = cellZones.size();
      fm->cellZones().setSize(zoneI + 1);
      Foam::word nameSet = "pg_" + std::to_string(i);
      auto clzn =
          new Foam::cellZone(nameSet, currentGroupList, zoneI, cellZones);
      fm->cellZones().set(zoneI, clzn);
    }
    fm->cellZones().writeOpt() = Foam::IOobject::AUTO_WRITE;
  }
  return fm;
}

InitializeFoam()

void NEM::MSH::foamGeoMesh::InitializeFoam ( )

private

Definition at line 667 of file foamGeoMesh.C.

References controlDict_, fvSchemes_, fvSolution_, and runTime_.

Referenced by foamGeoMesh(), and resetNative().

                                 {
  bool writeDicts = false;
  std::unique_ptr<getDicts> initFoam;
  initFoam = std::unique_ptr<getDicts>(new getDicts());
  controlDict_ = initFoam->createControlDict(writeDicts);
  fvSchemes_ = initFoam->createFvSchemes(writeDicts);
  fvSolution_ = initFoam->createFvSolution(writeDicts);

  // Create time class without reading controlDict
  runTime_ =
      std::unique_ptr<Foam::Time>(new Foam::Time(controlDict_.get(), ".", "."));
  Foam::argList::noParallel();
}

mergeGeoMesh()

void NEM::MSH::geoMeshBase::mergeGeoMesh ( geoMeshBase *  otherGeoMesh )

virtualinherited

Deletes the data from the new geoMesh pointer

Parameters

otherGeoMesh

A new geoMesh data to merge

Definition at line 113 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::New(), and NEM::MSH::geoMeshBase::resetNative().

                                                        {
  vtkSmartPointer<vtkAppendFilter> appendFilter =
      vtkSmartPointer<vtkAppendFilter>::New();
  appendFilter->AddInputData(_geoMesh.mesh);
  appendFilter->AddInputData(otherGeoMesh->_geoMesh.mesh);
  appendFilter->MergePointsOn();
  appendFilter->Update();
  _geoMesh.mesh = appendFilter->GetOutput();
  otherGeoMesh->_geoMesh = {
      vtkSmartPointer<vtkUnstructuredGrid>::New(), {}, {}, {}};
  otherGeoMesh->resetNative();
}

New()

static foamGeoMesh* NEM::MSH::foamGeoMesh::New ( )

static

Referenced by NEM::MSH::New(), and NEM::SRV::srvBase::RequestDataObject().

reconstructGeo()

void NEM::MSH::geoMeshBase::reconstructGeo ( )

virtualinherited

Sets geometry, link, and side set. Does not alter the mesh.

Reimplemented in NEM::MSH::exoGeoMesh, NEM::MSH::oshGeoMesh, and NEM::MSH::inpGeoMesh.

Definition at line 466 of file geoMeshBaseReconstructGeo.C.

References NEM::MSH::geoMeshBase::_angleThreshold, NEM::MSH::geoMeshBase::_geoMesh, NEM::MSH::geoMeshBase::GeoMesh::geo, NEM::MSH::geoMeshBase::GEO_ENT_DEFAULT_NAME, nemAux::getRandomString(), NEM::MSH::geoMeshBase::GeoMesh::link, NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::geoMeshBase::SideSet::sides, and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

Referenced by NEM::MSH::inpGeoMesh::reconstructGeo(), NEM::MSH::oshGeoMesh::reconstructGeo(), and NEM::MSH::exoGeoMesh::reconstructGeo().

                                 {
#ifdef HAVE_GMSH
  if (_geoMesh.geo.empty()) {
    _geoMesh.geo = "geoMesh_" + nemAux::getRandomString(6);
  } else {
    gmsh::model::setCurrent(_geoMesh.geo);
    gmsh::model::remove();
  }
  gmsh::model::add(_geoMesh.geo);
  gmsh::model::setCurrent(_geoMesh.geo);
#endif
  if (_geoMesh.link.empty()) {
    _geoMesh.link = GEO_ENT_DEFAULT_NAME;
  }
  _geoMesh.sideSet = SideSet{
      computeDiscreteGeoFromMsh(_geoMesh.mesh, _geoMesh.link, _angleThreshold)};
  assert(_geoMesh.mesh->GetPoints() == _geoMesh.sideSet.sides->GetPoints());
}

report()

void NEM::MSH::foamGeoMesh::report ( std::ostream &  out ) const

overridevirtual

Implements NEM::MSH::geoMeshBase.

Definition at line 642 of file foamGeoMesh.C.

References NEM::MSH::geoMeshBase::report().

{ geoMeshBase::report(out); }

resetNative()

void NEM::MSH::foamGeoMesh::resetNative ( )

overridevirtual

Implements NEM::MSH::geoMeshBase.

Definition at line 652 of file foamGeoMesh.C.

References controlDict_, fmesh_, fvSchemes_, fvSolution_, NEM::MSH::geoMeshBase::getGeoMesh(), GM2foam(), InitializeFoam(), and runTime_.

                              {
  // Clear
  controlDict_.reset();
  fvSchemes_.reset();
  fvSolution_.reset();
  runTime_.reset();
  fmesh_.reset();

  // Initialize required variables
  InitializeFoam();

  // Reset fvMesh
  fmesh_ = GM2foam(getGeoMesh(), runTime_.get());
}

setAngleThreshold()

void NEM::MSH::geoMeshBase::setAngleThreshold ( double  angleThreshold )

inlineinherited

Parameters

angleThreshold

(in radians)

Definition at line 176 of file geoMeshBase.H.

                                                {
    _angleThreshold = angleThreshold;
  }

setCellDataArray()

int NEM::MSH::geoMeshBase::setCellDataArray ( vtkAbstractArray *  array )

inlineprotectedinherited

Parameters

array

array pointer

Returns

array index

Definition at line 473 of file geoMeshBase.H.

                                                {
    return _geoMesh.mesh->GetCellData()->AddArray(array);
  }

setFieldDataArray()

int NEM::MSH::geoMeshBase::setFieldDataArray ( vtkAbstractArray *  array )

inlineprotectedinherited

Parameters

array

array pointer

Returns

array index

Definition at line 481 of file geoMeshBase.H.

                                                 {
    return _geoMesh.mesh->GetFieldData()->AddArray(array);
  }

setFoamMesh()

void NEM::MSH::foamGeoMesh::setFoamMesh

(

std::unique_ptr< Foam::fvMesh >

foamMesh

)

Parameters

foamMesh

existing fvMesh;

Definition at line 644 of file foamGeoMesh.C.

References fmesh_, foam2GM(), and NEM::MSH::geoMeshBase::setGeoMesh().

                                                                {
  // Setting class parameters
  fmesh_ = std::unique_ptr<Foam::fvMesh>(foamMesh.get());

  // Parent
  setGeoMesh(foam2GM(foamMesh.get()));
}

setGeoEntArrayName()

void NEM::MSH::geoMeshBase::setGeoEntArrayName ( const std::string &  geoEntArrayName )

inlineinherited

Parameters

geoEntArrayName

name of geometric entities array

Definition at line 162 of file geoMeshBase.H.

                                                            {
    auto a = _geoMesh.mesh->GetCellData()->GetArray(_geoMesh.link.c_str());
    if (a) a->SetName(geoEntArrayName.c_str());
    _geoMesh.link = geoEntArrayName;
  }

setGeoMesh()

void NEM::MSH::geoMeshBase::setGeoMesh ( const geoMeshBase::GeoMesh &  geoMesh )

inlineprotectedinherited

Parameters

geoMesh

a mesh and geometry

Definition at line 538 of file geoMeshBase.H.

References NEM::MSH::geoMeshBase::GeoMesh::mesh, NEM::MSH::geoMeshBase::SideSet::sides, and NEM::MSH::geoMeshBase::GeoMesh::sideSet.

Referenced by NEM::MSH::exoGeoMesh::addCellsToBlock(), NEM::MSH::exoGeoMesh::addElemBlock(), NEM::MSH::exoGeoMesh::addSideSet(), NEM::MSH::exoGeoMesh::reassignCells(), NEM::MSH::exoGeoMesh::reconstructGeo(), NEM::MSH::gmshGeoMesh::resetNative(), NEM::MSH::exoGeoMesh::resetNative(), NEM::MSH::exoGeoMesh::scaleNodes(), setFoamMesh(), NEM::MSH::oshGeoMesh::setOshMesh(), NEM::MSH::smeshGeoMesh::setSMeshMesh(), NEM::MSH::vtkGeoMesh::setVtkMesh(), NEM::MSH::exoGeoMesh::stitch(), NEM::MSH::oshGeoMesh::takeGeoMesh(), and NEM::MSH::exoGeoMesh::takeGeoMesh().

                                                     {
    assert(geoMesh.mesh->GetNumberOfCells() == 0 ||
           geoMesh.mesh->GetNumberOfPoints() == 0 ||
           geoMesh.sideSet.sides == nullptr ||
           geoMesh.sideSet.sides->GetPoints() == geoMesh.mesh->GetPoints());
    _geoMesh = geoMesh;
  }

setPointDataArray()

int NEM::MSH::geoMeshBase::setPointDataArray ( vtkAbstractArray *  array )

inlineprotectedinherited

Parameters

array

array pointer

Returns

array index

Definition at line 465 of file geoMeshBase.H.

                                                 {
    return _geoMesh.mesh->GetPointData()->AddArray(array);
  }

takeGeoMesh()

void NEM::MSH::geoMeshBase::takeGeoMesh ( geoMeshBase *  otherGeoMesh )

virtualinherited

Note that otherGeoMesh will be left with an empty mesh.

Parameters

otherGeoMesh

other geoMeshBase object; mesh will be left empty

Reimplemented in NEM::MSH::exoGeoMesh, and NEM::MSH::oshGeoMesh.

Definition at line 104 of file geoMeshBase.C.

References NEM::MSH::geoMeshBase::_geoMesh, NEM::MSH::New(), and NEM::MSH::geoMeshBase::resetNative().

Referenced by NEM::MSH::oshGeoMesh::takeGeoMesh(), and NEM::MSH::exoGeoMesh::takeGeoMesh().

                                                       {
  _geoMesh = std::move(otherGeoMesh->_geoMesh);
  otherGeoMesh->_geoMesh = {
      vtkSmartPointer<vtkUnstructuredGrid>::New(), {}, {}, {}};
  otherGeoMesh->resetNative();
  resetNative();
}

unsetCellDataArray() [1/2]

void NEM::MSH::geoMeshBase::unsetCellDataArray ( int  arrayIdx )

inlineprotectedinherited

Parameters

arrayIdx

array index

Definition at line 503 of file geoMeshBase.H.

                                        {
    _geoMesh.mesh->GetCellData()->RemoveArray(arrayIdx);
  }

unsetCellDataArray() [2/2]

void NEM::MSH::geoMeshBase::unsetCellDataArray ( const std::string &  arrayName )

inlineprotectedinherited

Parameters

arrayName

array name

Definition at line 510 of file geoMeshBase.H.

                                                      {
    _geoMesh.mesh->GetCellData()->RemoveArray(arrayName.c_str());
  }

unsetFieldDataArray() [1/2]

void NEM::MSH::geoMeshBase::unsetFieldDataArray ( int  arrayIdx )

inlineprotectedinherited

Parameters

arrayIdx

array index

Definition at line 517 of file geoMeshBase.H.

                                         {
    _geoMesh.mesh->GetFieldData()->RemoveArray(arrayIdx);
  }

unsetFieldDataArray() [2/2]

void NEM::MSH::geoMeshBase::unsetFieldDataArray ( const std::string &  arrayName )

inlineprotectedinherited

Parameters

arrayName

array name

Definition at line 524 of file geoMeshBase.H.

                                                       {
    _geoMesh.mesh->GetFieldData()->RemoveArray(arrayName.c_str());
  }

unsetPointDataArray() [1/2]

void NEM::MSH::geoMeshBase::unsetPointDataArray ( int  arrayIdx )

inlineprotectedinherited

Parameters

arrayIdx

array index

Definition at line 489 of file geoMeshBase.H.

                                         {
    _geoMesh.mesh->GetPointData()->RemoveArray(arrayIdx);
  }

unsetPointDataArray() [2/2]

void NEM::MSH::geoMeshBase::unsetPointDataArray ( const std::string &  arrayName )

inlineprotectedinherited

Parameters

arrayName

array name

Definition at line 496 of file geoMeshBase.H.

                                                       {
    _geoMesh.mesh->GetPointData()->RemoveArray(arrayName.c_str());
  }

write()

void NEM::MSH::foamGeoMesh::write ( const std::string &  fileName )

overridevirtual

Parameters

fileName

Directory path where foam mesh should be written

Implements NEM::MSH::geoMeshBase.

Definition at line 529 of file foamGeoMesh.C.

References controlDict_, fmesh_, fvSchemes_, and fvSolution_.

                                                 {
  // Create system directory
  Foam::word w = "system";
  if (!Foam::isDir(w)) Foam::mkDir(w);

  // Write ControlDict
  Foam::fileName fcontrolDict = "system/controlDict";
  if (!Foam::exists(fcontrolDict)) {
    Foam::OFstream outcontrolDict(fcontrolDict);
    Foam::IOobject::writeBanner(outcontrolDict);
    controlDict_->write(outcontrolDict, false);
  }

  // Write fvSchemes
  Foam::fileName ffvSchemes = "system/fvSchemes";
  if (!Foam::exists(ffvSchemes)) {
    Foam::OFstream outfvSchemes(ffvSchemes);
    Foam::IOobject::writeBanner(outfvSchemes);
    fvSchemes_->write(outfvSchemes, false);
  }

  // Write fvSolution
  Foam::fileName ffvSolution = "system/fvSolution";
  if (!Foam::exists(ffvSolution)) {
    Foam::OFstream outfvSolution(ffvSolution);
    Foam::IOobject::writeBanner(outfvSolution);
    fvSolution_->write(outfvSolution, false);
  }

  // Region to write in
  Foam::fileName newReg = "";
  if (fileName.empty())
    newReg = "";
  else
    newReg = fileName;

  // Write dictionaries to the specific region too
  if (!Foam::isDir("system/" + newReg)) Foam::mkDir("system/" + newReg);

  Foam::fileName fcontrolDict_2 = "system/" + newReg + "/controlDict";
  if (!Foam::exists(fcontrolDict_2)) { Foam::cp(fcontrolDict, fcontrolDict_2); }

  // Write fvSchemes
  Foam::fileName ffvSchemes_2 = "system/" + newReg + "/fvSchemes";
  if (!Foam::exists(ffvSchemes_2)) { Foam::cp(ffvSchemes, ffvSchemes_2); }

  // Write fvSolution
  Foam::fileName ffvSolution_2 = "system/" + newReg + "/fvSolution";
  if (!Foam::exists(ffvSolution_2)) { Foam::cp(ffvSolution, ffvSolution_2); }

  // Write mesh in fileName
  if (!Foam::isDir("0")) Foam::mkDir("0");

  // Write cellZones and cellSets
  const Foam::cellZoneMesh &czMesh = fmesh_->cellZones();
  Foam::label numZones = czMesh.size();

  fmesh_->setInstance("0");
  fmesh_->write();

  if (numZones > 0) {
    for (int i = 0; i < numZones; i++) {
      const Foam::cellZone &cz = czMesh[i];
      Foam::cellSet(*fmesh_, cz.name(), cz).write();
    }
  }

  Foam::fileName currentDir = "0";
  Foam::fileName currentReg = fmesh_->dbDir();
  Foam::fileName newDir = "constant";
  Foam::fileName finalMesh = "";

  if (currentReg.empty()) {
    if (!Foam::isDir(currentDir + "/" + newReg))
      Foam::mkDir(currentDir + "/" + newReg);
    if (!newReg.empty()) {
      Foam::mv(currentDir + "/polyMesh",
               currentDir + "/" + newReg + "/polyMesh");
      finalMesh = currentDir + "/" + newReg;
    } else {
      finalMesh = currentDir + "/polyMesh";
    }
  } else {
    if (!newReg.empty()) {
      Foam::mv(currentDir + "/" + currentReg, currentDir + "/" + newReg);
      finalMesh = currentDir + "/" + newReg;
    } else {
      Foam::mv(currentDir + "/" + currentReg, currentDir + "/");
      finalMesh = currentDir + "/polyMesh";
    }
  }

  if (!Foam::isDir(newDir + "/" + newReg)) {
    if (!newReg.empty()) {
      Foam::mkDir(newDir + "/" + newReg);
      Foam::mv(finalMesh, newDir + "/" + newReg);
    } else {
      Foam::mkDir(newDir + "/polyMesh");
      Foam::mv(finalMesh, newDir + "/polyMesh");
    }
  }

  if (!newReg.empty()) {
    if (!Foam::isDir(newDir + "/" + newReg)) {
      Foam::mkDir(newDir + "/" + newReg);
      Foam::mv(finalMesh, newDir + "/" + newReg);
    }
  } else {
    if (!Foam::isDir(newDir + "/polyMesh")) Foam::mkDir(newDir + "/polyMesh");
    Foam::mv(finalMesh, newDir + "/polyMesh");
  }
}

Member Data Documentation

controlDict_

std::unique_ptr<Foam::dictionary> NEM::MSH::foamGeoMesh::controlDict_

private

Definition at line 150 of file foamGeoMesh.H.

Referenced by InitializeFoam(), resetNative(), and write().

fmesh_

std::unique_ptr<Foam::fvMesh> NEM::MSH::foamGeoMesh::fmesh_

private

Definition at line 162 of file foamGeoMesh.H.

Referenced by resetNative(), setFoamMesh(), and write().

fvSchemes_

std::unique_ptr<Foam::dictionary> NEM::MSH::foamGeoMesh::fvSchemes_

private

Definition at line 153 of file foamGeoMesh.H.

Referenced by InitializeFoam(), resetNative(), and write().

fvSolution_

std::unique_ptr<Foam::dictionary> NEM::MSH::foamGeoMesh::fvSolution_

private

Definition at line 156 of file foamGeoMesh.H.

Referenced by InitializeFoam(), resetNative(), and write().

GEO_ENT_DEFAULT_NAME

constexpr auto NEM::MSH::geoMeshBase::GEO_ENT_DEFAULT_NAME = "GeoEnt"

staticprotectedinherited

Definition at line 446 of file geoMeshBase.H.

Referenced by NEM::MSH::gmshGeoMesh::gmsh2GM(), NEM::MSH::inpGeoMesh::inp2GM(), NEM::MSH::oshGeoMesh::osh2GM(), NEM::MSH::exoGeoMesh::reconstructGeo(), NEM::MSH::geoMeshBase::reconstructGeo(), and NEM::MSH::gmshGeoMesh::resetNative().

runTime_

std::unique_ptr<Foam::Time> NEM::MSH::foamGeoMesh::runTime_

private

Definition at line 159 of file foamGeoMesh.H.

Referenced by InitializeFoam(), and resetNative().

---

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

• foamGeoMesh.H
• foamGeoMesh.C