Shuenhoy/vtk-m2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
4758d3d978
vtk-m2/vtkm/cont/Field.h

465 lines
11 KiB
C
Raw Normal View History

encapsulating field for data set.
2015-02-10 17:36:10 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
// 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.
//
// Copyright 2014 Sandia Corporation.
// Copyright 2014 UT-Battelle, LLC.
Correct headers to have the new copyright.
2015-06-03 19:06:43 +00:00
// Copyright 2014 Los Alamos National Security.
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Under the terms of Contract DE-AC52-06NA25396 with Los Alamos National
// Laboratory (LANL), the U.S. Government retains certain rights in
// this software.
//============================================================================
Correct the include guards on vtkm::cont::Field.
2015-05-29 13:51:11 +00:00
#ifndef vtk_m_cont_Field_h
#define vtk_m_cont_Field_h
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
Introduce vtkm_cont library to reduce weak vtable creation. This reduces the number of weak vtables vtkm generates, resulting in a reduction of binary sizes for projects that include vtkm classes in multiple translation units.
2016-12-16 22:04:58 +00:00
#include <vtkm/cont/vtkm_cont_export.h>
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
#include <vtkm/Range.h>
#include <vtkm/Types.h>
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
#include <vtkm/cont/ArrayHandle.h>
Move ComputeRange for ArrayHandle to its own header It will be convenient to make this accessible outside of Field.
2016-08-05 20:05:32 +00:00
#include <vtkm/cont/ArrayRangeCompute.h>
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
#include <vtkm/cont/ArrayPortalToIterators.h>
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
#include <vtkm/cont/DynamicArrayHandle.h>
Field now uses ArrayHandle.allocate + std::copy in CopyData. The original implementation use the naive approach of the device adapter to copy the memory to the dynamic array handle. The issue with this approach is that it would do a upload to device, and than a copy on device. Instead we should prefer a copy on host, and than an upload to device.
2015-05-29 13:44:57 +00:00
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
namespace vtkm {
namespace cont {
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
namespace internal {
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
class ComputeRange
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
public:
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
ComputeRange(ArrayHandle<vtkm::Range>& range) : Range(&range) {}
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
template<typename ArrayHandleType>
void operator()(const ArrayHandleType &input) const
{
Use ArrayRangeCompute without specifying a device Most uses of ArrayRangeCompute just want to get the range of the data and probably don't have a particular device in mind. Thus, it is better to use a TryExecute internally use whatever devices are available. Note that when using TryExecute, the calling code is expected to be able to support all devices. That might not always be the case. Thus, I am experimenting a bit with how we incorporate this in a library. The advantage of having the code compiled in a library is that you only have to compile it once and the calling code does not need to worry about CUDA, etc. However, because ArrayRangeCompute is templated, we can only pre-compile some subset of array handle types. The most common are compiled into the code (matching all the predefined ArrayHandles as well as some special cases). If the code wants to use some other type, it has to include ArrayRangeCompute.hxx. The only place where this is necessary is a test that intentially trys to find the range on an uncommon type. If array portals were to support virtual methods, then we should be able to modify this code so that we could precompile for all array handle types.
2017-02-24 00:12:14 +00:00
*this->Range = vtkm::cont::ArrayRangeCompute(input);
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
Simplify the bounds computation code to reduce library size. The previous version of the bounds code required once less pass across the data, but significantly increase the size of the resulting library: Data for VTK-VTK-m interop: - 7k more symbol table entries - 1.5MB larger library Because of the significant savings we need to use a less efficient implementation that minimized the code size.
2016-05-26 12:40:26 +00:00
private:
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
vtkm::cont::ArrayHandle<vtkm::Range> *Range;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
};
} // namespace internal
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
/// A \c Field encapsulates an array on some piece of the mesh, such as
Change Node -> Point Most of VTK-m follows the convention of calling the 0D topology elements "points" (which follows the convention of VTK). However, there were several places where they were referred to as "nodes." Make things consistent by calling them points everywhere. Also merged some redundant ExecutionSignature tags.
2015-08-03 16:06:59 +00:00
/// the points, a cell set, a point logical dimension, or the whole mesh.
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
///
Introduce vtkm_cont library to reduce weak vtable creation. This reduces the number of weak vtables vtkm generates, resulting in a reduction of binary sizes for projects that include vtkm classes in multiple translation units.
2016-12-16 22:04:58 +00:00
class VTKM_CONT_EXPORT Field
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
{
public:
completing field.
2015-05-11 20:15:58 +00:00
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
enum AssociationEnum
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
{
adding ability to specify an association type when requesting fields. also adding testing of GetField to UnitTestDataSet tests.
2015-08-12 15:51:14 +00:00
ASSOC_ANY,
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ASSOC_WHOLE_MESH,
ASSOC_POINTS,
ASSOC_CELL_SET,
ASSOC_LOGICAL_DIM
};
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
/// constructors for points / whole mesh
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_CONT
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
Field(std::string name,
AssociationEnum association,
Have CoordinateSystem inherit from Field Previously, coordinate systems in a DataSet simply pointed to field data specifying the coordinate information (although the ability to get that back out of the DataSet was missing). This makes sense since point coordinates are in fact just fields with a particular semantic meaning to them. However, there is an issue with this approach. It turns out that there are special representations that are very common for point coordinates and very uncommon for other types of fields. For example, a uniform (a.k.a. regular or image) grid has point coordinates that are easily derived from the point index, but such fields are quite uncommon elsewhere. Representing this kind of structure in the Field list of a DataSet is problematic. Either all fields have to check to see if they are this type, which will cause an explosion of unnecessary generated code, or you will have to actually write out the coordinates in memory, which is really wasteful but what was done previously. However, by storing fields representing coordinate systems in a separate batch, we can use these special types without the stated explosion.
2015-08-17 18:47:46 +00:00
const vtkm::cont::DynamicArrayHandle &data)
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
ModifiedFlag(true)
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_WHOLE_MESH ||
this->Association == ASSOC_POINTS);
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
}
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
template<typename T, typename Storage>
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
Have CoordinateSystem inherit from Field Previously, coordinate systems in a DataSet simply pointed to field data specifying the coordinate information (although the ability to get that back out of the DataSet was missing). This makes sense since point coordinates are in fact just fields with a particular semantic meaning to them. However, there is an issue with this approach. It turns out that there are special representations that are very common for point coordinates and very uncommon for other types of fields. For example, a uniform (a.k.a. regular or image) grid has point coordinates that are easily derived from the point index, but such fields are quite uncommon elsewhere. Representing this kind of structure in the Field list of a DataSet is problematic. Either all fields have to check to see if they are this type, which will cause an explosion of unnecessary generated code, or you will have to actually write out the coordinates in memory, which is really wasteful but what was done previously. However, by storing fields representing coordinate systems in a separate batch, we can use these special types without the stated explosion.
2015-08-17 18:47:46 +00:00
const ArrayHandle<T, Storage> &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
completing field.
2015-05-11 20:15:58 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
completing field.
2015-05-11 20:15:58 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::vector<T> &data)
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
this->CopyData(&data[0], static_cast<vtkm::Id>(data.size()));
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const T *data,
vtkm::Id nvals)
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(-1),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT((this->Association == ASSOC_WHOLE_MESH) ||
(this->Association == ASSOC_POINTS));
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
this->CopyData(data, nvals);
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
/// constructors for cell set associations
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::string& cellSetName,
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
const vtkm::cont::DynamicArrayHandle &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
}
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
template <typename T, typename Storage>
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::string& cellSetName,
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
const vtkm::cont::ArrayHandle<T, Storage> &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
completing field.
2015-05-11 20:15:58 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
completing field.
2015-05-11 20:15:58 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::string& cellSetName,
const std::vector<T> &data)
: Name(name),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
this->CopyData(&data[0], static_cast<vtkm::Id>(data.size()));
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
const std::string& cellSetName,
const T *data,
vtkm::Id nvals)
: Name(name),
Association(association),
AssocCellSetName(cellSetName),
AssocLogicalDim(-1),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_CELL_SET);
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
this->CopyData(data, nvals);
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
/// constructors for logical dimension associations
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
vtkm::IdComponent logicalDim,
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
const vtkm::cont::DynamicArrayHandle &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocCellSetName(),
AssocLogicalDim(logicalDim),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
Consturct Field from given DynamicArrayHandle Add un-templated contructors to Field that construct a Field from the given DynamicArrayHandle, without knowing the underlying type.
2015-07-13 19:50:07 +00:00
}
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
template <typename T, typename Storage>
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
vtkm::IdComponent logicalDim,
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
const vtkm::cont::ArrayHandle<T, Storage> &data)
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
: Name(name),
Association(association),
AssocLogicalDim(logicalDim),
Data(data),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
completing field.
2015-05-11 20:15:58 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
completing field.
2015-05-11 20:15:58 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
vtkm::IdComponent logicalDim,
const std::vector<T> &data)
: Name(name),
Association(association),
AssocLogicalDim(logicalDim),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
this->CopyData(&data[0], static_cast<vtkm::Id>(data.size()));
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +00:00
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
template <typename T>
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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
Field(std::string name,
AssociationEnum association,
vtkm::IdComponent logicalDim,
const T *data, vtkm::Id nvals)
: Name(name),
Association(association),
AssocLogicalDim(logicalDim),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
ModifiedFlag(true)
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
{
Remove cont/Assert.h and exec/Assert.h These asserts are consolidated into the unified Assert.h. Also made some minor edits to add asserts where appropriate and a little bit of reconfiguring as found.
2016-04-20 21:41:14 +00:00
VTKM_ASSERT(this->Association == ASSOC_LOGICAL_DIM);
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
CopyData(data, nvals);
moderately substantial cleanup to fields.
2015-05-19 20:49:17 +00:00
}
Correct double to float conversion warnings.
2015-06-04 13:06:47 +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_CONT
Allow vtkm::cont::Field to have a default constructor. When designing vtkm::filter we needed the ability to construct invalid Fields. This now allows us to do exactly that.
2016-01-04 20:40:37 +00:00
Field()
: Name(),
Fix vtkm::cont::Field default constructor to have valid values.
2016-01-12 21:29:54 +00:00
Association(ASSOC_ANY),
Allow vtkm::cont::Field to have a default constructor. When designing vtkm::filter we needed the ability to construct invalid Fields. This now allows us to do exactly that.
2016-01-04 20:40:37 +00:00
AssocCellSetName(),
AssocLogicalDim(),
Data(),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
Range(),
Allow vtkm::cont::Field to have a default constructor. When designing vtkm::filter we needed the ability to construct invalid Fields. This now allows us to do exactly that.
2016-01-04 20:40:37 +00:00
ModifiedFlag(true)
{
//Generate an empty field
}
Correct compilation errors on Windows with CUDA.
2017-01-18 14:10:11 +00:00
VTKM_CONT
Field &operator=(const vtkm::cont::Field &src) = default;
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_CONT
Make vtkm::cont::Field class const correct
2015-07-13 20:20:39 +00:00
const std::string &GetName() const
starting some field/dataset cleanup
2015-05-19 20:21:15 +00:00
{
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
return this->Name;
starting some field/dataset cleanup
2015-05-19 20:21:15 +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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
AssociationEnum GetAssociation() const
completing field.
2015-05-11 20:15:58 +00:00
{
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
return this->Association;
completing field.
2015-05-11 20:15:58 +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_CONT
Make vtkm::cont::Field class const correct
2015-07-13 20:20:39 +00:00
std::string GetAssocCellSet() const
completing field.
2015-05-11 20:15:58 +00:00
{
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
return this->AssocCellSetName;
completing field.
2015-05-11 20:15:58 +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_CONT
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
vtkm::IdComponent GetAssocLogicalDim() const
completing field.
2015-05-11 20:15:58 +00:00
{
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
return this->AssocLogicalDim;
completing field.
2015-05-11 20:15:58 +00:00
}
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
template<typename TypeList, typename StorageList>
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_CONT
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
const vtkm::cont::ArrayHandle<vtkm::Range>&
GetRange(TypeList, StorageList) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
return this->GetRangeImpl(TypeList(), StorageList());
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>&
GetRange(VTKM_DEFAULT_TYPE_LIST_TAG, VTKM_DEFAULT_STORAGE_LIST_TAG) const;
template<typename TypeList, typename StorageList>
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_CONT
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
void GetRange(vtkm::Range *range,
TypeList,
StorageList) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
this->GetRange(TypeList(), StorageList());
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
vtkm::Id length = this->Range.GetNumberOfValues();
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
for (vtkm::Id i = 0; i < length; ++i)
{
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
range[i] = this->Range.GetPortalConstControl().Get(i);
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
}
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
template<typename TypeList>
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_CONT
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange(TypeList) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
VTKM_IS_LIST_TAG(TypeList);
return this->GetRange(TypeList(),
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
VTKM_DEFAULT_STORAGE_LIST_TAG());
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
}
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
template<typename TypeList>
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_CONT
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
void GetRange(vtkm::Range *range, TypeList) const
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
{
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
VTKM_IS_LIST_TAG(TypeList);
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
this->GetRange(range,
TypeList(),
VTKM_DEFAULT_STORAGE_LIST_TAG());
Add compute bounds to Fields
2015-07-16 19:10:01 +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_CONT
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
const vtkm::cont::ArrayHandle<vtkm::Range>& GetRange() const;
Add compute bounds to Fields
2015-07-16 19:10:01 +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_CONT
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
void GetRange(vtkm::Range *range) const;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
Introduce vtkm_cont library to reduce weak vtable creation. This reduces the number of weak vtables vtkm generates, resulting in a reduction of binary sizes for projects that include vtkm classes in multiple translation units.
2016-12-16 22:04:58 +00:00
const vtkm::cont::DynamicArrayHandle &GetData() const;
vtkm::cont::DynamicArrayHandle &GetData();
Minor fixes to Field class
2015-07-30 14:22:25 +00:00
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
completing field.
2015-05-11 20:15:58 +00:00
template <typename T>
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_CONT
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
void SetData(const vtkm::cont::ArrayHandle<T> &newdata)
{
this->Data = newdata;
this->ModifiedFlag = true;
}
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_CONT
Fix issues with Field constructor overloads I ran into a few minor issues with the constructors to the Field class. The big change I made was that I removed the Field constructors that take an example type and create an empty field of that type. The problem was that the example type was easily confused with some other type that was supposed to describe an array. This lead to some odd behavior in the compiler and resulted in errors in unexpected places. The use case for this constructor is dubious. There were several tests in the code that would create an empty field, add it to a data set, then get it back out to pass to the worklet. The code is much simpler if you just make an ArrayHandle of the right type and use that in the worklet invoke directly. It is also faster to compile with smaller code because the type is known statically (whereas it is lost the other way). The other change was to declare references to ArrayHandle and DynamicArrayHandle as const. There is nothing in the behavior that invalidates the const, and it accepts arrays constructed in the parameter.
2016-01-21 20:51:36 +00:00
void SetData(const vtkm::cont::DynamicArrayHandle &newdata)
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
{
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
this->Data = newdata;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
this->ModifiedFlag = true;
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
}
starting some field/dataset cleanup
2015-05-19 20:21:15 +00:00
template <typename T>
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_CONT
Field now uses ArrayHandle.allocate + std::copy in CopyData. The original implementation use the naive approach of the device adapter to copy the memory to the dynamic array handle. The issue with this approach is that it would do a upload to device, and than a copy on device. Instead we should prefer a copy on host, and than an upload to device.
2015-05-29 13:44:57 +00:00
void CopyData(const T *ptr, vtkm::Id nvals)
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
{
Field now uses ArrayHandle.allocate + std::copy in CopyData. The original implementation use the naive approach of the device adapter to copy the memory to the dynamic array handle. The issue with this approach is that it would do a upload to device, and than a copy on device. Instead we should prefer a copy on host, and than an upload to device.
2015-05-29 13:44:57 +00:00
//allocate main memory using an array handle
vtkm::cont::ArrayHandle<T> tmp;
tmp.Allocate(nvals);
//copy into the memory owned by the array handle
std::copy(ptr,
ptr + static_cast<std::size_t>(nvals),
vtkm::cont::ArrayPortalToIteratorBegin(tmp.GetPortalControl()));
//assign to the dynamic array handle
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
this->Data = tmp;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
this->ModifiedFlag = true;
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
}
Add PrintSummary() for DataSet.
2015-05-20 19:26:10 +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_CONT
Introduce vtkm_cont library to reduce weak vtable creation. This reduces the number of weak vtables vtkm generates, resulting in a reduction of binary sizes for projects that include vtkm classes in multiple translation units.
2016-12-16 22:04:58 +00:00
virtual void PrintSummary(std::ostream &out) const;
Field now uses ArrayHandle.allocate + std::copy in CopyData. The original implementation use the naive approach of the device adapter to copy the memory to the dynamic array handle. The issue with this approach is that it would do a upload to device, and than a copy on device. Instead we should prefer a copy on host, and than an upload to device.
2015-05-29 13:44:57 +00:00
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
private:
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
std::string Name; ///< name of field
starting some field/dataset cleanup
2015-05-19 20:21:15 +00:00
Conform DataSet classes to coding practices better The most common changes were making class members uppercase and spelled out, adding "this->" whenever a class member is used, and declare functions and members with export macros. Also fixed some uses of int (instead of vtkm::Id or something similar) and a bit of indentation. I also sprinkled some const goodness over the code. It should be noted that I had about a week delay between first making these changes and checking them in. In the mean time Sujin also made some similar changes, so there might be some repetative changes.
2015-07-12 16:05:47 +00:00
AssociationEnum Association;
std::string AssocCellSetName; ///< only populate if assoc is cells
vtkm::IdComponent AssocLogicalDim; ///< only populate if assoc is logical dim
completing field.
2015-05-11 20:15:58 +00:00
Changes to follow VTK-m coding conventions
2015-07-13 19:17:03 +00:00
vtkm::cont::DynamicArrayHandle Data;
Change Field and related methods to use Range and Bounds First, be more explicit when we mean a range of values in a field or a spacial bounds. Use the Range and Bounds structs in Field and CoordinateSystem to make all of this more clear (and reduce a bit of code as well).
2016-05-26 22:02:30 +00:00
mutable vtkm::cont::ArrayHandle<vtkm::Range> Range;
Add compute bounds to Fields
2015-07-16 19:10:01 +00:00
mutable bool ModifiedFlag;
Add Field::GetRange and CoordinateSystem::GetBounds to library Following what was done with ArrayRangeCompute, the GetRange and GetBounds methods are embedded into the vtkm_cont library for the most common type lists. Also, and probably more importantly, the device adapter is no longer one of the arguments for either of these methods. It is no longer needed as ArrayRangeCompute no longer needs it.
2017-02-24 21:39:37 +00:00
template<typename TypeList, typename StorageList>
VTKM_CONT
const vtkm::cont::ArrayHandle<vtkm::Range>&
GetRangeImpl(TypeList, StorageList) const
{
VTKM_IS_LIST_TAG(TypeList);
VTKM_IS_LIST_TAG(StorageList);
if (this->ModifiedFlag)
{
internal::ComputeRange computeRange(this->Range);
this->Data.ResetTypeAndStorageLists(TypeList(),StorageList()).CastAndCall(computeRange);
this->ModifiedFlag = false;
}
return this->Range;
}
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
};
make CastAndCall a free function instead of a class. Overloading the function serves the same purpose of specializing the class, but requires less syntax sugar to do.
2016-08-05 18:47:19 +00:00
template<typename Functor>
void CastAndCall(const vtkm::cont::Field& field, const Functor &f)
{
field.GetData().CastAndCall(f);
}
Add vtkm::cont::Field,CoordinateSystem as Invokable parameters. Originally, only array handles could be passed to the dispatcher. This update extends the list to Field and CoordinateSystem as dynamic objects.
2016-08-03 18:38:25 +00:00
make CastAndCall a free function instead of a class. Overloading the function serves the same purpose of specializing the class, but requires less syntax sugar to do.
2016-08-05 18:47:19 +00:00
namespace internal {
Add vtkm::cont::Field,CoordinateSystem as Invokable parameters. Originally, only array handles could be passed to the dispatcher. This update extends the list to Field and CoordinateSystem as dynamic objects.
2016-08-03 18:38:25 +00:00
template<>
struct DynamicTransformTraits<vtkm::cont::Field>
{
typedef vtkm::cont::internal::DynamicTransformTagCastAndCall DynamicTag;
};
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
Add vtkm::cont::Field,CoordinateSystem as Invokable parameters. Originally, only array handles could be passed to the dispatcher. This update extends the list to Field and CoordinateSystem as dynamic objects.
2016-08-03 18:38:25 +00:00
} // namespace internal
encapsulating field for data set.
2015-02-10 17:36:10 +00:00
} // namespace cont
} // namespace vtkm
Correct the include guards on vtkm::cont::Field.
2015-05-29 13:51:11 +00:00
#endif //vtk_m_cont_Field_h
Reference in New Issue Copy Permalink