2015-07-31 21:48:06 +00:00
|
|
|
//============================================================================
|
|
|
|
// Copyright (c) Kitware, Inc.
|
|
|
|
// All rights reserved.
|
|
|
|
// See LICENSE.txt for details.
|
2019-04-15 23:24:21 +00:00
|
|
|
//
|
2015-07-31 21:48:06 +00:00
|
|
|
// This software is distributed WITHOUT ANY WARRANTY; without even
|
|
|
|
// the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
|
|
// PURPOSE. See the above copyright notice for more information.
|
|
|
|
//============================================================================
|
|
|
|
|
|
|
|
#ifndef vtk_m_internal_ConnectivityStructuredInternals_h
|
|
|
|
#define vtk_m_internal_ConnectivityStructuredInternals_h
|
|
|
|
|
2015-08-16 18:53:44 +00:00
|
|
|
#include <vtkm/CellShape.h>
|
2015-09-17 19:45:35 +00:00
|
|
|
#include <vtkm/StaticAssert.h>
|
2015-07-31 21:48:06 +00:00
|
|
|
#include <vtkm/TopologyElementTag.h>
|
|
|
|
#include <vtkm/Types.h>
|
2015-08-27 22:49:24 +00:00
|
|
|
#include <vtkm/VecVariable.h>
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2018-09-15 17:01:56 +00:00
|
|
|
#include <vtkm/internal/Assume.h>
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
namespace vtkm
|
|
|
|
{
|
|
|
|
namespace internal
|
|
|
|
{
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <vtkm::IdComponent>
|
|
|
|
class ConnectivityStructuredInternals;
|
2015-07-31 21:48:06 +00:00
|
|
|
|
|
|
|
//1 D specialization.
|
2017-05-18 14:29:41 +00:00
|
|
|
template <>
|
2015-07-31 21:48:06 +00:00
|
|
|
class ConnectivityStructuredInternals<1>
|
|
|
|
{
|
|
|
|
public:
|
2018-02-22 13:29:13 +00:00
|
|
|
using SchedulingRangeType = vtkm::Id;
|
2015-08-02 21:59:44 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
void SetPointDimensions(vtkm::Id dimensions) { this->PointDimensions = dimensions; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2018-12-03 20:56:45 +00:00
|
|
|
VTKM_EXEC_CONT
|
|
|
|
void SetGlobalPointIndexStart(vtkm::Id start) { this->GlobalPointIndexStart = start; }
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id GetPointDimensions() const { return this->PointDimensions; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id GetCellDimensions() const { return this->PointDimensions - 1; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2015-08-02 21:59:44 +00:00
|
|
|
SchedulingRangeType GetSchedulingRange(vtkm::TopologyElementTagCell) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
|
|
|
return this->GetNumberOfCells();
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2015-08-02 21:59:44 +00:00
|
|
|
SchedulingRangeType GetSchedulingRange(vtkm::TopologyElementTagPoint) const
|
|
|
|
{
|
|
|
|
return this->GetNumberOfPoints();
|
|
|
|
}
|
|
|
|
|
2018-12-03 20:56:45 +00:00
|
|
|
VTKM_EXEC_CONT
|
|
|
|
SchedulingRangeType GetGlobalPointIndexStart() const { return this->GlobalPointIndexStart; }
|
|
|
|
|
2018-02-27 14:25:25 +00:00
|
|
|
static constexpr vtkm::IdComponent NUM_POINTS_IN_CELL = 2;
|
|
|
|
static constexpr vtkm::IdComponent MAX_CELL_TO_POINT = 2;
|
2015-08-11 05:38:23 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id GetNumberOfPoints() const { return this->PointDimensions; }
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id GetNumberOfCells() const { return this->PointDimensions - 1; }
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::IdComponent GetNumberOfPointsInCell() const { return NUM_POINTS_IN_CELL; }
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::IdComponent GetCellShape() const { return vtkm::CELL_SHAPE_LINE; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2018-02-22 13:29:13 +00:00
|
|
|
using CellShapeTag = vtkm::CellShapeTagLine;
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Vec<vtkm::Id, NUM_POINTS_IN_CELL> GetPointsOfCell(vtkm::Id index) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2018-09-15 17:01:56 +00:00
|
|
|
VTKM_ASSUME(index >= 0);
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Vec<vtkm::Id, NUM_POINTS_IN_CELL> pointIds;
|
2015-08-11 05:38:23 +00:00
|
|
|
pointIds[0] = index;
|
|
|
|
pointIds[1] = pointIds[0] + 1;
|
|
|
|
return pointIds;
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2017-07-28 21:02:05 +00:00
|
|
|
VTKM_EXEC_CONT
|
|
|
|
vtkm::IdComponent GetNumberOfCellsOnPoint(vtkm::Id pointIndex) const
|
|
|
|
{
|
2018-09-15 17:01:56 +00:00
|
|
|
VTKM_ASSUME(pointIndex >= 0);
|
|
|
|
|
2017-07-28 21:02:05 +00:00
|
|
|
if ((pointIndex > 0) && (pointIndex < this->PointDimensions - 1))
|
|
|
|
{
|
|
|
|
return 2;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::VecVariable<vtkm::Id, MAX_CELL_TO_POINT> GetCellsOfPoint(vtkm::Id index) const
|
2015-08-11 05:38:23 +00:00
|
|
|
{
|
2018-09-15 17:01:56 +00:00
|
|
|
VTKM_ASSUME(index >= 0);
|
|
|
|
VTKM_ASSUME(this->PointDimensions > 1);
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::VecVariable<vtkm::Id, MAX_CELL_TO_POINT> cellIds;
|
2015-08-11 05:38:23 +00:00
|
|
|
|
2015-07-31 21:48:06 +00:00
|
|
|
if (index > 0)
|
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(index - 1);
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if (index < this->PointDimensions - 1)
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2015-08-27 22:49:24 +00:00
|
|
|
cellIds.Append(index);
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2015-08-11 05:38:23 +00:00
|
|
|
|
|
|
|
return cellIds;
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2018-09-15 17:01:56 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id FlatToLogicalPointIndex(vtkm::Id flatPointIndex) const { return flatPointIndex; }
|
2015-09-02 18:08:25 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id LogicalToFlatPointIndex(vtkm::Id logicalPointIndex) const { return logicalPointIndex; }
|
2015-09-02 18:08:25 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id FlatToLogicalCellIndex(vtkm::Id flatCellIndex) const { return flatCellIndex; }
|
2015-09-02 18:08:25 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id LogicalToFlatCellIndex(vtkm::Id logicalCellIndex) const { return logicalCellIndex; }
|
2015-09-02 18:08:25 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
void PrintSummary(std::ostream& out) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
out << " UniformConnectivity<1> ";
|
|
|
|
out << "this->PointDimensions[" << this->PointDimensions << "] ";
|
|
|
|
out << "\n";
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2018-12-03 20:56:45 +00:00
|
|
|
vtkm::Id PointDimensions = 0;
|
|
|
|
vtkm::Id GlobalPointIndexStart = 0;
|
2015-07-31 21:48:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
//2 D specialization.
|
2017-05-18 14:29:41 +00:00
|
|
|
template <>
|
2015-07-31 21:48:06 +00:00
|
|
|
class ConnectivityStructuredInternals<2>
|
|
|
|
{
|
|
|
|
public:
|
2018-02-22 13:29:13 +00:00
|
|
|
using SchedulingRangeType = vtkm::Id2;
|
2015-08-02 21:59:44 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
void SetPointDimensions(vtkm::Id2 dims) { this->PointDimensions = dims; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2018-12-03 20:56:45 +00:00
|
|
|
VTKM_EXEC_CONT
|
|
|
|
void SetGlobalPointIndexStart(vtkm::Id2 start) { this->GlobalPointIndexStart = start; }
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
const vtkm::Id2& GetPointDimensions() const { return this->PointDimensions; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id2 GetCellDimensions() const { return this->PointDimensions - vtkm::Id2(1); }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id GetNumberOfPoints() const { return vtkm::ReduceProduct(this->GetPointDimensions()); }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
|
|
|
//returns an id2 to signal what kind of scheduling to use
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id2 GetSchedulingRange(vtkm::TopologyElementTagCell) const
|
|
|
|
{
|
2015-07-31 21:48:06 +00:00
|
|
|
return this->GetCellDimensions();
|
|
|
|
}
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id2 GetSchedulingRange(vtkm::TopologyElementTagPoint) const
|
|
|
|
{
|
2015-08-02 21:59:44 +00:00
|
|
|
return this->GetPointDimensions();
|
|
|
|
}
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2018-12-03 20:56:45 +00:00
|
|
|
VTKM_EXEC_CONT
|
|
|
|
const vtkm::Id2& GetGlobalPointIndexStart() const { return this->GlobalPointIndexStart; }
|
|
|
|
|
2018-02-27 14:25:25 +00:00
|
|
|
static constexpr vtkm::IdComponent NUM_POINTS_IN_CELL = 4;
|
|
|
|
static constexpr vtkm::IdComponent MAX_CELL_TO_POINT = 4;
|
2015-08-11 05:38:23 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id GetNumberOfCells() const { return vtkm::ReduceProduct(this->GetCellDimensions()); }
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::IdComponent GetNumberOfPointsInCell() const { return NUM_POINTS_IN_CELL; }
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2015-08-27 23:03:13 +00:00
|
|
|
vtkm::IdComponent GetCellShape() const { return vtkm::CELL_SHAPE_QUAD; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2018-02-22 13:29:13 +00:00
|
|
|
using CellShapeTag = vtkm::CellShapeTagQuad;
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Vec<vtkm::Id, NUM_POINTS_IN_CELL> GetPointsOfCell(
|
|
|
|
const SchedulingRangeType& logicalCellIndex) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Vec<vtkm::Id, NUM_POINTS_IN_CELL> pointIds;
|
2015-10-07 18:14:00 +00:00
|
|
|
pointIds[0] = this->LogicalToFlatPointIndex(logicalCellIndex);
|
2015-08-11 05:38:23 +00:00
|
|
|
pointIds[1] = pointIds[0] + 1;
|
2015-08-27 23:03:13 +00:00
|
|
|
pointIds[2] = pointIds[1] + this->PointDimensions[0];
|
|
|
|
pointIds[3] = pointIds[2] - 1;
|
2015-08-11 05:38:23 +00:00
|
|
|
return pointIds;
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Vec<vtkm::Id, NUM_POINTS_IN_CELL> GetPointsOfCell(vtkm::Id cellIndex) const
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return this->GetPointsOfCell(this->FlatToLogicalCellIndex(cellIndex));
|
|
|
|
}
|
|
|
|
|
2017-07-28 21:02:05 +00:00
|
|
|
VTKM_EXEC_CONT vtkm::IdComponent GetNumberOfCellsOnPoint(const SchedulingRangeType& ij) const
|
|
|
|
{
|
|
|
|
vtkm::IdComponent numCells = 1;
|
|
|
|
|
|
|
|
for (vtkm::IdComponent dim = 0; dim < 2; dim++)
|
|
|
|
{
|
|
|
|
if ((ij[dim] > 0) && (ij[dim] < this->PointDimensions[dim] - 1))
|
|
|
|
{
|
|
|
|
numCells *= 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return numCells;
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
vtkm::IdComponent GetNumberOfCellsOnPoint(vtkm::Id pointIndex) const
|
|
|
|
{
|
|
|
|
return this->GetNumberOfCellsOnPoint(this->FlatToLogicalPointIndex(pointIndex));
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::VecVariable<vtkm::Id, MAX_CELL_TO_POINT> GetCellsOfPoint(
|
|
|
|
const SchedulingRangeType& ij) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::VecVariable<vtkm::Id, MAX_CELL_TO_POINT> cellIds;
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2015-09-02 18:08:25 +00:00
|
|
|
if ((ij[0] > 0) && (ij[1] > 0))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ij - vtkm::Id2(1, 1)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ij[0] < this->PointDimensions[0] - 1) && (ij[1] > 0))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ij - vtkm::Id2(0, 1)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ij[0] > 0) && (ij[1] < this->PointDimensions[1] - 1))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ij - vtkm::Id2(1, 0)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ij[0] < this->PointDimensions[0] - 1) && (ij[1] < this->PointDimensions[1] - 1))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2015-09-02 18:08:25 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ij));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2015-08-11 05:38:23 +00:00
|
|
|
|
|
|
|
return cellIds;
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::VecVariable<vtkm::Id, MAX_CELL_TO_POINT> GetCellsOfPoint(vtkm::Id pointIndex) const
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return this->GetCellsOfPoint(this->FlatToLogicalPointIndex(pointIndex));
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2015-09-02 18:08:25 +00:00
|
|
|
vtkm::Id2 FlatToLogicalPointIndex(vtkm::Id flatPointIndex) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2015-09-02 18:08:25 +00:00
|
|
|
vtkm::Id2 logicalPointIndex;
|
|
|
|
logicalPointIndex[0] = flatPointIndex % this->PointDimensions[0];
|
|
|
|
logicalPointIndex[1] = flatPointIndex / this->PointDimensions[0];
|
|
|
|
return logicalPointIndex;
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id LogicalToFlatPointIndex(const vtkm::Id2& logicalPointIndex) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
return logicalPointIndex[0] + this->PointDimensions[0] * logicalPointIndex[1];
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2015-09-02 18:08:25 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2015-09-02 18:08:25 +00:00
|
|
|
vtkm::Id2 FlatToLogicalCellIndex(vtkm::Id flatCellIndex) const
|
2015-09-01 16:56:32 +00:00
|
|
|
{
|
|
|
|
vtkm::Id2 cellDimensions = this->GetCellDimensions();
|
2015-09-02 18:08:25 +00:00
|
|
|
vtkm::Id2 logicalCellIndex;
|
|
|
|
logicalCellIndex[0] = flatCellIndex % cellDimensions[0];
|
|
|
|
logicalCellIndex[1] = flatCellIndex / cellDimensions[0];
|
|
|
|
return logicalCellIndex;
|
2015-09-01 16:56:32 +00:00
|
|
|
}
|
2015-09-02 18:08:25 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id LogicalToFlatCellIndex(const vtkm::Id2& logicalCellIndex) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
|
|
|
vtkm::Id2 cellDimensions = this->GetCellDimensions();
|
2017-05-18 14:29:41 +00:00
|
|
|
return logicalCellIndex[0] + cellDimensions[0] * logicalCellIndex[1];
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2015-09-02 18:08:25 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
void PrintSummary(std::ostream& out) const
|
2015-09-02 18:08:25 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
out << " UniformConnectivity<2> ";
|
|
|
|
out << "pointDim[" << this->PointDimensions[0] << " " << this->PointDimensions[1] << "] ";
|
|
|
|
out << std::endl;
|
2015-09-02 18:08:25 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2018-12-03 20:56:45 +00:00
|
|
|
vtkm::Id2 PointDimensions = { 0, 0 };
|
|
|
|
vtkm::Id2 GlobalPointIndexStart = { 0, 0 };
|
2015-07-31 21:48:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
//3 D specialization.
|
2017-05-18 14:29:41 +00:00
|
|
|
template <>
|
2015-07-31 21:48:06 +00:00
|
|
|
class ConnectivityStructuredInternals<3>
|
|
|
|
{
|
|
|
|
public:
|
2018-02-22 13:29:13 +00:00
|
|
|
using SchedulingRangeType = vtkm::Id3;
|
2015-08-02 21:59:44 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2015-07-31 21:48:06 +00:00
|
|
|
void SetPointDimensions(vtkm::Id3 dims)
|
|
|
|
{
|
|
|
|
this->PointDimensions = dims;
|
2015-09-25 20:55:57 +00:00
|
|
|
this->CellDimensions = dims - vtkm::Id3(1);
|
2017-05-18 14:29:41 +00:00
|
|
|
this->CellDim01 = (dims[0] - 1) * (dims[1] - 1);
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2018-12-03 20:56:45 +00:00
|
|
|
VTKM_EXEC_CONT
|
|
|
|
void SetGlobalPointIndexStart(vtkm::Id3 start) { this->GlobalPointIndexStart = start; }
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
const vtkm::Id3& GetPointDimensions() const { return this->PointDimensions; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
const vtkm::Id3& GetCellDimensions() const { return this->CellDimensions; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id GetNumberOfPoints() const { return vtkm::ReduceProduct(this->PointDimensions); }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
|
|
|
//returns an id3 to signal what kind of scheduling to use
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
const vtkm::Id3& GetSchedulingRange(vtkm::TopologyElementTagCell) const
|
|
|
|
{
|
2015-07-31 21:48:06 +00:00
|
|
|
return this->GetCellDimensions();
|
|
|
|
}
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
const vtkm::Id3& GetSchedulingRange(vtkm::TopologyElementTagPoint) const
|
|
|
|
{
|
2015-08-02 21:59:44 +00:00
|
|
|
return this->GetPointDimensions();
|
|
|
|
}
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2018-12-03 20:56:45 +00:00
|
|
|
VTKM_EXEC_CONT
|
|
|
|
const vtkm::Id3& GetGlobalPointIndexStart() const { return this->GlobalPointIndexStart; }
|
|
|
|
|
2018-02-27 14:25:25 +00:00
|
|
|
static constexpr vtkm::IdComponent NUM_POINTS_IN_CELL = 8;
|
|
|
|
static constexpr vtkm::IdComponent MAX_CELL_TO_POINT = 8;
|
2015-08-11 05:38:23 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id GetNumberOfCells() const { return vtkm::ReduceProduct(this->GetCellDimensions()); }
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::IdComponent GetNumberOfPointsInCell() const { return NUM_POINTS_IN_CELL; }
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2015-08-27 23:03:13 +00:00
|
|
|
vtkm::IdComponent GetCellShape() const { return vtkm::CELL_SHAPE_HEXAHEDRON; }
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2018-02-22 13:29:13 +00:00
|
|
|
using CellShapeTag = vtkm::CellShapeTagHexahedron;
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Vec<vtkm::Id, NUM_POINTS_IN_CELL> GetPointsOfCell(const SchedulingRangeType& ijk) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Vec<vtkm::Id, NUM_POINTS_IN_CELL> pointIds;
|
2015-09-02 18:08:25 +00:00
|
|
|
pointIds[0] = (ijk[2] * this->PointDimensions[1] + ijk[1]) * this->PointDimensions[0] + ijk[0];
|
2015-08-11 05:38:23 +00:00
|
|
|
pointIds[1] = pointIds[0] + 1;
|
2015-08-27 23:03:13 +00:00
|
|
|
pointIds[2] = pointIds[1] + this->PointDimensions[0];
|
|
|
|
pointIds[3] = pointIds[2] - 1;
|
2017-05-18 14:29:41 +00:00
|
|
|
pointIds[4] = pointIds[0] + this->PointDimensions[0] * this->PointDimensions[1];
|
2015-08-11 05:38:23 +00:00
|
|
|
pointIds[5] = pointIds[4] + 1;
|
2015-08-27 23:03:13 +00:00
|
|
|
pointIds[6] = pointIds[5] + this->PointDimensions[0];
|
|
|
|
pointIds[7] = pointIds[6] - 1;
|
2015-08-11 05:38:23 +00:00
|
|
|
|
|
|
|
return pointIds;
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Vec<vtkm::Id, NUM_POINTS_IN_CELL> GetPointsOfCell(vtkm::Id cellIndex) const
|
2015-08-28 17:21:19 +00:00
|
|
|
{
|
2015-10-07 18:14:00 +00:00
|
|
|
return this->GetPointsOfCell(this->FlatToLogicalCellIndex(cellIndex));
|
|
|
|
}
|
2015-08-28 17:21:19 +00:00
|
|
|
|
2017-07-28 21:02:05 +00:00
|
|
|
VTKM_EXEC_CONT vtkm::IdComponent GetNumberOfCellsOnPoint(const SchedulingRangeType& ijk) const
|
|
|
|
{
|
|
|
|
vtkm::IdComponent numCells = 1;
|
|
|
|
|
|
|
|
for (vtkm::IdComponent dim = 0; dim < 3; dim++)
|
|
|
|
{
|
|
|
|
if ((ijk[dim] > 0) && (ijk[dim] < this->PointDimensions[dim] - 1))
|
|
|
|
{
|
|
|
|
numCells *= 2;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return numCells;
|
|
|
|
}
|
|
|
|
|
|
|
|
VTKM_EXEC_CONT
|
|
|
|
vtkm::IdComponent GetNumberOfCellsOnPoint(vtkm::Id pointIndex) const
|
|
|
|
{
|
|
|
|
return this->GetNumberOfCellsOnPoint(this->FlatToLogicalPointIndex(pointIndex));
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::VecVariable<vtkm::Id, MAX_CELL_TO_POINT> GetCellsOfPoint(
|
|
|
|
const SchedulingRangeType& ijk) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::VecVariable<vtkm::Id, MAX_CELL_TO_POINT> cellIds;
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2015-09-02 18:08:25 +00:00
|
|
|
if ((ijk[0] > 0) && (ijk[1] > 0) && (ijk[2] > 0))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ijk - vtkm::Id3(1, 1, 1)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ijk[0] < this->PointDimensions[0] - 1) && (ijk[1] > 0) && (ijk[2] > 0))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ijk - vtkm::Id3(0, 1, 1)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ijk[0] > 0) && (ijk[1] < this->PointDimensions[1] - 1) && (ijk[2] > 0))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ijk - vtkm::Id3(1, 0, 1)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ijk[0] < this->PointDimensions[0] - 1) && (ijk[1] < this->PointDimensions[1] - 1) &&
|
2015-09-02 18:08:25 +00:00
|
|
|
(ijk[2] > 0))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ijk - vtkm::Id3(0, 0, 1)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ijk[0] > 0) && (ijk[1] > 0) && (ijk[2] < this->PointDimensions[2] - 1))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ijk - vtkm::Id3(1, 1, 0)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ijk[0] < this->PointDimensions[0] - 1) && (ijk[1] > 0) &&
|
|
|
|
(ijk[2] < this->PointDimensions[2] - 1))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ijk - vtkm::Id3(0, 1, 0)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ijk[0] > 0) && (ijk[1] < this->PointDimensions[1] - 1) &&
|
|
|
|
(ijk[2] < this->PointDimensions[2] - 1))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ijk - vtkm::Id3(1, 0, 0)));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2017-05-18 14:29:41 +00:00
|
|
|
if ((ijk[0] < this->PointDimensions[0] - 1) && (ijk[1] < this->PointDimensions[1] - 1) &&
|
|
|
|
(ijk[2] < this->PointDimensions[2] - 1))
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2015-09-02 18:08:25 +00:00
|
|
|
cellIds.Append(this->LogicalToFlatCellIndex(ijk));
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2015-08-11 05:38:23 +00:00
|
|
|
|
|
|
|
return cellIds;
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::VecVariable<vtkm::Id, MAX_CELL_TO_POINT> GetCellsOfPoint(vtkm::Id pointIndex) const
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return this->GetCellsOfPoint(this->FlatToLogicalPointIndex(pointIndex));
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
void PrintSummary(std::ostream& out) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
out << " UniformConnectivity<3> ";
|
|
|
|
out << "pointDim[" << this->PointDimensions[0] << " " << this->PointDimensions[1] << " "
|
|
|
|
<< this->PointDimensions[2] << "] ";
|
|
|
|
out << std::endl;
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2015-09-02 18:08:25 +00:00
|
|
|
vtkm::Id3 FlatToLogicalPointIndex(vtkm::Id flatPointIndex) const
|
|
|
|
{
|
2015-09-25 20:55:57 +00:00
|
|
|
const vtkm::Id pointDims01 = this->PointDimensions[0] * this->PointDimensions[1];
|
|
|
|
const vtkm::Id indexij = flatPointIndex % pointDims01;
|
|
|
|
|
2017-05-26 17:53:28 +00:00
|
|
|
return vtkm::Id3(indexij % this->PointDimensions[0],
|
|
|
|
indexij / this->PointDimensions[0],
|
2015-09-25 20:55:57 +00:00
|
|
|
flatPointIndex / pointDims01);
|
2015-09-02 18:08:25 +00:00
|
|
|
}
|
2015-07-31 21:48:06 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id LogicalToFlatPointIndex(const vtkm::Id3& logicalPointIndex) const
|
2015-09-01 16:56:32 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
return logicalPointIndex[0] +
|
|
|
|
this->PointDimensions[0] *
|
|
|
|
(logicalPointIndex[1] + this->PointDimensions[1] * logicalPointIndex[2]);
|
2015-09-01 16:56:32 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2015-09-02 18:08:25 +00:00
|
|
|
vtkm::Id3 FlatToLogicalCellIndex(vtkm::Id flatCellIndex) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2015-09-25 20:55:57 +00:00
|
|
|
const vtkm::Id indexij = flatCellIndex % this->CellDim01;
|
2017-05-26 17:53:28 +00:00
|
|
|
return vtkm::Id3(indexij % this->CellDimensions[0],
|
|
|
|
indexij / this->CellDimensions[0],
|
2017-05-18 14:29:41 +00:00
|
|
|
flatCellIndex / this->CellDim01);
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
vtkm::Id LogicalToFlatCellIndex(const vtkm::Id3& logicalCellIndex) const
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2017-05-18 14:29:41 +00:00
|
|
|
return logicalCellIndex[0] +
|
|
|
|
this->CellDimensions[0] *
|
|
|
|
(logicalCellIndex[1] + this->CellDimensions[1] * logicalCellIndex[2]);
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
2015-09-02 18:08:25 +00:00
|
|
|
|
|
|
|
private:
|
2018-12-03 20:56:45 +00:00
|
|
|
vtkm::Id3 PointDimensions = { 0, 0, 0 };
|
|
|
|
vtkm::Id3 GlobalPointIndexStart = { 0, 0, 0 };
|
|
|
|
vtkm::Id3 CellDimensions = { 0, 0, 0 };
|
|
|
|
vtkm::Id CellDim01 = 0;
|
2015-07-31 21:48:06 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
// We may want to generalize this class depending on how ConnectivityExplicit
|
|
|
|
// eventually handles retrieving cell to point connectivity.
|
|
|
|
|
2019-07-30 16:53:51 +00:00
|
|
|
template <typename VisitTopology, typename IncidentTopology, vtkm::IdComponent Dimension>
|
2015-07-31 21:48:06 +00:00
|
|
|
struct ConnectivityStructuredIndexHelper
|
|
|
|
{
|
|
|
|
// We want an unconditional failure if this unspecialized class ever gets
|
|
|
|
// instantiated, because it means someone missed a topology mapping type.
|
|
|
|
// We need to create a test which depends on the templated types so
|
|
|
|
// it doesn't get picked up without a concrete instantiation.
|
2019-07-30 16:53:51 +00:00
|
|
|
VTKM_STATIC_ASSERT_MSG(sizeof(VisitTopology) == static_cast<size_t>(-1),
|
2015-09-17 19:45:35 +00:00
|
|
|
"Missing Specialization for Topologies");
|
2015-07-31 21:48:06 +00:00
|
|
|
};
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <vtkm::IdComponent Dimension>
|
2019-07-30 16:53:51 +00:00
|
|
|
struct ConnectivityStructuredIndexHelper<vtkm::TopologyElementTagCell,
|
|
|
|
vtkm::TopologyElementTagPoint,
|
2017-05-26 17:53:28 +00:00
|
|
|
Dimension>
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2018-02-22 13:29:13 +00:00
|
|
|
using ConnectivityType = vtkm::internal::ConnectivityStructuredInternals<Dimension>;
|
|
|
|
using LogicalIndexType = typename ConnectivityType::SchedulingRangeType;
|
2015-08-11 05:38:23 +00:00
|
|
|
|
2017-07-28 21:02:05 +00:00
|
|
|
using CellShapeTag = typename ConnectivityType::CellShapeTag;
|
|
|
|
|
2018-02-22 13:29:13 +00:00
|
|
|
using IndicesType = vtkm::Vec<vtkm::Id, ConnectivityType::NUM_POINTS_IN_CELL>;
|
2015-08-11 05:38:23 +00:00
|
|
|
|
2017-07-28 21:02:05 +00:00
|
|
|
VTKM_EXEC_CONT static vtkm::Id GetNumberOfElements(const ConnectivityType& connectivity)
|
|
|
|
{
|
|
|
|
return connectivity.GetNumberOfCells();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename IndexType>
|
|
|
|
VTKM_EXEC_CONT static vtkm::IdComponent GetNumberOfIndices(
|
|
|
|
const ConnectivityType& vtkmNotUsed(connectivity),
|
|
|
|
const IndexType& vtkmNotUsed(cellIndex))
|
|
|
|
{
|
|
|
|
return ConnectivityType::NUM_POINTS_IN_CELL;
|
|
|
|
}
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename IndexType>
|
|
|
|
VTKM_EXEC_CONT static IndicesType GetIndices(const ConnectivityType& connectivity,
|
|
|
|
const IndexType& cellIndex)
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2015-08-11 05:38:23 +00:00
|
|
|
return connectivity.GetPointsOfCell(cellIndex);
|
2015-07-31 21:48:06 +00:00
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
static LogicalIndexType FlatToLogicalFromIndex(const ConnectivityType& connectivity,
|
|
|
|
vtkm::Id flatFromIndex)
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return connectivity.FlatToLogicalPointIndex(flatFromIndex);
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
static vtkm::Id LogicalToFlatFromIndex(const ConnectivityType& connectivity,
|
|
|
|
const LogicalIndexType& logicalFromIndex)
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return connectivity.LogicalToFlatPointIndex(logicalFromIndex);
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
static LogicalIndexType FlatToLogicalToIndex(const ConnectivityType& connectivity,
|
|
|
|
vtkm::Id flatToIndex)
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return connectivity.FlatToLogicalCellIndex(flatToIndex);
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
static vtkm::Id LogicalToFlatToIndex(const ConnectivityType& connectivity,
|
|
|
|
const LogicalIndexType& logicalToIndex)
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return connectivity.LogicalToFlatCellIndex(logicalToIndex);
|
|
|
|
}
|
2015-07-31 21:48:06 +00:00
|
|
|
};
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <vtkm::IdComponent Dimension>
|
2019-07-30 16:53:51 +00:00
|
|
|
struct ConnectivityStructuredIndexHelper<vtkm::TopologyElementTagPoint,
|
|
|
|
vtkm::TopologyElementTagCell,
|
2017-05-26 17:53:28 +00:00
|
|
|
Dimension>
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2018-02-22 13:29:13 +00:00
|
|
|
using ConnectivityType = vtkm::internal::ConnectivityStructuredInternals<Dimension>;
|
|
|
|
using LogicalIndexType = typename ConnectivityType::SchedulingRangeType;
|
2015-08-11 05:38:23 +00:00
|
|
|
|
2017-07-28 21:02:05 +00:00
|
|
|
using CellShapeTag = vtkm::CellShapeTagVertex;
|
|
|
|
|
2018-02-22 13:29:13 +00:00
|
|
|
using IndicesType = vtkm::VecVariable<vtkm::Id, ConnectivityType::MAX_CELL_TO_POINT>;
|
2015-08-11 05:38:23 +00:00
|
|
|
|
2017-07-28 21:02:05 +00:00
|
|
|
VTKM_EXEC_CONT static vtkm::Id GetNumberOfElements(const ConnectivityType& connectivity)
|
|
|
|
{
|
|
|
|
return connectivity.GetNumberOfPoints();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename IndexType>
|
|
|
|
VTKM_EXEC_CONT static vtkm::IdComponent GetNumberOfIndices(const ConnectivityType& connectivity,
|
|
|
|
const IndexType& pointIndex)
|
|
|
|
{
|
|
|
|
return connectivity.GetNumberOfCellsOnPoint(pointIndex);
|
|
|
|
}
|
|
|
|
|
2017-05-18 14:29:41 +00:00
|
|
|
template <typename IndexType>
|
|
|
|
VTKM_EXEC_CONT static IndicesType GetIndices(const ConnectivityType& connectivity,
|
|
|
|
const IndexType& pointIndex)
|
2015-07-31 21:48:06 +00:00
|
|
|
{
|
2015-08-11 05:38:23 +00:00
|
|
|
return connectivity.GetCellsOfPoint(pointIndex);
|
|
|
|
}
|
2015-10-07 18:14:00 +00:00
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
static LogicalIndexType FlatToLogicalFromIndex(const ConnectivityType& connectivity,
|
|
|
|
vtkm::Id flatFromIndex)
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return connectivity.FlatToLogicalCellIndex(flatFromIndex);
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
static vtkm::Id LogicalToFlatFromIndex(const ConnectivityType& connectivity,
|
|
|
|
const LogicalIndexType& logicalFromIndex)
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return connectivity.LogicalToFlatCellIndex(logicalFromIndex);
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
static LogicalIndexType FlatToLogicalToIndex(const ConnectivityType& connectivity,
|
|
|
|
vtkm::Id flatToIndex)
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return connectivity.FlatToLogicalPointIndex(flatToIndex);
|
|
|
|
}
|
|
|
|
|
2016-10-19 22:42:58 +00:00
|
|
|
VTKM_EXEC_CONT
|
2017-05-18 14:29:41 +00:00
|
|
|
static vtkm::Id LogicalToFlatToIndex(const ConnectivityType& connectivity,
|
|
|
|
const LogicalIndexType& logicalToIndex)
|
2015-10-07 18:14:00 +00:00
|
|
|
{
|
|
|
|
return connectivity.LogicalToFlatPointIndex(logicalToIndex);
|
|
|
|
}
|
2015-07-31 21:48:06 +00:00
|
|
|
};
|
|
|
|
}
|
|
|
|
} // namespace vtkm::internal
|
|
|
|
|
|
|
|
#endif //vtk_m_internal_ConnectivityStructuredInternals_h
|