Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
fc570a75a5
vtk-m/vtkm/exec/ConnectivityPermuted.h

124 lines
3.7 KiB
C
Raw Normal View History

Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
//
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +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.
//============================================================================
Simplify using CellSetPermutation by providing a default permutation type. Previously you had to explicitly state you wanted a CellSetPermutation with an ArrayHanlde of Id's, now that is done automatically.
2016-04-08 17:49:51 +00:00
#ifndef vtk_m_exec_ConnectivityPermuted_h
#define vtk_m_exec_ConnectivityPermuted_h
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
#include <vtkm/CellShape.h>
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
#include <vtkm/TopologyElementTag.h>
#include <vtkm/Types.h>
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
#include <vtkm/VecFromPortal.h>
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace vtkm
{
namespace exec
{
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename PermutationPortal, typename OriginalConnectivity>
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
class ConnectivityPermutedVisitCellsWithPoints
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
{
public:
Convert VTK-m over to use 'using' instead of 'typedef'
2017-08-16 15:34:21 +00:00
using SchedulingRangeType = typename OriginalConnectivity::SchedulingRangeType;
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
Make connectivity structures trivially copyable It always worked to trivially copy these classes, but the compiler did not think so because copy constructors were defined. Change these constructors to be default so that the compler can properly check triviality.
2021-02-22 15:44:23 +00:00
ConnectivityPermutedVisitCellsWithPoints() = default;
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
ConnectivityPermutedVisitCellsWithPoints(const PermutationPortal& portal,
const OriginalConnectivity& src)
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
: Portal(portal)
, Connectivity(src)
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
{
}
Make connectivity structures trivially copyable It always worked to trivially copy these classes, but the compiler did not think so because copy constructors were defined. Change these constructors to be default so that the compler can properly check triviality.
2021-02-22 15:44:23 +00:00
ConnectivityPermutedVisitCellsWithPoints(const ConnectivityPermutedVisitCellsWithPoints& src) =
default;
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
Correct warnings found by GCC 9.2
2019-11-28 15:43:27 +00:00
ConnectivityPermutedVisitCellsWithPoints& operator=(
const ConnectivityPermutedVisitCellsWithPoints& src) = default;
ConnectivityPermutedVisitCellsWithPoints& operator=(
ConnectivityPermutedVisitCellsWithPoints&& src) = default;
Add a test for the WholeCellSetIn argument All types of cell sets should have a consistent interface. This is tested (and fixed) for explicit and permutation cell sets. However, an unfixed bug that has been identified is that permutation cell sets only work for point to cell topologies. All others are not supported correctly.
2017-07-28 19:40:31 +00:00
VTKM_EXEC
vtkm::Id GetNumberOfElements() const { return this->Portal.GetNumberOfValues(); }
Convert VTK-m over to use 'using' instead of 'typedef'
2017-08-16 15:34:21 +00:00
using CellShapeTag = typename OriginalConnectivity::CellShapeTag;
Simplify using CellSetPermutation by providing a default permutation type. Previously you had to explicitly state you wanted a CellSetPermutation with an ArrayHanlde of Id's, now that is done automatically.
2016-04-08 17:49:51 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CellShapeTag GetCellShape(vtkm::Id index) const
{
Simplify using CellSetPermutation by providing a default permutation type. Previously you had to explicitly state you wanted a CellSetPermutation with an ArrayHanlde of Id's, now that is done automatically.
2016-04-08 17:49:51 +00:00
vtkm::Id pIndex = this->Portal.Get(index);
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return this->Connectivity.GetCellShape(pIndex);
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
}
Add a test for the WholeCellSetIn argument All types of cell sets should have a consistent interface. This is tested (and fixed) for explicit and permutation cell sets. However, an unfixed bug that has been identified is that permutation cell sets only work for point to cell topologies. All others are not supported correctly.
2017-07-28 19:40:31 +00:00
VTKM_EXEC
vtkm::IdComponent GetNumberOfIndices(vtkm::Id index) const
{
return this->Connectivity.GetNumberOfIndices(this->Portal.Get(index));
}
Convert VTK-m over to use 'using' instead of 'typedef'
2017-08-16 15:34:21 +00:00
using IndicesType = typename OriginalConnectivity::IndicesType;
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename IndexType>
VTKM_EXEC IndicesType GetIndices(const IndexType& index) const
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
{
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
return this->Connectivity.GetIndices(this->Portal.Get(index));
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
}
PermutationPortal Portal;
Simplify using CellSetPermutation by providing a default permutation type. Previously you had to explicitly state you wanted a CellSetPermutation with an ArrayHanlde of Id's, now that is done automatically.
2016-04-08 17:49:51 +00:00
OriginalConnectivity Connectivity;
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
};
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
Refactor CellSetExplicit to remove NumIndices. See #408 for details.
2019-08-30 17:04:17 +00:00
template <typename ConnectivityPortalType, typename OffsetPortalType>
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
class ConnectivityPermutedVisitPointsWithCells
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
{
public:
using SchedulingRangeType = vtkm::Id;
using IndicesType = vtkm::VecFromPortal<ConnectivityPortalType>;
using CellShapeTag = vtkm::CellShapeTagVertex;
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
ConnectivityPermutedVisitPointsWithCells() = default;
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
ConnectivityPermutedVisitPointsWithCells(const ConnectivityPortalType& connectivity,
Refactor CellSetExplicit to remove NumIndices. See #408 for details.
2019-08-30 17:04:17 +00:00
const OffsetPortalType& offsets)
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
: Connectivity(connectivity)
Refactor CellSetExplicit to remove NumIndices. See #408 for details.
2019-08-30 17:04:17 +00:00
, Offsets(offsets)
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
{
}
VTKM_EXEC
Refactor CellSetExplicit to remove NumIndices. See #408 for details.
2019-08-30 17:04:17 +00:00
SchedulingRangeType GetNumberOfElements() const { return this->Offsets.GetNumberOfValues() - 1; }
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
VTKM_EXEC CellShapeTag GetCellShape(vtkm::Id) const { return CellShapeTag(); }
VTKM_EXEC
Refactor CellSetExplicit to remove NumIndices. See #408 for details.
2019-08-30 17:04:17 +00:00
vtkm::IdComponent GetNumberOfIndices(vtkm::Id index) const
{
const vtkm::Id offBegin = this->Offsets.Get(index);
const vtkm::Id offEnd = this->Offsets.Get(index + 1);
return static_cast<vtkm::IdComponent>(offEnd - offBegin);
}
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
VTKM_EXEC IndicesType GetIndices(vtkm::Id index) const
{
Refactor CellSetExplicit to remove NumIndices. See #408 for details.
2019-08-30 17:04:17 +00:00
const vtkm::Id offBegin = this->Offsets.Get(index);
const vtkm::Id offEnd = this->Offsets.Get(index + 1);
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
return IndicesType(
Refactor CellSetExplicit to remove NumIndices. See #408 for details.
2019-08-30 17:04:17 +00:00
this->Connectivity, static_cast<vtkm::IdComponent>(offEnd - offBegin), offBegin);
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
}
private:
ConnectivityPortalType Connectivity;
Refactor CellSetExplicit to remove NumIndices. See #408 for details.
2019-08-30 17:04:17 +00:00
OffsetPortalType Offsets;
Implement CellToPoint for CellSetPermutation
2017-07-21 16:19:19 +00:00
};
Add CellSetPermutation which allows custom iteration over a cell set. When you create a CellSetPermutation you provide an array of the cell ids that you want to iterate. This allows the user to do custom blanking of a data set, or to do multi iteration over a set of cells.
2015-09-28 17:15:26 +00:00
}
} // namespace vtkm::exec
Simplify using CellSetPermutation by providing a default permutation type. Previously you had to explicitly state you wanted a CellSetPermutation with an ArrayHanlde of Id's, now that is done automatically.
2016-04-08 17:49:51 +00:00
#endif //vtk_m_exec_ConnectivityPermuted_h
Reference in New Issue Copy Permalink