Detailed Description

Definition at line 44 of file ConservativeVolumeTransfer.H.

Public Member Functions
	ConservativeVolumeTransfer (meshBase _source, meshBase _target)

	~ConservativeVolumeTransfer () override

int	transferPointData (const std::vector< int > &arrayIDs, const std::vector< std::string > &newnames=std::vector< std::string >())
	Transfer point data with given ids from source to target. More...

int	transferPointData (int i, vtkSmartPointer< vtkGenericCell > genCell, std::vector< vtkSmartPointer< vtkDoubleArray >> &dasSource, std::vector< vtkSmartPointer< vtkDoubleArray >> &dasTarget, bool flip)

int	transferCellData (const std::vector< int > &arrayIDs, const std::vector< std::string > &newnames=std::vector< std::string >())
	Transfer cell data with given ids from source to target. More...

int	transferCellData (int i, vtkSmartPointer< vtkGenericCell > genCell, std::vector< vtkSmartPointer< vtkDoubleArray >> &dasSourceToPoint, std::vector< vtkSmartPointer< vtkDoubleArray >> &dasTarget)

int	run (const std::vector< std::string > &newnames=std::vector< std::string >()) override
	Transfer all fields. More...

int	initialize ()

int	transferSurfacePointData (const std::vector< int > &arrayIDs)

void	enableSurfaceTransfer ()
	Enable surface transfer. More...

void	disableSurfaceTransfer ()
	Disable surface transfer. More...

int	constructSupermesh ()
	Construct supermesh. More...

int	constructMassMatrix ()
	Construct mass matrix corresponding to target. More...

int	constructMixedMassMatrix ()
	Construct mixed mass matrix corresponding to the source and target. More...

int	constructLoadVector (int arrayId, int componentId)
	Construct load vector corresponding to a given array and component. More...

int	transfer (int arrayId)
	Transfer array given its id. More...

int	convertSupermeshToUnstructuredGrid ()
	Convertes supermesh to an unstructured grid. More...

vtkSmartPointer< vtkUnstructuredGrid >	getSourceGrid ()
	Get the source grid in the transfer. More...

vtkSmartPointer< vtkUnstructuredGrid >	getTargetGrid ()
	Get the target grid in the transfer. More...

vtkSmartPointer< vtkUnstructuredGrid >	getSupermeshGrid ()
	Get the supermesh grid in the transfer. More...

int	transferPointData (const std::vector< std::string > &arrayNames, const std::vector< std::string > &newnames=std::vector< std::string >())
	Transfer point data with given field names from source to target. More...

int	transferCellData (const std::vector< std::string > &arrayNames, const std::vector< std::string > &newnames=std::vector< std::string >())
	Transfer cell data with given field names from source to target. More...

void	setCheckQual (bool x)

void	setContBool (bool x)

Static Public Member Functions
static ConservativeVolumeTransfer *	Create (meshBase _source, meshBase _target)

static std::shared_ptr< ConservativeVolumeTransfer >	CreateShared (meshBase _source, meshBase _target)

Protected Attributes
meshBase *	source

meshBase *	target

vtkSmartPointer< vtkStaticCellLocator >	srcCellLocator = nullptr

vtkSmartPointer< vtkStaticCellLocator >	trgCellLocator = nullptr

vtkSmartPointer< vtkStaticPointLocator >	srcPointLocator = nullptr

vtkSmartPointer< vtkStaticPointLocator >	trgPointLocator = nullptr

bool	checkQual

bool	continuous

double	c2cTrnsDistTol

Private Member Functions
void	getLibSupermeshData (vtkDataSet data, long &nnodes, int &dim, long &nelements, int &loc, double &positions, long *&enlist, long &initTetId)

int	interpolateCellDataToPoints (int cellArrayId)

vtkSmartPointer< vtkPolyData >	extractSurface (vtkUnstructuredGrid *grid)

void	volumeCheck ()

Private Attributes
double	TET8 [32]

double	TET8W [8]

double	TET4 [16]

double	TET4W [4]

double	TET10 [40]

double	TET10W [10]

long	numSourceNodes

long	numTargetNodes

long	initSourceTetId

long	initTargetTetId

vtkSmartPointer< vtkUnstructuredGrid >	sourceGrid

vtkSmartPointer< vtkUnstructuredGrid >	targetGrid

vtkSmartPointer< vtkUnstructuredGrid >	supermeshGrid

vtkSmartPointer< vtkQuadratureSchemeDefinition >	quadrature

Eigen::SparseMatrix< double, Eigen::ColMajor, long >	massMatrix

Eigen::SparseMatrix< double, Eigen::ColMajor, long >	mixedMassMatrix

Eigen::VectorXd	loadVector

std::vector< std::vector< double > >	children_a

std::vector< std::vector< double > >	children_b

std::vector< std::vector< double > >	tets_c

std::vector< long >	parents_a

std::vector< long >	parents_b

bool	surfaceTransferEnabled = false

Inherits TransferBase.

Constructor & Destructor Documentation

◆ ConservativeVolumeTransfer()

ConservativeVolumeTransfer::ConservativeVolumeTransfer	(	meshBase *	_source,
		meshBase *	_target
	)

Definition at line 47 of file ConservativeVolumeTransfer.C.

References meshBase::getDataSet(), massMatrix, mixedMassMatrix, NEM::MSH::New(), numSourceNodes, numTargetNodes, quadrature, TransferBase::source, sourceGrid, TransferBase::target, targetGrid, TET4, and TET4W.

                                                                           {
   source = _source;
   target = _target;
 
   // Set grids, allocate vectors/matrices, quadrature scheme and construct
   // transfer objects
   sourceGrid = vtkUnstructuredGrid::SafeDownCast(source->getDataSet());
   targetGrid = vtkUnstructuredGrid::SafeDownCast(target->getDataSet());
 
   numSourceNodes = sourceGrid->GetNumberOfPoints();
   numTargetNodes = targetGrid->GetNumberOfPoints();
 
   massMatrix = Eigen::SparseMatrix<double, Eigen::ColMajor, long>(
       numTargetNodes, numTargetNodes);
   mixedMassMatrix = Eigen::SparseMatrix<double, Eigen::ColMajor, long>(
       numTargetNodes, numSourceNodes);
 
   // set quadrature scheme
   quadrature = vtkSmartPointer<vtkQuadratureSchemeDefinition>::New();
   quadrature->Initialize(VTK_TETRA, 4, 4, TET4, TET4W);
   // quadrature->Initialize(VTK_TETRA, 4, 8, TET8, TET8W);
 }

◆ ~ConservativeVolumeTransfer()

ConservativeVolumeTransfer::~ConservativeVolumeTransfer ( )

inlineoverride

Definition at line 49 of file ConservativeVolumeTransfer.H.

                                          {
     std::cout << "Conservative Volume Transfer destroyed" << std::endl;
   }

Member Function Documentation

◆ constructLoadVector()

int ConservativeVolumeTransfer::constructLoadVector	(	int	arrayId,
		int	componentId
	)

Definition at line 421 of file ConservativeVolumeTransfer.C.

References nemAux::Timer::elapsed(), loadVector, mixedMassMatrix, numSourceNodes, sourceGrid, nemAux::Timer::start(), and nemAux::Timer::stop().

Referenced by transfer().

                                                                      {
   nemAux::Timer timer;
 
   std::cout << "Constructing load vector ..." << std::endl;
   timer.start();
 
   vtkSmartPointer<vtkDoubleArray> sourceArray = vtkDoubleArray::SafeDownCast(
       sourceGrid->GetPointData()->GetArray(arrayId));
 
   // allocate and populate source values vector
   Eigen::VectorXd sourceValuesVector = Eigen::VectorXd(numSourceNodes);
   auto sourcePointValues = vtkDoubleArray::SafeDownCast(
       sourceGrid->GetPointData()->GetArray(arrayId));
   for (int i = 0; i < numSourceNodes; ++i) {
     sourceValuesVector(i) = sourcePointValues->GetComponent(i, componentId);
   }
 
   loadVector = mixedMassMatrix * sourceValuesVector;
   timer.stop();
 
   std::cout << "Load vector constructed in " << timer.elapsed()
             << " milliseconds." << std::endl;
 
   return 0;
 }

◆ constructMassMatrix()

int ConservativeVolumeTransfer::constructMassMatrix ( )

Definition at line 280 of file ConservativeVolumeTransfer.C.

References nemAux::Timer::elapsed(), initTargetTetId, massMatrix, quadrature, nemAux::Timer::start(), nemAux::Timer::stop(), and targetGrid.

Referenced by initialize(), and run().

                                                     {
   nemAux::Timer timer;
   std::cout << "Constructing mass matrix..." << std::endl;
   timer.start();
 
   const double *weights = quadrature->GetQuadratureWeights();
 
   using Tripletd = Eigen::Triplet<double>;
   std::vector<Tripletd> tripletList;
 
   // TODO start from initTargetTetId
   for (long cellId = initTargetTetId; cellId < targetGrid->GetNumberOfCells();
        ++cellId) {
     if (targetGrid->GetCellType(cellId) != VTK_TETRA)
       continue;
     vtkTetra *tet = vtkTetra::SafeDownCast(targetGrid->GetCell(cellId));
 
     double detJ = vtkMeshQuality::TetVolume(tet);
 
     for (int qi = 0; qi < quadrature->GetNumberOfQuadraturePoints(); ++qi) {
       const double *psi = quadrature->GetShapeFunctionWeights(qi);
       double wi = weights[qi];
 
       for (int r = 0; r < 4; ++r) {
         for (int s = 0; s < 4; ++s) {
           // TODO check that point ids are zero indexed
           long rGlob = tet->GetPointId(r);
           long sGlob = tet->GetPointId(s);
           tripletList.push_back(
               Tripletd(rGlob, sGlob, wi * psi[r] * psi[s] * detJ));
         }
       }
     }
   }
 
   massMatrix.setFromTriplets(tripletList.begin(), tripletList.end());
 
   timer.stop();
   std::cout << "Mass matrix constructed in " << timer.elapsed()
             << " milliseconds." << std::endl;
 
   return 0;
 }

◆ constructMixedMassMatrix()

int ConservativeVolumeTransfer::constructMixedMassMatrix ( )

Requires a constructed supermesh.

Definition at line 324 of file ConservativeVolumeTransfer.C.

References nemAux::Timer::elapsed(), initSourceTetId, initTargetTetId, mixedMassMatrix, parents_a, parents_b, quadrature, sourceGrid, nemAux::Timer::start(), nemAux::Timer::stop(), targetGrid, and tets_c.

Referenced by initialize(), and run().

                                                          {
   nemAux::Timer timer;
   timer.start();
   std::cout << "Constructing mixed mass matrix ..." << std::endl;
 
   const double *weights = quadrature->GetQuadratureWeights();
 
   using Tripletd = Eigen::Triplet<double>;
   std::vector<Tripletd> tripletList(tets_c.size());
 
   for (long subCellIdx = 0; subCellIdx < tets_c.size(); ++subCellIdx) {
     std::vector<double> childTet = tets_c[subCellIdx];
 
     long sourceCellId = parents_a[subCellIdx];
     long targetCellId = parents_b[subCellIdx];
 
     // TODO check indexing for initSource/initTargetTetIds
     vtkTetra *sourceParentTet = vtkTetra::SafeDownCast(
         sourceGrid->GetCell(initSourceTetId + sourceCellId));
     vtkTetra *targetParentTet = vtkTetra::SafeDownCast(
         targetGrid->GetCell(initTargetTetId + targetCellId));
 
     double childVertices[4][3];
     for (int i = 0; i < 4; ++i) {
       int offs = i * 3;
       childVertices[i][0] = childTet[offs];
       childVertices[i][1] = childTet[offs + 1];
       childVertices[i][2] = childTet[offs + 2];
     }
 
     double sourceParentVertices[4][3];
     double targetParentVertices[4][3];
     for (int i = 0; i < 4; ++i) {
       double x[3];
 
       sourceParentTet->GetPoints()->GetPoint(i, x);
       for (int j = 0; j < 3; ++j)
         sourceParentVertices[i][j] = x[j];
 
       targetParentTet->GetPoints()->GetPoint(i, x);
       for (int j = 0; j < 3; ++j)
         targetParentVertices[i][j] = x[j];
     }
 
     // TODO check vol = detJ
     double detJ;
     libsupermesh_tetrahedron_volume(&childTet[0], &detJ);
     // if(detJ < 1e-20) continue;
 
     for (int qi = 0; qi < quadrature->GetNumberOfQuadraturePoints(); ++qi) {
       const double *psi = quadrature->GetShapeFunctionWeights(qi);
       double wi = weights[qi];
 
       double x[3] = {0., 0., 0.};
 
       // get geometric coordinate
       // TODO make sure x is contained in subtet
       for (int i = 0; i < 4; ++i) {
         for (int j = 0; j < 3; ++j)
           x[j] += psi[i] * childVertices[i][j];
       }
 
       // TODO check source/target psis are positive and sum to 1
       // source shape function val
       double srcPsi[4] = {};
       vtkTetra::BarycentricCoords(
           x, sourceParentVertices[0], sourceParentVertices[1],
           sourceParentVertices[2], sourceParentVertices[3], srcPsi);
 
       // target shape function val
       double tgtPsi[4] = {};
       vtkTetra::BarycentricCoords(
           x, targetParentVertices[0], targetParentVertices[1],
           targetParentVertices[2], targetParentVertices[3], tgtPsi);
 
       for (int r = 0; r < 4; ++r) {
         for (int s = 0; s < 4; ++s) {
           // TODO check that point ids are zero indexed
           long rGlobal = targetParentTet->GetPointId(r);
           long sGlobal = sourceParentTet->GetPointId(s);
           tripletList.push_back(
               Tripletd(rGlobal, sGlobal, wi * tgtPsi[r] * srcPsi[s] * detJ));
         }
       }
     }
   }
 
   mixedMassMatrix.setFromTriplets(tripletList.begin(), tripletList.end());
 
   timer.stop();
 
   std::cout << "Mixed mass matrix constructed in " << timer.elapsed()
             << " milliseconds." << std::endl;
 
   return 0;
 }

◆ constructSupermesh()

int ConservativeVolumeTransfer::constructSupermesh ( )

Definition at line 131 of file ConservativeVolumeTransfer.C.

References nemAux::Timer::elapsed(), meshBase::getDataSet(), getLibSupermeshData(), initSourceTetId, initTargetTetId, parents_a, parents_b, TransferBase::source, nemAux::Timer::start(), nemAux::Timer::stop(), TransferBase::target, and tets_c.

Referenced by initialize(), and run().

                                                    {
   nemAux::Timer supermeshTimer;
   std::cout << "Constructing supermesh..." << std::endl;
   supermeshTimer.start();
 
   /*
    * A - source
    * B - target
    */
 
   long nnodes_a;
   int dim_a;
   long nelements_a;
   int loc_a;
   double *positions_a;
   long *enlist_a;
 
   nemAux::Timer sourceConversionTimer;
   sourceConversionTimer.start();
 
   getLibSupermeshData(source->getDataSet(), nnodes_a, dim_a, nelements_a, loc_a,
                       positions_a, enlist_a, initSourceTetId);
 
   sourceConversionTimer.stop();
   std::cout << "source converted to libsupermesh format in "
             << sourceConversionTimer.elapsed() << " milliseconds." << std::endl;
 
   long nnodes_b;
   int dim_b;
   long nelements_b;
   int loc_b;
   double *positions_b;
   long *enlist_b;
 
   nemAux::Timer targetConversionTimer;
   targetConversionTimer.start();
 
   getLibSupermeshData(target->getDataSet(), nnodes_b, dim_b, nelements_b, loc_b,
                       positions_b, enlist_b, initTargetTetId);
 
   targetConversionTimer.stop();
   std::cout << "target converted to libsupermesh format in "
             << targetConversionTimer.elapsed() << " milliseconds." << std::endl;
 
   // volumeCheck();
 
   nemAux::Timer intersectionSearchTimer;
   intersectionSearchTimer.start();
 
   libsupermesh_tree_intersection_finder_set_input(
       &nnodes_a, &dim_a, &nelements_a, &loc_a, &nnodes_b, &dim_b, &nelements_b,
       &loc_b, positions_a, enlist_a, positions_b, enlist_b);
 
   intersectionSearchTimer.stop();
   std::cout << "intersection search completed in "
             << intersectionSearchTimer.elapsed() << std::endl;
 
   nemAux::Timer intersectionCalcTimer;
   intersectionCalcTimer.start();
 
   long nindices;
   libsupermesh_tree_intersection_finder_query_output(&nindices);
 
   long nelements = nelements_a;
   long *indices = new long[nindices];
   long *ind_ptr = new long[nelements_a + 1];
   libsupermesh_tree_intersection_finder_get_output(&nelements, &nindices,
                                                    indices, ind_ptr);
 
   auto getTet = [](long i, long *enlist, double *positions) -> double * {
     double *tet = new double[3 * 4];
     for (int j = 0; j < 4; ++j) {
       // i*4 + j : index of node j in tet i
       // multiply this by 3 to account for offset in positions array
       long ptIndex = enlist[i * 4 + j] * 3;
       double pt[3] = {positions[ptIndex], positions[ptIndex + 1],
                       positions[ptIndex + 2]};
       int offset = j * 3;
       tet[offset] = pt[0];
       tet[offset + 1] = pt[1];
       tet[offset + 2] = pt[2];
     }
     return tet;
   };
 
   double *tets_c_buf = new double[1000];
 
   auto pushData = [this](std::vector<double> tet_c, long parent_a,
                          long parent_b) {
     this->tets_c.push_back(tet_c);
     this->parents_a.push_back(parent_a);
     this->parents_b.push_back(parent_b);
   };
 
   for (long ai = 0; ai < nelements_a; ++ai) // cells in A
   {
     double *tet_a = getTet(ai, enlist_a, positions_a);
 
     for (long bptr = ind_ptr[ai]; bptr < ind_ptr[ai + 1];
          ++bptr) // indices of intersection candidates in B
     {
       long bj = indices[bptr]; // get index in b
       double *tet_b = getTet(bj, enlist_b, positions_b);
 
       int n_tets_c;
       // TODO if n_tets_c > buffer size -> reallocate
       libsupermesh_intersect_tets_real(tet_a, tet_b, tets_c_buf, &n_tets_c);
       if (!n_tets_c)
         continue;
 
       for (int ck = 0; ck < n_tets_c; ++ck) {
         int offs = ck * 12;
 
         std::vector<double> tet_c;
         tet_c.insert(tet_c.end(), &tets_c_buf[offs], &tets_c_buf[offs + 12]);
 
         // push tet and its parent indices in A and B (source and target)
         pushData(tet_c, ai, bj);
       }
     }
   }
 
   intersectionCalcTimer.stop();
   std::cout << "intersection calculation completed in "
             << intersectionCalcTimer.elapsed() << " milliseconds." << std::endl;
 
   double totalVol = 0.;
   for (auto tet : tets_c) {
     double vol;
     libsupermesh_tetrahedron_volume(&tet[0], &vol);
     if (vol < 0)
       std::cout << "NEGATIVE VOL" << std::endl;
     totalVol += vol;
   }
   std::cout << std::setprecision(15) << "supermesh volume : " << totalVol
             << std::endl;
   std::cout << "number of elems  : " << tets_c.size() << std::endl;
 
   // free
   delete[] indices;
   delete[] ind_ptr;
   delete[] tets_c_buf;
 
   supermeshTimer.stop();
   std::cout << "Supermesh constructed in " << supermeshTimer.elapsed()
             << " milliseconds." << std::endl;
   return 0;
 }

◆ convertSupermeshToUnstructuredGrid()

int ConservativeVolumeTransfer::convertSupermeshToUnstructuredGrid ( )

See also: getSupermeshGrid

Definition at line 578 of file ConservativeVolumeTransfer.C.

References NEM::MSH::New(), sourceGrid, supermeshGrid, and tets_c.

                                                                    {
   supermeshGrid = vtkSmartPointer<vtkUnstructuredGrid>::New();
 
   auto mergePoints = vtkSmartPointer<vtkMergePoints>::New();
   auto supermeshGridPoints = vtkSmartPointer<vtkPoints>::New();
   double bounds[6];
   sourceGrid->GetBounds(bounds);
 
   mergePoints->InitPointInsertion(supermeshGridPoints, bounds, tets_c.size());
 
   // insert points
   for (auto tet : tets_c) {
     for (int ptIdx = 0; ptIdx < 4; ++ptIdx) {
       int offs = ptIdx * 3;
 
       double x[3] = {tet[offs], tet[offs + 1], tet[offs + 2]};
       vtkIdType ptId;
       int inserted = mergePoints->InsertUniquePoint(x, ptId);
     }
   }
 
   supermeshGrid->SetPoints(supermeshGridPoints);
 
   auto tetArray = vtkSmartPointer<vtkCellArray>::New();
   // add tets
   for (auto tet : tets_c) {
     auto tetra = vtkSmartPointer<vtkTetra>::New();
 
     Eigen::Vector3d faceVertices[3];
     Eigen::Vector3d topVertex;
 
     vtkIdType ptIds[4];
 
     // get points of face and "top" vertex
     for (int ptIdx = 0; ptIdx < 4; ++ptIdx) {
       int offs = ptIdx * 3;
 
       double x[3] = {tet[offs], tet[offs + 1], tet[offs + 2]};
 
       if (ptIdx < 3)
         faceVertices[ptIdx] = Eigen::Vector3d(x[0], x[1], x[2]);
       else
         topVertex = Eigen::Vector3d(x[0], x[1], x[2]);
 
       ptIds[ptIdx] = mergePoints->IsInsertedPoint(x);
 
       if (ptIds[ptIdx] < 0)
         std::cout << "INVALID POINT" << std::endl;
     }
 
     Eigen::Vector3d cross = (faceVertices[2] - faceVertices[0])
                                 .cross(faceVertices[1] - faceVertices[0]);
     cross = cross / cross.norm();
 
     Eigen::Vector3d topDirection = topVertex - faceVertices[0];
     topDirection = topDirection / topDirection.norm();
 
     // if negative, reverse first 3 point ids
     if (cross.dot(topDirection) > 0)
       std::swap(ptIds[0], ptIds[2]);
 
     tetra->GetPointIds()->SetId(0, ptIds[0]);
     tetra->GetPointIds()->SetId(1, ptIds[1]);
     tetra->GetPointIds()->SetId(2, ptIds[2]);
     tetra->GetPointIds()->SetId(3, ptIds[3]);
 
     // take first 3 - orient so that corresponding normal points to 4th
     tetArray->InsertNextCell(tetra);
   }
 
   supermeshGrid->SetCells(VTK_TETRA, tetArray);
 
   std::cout << "Converted grid has : " << supermeshGrid->GetNumberOfCells()
             << " cells." << std::endl;
 
   if (supermeshGrid->GetNumberOfCells() != tets_c.size()) {
     std::cout << "Reference grid has " << tets_c.size() << " cells."
               << std::endl;
   }
 
   return 0;
 }

◆ Create()

static ConservativeVolumeTransfer* ConservativeVolumeTransfer::Create	(	meshBase *	_source,
		meshBase *	_target
	)

inlinestatic

Definition at line 54 of file ConservativeVolumeTransfer.H.

Referenced by CreateShared().

                                                                {
     return new ConservativeVolumeTransfer(_source, _target);
   }

◆ CreateShared()

static std::shared_ptr<ConservativeVolumeTransfer> ConservativeVolumeTransfer::CreateShared	(	meshBase *	_source,
		meshBase *	_target
	)

inlinestatic

Definition at line 60 of file ConservativeVolumeTransfer.H.

References Create(), and TransferBase::transferPointData().

Referenced by NEM::DRV::TransferDriver::CreateTransferObject().

                                                      {
     return std::shared_ptr<ConservativeVolumeTransfer>(
         ConservativeVolumeTransfer::Create(_source, _target));
   }

◆ disableSurfaceTransfer()

void ConservativeVolumeTransfer::disableSurfaceTransfer ( )

inline

Definition at line 108 of file ConservativeVolumeTransfer.H.

108 { surfaceTransferEnabled = false; }

ConservativeVolumeTransfer::surfaceTransferEnabled

bool surfaceTransferEnabled

Definition: ConservativeVolumeTransfer.H:246

◆ enableSurfaceTransfer()

void ConservativeVolumeTransfer::enableSurfaceTransfer ( )

inline

This is necessary for meshes with a shared boundary.

Definition at line 103 of file ConservativeVolumeTransfer.H.

103 { surfaceTransferEnabled = true; }

ConservativeVolumeTransfer::surfaceTransferEnabled

bool surfaceTransferEnabled

Definition: ConservativeVolumeTransfer.H:246

◆ extractSurface()

vtkSmartPointer< vtkPolyData > ConservativeVolumeTransfer::extractSurface ( vtkUnstructuredGrid * grid )

private

Definition at line 677 of file ConservativeVolumeTransfer.C.

References NEM::MSH::New().

                                                                     {
   // extract surface
   auto surfaceFilter = vtkSmartPointer<vtkDataSetSurfaceFilter>::New();
   surfaceFilter->SetPassThroughPointIds(true);
   surfaceFilter->SetOriginalPointIdsName("original_point_ids");
 
   surfaceFilter->SetInputData(grid);
   surfaceFilter->Update();
 
   vtkPolyData *surface = surfaceFilter->GetOutput();
 
   // polydata appears to be freed once dataset filter is freed, make deep copy
   auto surfaceCopy = vtkSmartPointer<vtkPolyData>::New();
   surfaceCopy->DeepCopy(surface);
 
   return surfaceCopy;
 }

◆ getLibSupermeshData()

void ConservativeVolumeTransfer::getLibSupermeshData	(	vtkDataSet *	data,
		long &	nnodes,
		int &	dim,
		long &	nelements,
		int &	loc,
		double *&	positions,
		long *&	enlist,
		long &	initTetId
	)

private

Definition at line 530 of file ConservativeVolumeTransfer.C.

Referenced by constructSupermesh().

                                                         {
   initTetId = 0;
   for (int cellId = 0; cellId < data->GetNumberOfCells(); ++cellId) {
     if (data->GetCellType(cellId) == VTK_TETRA) {
       initTetId = cellId;
       break;
     }
   }
 
   long numNodes = data->GetNumberOfPoints();
   // assume remaining cells are tets
   long numTets = data->GetNumberOfCells() - initTetId;
 
   nnodes = numNodes;
   dim = 3;
   nelements = numTets;
   loc = 4;
 
   // coordinates of nodes
   positions = new double[dim * nnodes];
   // element-node graph
   enlist = new long[loc * nelements];
 
   // get coordinates
   for (int ptIdx = 0; ptIdx < numNodes; ++ptIdx) {
     double pt[3];
     data->GetPoint(ptIdx, pt);
 
     int offset = ptIdx * 3;
     positions[offset] = pt[0];
     positions[offset + 1] = pt[1];
     positions[offset + 2] = pt[2];
   }
 
   // get element-node graph
   for (int cellId = initTetId; cellId < data->GetNumberOfCells(); ++cellId) {
     vtkCell *tet = data->GetCell(cellId);
 
     int offset = (cellId - initTetId) * 4;
     enlist[offset] = tet->GetPointId(0);
     enlist[offset + 1] = tet->GetPointId(1);
     enlist[offset + 2] = tet->GetPointId(2);
     enlist[offset + 3] = tet->GetPointId(3);
   }
 }

◆ getSourceGrid()

vtkSmartPointer<vtkUnstructuredGrid> ConservativeVolumeTransfer::getSourceGrid ( )

inline

Definition at line 141 of file ConservativeVolumeTransfer.H.

141 { return sourceGrid; }

ConservativeVolumeTransfer::sourceGrid

vtkSmartPointer< vtkUnstructuredGrid > sourceGrid

Definition: ConservativeVolumeTransfer.H:216

◆ getSupermeshGrid()

vtkSmartPointer<vtkUnstructuredGrid> ConservativeVolumeTransfer::getSupermeshGrid ( )

inline

Call convertSupermeshToUnstructuredGrid before this query.

Definition at line 151 of file ConservativeVolumeTransfer.H.

                                                           {
     return supermeshGrid;
   }

◆ getTargetGrid()

vtkSmartPointer<vtkUnstructuredGrid> ConservativeVolumeTransfer::getTargetGrid ( )

inline

Definition at line 145 of file ConservativeVolumeTransfer.H.

145 { return targetGrid; }

ConservativeVolumeTransfer::targetGrid

vtkSmartPointer< vtkUnstructuredGrid > targetGrid

Definition: ConservativeVolumeTransfer.H:217

◆ initialize()

int ConservativeVolumeTransfer::initialize ( )

Definition at line 94 of file ConservativeVolumeTransfer.C.

References constructMassMatrix(), constructMixedMassMatrix(), and constructSupermesh().

                                            {
   constructSupermesh();
   constructMassMatrix();
   constructMixedMassMatrix();
 }

◆ interpolateCellDataToPoints()

int ConservativeVolumeTransfer::interpolateCellDataToPoints ( int cellArrayId )

private

Definition at line 488 of file ConservativeVolumeTransfer.C.

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

                                                                            {
   vtkSmartPointer<vtkDataArray> sourceCellValues =
       sourceGrid->GetCellData()->GetArray(cellArrayId);
 
   auto sourcePointValues = vtkSmartPointer<vtkDoubleArray>::New();
   sourcePointValues->SetName(sourceCellValues->GetName());
   sourcePointValues->SetNumberOfComponents(
       sourceCellValues->GetNumberOfComponents());
 
   for (int pointId = 0; pointId < sourceGrid->GetNumberOfPoints(); ++pointId) {
     auto incidentCellIds = vtkSmartPointer<vtkIdList>::New();
     sourceGrid->GetPointCells(pointId, incidentCellIds);
 
     double *tuple = new double[sourceCellValues->GetNumberOfComponents()]();
 
     double volSum = 0.;
 
     // get contribution from each incident cell
     for (int i = 0; i < incidentCellIds->GetNumberOfIds(); ++i) {
       int cellId = incidentCellIds->GetId(i);
       vtkTetra *tet = vtkTetra::SafeDownCast(sourceGrid->GetCell(cellId));
 
       double vol = vtkMeshQuality::TetVolume(tet);
       volSum += vol;
       // ... at each component
       for (int compIdx = 0; compIdx < sourceCellValues->GetNumberOfComponents();
            ++compIdx) {
         tuple[compIdx] += vol * sourceCellValues->GetComponent(cellId, compIdx);
       }
     }
     double volAvg = volSum / incidentCellIds->GetNumberOfIds();
 
     // divide by volume average
     for (int compIdx = 0; compIdx < sourceCellValues->GetNumberOfComponents();
          ++compIdx) {
       tuple[compIdx] = tuple[compIdx] / volAvg;
     }
   }
 
   return 0;
 }

◆ run()

int ConservativeVolumeTransfer::run ( const std::vector< std::string > & newnames = std::vector< std::string >() )

overridevirtual

Parameters

newnames optional array of names to be applied to transferred fields

Returns: 0 upon completion

Implements TransferBase.

Definition at line 71 of file ConservativeVolumeTransfer.C.

References constructMassMatrix(), constructMixedMassMatrix(), constructSupermesh(), sourceGrid, and transfer().

                                                                         {
   constructSupermesh();
   constructMassMatrix();
   constructMixedMassMatrix();
 
   // transfer all point data
   vtkSmartPointer<vtkPointData> sourcePointData = sourceGrid->GetPointData();
   for (int arrayIdx = 0; arrayIdx < sourcePointData->GetNumberOfArrays();
        ++arrayIdx) {
     transfer(arrayIdx);
   }
 
   /*
   vtkSmartPointer<vtkCellData> sourceCellData = sourceGrid->GetCellData();
   for(int arrayIdx = 0; arrayIdx < sourceCellData->GetNumberOfArrays();
   ++arrayIdx)
   {
     // TODO implement transferCellData
   }
   */
   return 0;
 }

◆ setCheckQual()

void TransferBase::setCheckQual ( bool x )

inlineinherited

Definition at line 100 of file TransferBase.H.

100 { checkQual = x; }

TransferBase::checkQual

bool checkQual

Definition: TransferBase.H:114

◆ setContBool()

void TransferBase::setContBool ( bool x )

inlineinherited

Definition at line 102 of file TransferBase.H.

102 { continuous = x; }

TransferBase::continuous

bool continuous

Definition: TransferBase.H:115

◆ transfer()

int ConservativeVolumeTransfer::transfer ( int arrayId )

Definition at line 448 of file ConservativeVolumeTransfer.C.

References constructLoadVector(), nemAux::Timer::elapsed(), loadVector, massMatrix, NEM::MSH::New(), numTargetNodes, sourceGrid, nemAux::Timer::start(), nemAux::Timer::stop(), and targetGrid.

Referenced by run(), and transferPointData().

                                                     {
   nemAux::Timer timer;
   timer.start();
   std::cout << "Transferring ..." << std::endl;
 
   vtkSmartPointer<vtkDataArray> sourceArray =
       sourceGrid->GetPointData()->GetArray(arrayId);
 
   auto targetPointValues = vtkSmartPointer<vtkDoubleArray>::New();
   targetPointValues->SetName(sourceArray->GetName());
   targetPointValues->SetNumberOfComponents(
       sourceArray->GetNumberOfComponents());
 
   Eigen::SparseLU<Eigen::SparseMatrix<double, Eigen::ColMajor>,
                   Eigen::COLAMDOrdering<int>>
       solver;
   solver.analyzePattern(massMatrix);
   solver.factorize(massMatrix);
 
   for (int componentId = 0; componentId < sourceArray->GetNumberOfComponents();
        ++componentId) {
     constructLoadVector(arrayId, componentId);
 
     Eigen::VectorXd targetValuesVector = solver.solve(loadVector);
 
     for (int targetNodeId = 0; targetNodeId < numTargetNodes; ++targetNodeId) {
       targetPointValues->InsertComponent(targetNodeId, componentId,
                                          targetValuesVector(targetNodeId));
     }
   }
 
   targetGrid->GetPointData()->AddArray(targetPointValues);
 
   timer.stop();
   std::cout << "Transfer completed in " << timer.elapsed() << " milliseconds."
             << std::endl;
 
   return 0;
 }

◆ transferCellData() [1/3]

int ConservativeVolumeTransfer::transferCellData	(	const std::vector< int > &	arrayIDs,
		const std::vector< std::string > &	newnames = `std::vector< std::string >()`
	)

inlinevirtual

Parameters

arrayIDs	array of array ids to specify which fields to transfer
newnames	optional array of names to be applied to transferred fields

Returns: 0 upon completion

Implements TransferBase.

Definition at line 78 of file ConservativeVolumeTransfer.H.

                                                                      {
     return 0;
   }

◆ transferCellData() [2/3]

int ConservativeVolumeTransfer::transferCellData	(	int	i,
		vtkSmartPointer< vtkGenericCell >	genCell,
		std::vector< vtkSmartPointer< vtkDoubleArray >> &	dasSourceToPoint,
		std::vector< vtkSmartPointer< vtkDoubleArray >> &	dasTarget
	)

inline

Definition at line 84 of file ConservativeVolumeTransfer.H.

References TransferBase::run().

                                                              {
     return 0;
   }

◆ transferCellData() [3/3]

int TransferBase::transferCellData	(	const std::vector< std::string > &	arrayNames,
		const std::vector< std::string > &	newnames = `std::vector<std::string>()`
	)

inherited

Parameters

arrayIDs	array of array names to specify which fields to transfer
newnames	optional array of names to be applied to transferred fields

Returns: 0 upon completion

Definition at line 47 of file TransferBase.C.

References TransferBase::getArrayIDs(), meshBase::getDataSet(), TransferBase::source, and TransferBase::transferCellData().

 {
   vtkCellData* cellData = source->getDataSet()->GetCellData();
   std::vector<int> arrayIDs = getArrayIDs(arrayNames, cellData);
 
   return transferCellData(arrayIDs, newnames);
 }

◆ transferPointData() [1/3]

int ConservativeVolumeTransfer::transferPointData	(	const std::vector< int > &	arrayIDs,
		const std::vector< std::string > &	newnames = `std::vector< std::string >()`
	)

virtual

Parameters

arrayIDs	array of array ids to specify which fields to transfer
newnames	optional array of names to be applied to transferred fields

Returns: 0 upon completion

Implements TransferBase.

Definition at line 100 of file ConservativeVolumeTransfer.C.

References transfer().

                                           {
   /*
   if(surfaceTransferEnabled)
   {
     // extract source surface
     vtkSmartPointer<vtkPolyData> sourceSurface = extractSurface(sourceGrid);
     vtkSmartPointer<vtkPolyData> targetSurface = extractSurface(targetGrid);
 
     vtkMesh* sourceMesh = new vtkMesh(sourceSurface, "sourceSurface.vtp");
     vtkMesh* targetMesh = new vtkMesh(targetSurface, "targetSurface.vtp");
 
     sourceMesh->write("source_surface_test.vtp");
     targetMesh->write("target_surface_test.vtp");
 
     ConservativeSurfaceTransfer* surfaceTransfer = new
   ConservativeSurfaceTransfer(sourceMesh, targetMesh);
 
     surfaceTransfer->transferPointData(arrayIDs);
 
     targetMesh->write("target_surface_test.vtp");
   }
   */
 
   for (const int &arrayId : arrayIDs) {
     transfer(arrayId);
   }
   return 0;
 }

◆ transferPointData() [2/3]

int ConservativeVolumeTransfer::transferPointData	(	int	i,
		vtkSmartPointer< vtkGenericCell >	genCell,
		std::vector< vtkSmartPointer< vtkDoubleArray >> &	dasSource,
		std::vector< vtkSmartPointer< vtkDoubleArray >> &	dasTarget,
		bool	flip
	)

inline

Definition at line 70 of file ConservativeVolumeTransfer.H.

                                    {
     return 0;
   }

◆ transferPointData() [3/3]

int TransferBase::transferPointData	(	const std::vector< std::string > &	arrayNames,
		const std::vector< std::string > &	newnames = `std::vector<std::string>()`
	)

inherited

Parameters

arrayIDs	array of array names to specify which fields to transfer
newnames	optional array of names to be applied to transferred fields

Returns: 0 upon completion

Definition at line 36 of file TransferBase.C.

References TransferBase::getArrayIDs(), meshBase::getDataSet(), TransferBase::source, and TransferBase::transferPointData().

 {
   vtkPointData* pointData = source->getDataSet()->GetPointData();
   std::vector<int> arrayIDs = getArrayIDs(arrayNames, pointData);
 
   return transferPointData(arrayIDs, newnames);
 }

◆ transferSurfacePointData()

int ConservativeVolumeTransfer::transferSurfacePointData ( const std::vector< int > & arrayIDs )

◆ volumeCheck()

void ConservativeVolumeTransfer::volumeCheck ( )

private

Definition at line 661 of file ConservativeVolumeTransfer.C.

References initSourceTetId, initTargetTetId, sourceGrid, and targetGrid.

                                              {
   for (int i = initSourceTetId; i < sourceGrid->GetNumberOfCells(); ++i) {
     vtkTetra *tet = vtkTetra::SafeDownCast(sourceGrid->GetCell(i));
     if (vtkMeshQuality::TetVolume(tet) < 0.) {
       std::cout << "source cell " << i << " has negative volume" << std::endl;
     }
   }
   for (int i = initTargetTetId; i < targetGrid->GetNumberOfCells(); ++i) {
     vtkTetra *tet = vtkTetra::SafeDownCast(targetGrid->GetCell(i));
     if (vtkMeshQuality::TetVolume(tet) < 0.) {
       std::cout << "target cell " << i << " has negative volume" << std::endl;
     }
   }
 }

Member Data Documentation

◆ c2cTrnsDistTol

double TransferBase::c2cTrnsDistTol

protectedinherited

Definition at line 116 of file TransferBase.H.

Referenced by FETransfer::transferCellData().

◆ checkQual

bool TransferBase::checkQual

protectedinherited

Definition at line 114 of file TransferBase.H.

Referenced by FETransfer::transferPointData().

◆ children_a

std::vector<std::vector<double> > ConservativeVolumeTransfer::children_a

private

Definition at line 227 of file ConservativeVolumeTransfer.H.

◆ children_b

std::vector<std::vector<double> > ConservativeVolumeTransfer::children_b

private

Definition at line 228 of file ConservativeVolumeTransfer.H.

◆ continuous

bool TransferBase::continuous

protectedinherited

Definition at line 115 of file TransferBase.H.

Referenced by FETransfer::transferCellData().

◆ initSourceTetId

long ConservativeVolumeTransfer::initSourceTetId

private

Definition at line 213 of file ConservativeVolumeTransfer.H.

Referenced by constructMixedMassMatrix(), constructSupermesh(), and volumeCheck().

◆ initTargetTetId

long ConservativeVolumeTransfer::initTargetTetId

private

Definition at line 214 of file ConservativeVolumeTransfer.H.

Referenced by constructMassMatrix(), constructMixedMassMatrix(), constructSupermesh(), and volumeCheck().

◆ loadVector

Eigen::VectorXd ConservativeVolumeTransfer::loadVector

private

Definition at line 225 of file ConservativeVolumeTransfer.H.

Referenced by constructLoadVector(), and transfer().

◆ massMatrix

Eigen::SparseMatrix<double, Eigen::ColMajor, long> ConservativeVolumeTransfer::massMatrix

private

Definition at line 223 of file ConservativeVolumeTransfer.H.

Referenced by ConservativeVolumeTransfer(), constructMassMatrix(), and transfer().

◆ mixedMassMatrix

Eigen::SparseMatrix<double, Eigen::ColMajor, long> ConservativeVolumeTransfer::mixedMassMatrix

private

Definition at line 224 of file ConservativeVolumeTransfer.H.

Referenced by ConservativeVolumeTransfer(), constructLoadVector(), and constructMixedMassMatrix().

◆ numSourceNodes

long ConservativeVolumeTransfer::numSourceNodes

private

Definition at line 210 of file ConservativeVolumeTransfer.H.

Referenced by ConservativeVolumeTransfer(), and constructLoadVector().

◆ numTargetNodes

long ConservativeVolumeTransfer::numTargetNodes

private

Definition at line 211 of file ConservativeVolumeTransfer.H.

Referenced by ConservativeVolumeTransfer(), and transfer().

◆ parents_a

std::vector<long> ConservativeVolumeTransfer::parents_a

private

Definition at line 231 of file ConservativeVolumeTransfer.H.

Referenced by constructMixedMassMatrix(), and constructSupermesh().

◆ parents_b

std::vector<long> ConservativeVolumeTransfer::parents_b

private

Definition at line 232 of file ConservativeVolumeTransfer.H.

Referenced by constructMixedMassMatrix(), and constructSupermesh().

◆ quadrature

vtkSmartPointer<vtkQuadratureSchemeDefinition> ConservativeVolumeTransfer::quadrature

private

Definition at line 220 of file ConservativeVolumeTransfer.H.

Referenced by ConservativeVolumeTransfer(), constructMassMatrix(), and constructMixedMassMatrix().

◆ source

meshBase* TransferBase::source

protectedinherited

Definition at line 105 of file TransferBase.H.

Referenced by ConservativeVolumeTransfer(), constructSupermesh(), FETransfer::FETransfer(), FETransfer::getClosestSourceCell(), FETransfer::run(), TransferBase::transferCellData(), FETransfer::transferCellData(), ConservativeSurfaceTransfer::transferPointData(), FETransfer::transferPointData(), TransferBase::transferPointData(), and ConservativeSurfaceTransfer::writeOverlay().

◆ sourceGrid

vtkSmartPointer<vtkUnstructuredGrid> ConservativeVolumeTransfer::sourceGrid

private

Definition at line 216 of file ConservativeVolumeTransfer.H.

Referenced by ConservativeVolumeTransfer(), constructLoadVector(), constructMixedMassMatrix(), convertSupermeshToUnstructuredGrid(), interpolateCellDataToPoints(), run(), transfer(), and volumeCheck().

◆ srcCellLocator

vtkSmartPointer<vtkStaticCellLocator> TransferBase::srcCellLocator = nullptr

protectedinherited

Definition at line 108 of file TransferBase.H.

Referenced by FETransfer::FETransfer(), and FETransfer::getClosestSourceCell().

◆ srcPointLocator

vtkSmartPointer<vtkStaticPointLocator> TransferBase::srcPointLocator = nullptr

protectedinherited

Definition at line 111 of file TransferBase.H.

Referenced by FETransfer::FETransfer().

◆ supermeshGrid

vtkSmartPointer<vtkUnstructuredGrid> ConservativeVolumeTransfer::supermeshGrid

private

Definition at line 218 of file ConservativeVolumeTransfer.H.

Referenced by convertSupermeshToUnstructuredGrid().

◆ surfaceTransferEnabled

bool ConservativeVolumeTransfer::surfaceTransferEnabled = false

private

Definition at line 246 of file ConservativeVolumeTransfer.H.

◆ target

meshBase* TransferBase::target

protectedinherited

Definition at line 106 of file TransferBase.H.

Referenced by ConservativeVolumeTransfer(), constructSupermesh(), FETransfer::FETransfer(), FETransfer::getClosestSourceCell(), FETransfer::run(), FETransfer::transferCellData(), ConservativeSurfaceTransfer::transferPointData(), FETransfer::transferPointData(), and ConservativeSurfaceTransfer::writeOverlay().

◆ targetGrid

vtkSmartPointer<vtkUnstructuredGrid> ConservativeVolumeTransfer::targetGrid

private

Definition at line 217 of file ConservativeVolumeTransfer.H.

Referenced by ConservativeVolumeTransfer(), constructMassMatrix(), constructMixedMassMatrix(), transfer(), and volumeCheck().

◆ TET10

double ConservativeVolumeTransfer::TET10[40]

private

Initial value:

= {
      .7784952948213300, .0738349017262234, .0738349017262234,
      .0738349017262234, .0738349017262234, .7784952948213300,
      .0738349017262234, .0738349017262234, .0738349017262234,
      .0738349017262234, .7784952948213300, .0738349017262234,
      .0738349017262234, .0738349017262234, .0738349017262234,
      .7784952948213300,
      .4062443438840510, .4062443438840510, .0937556561159491,
      .0937556561159491, .4062443438840510, .0937556561159491,
      .4062443438840510, .0937556561159491, .4062443438840510,
      .0937556561159491, .0937556561159491, .4062443438840510,
      .0937556561159491, .4062443438840510, .4062443438840510,
      .0937556561159491, .0937556561159491, .4062443438840510,
      .0937556561159491, .4062443438840510, .0937556561159491,
      .0937556561159491, .4062443438840510, .4062443438840510,
  }

Definition at line 183 of file ConservativeVolumeTransfer.H.

◆ TET10W

double ConservativeVolumeTransfer::TET10W[10]

private

Initial value:

= {
      .0476331348432089, .0476331348432089, .0476331348432089,
      .0476331348432089,
      .1349112434378610, .1349112434378610, .1349112434378610,
      .1349112434378610, .1349112434378610, .1349112434378610,
  }

Definition at line 202 of file ConservativeVolumeTransfer.H.

◆ TET4

double ConservativeVolumeTransfer::TET4[16]

private

Initial value:

= {.5854101966249684, .1381966011250105, .1381966011250105,
                     .1381966011250105, .1381966011250105, .5854101966249684,
                     .1381966011250105, .1381966011250105, .1381966011250105,
                     .1381966011250105, .5854101966249684, .1381966011250105,
                     .1381966011250105, .1381966011250105, .1381966011250105,
                     .5854101966249684}

Definition at line 173 of file ConservativeVolumeTransfer.H.

Referenced by ConservativeVolumeTransfer().

◆ TET4W

double ConservativeVolumeTransfer::TET4W[4]

private

Initial value:

= {0.250000000000000, 0.250000000000000, 0.250000000000000,

0.250000000000000}

Definition at line 180 of file ConservativeVolumeTransfer.H.

Referenced by ConservativeVolumeTransfer().

◆ TET8

double ConservativeVolumeTransfer::TET8[32]

private

Initial value:

= {
3281633025163817,  0.3281633025163817,  0.3281633025163817,
01551009245085488, 0.1080472498984286,  0.1080472498984286,
1080472498984286,  0.6758582503047142,  0.3281633025163817,
3281633025163817,  0.01551009245085488, 0.3281633025163817,
1080472498984286,  0.1080472498984286,  0.6758582503047142,
1080472498984286,  0.3281633025163817,  0.01551009245085488,
3281633025163817,  0.3281633025163817,  0.1080472498984286,
6758582503047142,  0.1080472498984286,  0.1080472498984286,
01551009245085488, 0.3281633025163817,  0.3281633025163817,
3281633025163817,  0.6758582503047142,  0.1080472498984286,
1080472498984286,  0.1080472498984286}

Definition at line 156 of file ConservativeVolumeTransfer.H.

◆ TET8W

double ConservativeVolumeTransfer::TET8W[8]

private

Initial value:

= {0.1362178425370874, 0.1137821574629126, 0.1362178425370874,
                     0.1137821574629126, 0.1362178425370874, 0.1137821574629126,
                     0.1362178425370874, 0.1137821574629126}

Definition at line 169 of file ConservativeVolumeTransfer.H.

◆ tets_c

std::vector<std::vector<double> > ConservativeVolumeTransfer::tets_c

private

Definition at line 230 of file ConservativeVolumeTransfer.H.

Referenced by constructMixedMassMatrix(), constructSupermesh(), and convertSupermeshToUnstructuredGrid().

◆ trgCellLocator

vtkSmartPointer<vtkStaticCellLocator> TransferBase::trgCellLocator = nullptr

protectedinherited

Definition at line 109 of file TransferBase.H.

Referenced by FETransfer::FETransfer(), and FETransfer::getClosestSourceCell().

◆ trgPointLocator

vtkSmartPointer<vtkStaticPointLocator> TransferBase::trgPointLocator = nullptr

protectedinherited

Definition at line 112 of file TransferBase.H.

Referenced by FETransfer::FETransfer().

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

Detailed Description

Public Member Functions

Static Public Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Constructor & Destructor Documentation

◆ ConservativeVolumeTransfer()

◆ ~ConservativeVolumeTransfer()

Member Function Documentation

◆ constructLoadVector()

◆ constructMassMatrix()

◆ constructMixedMassMatrix()

◆ constructSupermesh()

◆ convertSupermeshToUnstructuredGrid()

◆ Create()

◆ CreateShared()

◆ disableSurfaceTransfer()

◆ enableSurfaceTransfer()

◆ extractSurface()

◆ getLibSupermeshData()

◆ getSourceGrid()

◆ getSupermeshGrid()

◆ getTargetGrid()

◆ initialize()

◆ interpolateCellDataToPoints()

◆ run()

◆ setCheckQual()

◆ setContBool()

◆ transfer()

◆ transferCellData() [1/3]

◆ transferCellData() [2/3]

◆ transferCellData() [3/3]

◆ transferPointData() [1/3]

◆ transferPointData() [2/3]

◆ transferPointData() [3/3]

◆ transferSurfacePointData()

◆ volumeCheck()

Member Data Documentation

◆ c2cTrnsDistTol

◆ checkQual

◆ children_a

◆ children_b

◆ continuous

◆ initSourceTetId

◆ initTargetTetId

◆ loadVector

◆ massMatrix

◆ mixedMassMatrix

◆ numSourceNodes

◆ numTargetNodes

◆ parents_a

◆ parents_b

◆ quadrature

◆ source

◆ sourceGrid

◆ srcCellLocator

◆ srcPointLocator

◆ supermeshGrid

◆ surfaceTransferEnabled

◆ target

◆ targetGrid

◆ TET10

◆ TET10W

◆ TET4

◆ TET4W

◆ TET8

◆ TET8W

◆ tets_c

◆ trgCellLocator

◆ trgPointLocator